1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This module provides three functions: dbx_symfile_init,
22 which initializes to read a symbol file; dbx_new_init, which
23 discards existing cached information when all symbols are being
24 discarded; and dbx_symfile_read, which reads a symbol table
27 dbx_symfile_read only does the minimum work necessary for letting the
28 user "name" things symbolically; it does not read the entire symtab.
29 Instead, it reads the external and static symbols and puts them in partial
30 symbol tables. When more extensive information is requested of a
31 file, the corresponding partial symbol table is mutated into a full
32 fledged symbol table by going back and reading the symbols
33 for real. dbx_psymtab_to_symtab() is the function that does this */
36 #include "gdb_string.h"
38 #if defined(USG) || defined(__CYGNUSCLIB__)
39 #include <sys/types.h>
47 #include "breakpoint.h"
50 #include "gdbcore.h" /* for bfd stuff */
51 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
55 #include "stabsread.h"
56 #include "gdb-stabs.h"
58 #include "language.h" /* Needed inside partial-stab.h */
59 #include "complaints.h"
61 #include "aout/aout64.h"
62 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
65 /* This macro returns the size field of a minimal symbol, which is normally
66 stored in the "info" field. The macro can be overridden for specific
67 targets (e.g. MIPS16) that use the info field for other purposes. */
69 #define MSYMBOL_SIZE(msym) ((long) MSYMBOL_INFO (msym))
73 /* We put a pointer to this structure in the read_symtab_private field
78 /* Offset within the file symbol table of first local symbol for this
83 /* Length (in bytes) of the section of the symbol table devoted to
84 this file's symbols (actually, the section bracketed may contain
85 more than just this file's symbols). If ldsymlen is 0, the only
86 reason for this thing's existence is the dependency list. Nothing
87 else will happen when it is read in. */
91 /* The size of each symbol in the symbol file (in external form). */
95 /* Further information needed to locate the symbols if they are in
100 int file_string_offset
;
103 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
104 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
105 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
106 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
107 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
108 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
109 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
112 /* Macro to determine which symbols to ignore when reading the first symbol
113 of a file. Some machines override this definition. */
114 #ifndef IGNORE_SYMBOL
115 /* This code is used on Ultrix systems. Ignore it */
116 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
119 /* Remember what we deduced to be the source language of this psymtab. */
121 static enum language psymtab_language
= language_unknown
;
123 /* Nonzero means give verbose info on gdb action. From main.c. */
124 extern int info_verbose
;
126 /* The BFD for this file -- implicit parameter to next_symbol_text. */
128 static bfd
*symfile_bfd
;
130 /* The size of each symbol in the symbol file (in external form).
131 This is set by dbx_symfile_read when building psymtabs, and by
132 dbx_psymtab_to_symtab when building symtabs. */
134 static unsigned symbol_size
;
136 /* This is the offset of the symbol table in the executable file */
137 static unsigned symbol_table_offset
;
139 /* This is the offset of the string table in the executable file */
140 static unsigned string_table_offset
;
142 /* For elf+stab executables, the n_strx field is not a simple index
143 into the string table. Instead, each .o file has a base offset
144 in the string table, and the associated symbols contain offsets
145 from this base. The following two variables contain the base
146 offset for the current and next .o files. */
147 static unsigned int file_string_table_offset
;
148 static unsigned int next_file_string_table_offset
;
150 /* .o and NLM files contain unrelocated addresses which are based at 0. When
151 non-zero, this flag disables some of the special cases for Solaris elf+stab
152 text addresses at location 0. */
154 static int symfile_relocatable
= 0;
156 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
157 to the function start address. */
159 static int block_address_function_relative
= 0;
161 /* The lowest text address we have yet encountered. This is needed
162 because in an a.out file, there is no header field which tells us
163 what address the program is actually going to be loaded at, so we
164 need to make guesses based on the symbols (which *are* relocated to
165 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 /* During initial symbol readin, we need to have a structure to keep
203 track of which psymtabs have which bincls in them. This structure
204 is used during readin to setup the list of dependencies within each
205 partial symbol table. */
207 struct header_file_location
209 char *name
; /* Name of header file */
210 int instance
; /* See above */
211 struct partial_symtab
*pst
; /* Partial symtab that has the
212 BINCL/EINCL defs for this file */
215 /* The actual list and controling variables */
216 static struct header_file_location
*bincl_list
, *next_bincl
;
217 static int bincls_allocated
;
219 /* Local function prototypes */
222 process_now
PARAMS ((struct objfile
*));
225 free_header_files
PARAMS ((void));
228 init_header_files
PARAMS ((void));
231 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
234 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
237 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
240 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
241 struct objfile
*objfile
));
244 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
248 free_bincl_list
PARAMS ((struct objfile
*));
250 static struct partial_symtab
*
251 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
254 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
257 init_bincl_list
PARAMS ((int, struct objfile
*));
260 dbx_next_symbol_text
PARAMS ((struct objfile
*));
263 fill_symbuf
PARAMS ((bfd
*));
266 dbx_symfile_init
PARAMS ((struct objfile
*));
269 dbx_new_init
PARAMS ((struct objfile
*));
272 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
275 dbx_symfile_finish
PARAMS ((struct objfile
*));
278 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
281 add_new_header_file
PARAMS ((char *, int));
284 add_old_header_file
PARAMS ((char *, int));
287 add_this_object_header_file
PARAMS ((int));
289 /* Free up old header file tables */
294 if (this_object_header_files
)
296 free ((PTR
)this_object_header_files
);
297 this_object_header_files
= NULL
;
299 n_allocated_this_object_header_files
= 0;
302 /* Allocate new header file tables */
307 n_allocated_this_object_header_files
= 10;
308 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
311 /* Add header file number I for this object file
312 at the next successive FILENUM. */
315 add_this_object_header_file (i
)
318 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
320 n_allocated_this_object_header_files
*= 2;
321 this_object_header_files
322 = (int *) xrealloc ((char *) this_object_header_files
,
323 n_allocated_this_object_header_files
* sizeof (int));
326 this_object_header_files
[n_this_object_header_files
++] = i
;
329 /* Add to this file an "old" header file, one already seen in
330 a previous object file. NAME is the header file's name.
331 INSTANCE is its instance code, to select among multiple
332 symbol tables for the same header file. */
335 add_old_header_file (name
, instance
)
339 register struct header_file
*p
= HEADER_FILES (current_objfile
);
342 for (i
= 0; i
< N_HEADER_FILES (current_objfile
); i
++)
343 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
345 add_this_object_header_file (i
);
348 complain (&repeated_header_complaint
, name
, symnum
);
351 /* Add to this file a "new" header file: definitions for its types follow.
352 NAME is the header file's name.
353 Most often this happens only once for each distinct header file,
354 but not necessarily. If it happens more than once, INSTANCE has
355 a different value each time, and references to the header file
356 use INSTANCE values to select among them.
358 dbx output contains "begin" and "end" markers for each new header file,
359 but at this level we just need to know which files there have been;
360 so we record the file when its "begin" is seen and ignore the "end". */
363 add_new_header_file (name
, instance
)
368 register struct header_file
*hfile
;
370 /* Make sure there is room for one more header file. */
372 i
= N_ALLOCATED_HEADER_FILES (current_objfile
);
374 if (N_HEADER_FILES (current_objfile
) == i
)
378 N_ALLOCATED_HEADER_FILES (current_objfile
) = 10;
379 HEADER_FILES (current_objfile
) = (struct header_file
*)
380 xmalloc (10 * sizeof (struct header_file
));
385 N_ALLOCATED_HEADER_FILES (current_objfile
) = i
;
386 HEADER_FILES (current_objfile
) = (struct header_file
*)
387 xrealloc ((char *) HEADER_FILES (current_objfile
),
388 (i
* sizeof (struct header_file
)));
392 /* Create an entry for this header file. */
394 i
= N_HEADER_FILES (current_objfile
)++;
395 hfile
= HEADER_FILES (current_objfile
) + i
;
396 hfile
->name
= savestring (name
, strlen(name
));
397 hfile
->instance
= instance
;
400 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
401 memset (hfile
->vector
, 0, 10 * sizeof (struct type
*));
403 add_this_object_header_file (i
);
407 static struct type
**
408 explicit_lookup_type (real_filenum
, index
)
409 int real_filenum
, index
;
411 register struct header_file
*f
= &HEADER_FILES (current_objfile
)[real_filenum
];
413 if (index
>= f
->length
)
416 f
->vector
= (struct type
**)
417 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
418 memset (&f
->vector
[f
->length
/ 2],
419 '\0', f
->length
* sizeof (struct type
*) / 2);
421 return &f
->vector
[index
];
426 record_minimal_symbol (name
, address
, type
, objfile
)
430 struct objfile
*objfile
;
432 enum minimal_symbol_type ms_type
;
434 asection
*bfd_section
;
440 section
= SECT_OFF_TEXT
;
441 bfd_section
= DBX_TEXT_SECTION (objfile
);
445 section
= SECT_OFF_DATA
;
446 bfd_section
= DBX_DATA_SECTION (objfile
);
450 section
= SECT_OFF_BSS
;
451 bfd_section
= DBX_BSS_SECTION (objfile
);
461 section
= SECT_OFF_DATA
;
462 bfd_section
= DBX_DATA_SECTION (objfile
);
465 /* I don't think this type actually exists; since a N_SETV is the result
466 of going over many .o files, it doesn't make sense to have one
468 ms_type
= mst_file_data
;
469 section
= SECT_OFF_DATA
;
470 bfd_section
= DBX_DATA_SECTION (objfile
);
477 ms_type
= mst_file_text
;
478 section
= SECT_OFF_TEXT
;
479 bfd_section
= DBX_TEXT_SECTION (objfile
);
482 ms_type
= mst_file_data
;
484 /* Check for __DYNAMIC, which is used by Sun shared libraries.
485 Record it as global even if it's local, not global, so
486 lookup_minimal_symbol can find it. We don't check symbol_leading_char
487 because for SunOS4 it always is '_'. */
488 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
491 /* Same with virtual function tables, both global and static. */
493 char *tempstring
= name
;
494 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
496 if (VTBL_PREFIX_P ((tempstring
)))
499 section
= SECT_OFF_DATA
;
500 bfd_section
= DBX_DATA_SECTION (objfile
);
503 ms_type
= mst_file_bss
;
504 section
= SECT_OFF_BSS
;
505 bfd_section
= DBX_BSS_SECTION (objfile
);
508 ms_type
= mst_unknown
;
514 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
515 && address
< lowest_text_address
)
516 lowest_text_address
= address
;
518 prim_record_minimal_symbol_and_info
519 (name
, address
, ms_type
, NULL
, section
, bfd_section
, objfile
);
522 /* Scan and build partial symbols for a symbol file.
523 We have been initialized by a call to dbx_symfile_init, which
524 put all the relevant info into a "struct dbx_symfile_info",
525 hung off the objfile structure.
527 SECTION_OFFSETS contains offsets relative to which the symbols in the
528 various sections are (depending where the sections were actually loaded).
529 MAINLINE is true if we are reading the main symbol
530 table (as opposed to a shared lib or dynamically loaded file). */
533 dbx_symfile_read (objfile
, section_offsets
, mainline
)
534 struct objfile
*objfile
;
535 struct section_offsets
*section_offsets
;
536 int mainline
; /* FIXME comments above */
540 struct cleanup
*back_to
;
542 val
= strlen (objfile
->name
);
544 sym_bfd
= objfile
->obfd
;
546 /* .o and .nlm files are relocatables with text, data and bss segs based at
547 0. This flag disables special (Solaris stabs-in-elf only) fixups for
548 symbols with a value of 0. */
550 symfile_relocatable
= bfd_get_file_flags (sym_bfd
) & HAS_RELOC
;
552 /* This is true for Solaris (and all other systems which put stabs
553 in sections, hopefully, since it would be silly to do things
554 differently from Solaris), and false for SunOS4 and other a.out
556 block_address_function_relative
=
557 ((0 == strncmp (bfd_get_target (sym_bfd
), "elf", 3))
558 || (0 == strncmp (bfd_get_target (sym_bfd
), "som", 3))
559 || (0 == strncmp (bfd_get_target (sym_bfd
), "coff", 4))
560 || (0 == strncmp (bfd_get_target (sym_bfd
), "pe", 2))
561 || (0 == strncmp (bfd_get_target (sym_bfd
), "nlm", 3)));
563 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
565 perror_with_name (objfile
->name
);
567 /* If we are reinitializing, or if we have never loaded syms yet, init */
569 || objfile
->global_psymbols
.size
== 0
570 || objfile
->static_psymbols
.size
== 0)
571 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
573 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
574 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
576 free_pending_blocks ();
577 back_to
= make_cleanup (really_free_pendings
, 0);
579 init_minimal_symbol_collection ();
580 make_cleanup (discard_minimal_symbols
, 0);
582 /* Now that the symbol table data of the executable file are all in core,
583 process them and define symbols accordingly. */
585 read_dbx_symtab (section_offsets
, objfile
,
586 DBX_TEXT_ADDR (objfile
),
587 DBX_TEXT_SIZE (objfile
));
589 /* Add the dynamic symbols. */
591 read_dbx_dynamic_symtab (section_offsets
, objfile
);
593 /* Install any minimal symbols that have been collected as the current
594 minimal symbols for this objfile. */
596 install_minimal_symbols (objfile
);
598 do_cleanups (back_to
);
601 /* Initialize anything that needs initializing when a completely new
602 symbol file is specified (not just adding some symbols from another
603 file, e.g. a shared library). */
606 dbx_new_init (ignore
)
607 struct objfile
*ignore
;
609 stabsread_new_init ();
610 buildsym_new_init ();
611 init_header_files ();
615 /* dbx_symfile_init ()
616 is the dbx-specific initialization routine for reading symbols.
617 It is passed a struct objfile which contains, among other things,
618 the BFD for the file whose symbols are being read, and a slot for a pointer
619 to "private data" which we fill with goodies.
621 We read the string table into malloc'd space and stash a pointer to it.
623 Since BFD doesn't know how to read debug symbols in a format-independent
624 way (and may never do so...), we have to do it ourselves. We will never
625 be called unless this is an a.out (or very similar) file.
626 FIXME, there should be a cleaner peephole into the BFD environment here. */
628 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
631 dbx_symfile_init (objfile
)
632 struct objfile
*objfile
;
635 bfd
*sym_bfd
= objfile
->obfd
;
636 char *name
= bfd_get_filename (sym_bfd
);
638 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
640 /* Allocate struct to keep track of the symfile */
641 objfile
->sym_stab_info
= (PTR
)
642 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
643 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
645 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
646 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
647 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
649 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
650 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
651 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
653 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
655 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
657 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
659 error ("Can't find .text section in symbol file");
660 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
661 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
663 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
664 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
665 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
667 /* Read the string table and stash it away in the psymbol_obstack. It is
668 only needed as long as we need to expand psymbols into full symbols,
669 so when we blow away the psymbol the string table goes away as well.
670 Note that gdb used to use the results of attempting to malloc the
671 string table, based on the size it read, as a form of sanity check
672 for botched byte swapping, on the theory that a byte swapped string
673 table size would be so totally bogus that the malloc would fail. Now
674 that we put in on the psymbol_obstack, we can't do this since gdb gets
675 a fatal error (out of virtual memory) if the size is bogus. We can
676 however at least check to see if the size is less than the size of
677 the size field itself, or larger than the size of the entire file.
678 Note that all valid string tables have a size greater than zero, since
679 the bytes used to hold the size are included in the count. */
681 if (STRING_TABLE_OFFSET
== 0)
683 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
684 will never be zero, even when there is no string table. This
685 would appear to be a bug in bfd. */
686 DBX_STRINGTAB_SIZE (objfile
) = 0;
687 DBX_STRINGTAB (objfile
) = NULL
;
691 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
693 perror_with_name (name
);
695 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
696 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
699 perror_with_name (name
);
703 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
704 EOF if there is no string table, and attempting to read the size
705 from EOF will read zero bytes. */
706 DBX_STRINGTAB_SIZE (objfile
) = 0;
707 DBX_STRINGTAB (objfile
) = NULL
;
711 /* Read some data that would appear to be the string table size.
712 If there really is a string table, then it is probably the right
713 size. Byteswap if necessary and validate the size. Note that
714 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
715 random data that happened to be at STRING_TABLE_OFFSET, because
716 bfd can't tell us there is no string table, the sanity checks may
717 or may not catch this. */
718 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
720 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
721 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
722 error ("ridiculous string table size (%d bytes).",
723 DBX_STRINGTAB_SIZE (objfile
));
725 DBX_STRINGTAB (objfile
) =
726 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
727 DBX_STRINGTAB_SIZE (objfile
));
728 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
730 /* Now read in the string table in one big gulp. */
732 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
734 perror_with_name (name
);
735 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
737 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
738 perror_with_name (name
);
743 /* Perform any local cleanups required when we are done with a particular
744 objfile. I.E, we are in the process of discarding all symbol information
745 for an objfile, freeing up all memory held for it, and unlinking the
746 objfile struct from the global list of known objfiles. */
749 dbx_symfile_finish (objfile
)
750 struct objfile
*objfile
;
752 if (objfile
->sym_stab_info
!= NULL
)
754 if (HEADER_FILES (objfile
) != NULL
)
756 register int i
= N_HEADER_FILES (objfile
);
757 register struct header_file
*hfiles
= HEADER_FILES (objfile
);
761 free (hfiles
[i
].name
);
762 free (hfiles
[i
].vector
);
766 mfree (objfile
-> md
, objfile
->sym_stab_info
);
768 free_header_files ();
772 /* Buffer for reading the symbol table entries. */
773 static struct external_nlist symbuf
[4096];
774 static int symbuf_idx
;
775 static int symbuf_end
;
777 /* cont_elem is used for continuing information in cfront.
778 It saves information about which types need to be fixed up and
779 completed after all the stabs are read. */
782 /* sym and stabsstring for continuing information in cfront */
785 /* state dependancies (statics that must be preserved) */
789 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
790 /* other state dependancies include:
791 (assumption is that these will not change since process_now FIXME!!)
798 static struct cont_elem
*cont_list
= 0;
799 static int cont_limit
= 0;
800 static int cont_count
= 0;
802 /* Arrange for function F to be called with arguments SYM and P later
803 in the stabs reading process. */
805 process_later (sym
, p
, f
)
808 int (*f
) PARAMS ((struct objfile
*, struct symbol
*, char *));
811 /* Allocate more space for the deferred list. */
812 if (cont_count
>= cont_limit
- 1)
814 cont_limit
+= 32; /* chunk size */
817 = (struct cont_elem
*) xrealloc (cont_list
,
819 * sizeof (struct cont_elem
)));
821 error ("Virtual memory exhausted\n");
824 /* Save state variables so we can process these stabs later. */
825 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
826 cont_list
[cont_count
].sym_end
= symbuf_end
;
827 cont_list
[cont_count
].symnum
= symnum
;
828 cont_list
[cont_count
].sym
= sym
;
829 cont_list
[cont_count
].stabs
= p
;
830 cont_list
[cont_count
].func
= f
;
834 /* Call deferred funtions in CONT_LIST. */
837 process_now (objfile
)
838 struct objfile
*objfile
;
847 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
849 /* Save the state of our caller, we'll want to restore it before
851 save_symbuf_idx
= symbuf_idx
;
852 save_symbuf_end
= symbuf_end
;
853 save_symnum
= symnum
;
855 /* Iterate over all the deferred stabs. */
856 for (i
= 0; i
< cont_count
; i
++)
858 /* Restore the state for this deferred stab. */
859 symbuf_idx
= cont_list
[i
].sym_idx
;
860 symbuf_end
= cont_list
[i
].sym_end
;
861 symnum
= cont_list
[i
].symnum
;
862 sym
= cont_list
[i
].sym
;
863 stabs
= cont_list
[i
].stabs
;
864 func
= cont_list
[i
].func
;
866 /* Call the function to handle this deferrd stab. */
867 err
= (*func
) (objfile
, sym
, stabs
);
869 error ("Internal error: unable to resolve stab.\n");
872 /* Restore our caller's state. */
873 symbuf_idx
= save_symbuf_idx
;
874 symbuf_end
= save_symbuf_end
;
875 symnum
= save_symnum
;
880 /* Name of last function encountered. Used in Solaris to approximate
881 object file boundaries. */
882 static char *last_function_name
;
884 /* The address in memory of the string table of the object file we are
885 reading (which might not be the "main" object file, but might be a
886 shared library or some other dynamically loaded thing). This is
887 set by read_dbx_symtab when building psymtabs, and by
888 read_ofile_symtab when building symtabs, and is used only by
889 next_symbol_text. FIXME: If that is true, we don't need it when
890 building psymtabs, right? */
891 static char *stringtab_global
;
893 /* These variables are used to control fill_symbuf when the stabs
894 symbols are not contiguous (as may be the case when a COFF file is
895 linked using --split-by-reloc). */
896 static struct stab_section_list
*symbuf_sections
;
897 static unsigned int symbuf_left
;
898 static unsigned int symbuf_read
;
900 /* Refill the symbol table input buffer
901 and set the variables that control fetching entries from it.
902 Reports an error if no data available.
903 This function can read past the end of the symbol table
904 (into the string table) but this does no harm. */
907 fill_symbuf (sym_bfd
)
913 if (symbuf_sections
== NULL
)
914 count
= sizeof (symbuf
);
917 if (symbuf_left
<= 0)
919 file_ptr filepos
= symbuf_sections
->section
->filepos
;
920 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
921 perror_with_name (bfd_get_filename (sym_bfd
));
922 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
923 symbol_table_offset
= filepos
- symbuf_read
;
924 symbuf_sections
= symbuf_sections
->next
;
928 if (count
> sizeof (symbuf
))
929 count
= sizeof (symbuf
);
932 nbytes
= bfd_read ((PTR
)symbuf
, count
, 1, sym_bfd
);
934 perror_with_name (bfd_get_filename (sym_bfd
));
935 else if (nbytes
== 0)
936 error ("Premature end of file reading symbol table");
937 symbuf_end
= nbytes
/ symbol_size
;
939 symbuf_left
-= nbytes
;
940 symbuf_read
+= nbytes
;
943 #define SWAP_SYMBOL(symp, abfd) \
945 (symp)->n_strx = bfd_h_get_32(abfd, \
946 (unsigned char *)&(symp)->n_strx); \
947 (symp)->n_desc = bfd_h_get_16 (abfd, \
948 (unsigned char *)&(symp)->n_desc); \
949 (symp)->n_value = bfd_h_get_32 (abfd, \
950 (unsigned char *)&(symp)->n_value); \
953 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
955 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
956 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
957 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
958 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
961 /* Invariant: The symbol pointed to by symbuf_idx is the first one
962 that hasn't been swapped. Swap the symbol at the same time
963 that symbuf_idx is incremented. */
965 /* dbx allows the text of a symbol name to be continued into the
966 next symbol name! When such a continuation is encountered
967 (a \ at the end of the text of a name)
968 call this function to get the continuation. */
971 dbx_next_symbol_text (objfile
)
972 struct objfile
*objfile
;
974 struct internal_nlist nlist
;
976 if (symbuf_idx
== symbuf_end
)
977 fill_symbuf (symfile_bfd
);
980 INTERNALIZE_SYMBOL(nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
981 OBJSTAT (objfile
, n_stabs
++);
985 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
988 /* Initialize the list of bincls to contain none and have some
992 init_bincl_list (number
, objfile
)
994 struct objfile
*objfile
;
996 bincls_allocated
= number
;
997 next_bincl
= bincl_list
= (struct header_file_location
*)
998 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
1001 /* Add a bincl to the list. */
1004 add_bincl_to_list (pst
, name
, instance
)
1005 struct partial_symtab
*pst
;
1009 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1011 int offset
= next_bincl
- bincl_list
;
1012 bincls_allocated
*= 2;
1013 bincl_list
= (struct header_file_location
*)
1014 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
1015 bincls_allocated
* sizeof (struct header_file_location
));
1016 next_bincl
= bincl_list
+ offset
;
1018 next_bincl
->pst
= pst
;
1019 next_bincl
->instance
= instance
;
1020 next_bincl
++->name
= name
;
1023 /* Given a name, value pair, find the corresponding
1024 bincl in the list. Return the partial symtab associated
1025 with that header_file_location. */
1027 static struct partial_symtab
*
1028 find_corresponding_bincl_psymtab (name
, instance
)
1032 struct header_file_location
*bincl
;
1034 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1035 if (bincl
->instance
== instance
1036 && STREQ (name
, bincl
->name
))
1039 complain (&repeated_header_complaint
, name
, symnum
);
1040 return (struct partial_symtab
*) 0;
1043 /* Free the storage allocated for the bincl list. */
1046 free_bincl_list (objfile
)
1047 struct objfile
*objfile
;
1049 mfree (objfile
-> md
, (PTR
)bincl_list
);
1050 bincls_allocated
= 0;
1053 /* Scan a SunOs dynamic symbol table for symbols of interest and
1054 add them to the minimal symbol table. */
1057 read_dbx_dynamic_symtab (section_offsets
, objfile
)
1058 struct section_offsets
*section_offsets
;
1059 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 (free
, 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 (section_offsets
, SECT_OFF_TEXT
);
1120 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1122 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1125 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1127 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
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 (free
, 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 (section_offsets
, SECT_OFF_DATA
);
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 /* Given pointers to an a.out symbol table in core containing dbx
1198 style data, setup partial_symtab's describing each source file for
1199 which debugging information is available.
1200 SYMFILE_NAME is the name of the file we are reading from
1201 and SECTION_OFFSETS is the set of offsets for the various sections
1202 of the file (a set of zeros if the mainline program). */
1205 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1206 struct section_offsets
*section_offsets
;
1207 struct objfile
*objfile
;
1208 CORE_ADDR text_addr
;
1211 register struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1212 struct internal_nlist nlist
;
1214 register char *namestring
;
1216 int past_first_source_file
= 0;
1217 CORE_ADDR last_o_file_start
= 0;
1218 CORE_ADDR last_function_start
= 0;
1219 struct cleanup
*back_to
;
1221 int textlow_not_set
;
1223 /* Current partial symtab */
1224 struct partial_symtab
*pst
;
1226 /* List of current psymtab's include files */
1227 char **psymtab_include_list
;
1228 int includes_allocated
;
1231 /* Index within current psymtab dependency list */
1232 struct partial_symtab
**dependency_list
;
1233 int dependencies_used
, dependencies_allocated
;
1235 /* FIXME. We probably want to change stringtab_global rather than add this
1236 while processing every symbol entry. FIXME. */
1237 file_string_table_offset
= 0;
1238 next_file_string_table_offset
= 0;
1240 stringtab_global
= DBX_STRINGTAB (objfile
);
1242 pst
= (struct partial_symtab
*) 0;
1244 includes_allocated
= 30;
1246 psymtab_include_list
= (char **) alloca (includes_allocated
*
1249 dependencies_allocated
= 30;
1250 dependencies_used
= 0;
1252 (struct partial_symtab
**) alloca (dependencies_allocated
*
1253 sizeof (struct partial_symtab
*));
1255 /* Init bincl list */
1256 init_bincl_list (20, objfile
);
1257 back_to
= make_cleanup (free_bincl_list
, objfile
);
1259 last_source_file
= NULL
;
1261 lowest_text_address
= (CORE_ADDR
)-1;
1263 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1264 abfd
= objfile
->obfd
;
1265 symbuf_end
= symbuf_idx
= 0;
1266 next_symbol_text_func
= dbx_next_symbol_text
;
1267 textlow_not_set
= 1;
1268 has_line_numbers
= 0;
1270 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1272 /* Get the symbol for this run and pull out some info */
1273 QUIT
; /* allow this to be interruptable */
1274 if (symbuf_idx
== symbuf_end
)
1276 bufp
= &symbuf
[symbuf_idx
++];
1279 * Special case to speed up readin.
1281 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1283 has_line_numbers
= 1;
1287 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1288 OBJSTAT (objfile
, n_stabs
++);
1290 /* Ok. There is a lot of code duplicated in the rest of this
1291 switch statement (for efficiency reasons). Since I don't
1292 like duplicating code, I will do my penance here, and
1293 describe the code which is duplicated:
1295 *) The assignment to namestring.
1296 *) The call to strchr.
1297 *) The addition of a partial symbol the the two partial
1298 symbol lists. This last is a large section of code, so
1299 I've imbedded it in the following macro.
1302 /* Set namestring based on nlist. If the string table index is invalid,
1303 give a fake name, and print a single error message per symbol file read,
1304 rather than abort the symbol reading or flood the user with messages. */
1306 /*FIXME: Too many adds and indirections in here for the inner loop. */
1307 #define SET_NAMESTRING()\
1308 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1309 DBX_STRINGTAB_SIZE (objfile)) { \
1310 complain (&string_table_offset_complaint, symnum); \
1311 namestring = "<bad string table offset>"; \
1313 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1314 DBX_STRINGTAB (objfile)
1316 #define CUR_SYMBOL_TYPE nlist.n_type
1317 #define CUR_SYMBOL_VALUE nlist.n_value
1318 #define CUR_SYMBOL_STRX nlist.n_strx
1319 #define DBXREAD_ONLY
1320 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1321 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1322 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1323 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1325 #include "partial-stab.h"
1328 /* If there's stuff to be cleaned up, clean it up. */
1329 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1330 /*FIXME, does this have a bug at start address 0? */
1331 && last_o_file_start
1332 && objfile
-> ei
.entry_point
< nlist
.n_value
1333 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1335 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1336 objfile
-> ei
.entry_file_highpc
= nlist
.n_value
;
1341 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1342 symnum
* symbol_size
,
1343 (lowest_text_address
== (CORE_ADDR
)-1
1344 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1345 : lowest_text_address
)
1347 dependency_list
, dependencies_used
, textlow_not_set
);
1350 do_cleanups (back_to
);
1353 /* Allocate and partially fill a partial symtab. It will be
1354 completely filled at the end of the symbol list.
1356 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1357 is the address relative to which its symbols are (incremental) or 0
1361 struct partial_symtab
*
1362 start_psymtab (objfile
, section_offsets
,
1363 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1364 struct objfile
*objfile
;
1365 struct section_offsets
*section_offsets
;
1369 struct partial_symbol
**global_syms
;
1370 struct partial_symbol
**static_syms
;
1372 struct partial_symtab
*result
=
1373 start_psymtab_common(objfile
, section_offsets
,
1374 filename
, textlow
, global_syms
, static_syms
);
1376 result
->read_symtab_private
= (char *)
1377 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1378 LDSYMOFF(result
) = ldsymoff
;
1379 result
->read_symtab
= dbx_psymtab_to_symtab
;
1380 SYMBOL_SIZE(result
) = symbol_size
;
1381 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1382 STRING_OFFSET(result
) = string_table_offset
;
1383 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1385 /* If we're handling an ELF file, drag some section-relocation info
1386 for this source file out of the ELF symbol table, to compensate for
1387 Sun brain death. This replaces the section_offsets in this psymtab,
1389 elfstab_offset_sections (objfile
, result
);
1391 /* Deduce the source language from the filename for this psymtab. */
1392 psymtab_language
= deduce_language_from_filename (filename
);
1397 /* Close off the current usage of PST.
1398 Returns PST or NULL if the partial symtab was empty and thrown away.
1400 FIXME: List variables and peculiarities of same. */
1402 struct partial_symtab
*
1403 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1404 capping_text
, dependency_list
, number_dependencies
, textlow_not_set
)
1405 struct partial_symtab
*pst
;
1406 char **include_list
;
1408 int capping_symbol_offset
;
1409 CORE_ADDR capping_text
;
1410 struct partial_symtab
**dependency_list
;
1411 int number_dependencies
;
1412 int textlow_not_set
;
1415 struct objfile
*objfile
= pst
-> objfile
;
1417 if (capping_symbol_offset
!= -1)
1418 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1419 pst
->texthigh
= capping_text
;
1421 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1422 /* Under Solaris, the N_SO symbols always have a value of 0,
1423 instead of the usual address of the .o file. Therefore,
1424 we have to do some tricks to fill in texthigh and textlow.
1425 The first trick is in partial-stab.h: if we see a static
1426 or global function, and the textlow for the current pst
1427 is not set (ie: textlow_not_set), then we use that function's
1428 address for the textlow of the pst. */
1430 /* Now, to fill in texthigh, we remember the last function seen
1431 in the .o file (also in partial-stab.h). Also, there's a hack in
1432 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1433 to here via the misc_info field. Therefore, we can fill in
1434 a reliable texthigh by taking the address plus size of the
1435 last function in the file. */
1437 if (pst
->texthigh
== 0 && last_function_name
)
1441 struct minimal_symbol
*minsym
;
1443 p
= strchr (last_function_name
, ':');
1445 p
= last_function_name
;
1446 n
= p
- last_function_name
;
1448 strncpy (p
, last_function_name
, n
);
1451 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1454 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) + MSYMBOL_SIZE (minsym
);
1456 last_function_name
= NULL
;
1459 /* this test will be true if the last .o file is only data */
1460 if (textlow_not_set
)
1461 pst
->textlow
= pst
->texthigh
;
1464 struct partial_symtab
*p1
;
1466 /* If we know our own starting text address, then walk through all other
1467 psymtabs for this objfile, and if any didn't know their ending text
1468 address, set it to our starting address. Take care to not set our
1469 own ending address to our starting address, nor to set addresses on
1470 `dependency' files that have both textlow and texthigh zero. */
1472 ALL_OBJFILE_PSYMTABS (objfile
, p1
)
1474 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
)
1476 p1
->texthigh
= pst
->textlow
;
1477 /* if this file has only data, then make textlow match texthigh */
1478 if (p1
->textlow
== 0)
1479 p1
->textlow
= p1
->texthigh
;
1484 /* End of kludge for patching Solaris textlow and texthigh. */
1485 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1487 pst
->n_global_syms
=
1488 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1489 pst
->n_static_syms
=
1490 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1492 pst
->number_of_dependencies
= number_dependencies
;
1493 if (number_dependencies
)
1495 pst
->dependencies
= (struct partial_symtab
**)
1496 obstack_alloc (&objfile
->psymbol_obstack
,
1497 number_dependencies
* sizeof (struct partial_symtab
*));
1498 memcpy (pst
->dependencies
, dependency_list
,
1499 number_dependencies
* sizeof (struct partial_symtab
*));
1502 pst
->dependencies
= 0;
1504 for (i
= 0; i
< num_includes
; i
++)
1506 struct partial_symtab
*subpst
=
1507 allocate_psymtab (include_list
[i
], objfile
);
1509 subpst
->section_offsets
= pst
->section_offsets
;
1510 subpst
->read_symtab_private
=
1511 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1512 sizeof (struct symloc
));
1516 subpst
->texthigh
= 0;
1518 /* We could save slight bits of space by only making one of these,
1519 shared by the entire set of include files. FIXME-someday. */
1520 subpst
->dependencies
= (struct partial_symtab
**)
1521 obstack_alloc (&objfile
->psymbol_obstack
,
1522 sizeof (struct partial_symtab
*));
1523 subpst
->dependencies
[0] = pst
;
1524 subpst
->number_of_dependencies
= 1;
1526 subpst
->globals_offset
=
1527 subpst
->n_global_syms
=
1528 subpst
->statics_offset
=
1529 subpst
->n_static_syms
= 0;
1533 subpst
->read_symtab
= pst
->read_symtab
;
1536 sort_pst_symbols (pst
);
1538 /* If there is already a psymtab or symtab for a file of this name, remove it.
1539 (If there is a symtab, more drastic things also happen.)
1540 This happens in VxWorks. */
1541 free_named_symtabs (pst
->filename
);
1543 if (num_includes
== 0
1544 && number_dependencies
== 0
1545 && pst
->n_global_syms
== 0
1546 && pst
->n_static_syms
== 0
1547 && has_line_numbers
== 0)
1549 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1550 it is on the obstack, but we can forget to chain it on the list. */
1551 /* Empty psymtabs happen as a result of header files which don't have
1552 any symbols in them. There can be a lot of them. But this check
1553 is wrong, in that a psymtab with N_SLINE entries but nothing else
1554 is not empty, but we don't realize that. Fixing that without slowing
1555 things down might be tricky. */
1556 struct partial_symtab
*prev_pst
;
1558 /* First, snip it out of the psymtab chain */
1560 if (pst
->objfile
->psymtabs
== pst
)
1561 pst
->objfile
->psymtabs
= pst
->next
;
1563 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1564 if (prev_pst
->next
== pst
)
1565 prev_pst
->next
= pst
->next
;
1567 /* Next, put it on a free list for recycling */
1569 pst
->next
= pst
->objfile
->free_psymtabs
;
1570 pst
->objfile
->free_psymtabs
= pst
;
1572 /* Indicate that psymtab was thrown away. */
1573 pst
= (struct partial_symtab
*)NULL
;
1579 dbx_psymtab_to_symtab_1 (pst
)
1580 struct partial_symtab
*pst
;
1582 struct cleanup
*old_chain
;
1590 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1595 /* Read in all partial symtabs on which this one is dependent */
1596 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1597 if (!pst
->dependencies
[i
]->readin
)
1599 /* Inform about additional files that need to be read in. */
1602 fputs_filtered (" ", gdb_stdout
);
1604 fputs_filtered ("and ", gdb_stdout
);
1606 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1607 wrap_here (""); /* Flush output */
1608 gdb_flush (gdb_stdout
);
1610 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1613 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1615 /* Init stuff necessary for reading in symbols */
1618 old_chain
= make_cleanup (really_free_pendings
, 0);
1619 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1620 symbol_size
= SYMBOL_SIZE (pst
);
1622 /* Read in this file's symbols */
1623 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1624 read_ofile_symtab (pst
);
1625 sort_symtab_syms (pst
->symtab
);
1627 do_cleanups (old_chain
);
1633 /* Read in all of the symbols for a given psymtab for real.
1634 Be verbose about it if the user wants that. */
1637 dbx_psymtab_to_symtab (pst
)
1638 struct partial_symtab
*pst
;
1647 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1652 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1654 /* Print the message now, before reading the string table,
1655 to avoid disconcerting pauses. */
1658 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1659 gdb_flush (gdb_stdout
);
1662 sym_bfd
= pst
->objfile
->obfd
;
1664 next_symbol_text_func
= dbx_next_symbol_text
;
1666 dbx_psymtab_to_symtab_1 (pst
);
1668 /* Match with global symbols. This only needs to be done once,
1669 after all of the symtabs and dependencies have been read in. */
1670 scan_file_globals (pst
->objfile
);
1672 /* Finish up the debug error message. */
1674 printf_filtered ("done.\n");
1678 /* Read in a defined section of a specific object file's symbols. */
1681 read_ofile_symtab (pst
)
1682 struct partial_symtab
*pst
;
1684 register char *namestring
;
1685 register struct external_nlist
*bufp
;
1686 struct internal_nlist nlist
;
1688 unsigned max_symnum
;
1690 struct objfile
*objfile
;
1691 int sym_offset
; /* Offset to start of symbols to read */
1692 int sym_size
; /* Size of symbols to read */
1693 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1694 int text_size
; /* Size of text segment for symbols */
1695 struct section_offsets
*section_offsets
;
1697 objfile
= pst
->objfile
;
1698 sym_offset
= LDSYMOFF(pst
);
1699 sym_size
= LDSYMLEN(pst
);
1700 text_offset
= pst
->textlow
;
1701 text_size
= pst
->texthigh
- pst
->textlow
;
1702 section_offsets
= pst
->section_offsets
;
1704 current_objfile
= objfile
;
1705 subfile_stack
= NULL
;
1707 stringtab_global
= DBX_STRINGTAB (objfile
);
1708 last_source_file
= NULL
;
1710 abfd
= objfile
->obfd
;
1711 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1712 symbuf_end
= symbuf_idx
= 0;
1714 /* It is necessary to actually read one symbol *before* the start
1715 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1716 occurs before the N_SO symbol.
1718 Detecting this in read_dbx_symtab
1719 would slow down initial readin, so we look for it here instead. */
1720 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1722 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1724 bufp
= &symbuf
[symbuf_idx
++];
1725 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1726 OBJSTAT (objfile
, n_stabs
++);
1730 processing_gcc_compilation
= 0;
1731 if (nlist
.n_type
== N_TEXT
)
1733 const char *tempstring
= namestring
;
1735 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1736 processing_gcc_compilation
= 1;
1737 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1738 processing_gcc_compilation
= 2;
1739 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1741 if (STREQN (tempstring
, "__gnu_compiled", 14))
1742 processing_gcc_compilation
= 2;
1745 /* Try to select a C++ demangling based on the compilation unit
1748 if (processing_gcc_compilation
)
1750 if (AUTO_DEMANGLING
)
1752 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1758 /* The N_SO starting this symtab is the first symbol, so we
1759 better not check the symbol before it. I'm not this can
1760 happen, but it doesn't hurt to check for it. */
1761 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1762 processing_gcc_compilation
= 0;
1765 if (symbuf_idx
== symbuf_end
)
1767 bufp
= &symbuf
[symbuf_idx
];
1768 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
1769 error("First symbol in segment of executable not a source symbol");
1771 max_symnum
= sym_size
/ symbol_size
;
1774 symnum
< max_symnum
;
1777 QUIT
; /* Allow this to be interruptable */
1778 if (symbuf_idx
== symbuf_end
)
1780 bufp
= &symbuf
[symbuf_idx
++];
1781 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1782 OBJSTAT (objfile
, n_stabs
++);
1784 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
1788 if (type
& N_STAB
) {
1789 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
1790 namestring
, section_offsets
, objfile
);
1792 /* We skip checking for a new .o or -l file; that should never
1793 happen in this routine. */
1794 else if (type
== N_TEXT
)
1796 /* I don't think this code will ever be executed, because
1797 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1798 the N_SO symbol which starts this source file.
1799 However, there is no reason not to accept
1800 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1802 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1803 processing_gcc_compilation
= 1;
1804 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1805 processing_gcc_compilation
= 2;
1807 if (AUTO_DEMANGLING
)
1809 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1812 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1813 || type
== (unsigned char)N_NBTEXT
1815 /* Global symbol: see if we came across a dbx defintion for
1816 a corresponding symbol. If so, store the value. Remove
1817 syms from the chain when their values are stored, but
1818 search the whole chain, as there may be several syms from
1819 different files with the same name. */
1820 /* This is probably not true. Since the files will be read
1821 in one at a time, each reference to a global symbol will
1822 be satisfied in each file as it appears. So we skip this
1828 current_objfile
= NULL
;
1830 /* In a Solaris elf file, this variable, which comes from the
1831 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1832 which comes from pst->textlow is correct. */
1833 if (last_source_start_addr
== 0)
1834 last_source_start_addr
= text_offset
;
1836 /* In reordered executables last_source_start_addr may not be the
1837 lower bound for this symtab, instead use text_offset which comes
1838 from pst->textlow which is correct. */
1839 if (last_source_start_addr
> text_offset
)
1840 last_source_start_addr
= text_offset
;
1842 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1844 /* Process items which we had to "process_later" due to dependancies
1846 process_now (objfile
);
1852 /* This handles a single symbol from the symbol-file, building symbols
1853 into a GDB symtab. It takes these arguments and an implicit argument.
1855 TYPE is the type field of the ".stab" symbol entry.
1856 DESC is the desc field of the ".stab" entry.
1857 VALU is the value field of the ".stab" entry.
1858 NAME is the symbol name, in our address space.
1859 SECTION_OFFSETS is a set of amounts by which the sections of this object
1860 file were relocated when it was loaded into memory.
1861 All symbols that refer
1862 to memory locations need to be offset by these amounts.
1863 OBJFILE is the object file from which we are reading symbols.
1864 It is used in end_symtab. */
1867 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1871 struct section_offsets
*section_offsets
;
1872 struct objfile
*objfile
;
1874 #ifdef SUN_FIXED_LBRAC_BUG
1875 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1876 to correct the address of N_LBRAC's. If it is not defined, then
1877 we never need to correct the addresses. */
1879 /* This records the last pc address we've seen. We depend on there being
1880 an SLINE or FUN or SO before the first LBRAC, since the variable does
1881 not get reset in between reads of different symbol files. */
1882 static CORE_ADDR last_pc_address
;
1885 register struct context_stack
*new;
1886 /* This remembers the address of the start of a function. It is used
1887 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1888 relative to the current function's start address. On systems
1889 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1890 used to relocate these symbol types rather than SECTION_OFFSETS. */
1891 static CORE_ADDR function_start_offset
;
1893 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1894 file. Used to detect the SunPRO solaris compiler. */
1895 static int n_opt_found
;
1897 /* The stab type used for the definition of the last function.
1898 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1899 static int function_stab_type
= 0;
1901 if (!block_address_function_relative
)
1902 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1903 function start address, so just use the text offset. */
1904 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1906 /* Something is wrong if we see real data before
1907 seeing a source file name. */
1909 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1911 /* Ignore any symbols which appear before an N_SO symbol. Currently
1912 no one puts symbols there, but we should deal gracefully with the
1913 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1914 but this should not be an error (). */
1923 if (*name
== '\000')
1925 /* This N_FUN marks the end of a function. This closes off the
1927 within_function
= 0;
1928 new = pop_context ();
1930 /* Make a block for the local symbols within. */
1931 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1932 new->start_addr
, new->start_addr
+ valu
,
1937 /* Relocate for dynamic loading */
1938 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1939 goto define_a_symbol
;
1942 /* This "symbol" just indicates the start of an inner lexical
1943 context within a function. */
1945 /* Ignore extra outermost context from SunPRO cc and acc. */
1946 if (n_opt_found
&& desc
== 1)
1949 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1950 /* Relocate for dynamic loading (?). */
1951 valu
+= function_start_offset
;
1953 if (block_address_function_relative
)
1954 /* Relocate for Sun ELF acc fn-relative syms. */
1955 valu
+= function_start_offset
;
1957 /* On most machines, the block addresses are relative to the
1958 N_SO, the linker did not relocate them (sigh). */
1959 valu
+= last_source_start_addr
;
1962 #ifdef SUN_FIXED_LBRAC_BUG
1963 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1964 /* Patch current LBRAC pc value to match last handy pc value */
1965 complain (&lbrac_complaint
);
1966 valu
= last_pc_address
;
1969 new = push_context (desc
, valu
);
1973 /* This "symbol" just indicates the end of an inner lexical
1974 context that was started with N_LBRAC. */
1976 /* Ignore extra outermost context from SunPRO cc and acc. */
1977 if (n_opt_found
&& desc
== 1)
1980 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1981 /* Relocate for dynamic loading (?). */
1982 valu
+= function_start_offset
;
1984 if (block_address_function_relative
)
1985 /* Relocate for Sun ELF acc fn-relative syms. */
1986 valu
+= function_start_offset
;
1988 /* On most machines, the block addresses are relative to the
1989 N_SO, the linker did not relocate them (sigh). */
1990 valu
+= last_source_start_addr
;
1993 new = pop_context();
1994 if (desc
!= new->depth
)
1995 complain (&lbrac_mismatch_complaint
, symnum
);
1997 /* Some compilers put the variable decls inside of an
1998 LBRAC/RBRAC block. This macro should be nonzero if this
1999 is true. DESC is N_DESC from the N_RBRAC symbol.
2000 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
2001 or the GCC2_COMPILED_SYMBOL. */
2002 #if !defined (VARIABLES_INSIDE_BLOCK)
2003 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2006 /* Can only use new->locals as local symbols here if we're in
2007 gcc or on a machine that puts them before the lbrack. */
2008 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2009 local_symbols
= new->locals
;
2011 if (context_stack_depth
2012 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2014 /* This is not the outermost LBRAC...RBRAC pair in the function,
2015 its local symbols preceded it, and are the ones just recovered
2016 from the context stack. Define the block for them (but don't
2017 bother if the block contains no symbols. Should we complain
2018 on blocks without symbols? I can't think of any useful purpose
2020 if (local_symbols
!= NULL
)
2022 /* Muzzle a compiler bug that makes end < start. (which
2023 compilers? Is this ever harmful?). */
2024 if (new->start_addr
> valu
)
2026 complain (&lbrac_rbrac_complaint
);
2027 new->start_addr
= valu
;
2029 /* Make a block for the local symbols within. */
2030 finish_block (0, &local_symbols
, new->old_blocks
,
2031 new->start_addr
, valu
, objfile
);
2036 /* This is the outermost LBRAC...RBRAC pair. There is no
2037 need to do anything; leave the symbols that preceded it
2038 to be attached to the function's own block. We need to
2039 indicate that we just moved outside of the function. */
2040 within_function
= 0;
2043 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2044 /* Now pop locals of block just finished. */
2045 local_symbols
= new->locals
;
2050 /* This kind of symbol indicates the start of an object file. */
2051 /* Relocate for dynamic loading */
2052 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2056 /* This type of symbol indicates the start of data
2057 for one source file.
2058 Finish the symbol table of the previous source file
2059 (if any) and start accumulating a new symbol table. */
2060 /* Relocate for dynamic loading */
2061 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2065 #ifdef SUN_FIXED_LBRAC_BUG
2066 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2069 #ifdef PCC_SOL_BROKEN
2070 /* pcc bug, occasionally puts out SO for SOL. */
2071 if (context_stack_depth
> 0)
2073 start_subfile (name
, NULL
);
2077 if (last_source_file
)
2079 /* Check if previous symbol was also an N_SO (with some
2080 sanity checks). If so, that one was actually the directory
2081 name, and the current one is the real file name.
2083 if (previous_stab_code
== (unsigned char) N_SO
)
2085 patch_subfile_names (current_subfile
, name
);
2086 break; /* Ignore repeated SOs */
2088 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
2092 /* Null name means this just marks the end of text for this .o file.
2093 Don't start a new symtab in this case. */
2094 if (*name
== '\000')
2098 start_symtab (name
, NULL
, valu
);
2099 record_debugformat ("stabs");
2103 /* This type of symbol indicates the start of data for
2104 a sub-source-file, one whose contents were copied or
2105 included in the compilation of the main source file
2106 (whose name was given in the N_SO symbol.) */
2107 /* Relocate for dynamic loading */
2108 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2109 start_subfile (name
, current_subfile
->dirname
);
2114 add_new_header_file (name
, valu
);
2115 start_subfile (name
, current_subfile
->dirname
);
2119 start_subfile (pop_subfile (), current_subfile
->dirname
);
2123 add_old_header_file (name
, valu
);
2127 /* This type of "symbol" really just records
2128 one line-number -- core-address correspondence.
2129 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
;
2132 #ifdef SUN_FIXED_LBRAC_BUG
2133 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2135 record_line (current_subfile
, desc
, valu
);
2139 common_block_start (name
, objfile
);
2143 common_block_end (objfile
);
2146 /* The following symbol types need to have the appropriate offset added
2147 to their value; then we process symbol definitions in the name. */
2149 case N_STSYM
: /* Static symbol in data seg */
2150 case N_LCSYM
: /* Static symbol in BSS seg */
2151 case N_ROSYM
: /* Static symbol in Read-only data seg */
2152 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2153 Solaris2's stabs-in-elf makes *most* symbols relative
2154 but leaves a few absolute (at least for Solaris 2.1 and version
2155 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2156 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2157 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2158 This leaves us no choice but to search for the 'S' or 'V'...
2159 (or pass the whole section_offsets stuff down ONE MORE function
2160 call level, which we really don't want to do). */
2164 /* .o files and NLMs have non-zero text seg offsets, but don't need
2165 their static syms offset in this fashion. XXX - This is really a
2166 crock that should be fixed in the solib handling code so that I
2167 don't have to work around it here. */
2169 if (!symfile_relocatable
)
2171 p
= strchr (name
, ':');
2172 if (p
!= 0 && p
[1] == 'S')
2174 /* The linker relocated it. We don't want to add an
2175 elfstab_offset_sections-type offset, but we *do* want
2176 to add whatever solib.c passed to symbol_file_add as
2177 addr (this is known to affect SunOS4, and I suspect ELF
2178 too). Since elfstab_offset_sections currently does not
2179 muck with the text offset (there is no Ttext.text
2180 symbol), we can get addr from the text offset. If
2181 elfstab_offset_sections ever starts dealing with the
2182 text offset, and we still need to do this, we need to
2183 invent a SECT_OFF_ADDR_KLUDGE or something. */
2184 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2185 goto define_a_symbol
;
2188 /* Since it's not the kludge case, re-dispatch to the right handler. */
2190 case N_STSYM
: goto case_N_STSYM
;
2191 case N_LCSYM
: goto case_N_LCSYM
;
2192 case N_ROSYM
: goto case_N_ROSYM
;
2197 case_N_STSYM
: /* Static symbol in data seg */
2198 case N_DSLINE
: /* Source line number, data seg */
2199 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2200 goto define_a_symbol
;
2202 case_N_LCSYM
: /* Static symbol in BSS seg */
2203 case N_BSLINE
: /* Source line number, bss seg */
2204 /* N_BROWS: overlaps with N_BSLINE */
2205 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2206 goto define_a_symbol
;
2208 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2209 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2210 goto define_a_symbol
;
2212 case N_ENTRY
: /* Alternate entry point */
2213 /* Relocate for dynamic loading */
2214 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2215 goto define_a_symbol
;
2217 /* The following symbol types we don't know how to process. Handle
2218 them in a "default" way, but complain to people who care. */
2220 case N_CATCH
: /* Exception handler catcher */
2221 case N_EHDECL
: /* Exception handler name */
2222 case N_PC
: /* Global symbol in Pascal */
2223 case N_M2C
: /* Modula-2 compilation unit */
2224 /* N_MOD2: overlaps with N_EHDECL */
2225 case N_SCOPE
: /* Modula-2 scope information */
2226 case N_ECOML
: /* End common (local name) */
2227 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2232 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2235 /* The following symbol types don't need the address field relocated,
2236 since it is either unused, or is absolute. */
2238 case N_GSYM
: /* Global variable */
2239 case N_NSYMS
: /* Number of symbols (ultrix) */
2240 case N_NOMAP
: /* No map? (ultrix) */
2241 case N_RSYM
: /* Register variable */
2242 case N_DEFD
: /* Modula-2 GNU module dependency */
2243 case N_SSYM
: /* Struct or union element */
2244 case N_LSYM
: /* Local symbol in stack */
2245 case N_PSYM
: /* Parameter variable */
2246 case N_LENG
: /* Length of preceding symbol type */
2250 char *colon_pos
= strchr (name
, ':');
2251 if (colon_pos
== NULL
)
2254 deftype
= colon_pos
[1];
2260 function_stab_type
= type
;
2262 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2263 /* Deal with the SunPRO 3.0 compiler which omits the address
2264 from N_FUN symbols. */
2266 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2268 struct minimal_symbol
*msym
;
2272 p
= strchr (name
, ':');
2277 strncpy (p
, name
, n
);
2280 msym
= lookup_minimal_symbol (p
, last_source_file
,
2283 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2287 #ifdef SUN_FIXED_LBRAC_BUG
2288 /* The Sun acc compiler, under SunOS4, puts out
2289 functions with N_GSYM or N_STSYM. The problem is
2290 that the address of the symbol is no good (for N_GSYM
2291 it doesn't even attept an address; for N_STSYM it
2292 puts out an address but then it gets relocated
2293 relative to the data segment, not the text segment).
2294 Currently we can't fix this up later as we do for
2295 some types of symbol in scan_file_globals.
2296 Fortunately we do have a way of finding the address -
2297 we know that the value in last_pc_address is either
2298 the one we want (if we're dealing with the first
2299 function in an object file), or somewhere in the
2300 previous function. This means that we can use the
2301 minimal symbol table to get the address. */
2303 /* Starting with release 3.0, the Sun acc compiler,
2304 under SunOS4, puts out functions with N_FUN and a value
2305 of zero. This gets relocated to the start of the text
2306 segment of the module, which is no good either.
2307 Under SunOS4 we can deal with this as N_SLINE and N_SO
2308 entries contain valid absolute addresses.
2309 Release 3.0 acc also puts out N_OPT entries, which makes
2310 it possible to discern acc from cc or gcc. */
2312 if (type
== N_GSYM
|| type
== N_STSYM
2314 && n_opt_found
&& !block_address_function_relative
))
2316 struct minimal_symbol
*m
;
2317 int l
= colon_pos
- name
;
2319 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2320 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2321 && SYMBOL_NAME (m
) [l
] == '\0')
2322 /* last_pc_address was in this function */
2323 valu
= SYMBOL_VALUE (m
);
2324 else if (m
&& SYMBOL_NAME (m
+1)
2325 && STREQN (SYMBOL_NAME (m
+1), name
, l
)
2326 && SYMBOL_NAME (m
+1) [l
] == '\0')
2327 /* last_pc_address was in last function */
2328 valu
= SYMBOL_VALUE (m
+1);
2330 /* Not found - use last_pc_address (for finish_block) */
2331 valu
= last_pc_address
;
2334 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2337 if (block_address_function_relative
)
2338 /* For Solaris 2.0 compilers, the block addresses and
2339 N_SLINE's are relative to the start of the
2340 function. On normal systems, and when using gcc on
2341 Solaris 2.0, these addresses are just absolute, or
2342 relative to the N_SO, depending on
2343 BLOCK_ADDRESS_ABSOLUTE. */
2344 function_start_offset
= valu
;
2346 within_function
= 1;
2347 if (context_stack_depth
> 0)
2349 new = pop_context ();
2350 /* Make a block for the local symbols within. */
2351 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2352 new->start_addr
, valu
, objfile
);
2354 /* Stack must be empty now. */
2355 if (context_stack_depth
!= 0)
2356 complain (&lbrac_unmatched_complaint
, symnum
);
2358 new = push_context (0, valu
);
2359 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2363 define_symbol (valu
, name
, desc
, type
, objfile
);
2369 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2370 for a bunch of other flags, too. Someday we may parse their
2371 flags; for now we ignore theirs and hope they'll ignore ours. */
2372 case N_OPT
: /* Solaris 2: Compiler options */
2375 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2377 processing_gcc_compilation
= 2;
2378 #if 1 /* Works, but is experimental. -fnf */
2379 if (AUTO_DEMANGLING
)
2381 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2390 /* The following symbol types can be ignored. */
2391 case N_OBJ
: /* Solaris 2: Object file dir and name */
2392 /* N_UNDF: Solaris 2: file separator mark */
2393 /* N_UNDF: -- we will never encounter it, since we only process one
2394 file's symbols at once. */
2395 case N_ENDM
: /* Solaris 2: End of module */
2396 case N_MAIN
: /* Name of main routine. */
2400 /* '#' is a GNU C extension to allow one symbol to refer to another
2403 Generally this is used so that an alias can refer to its main
2407 /* Initialize symbol reference names and determine if this is
2408 a definition. If symbol reference is being defined, go
2409 ahead and add it. Otherwise, just return sym. */
2414 /* If this stab defines a new reference ID that is not on the
2415 reference list, then put it on the reference list.
2417 We go ahead and advance NAME past the reference, even though
2418 it is not strictly necessary at this time. */
2419 if (refnum
= symbol_reference_defined (&s
), refnum
)
2420 if (!ref_search (refnum
))
2421 ref_add (refnum
, 0, name
, valu
);
2426 previous_stab_code
= type
;
2429 /* FIXME: The only difference between this and elfstab_build_psymtabs
2430 is the call to install_minimal_symbols for elf, and the support for
2431 split sections. If the differences are really that small, the code
2432 should be shared. */
2434 /* Scan and build partial symbols for an coff symbol file.
2435 The coff file has already been processed to get its minimal symbols.
2437 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2440 OBJFILE is the object file we are reading symbols from.
2441 ADDR is the address relative to which the symbols are (e.g.
2442 the base address of the text segment).
2443 MAINLINE is true if we are reading the main symbol
2444 table (as opposed to a shared lib or dynamically loaded file).
2445 TEXTADDR is the address of the text section.
2446 TEXTSIZE is the size of the text section.
2447 STABSECTS is the list of .stab sections in OBJFILE.
2448 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2449 .stabstr section exists.
2451 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2452 adjusted for coff details. */
2455 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2456 textaddr
, textsize
, stabsects
,
2457 stabstroffset
, stabstrsize
)
2458 struct objfile
*objfile
;
2459 struct section_offsets
*section_offsets
;
2462 unsigned int textsize
;
2463 struct stab_section_list
*stabsects
;
2464 file_ptr stabstroffset
;
2465 unsigned int stabstrsize
;
2468 bfd
*sym_bfd
= objfile
->obfd
;
2469 char *name
= bfd_get_filename (sym_bfd
);
2470 struct dbx_symfile_info
*info
;
2471 unsigned int stabsize
;
2473 /* There is already a dbx_symfile_info allocated by our caller.
2474 It might even contain some info from the coff symtab to help us. */
2475 info
= objfile
->sym_stab_info
;
2477 DBX_TEXT_ADDR (objfile
) = textaddr
;
2478 DBX_TEXT_SIZE (objfile
) = textsize
;
2480 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2481 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2482 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2484 if (stabstrsize
> bfd_get_size (sym_bfd
))
2485 error ("ridiculous string table size: %d bytes", stabstrsize
);
2486 DBX_STRINGTAB (objfile
) = (char *)
2487 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2488 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2490 /* Now read in the string table in one big gulp. */
2492 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2494 perror_with_name (name
);
2495 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2496 if (val
!= stabstrsize
)
2497 perror_with_name (name
);
2499 stabsread_new_init ();
2500 buildsym_new_init ();
2501 free_header_files ();
2502 init_header_files ();
2504 processing_acc_compilation
= 1;
2506 /* In a coff file, we've already installed the minimal symbols that came
2507 from the coff (non-stab) symbol table, so always act like an
2508 incremental load here. */
2509 if (stabsects
->next
== NULL
)
2511 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2512 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2513 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2517 struct stab_section_list
*stabsect
;
2519 DBX_SYMCOUNT (objfile
) = 0;
2520 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2522 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2523 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2526 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2528 symbuf_sections
= stabsects
->next
;
2529 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2533 dbx_symfile_read (objfile
, section_offsets
, 0);
2536 /* Scan and build partial symbols for an ELF symbol file.
2537 This ELF file has already been processed to get its minimal symbols,
2538 and any DWARF symbols that were in it.
2540 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2543 OBJFILE is the object file we are reading symbols from.
2544 ADDR is the address relative to which the symbols are (e.g.
2545 the base address of the text segment).
2546 MAINLINE is true if we are reading the main symbol
2547 table (as opposed to a shared lib or dynamically loaded file).
2548 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2550 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2551 .stabstr section exists.
2553 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2554 adjusted for elf details. */
2557 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2558 staboffset
, stabsize
,
2559 stabstroffset
, stabstrsize
)
2560 struct objfile
*objfile
;
2561 struct section_offsets
*section_offsets
;
2563 file_ptr staboffset
;
2564 unsigned int stabsize
;
2565 file_ptr stabstroffset
;
2566 unsigned int stabstrsize
;
2569 bfd
*sym_bfd
= objfile
->obfd
;
2570 char *name
= bfd_get_filename (sym_bfd
);
2571 struct dbx_symfile_info
*info
;
2572 asection
*text_sect
;
2574 /* There is already a dbx_symfile_info allocated by our caller.
2575 It might even contain some info from the ELF symtab to help us. */
2576 info
= objfile
->sym_stab_info
;
2578 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
2580 error ("Can't find .text section in symbol file");
2581 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2582 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2584 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2585 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2586 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2587 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2588 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2590 if (stabstrsize
> bfd_get_size (sym_bfd
))
2591 error ("ridiculous string table size: %d bytes", stabstrsize
);
2592 DBX_STRINGTAB (objfile
) = (char *)
2593 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2594 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2596 /* Now read in the string table in one big gulp. */
2598 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2600 perror_with_name (name
);
2601 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2602 if (val
!= stabstrsize
)
2603 perror_with_name (name
);
2605 stabsread_new_init ();
2606 buildsym_new_init ();
2607 free_header_files ();
2608 init_header_files ();
2609 install_minimal_symbols (objfile
);
2611 processing_acc_compilation
= 1;
2613 /* In an elf file, we've already installed the minimal symbols that came
2614 from the elf (non-stab) symbol table, so always act like an
2615 incremental load here. */
2616 dbx_symfile_read (objfile
, section_offsets
, 0);
2619 /* Scan and build partial symbols for a file with special sections for stabs
2620 and stabstrings. The file has already been processed to get its minimal
2621 symbols, and any other symbols that might be necessary to resolve GSYMs.
2623 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2626 OBJFILE is the object file we are reading symbols from.
2627 ADDR is the address relative to which the symbols are (e.g. the base address
2628 of the text segment).
2629 MAINLINE is true if we are reading the main symbol table (as opposed to a
2630 shared lib or dynamically loaded file).
2631 STAB_NAME is the name of the section that contains the stabs.
2632 STABSTR_NAME is the name of the section that contains the stab strings.
2634 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2637 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2638 stabstr_name
, text_name
)
2639 struct objfile
*objfile
;
2640 struct section_offsets
*section_offsets
;
2647 bfd
*sym_bfd
= objfile
->obfd
;
2648 char *name
= bfd_get_filename (sym_bfd
);
2650 asection
*stabstrsect
;
2651 asection
*text_sect
;
2653 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2654 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2660 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2661 stab_name
, stabstr_name
);
2663 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2664 memset (objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
2666 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2668 error ("Can't find %s section in symbol file", text_name
);
2669 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2670 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2672 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2673 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2674 / DBX_SYMBOL_SIZE (objfile
);
2675 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2676 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2678 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2679 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2680 DBX_STRINGTAB (objfile
) = (char *)
2681 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2682 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2684 /* Now read in the string table in one big gulp. */
2686 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2687 stabstrsect
, /* bfd section */
2688 DBX_STRINGTAB (objfile
), /* input buffer */
2689 0, /* offset into section */
2690 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2693 perror_with_name (name
);
2695 stabsread_new_init ();
2696 buildsym_new_init ();
2697 free_header_files ();
2698 init_header_files ();
2699 install_minimal_symbols (objfile
);
2701 /* Now, do an incremental load */
2703 processing_acc_compilation
= 1;
2704 dbx_symfile_read (objfile
, section_offsets
, 0);
2707 static struct sym_fns aout_sym_fns
=
2709 bfd_target_aout_flavour
,
2710 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2711 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2712 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2713 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2714 default_symfile_offsets
,
2715 /* sym_offsets: parse user's offsets to internal form */
2716 NULL
/* next: pointer to next struct sym_fns */
2720 _initialize_dbxread ()
2722 add_symtab_fns(&aout_sym_fns
);