1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This module provides three functions: dbx_symfile_init,
23 which initializes to read a symbol file; dbx_new_init, which
24 discards existing cached information when all symbols are being
25 discarded; and dbx_symfile_read, which reads a symbol table
28 dbx_symfile_read only does the minimum work necessary for letting the
29 user "name" things symbolically; it does not read the entire symtab.
30 Instead, it reads the external and static symbols and puts them in partial
31 symbol tables. When more extensive information is requested of a
32 file, the corresponding partial symbol table is mutated into a full
33 fledged symbol table by going back and reading the symbols
34 for real. dbx_psymtab_to_symtab() is the function that does this */
37 #include "gdb_string.h"
39 #if defined(USG) || defined(__CYGNUSCLIB__)
40 #include <sys/types.h>
48 #include "breakpoint.h"
51 #include "gdbcore.h" /* for bfd stuff */
52 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
56 #include "stabsread.h"
57 #include "gdb-stabs.h"
59 #include "language.h" /* Needed inside partial-stab.h */
60 #include "complaints.h"
62 #include "aout/aout64.h"
63 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
66 /* This macro returns the size field of a minimal symbol, which is normally
67 stored in the "info" field. The macro can be overridden for specific
68 targets (e.g. MIPS16) that use the info field for other purposes. */
70 #define MSYMBOL_SIZE(msym) ((long) MSYMBOL_INFO (msym))
74 /* We put a pointer to this structure in the read_symtab_private field
80 /* Offset within the file symbol table of first local symbol for this
85 /* Length (in bytes) of the section of the symbol table devoted to
86 this file's symbols (actually, the section bracketed may contain
87 more than just this file's symbols). If ldsymlen is 0, the only
88 reason for this thing's existence is the dependency list. Nothing
89 else will happen when it is read in. */
93 /* The size of each symbol in the symbol file (in external form). */
97 /* Further information needed to locate the symbols if they are in
102 int file_string_offset
;
105 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
106 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
107 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
108 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
109 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
110 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
111 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
114 /* Remember what we deduced to be the source language of this psymtab. */
116 static enum language psymtab_language
= language_unknown
;
118 /* Nonzero means give verbose info on gdb action. From main.c. */
120 extern int info_verbose
;
122 /* The BFD for this file -- implicit parameter to next_symbol_text. */
124 static bfd
*symfile_bfd
;
126 /* The size of each symbol in the symbol file (in external form).
127 This is set by dbx_symfile_read when building psymtabs, and by
128 dbx_psymtab_to_symtab when building symtabs. */
130 static unsigned symbol_size
;
132 /* This is the offset of the symbol table in the executable file. */
134 static unsigned symbol_table_offset
;
136 /* This is the offset of the string table in the executable file. */
138 static unsigned string_table_offset
;
140 /* For elf+stab executables, the n_strx field is not a simple index
141 into the string table. Instead, each .o file has a base offset in
142 the string table, and the associated symbols contain offsets from
143 this base. The following two variables contain the base offset for
144 the current and next .o files. */
146 static unsigned int file_string_table_offset
;
147 static unsigned int next_file_string_table_offset
;
149 /* .o and NLM files contain unrelocated addresses which are based at
150 0. When non-zero, this flag disables some of the special cases for
151 Solaris elf+stab text addresses at location 0. */
153 static int symfile_relocatable
= 0;
155 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are
156 relative to the function start address. */
158 static int block_address_function_relative
= 0;
160 /* The lowest text address we have yet encountered. This is needed
161 because in an a.out file, there is no header field which tells us
162 what address the program is actually going to be loaded at, so we
163 need to make guesses based on the symbols (which *are* relocated to
164 reflect the address it will be loaded at). */
166 static CORE_ADDR lowest_text_address
;
168 /* Non-zero if there is any line number info in the objfile. Prevents
169 end_psymtab from discarding an otherwise empty psymtab. */
171 static int has_line_numbers
;
173 /* Complaints about the symbols we have encountered. */
175 struct complaint lbrac_complaint
=
176 {"bad block start address patched", 0, 0};
178 struct complaint string_table_offset_complaint
=
179 {"bad string table offset in symbol %d", 0, 0};
181 struct complaint unknown_symtype_complaint
=
182 {"unknown symbol type %s", 0, 0};
184 struct complaint unknown_symchar_complaint
=
185 {"unknown symbol descriptor `%c'", 0, 0};
187 struct complaint lbrac_rbrac_complaint
=
188 {"block start larger than block end", 0, 0};
190 struct complaint lbrac_unmatched_complaint
=
191 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
193 struct complaint lbrac_mismatch_complaint
=
194 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
196 struct complaint repeated_header_complaint
=
197 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
199 struct complaint unclaimed_bincl_complaint
=
200 {"N_BINCL %s not in entries for any file, at symtab pos %d", 0, 0};
202 /* find_text_range --- find start and end of loadable code sections
204 The find_text_range function finds the shortest address range that
205 encloses all sections containing executable code, and stores it in
206 objfile's text_addr and text_size members.
208 dbx_symfile_read will use this to finish off the partial symbol
209 table, in some cases. */
212 find_text_range (bfd
* sym_bfd
, struct objfile
*objfile
)
216 CORE_ADDR start
, end
;
218 for (sec
= sym_bfd
->sections
; sec
; sec
= sec
->next
)
219 if (bfd_get_section_flags (sym_bfd
, sec
) & SEC_CODE
)
221 CORE_ADDR sec_start
= bfd_section_vma (sym_bfd
, sec
);
222 CORE_ADDR sec_end
= sec_start
+ bfd_section_size (sym_bfd
, sec
);
226 if (sec_start
< start
)
241 error ("Can't find any code sections in symbol file");
243 DBX_TEXT_ADDR (objfile
) = start
;
244 DBX_TEXT_SIZE (objfile
) = end
- start
;
249 /* During initial symbol readin, we need to have a structure to keep
250 track of which psymtabs have which bincls in them. This structure
251 is used during readin to setup the list of dependencies within each
252 partial symbol table. */
254 struct header_file_location
256 char *name
; /* Name of header file */
257 int instance
; /* See above */
258 struct partial_symtab
*pst
; /* Partial symtab that has the
259 BINCL/EINCL defs for this file */
262 /* The actual list and controling variables */
263 static struct header_file_location
*bincl_list
, *next_bincl
;
264 static int bincls_allocated
;
266 /* Local function prototypes */
268 extern void _initialize_dbxread
PARAMS ((void));
271 process_now
PARAMS ((struct objfile
*));
274 free_header_files
PARAMS ((void));
277 init_header_files
PARAMS ((void));
280 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
283 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
286 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
289 read_dbx_dynamic_symtab
PARAMS ((struct objfile
* objfile
));
292 read_dbx_symtab
PARAMS ((struct objfile
*, CORE_ADDR
, int));
295 free_bincl_list
PARAMS ((struct objfile
*));
297 static struct partial_symtab
*
298 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
301 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
304 init_bincl_list
PARAMS ((int, struct objfile
*));
307 dbx_next_symbol_text
PARAMS ((struct objfile
*));
310 fill_symbuf
PARAMS ((bfd
*));
313 dbx_symfile_init
PARAMS ((struct objfile
*));
316 dbx_new_init
PARAMS ((struct objfile
*));
319 dbx_symfile_read
PARAMS ((struct objfile
*, int));
322 dbx_symfile_finish
PARAMS ((struct objfile
*));
325 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
328 add_new_header_file
PARAMS ((char *, int));
331 add_old_header_file
PARAMS ((char *, int));
334 add_this_object_header_file
PARAMS ((int));
336 /* Free up old header file tables */
341 if (this_object_header_files
)
343 free ((PTR
) this_object_header_files
);
344 this_object_header_files
= NULL
;
346 n_allocated_this_object_header_files
= 0;
349 /* Allocate new header file tables */
354 n_allocated_this_object_header_files
= 10;
355 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
358 /* Add header file number I for this object file
359 at the next successive FILENUM. */
362 add_this_object_header_file (i
)
365 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
367 n_allocated_this_object_header_files
*= 2;
368 this_object_header_files
369 = (int *) xrealloc ((char *) this_object_header_files
,
370 n_allocated_this_object_header_files
* sizeof (int));
373 this_object_header_files
[n_this_object_header_files
++] = i
;
376 /* Add to this file an "old" header file, one already seen in
377 a previous object file. NAME is the header file's name.
378 INSTANCE is its instance code, to select among multiple
379 symbol tables for the same header file. */
382 add_old_header_file (name
, instance
)
386 register struct header_file
*p
= HEADER_FILES (current_objfile
);
389 for (i
= 0; i
< N_HEADER_FILES (current_objfile
); i
++)
390 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
392 add_this_object_header_file (i
);
395 complain (&repeated_header_complaint
, name
, symnum
);
398 /* Add to this file a "new" header file: definitions for its types follow.
399 NAME is the header file's name.
400 Most often this happens only once for each distinct header file,
401 but not necessarily. If it happens more than once, INSTANCE has
402 a different value each time, and references to the header file
403 use INSTANCE values to select among them.
405 dbx output contains "begin" and "end" markers for each new header file,
406 but at this level we just need to know which files there have been;
407 so we record the file when its "begin" is seen and ignore the "end". */
410 add_new_header_file (name
, instance
)
415 register struct header_file
*hfile
;
417 /* Make sure there is room for one more header file. */
419 i
= N_ALLOCATED_HEADER_FILES (current_objfile
);
421 if (N_HEADER_FILES (current_objfile
) == i
)
425 N_ALLOCATED_HEADER_FILES (current_objfile
) = 10;
426 HEADER_FILES (current_objfile
) = (struct header_file
*)
427 xmalloc (10 * sizeof (struct header_file
));
432 N_ALLOCATED_HEADER_FILES (current_objfile
) = i
;
433 HEADER_FILES (current_objfile
) = (struct header_file
*)
434 xrealloc ((char *) HEADER_FILES (current_objfile
),
435 (i
* sizeof (struct header_file
)));
439 /* Create an entry for this header file. */
441 i
= N_HEADER_FILES (current_objfile
)++;
442 hfile
= HEADER_FILES (current_objfile
) + i
;
443 hfile
->name
= savestring (name
, strlen (name
));
444 hfile
->instance
= instance
;
447 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
448 memset (hfile
->vector
, 0, 10 * sizeof (struct type
*));
450 add_this_object_header_file (i
);
454 static struct type
**
455 explicit_lookup_type (real_filenum
, index
)
456 int real_filenum
, index
;
458 register struct header_file
*f
= &HEADER_FILES (current_objfile
)[real_filenum
];
460 if (index
>= f
->length
)
463 f
->vector
= (struct type
**)
464 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
465 memset (&f
->vector
[f
->length
/ 2],
466 '\0', f
->length
* sizeof (struct type
*) / 2);
468 return &f
->vector
[index
];
473 record_minimal_symbol (name
, address
, type
, objfile
)
477 struct objfile
*objfile
;
479 enum minimal_symbol_type ms_type
;
481 asection
*bfd_section
;
487 section
= SECT_OFF_TEXT
;
488 bfd_section
= DBX_TEXT_SECTION (objfile
);
492 section
= SECT_OFF_DATA
;
493 bfd_section
= DBX_DATA_SECTION (objfile
);
497 section
= SECT_OFF_BSS
;
498 bfd_section
= DBX_BSS_SECTION (objfile
);
508 section
= SECT_OFF_DATA
;
509 bfd_section
= DBX_DATA_SECTION (objfile
);
512 /* I don't think this type actually exists; since a N_SETV is the result
513 of going over many .o files, it doesn't make sense to have one
515 ms_type
= mst_file_data
;
516 section
= SECT_OFF_DATA
;
517 bfd_section
= DBX_DATA_SECTION (objfile
);
524 ms_type
= mst_file_text
;
525 section
= SECT_OFF_TEXT
;
526 bfd_section
= DBX_TEXT_SECTION (objfile
);
529 ms_type
= mst_file_data
;
531 /* Check for __DYNAMIC, which is used by Sun shared libraries.
532 Record it as global even if it's local, not global, so
533 lookup_minimal_symbol can find it. We don't check symbol_leading_char
534 because for SunOS4 it always is '_'. */
535 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
538 /* Same with virtual function tables, both global and static. */
540 char *tempstring
= name
;
541 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
543 if (VTBL_PREFIX_P ((tempstring
)))
546 section
= SECT_OFF_DATA
;
547 bfd_section
= DBX_DATA_SECTION (objfile
);
550 ms_type
= mst_file_bss
;
551 section
= SECT_OFF_BSS
;
552 bfd_section
= DBX_BSS_SECTION (objfile
);
555 ms_type
= mst_unknown
;
561 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
562 && address
< lowest_text_address
)
563 lowest_text_address
= address
;
565 prim_record_minimal_symbol_and_info
566 (name
, address
, ms_type
, NULL
, section
, bfd_section
, objfile
);
569 /* Scan and build partial symbols for a symbol file.
570 We have been initialized by a call to dbx_symfile_init, which
571 put all the relevant info into a "struct dbx_symfile_info",
572 hung off the objfile structure.
574 SECTION_OFFSETS contains offsets relative to which the symbols in the
575 various sections are (depending where the sections were actually loaded).
576 MAINLINE is true if we are reading the main symbol
577 table (as opposed to a shared lib or dynamically loaded file). */
580 dbx_symfile_read (objfile
, mainline
)
581 struct objfile
*objfile
;
582 int mainline
; /* FIXME comments above */
586 struct cleanup
*back_to
;
588 val
= strlen (objfile
->name
);
590 sym_bfd
= objfile
->obfd
;
592 /* .o and .nlm files are relocatables with text, data and bss segs based at
593 0. This flag disables special (Solaris stabs-in-elf only) fixups for
594 symbols with a value of 0. */
596 symfile_relocatable
= bfd_get_file_flags (sym_bfd
) & HAS_RELOC
;
598 /* This is true for Solaris (and all other systems which put stabs
599 in sections, hopefully, since it would be silly to do things
600 differently from Solaris), and false for SunOS4 and other a.out
602 block_address_function_relative
=
603 ((0 == strncmp (bfd_get_target (sym_bfd
), "elf", 3))
604 || (0 == strncmp (bfd_get_target (sym_bfd
), "som", 3))
605 || (0 == strncmp (bfd_get_target (sym_bfd
), "coff", 4))
606 || (0 == strncmp (bfd_get_target (sym_bfd
), "pe", 2))
607 || (0 == strncmp (bfd_get_target (sym_bfd
), "nlm", 3)));
609 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
611 perror_with_name (objfile
->name
);
613 /* If we are reinitializing, or if we have never loaded syms yet, init */
615 || objfile
->global_psymbols
.size
== 0
616 || objfile
->static_psymbols
.size
== 0)
617 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
619 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
620 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
622 free_pending_blocks ();
623 back_to
= make_cleanup (really_free_pendings
, 0);
625 init_minimal_symbol_collection ();
626 make_cleanup ((make_cleanup_func
) discard_minimal_symbols
, 0);
628 /* Now that the symbol table data of the executable file are all in core,
629 process them and define symbols accordingly. */
631 read_dbx_symtab (objfile
,
632 DBX_TEXT_ADDR (objfile
),
633 DBX_TEXT_SIZE (objfile
));
635 /* Add the dynamic symbols. */
637 read_dbx_dynamic_symtab (objfile
);
639 /* Install any minimal symbols that have been collected as the current
640 minimal symbols for this objfile. */
642 install_minimal_symbols (objfile
);
644 do_cleanups (back_to
);
647 /* Initialize anything that needs initializing when a completely new
648 symbol file is specified (not just adding some symbols from another
649 file, e.g. a shared library). */
652 dbx_new_init (ignore
)
653 struct objfile
*ignore
;
655 stabsread_new_init ();
656 buildsym_new_init ();
657 init_header_files ();
661 /* dbx_symfile_init ()
662 is the dbx-specific initialization routine for reading symbols.
663 It is passed a struct objfile which contains, among other things,
664 the BFD for the file whose symbols are being read, and a slot for a pointer
665 to "private data" which we fill with goodies.
667 We read the string table into malloc'd space and stash a pointer to it.
669 Since BFD doesn't know how to read debug symbols in a format-independent
670 way (and may never do so...), we have to do it ourselves. We will never
671 be called unless this is an a.out (or very similar) file.
672 FIXME, there should be a cleaner peephole into the BFD environment here. */
674 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
677 dbx_symfile_init (objfile
)
678 struct objfile
*objfile
;
681 bfd
*sym_bfd
= objfile
->obfd
;
682 char *name
= bfd_get_filename (sym_bfd
);
684 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
686 /* Allocate struct to keep track of the symfile */
687 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
688 xmmalloc (objfile
->md
, sizeof (struct dbx_symfile_info
));
689 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
691 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
692 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
693 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
695 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
696 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
697 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
699 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
701 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
703 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
705 error ("Can't find .text section in symbol file");
706 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
707 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
709 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
710 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
711 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
713 /* Read the string table and stash it away in the psymbol_obstack. It is
714 only needed as long as we need to expand psymbols into full symbols,
715 so when we blow away the psymbol the string table goes away as well.
716 Note that gdb used to use the results of attempting to malloc the
717 string table, based on the size it read, as a form of sanity check
718 for botched byte swapping, on the theory that a byte swapped string
719 table size would be so totally bogus that the malloc would fail. Now
720 that we put in on the psymbol_obstack, we can't do this since gdb gets
721 a fatal error (out of virtual memory) if the size is bogus. We can
722 however at least check to see if the size is less than the size of
723 the size field itself, or larger than the size of the entire file.
724 Note that all valid string tables have a size greater than zero, since
725 the bytes used to hold the size are included in the count. */
727 if (STRING_TABLE_OFFSET
== 0)
729 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
730 will never be zero, even when there is no string table. This
731 would appear to be a bug in bfd. */
732 DBX_STRINGTAB_SIZE (objfile
) = 0;
733 DBX_STRINGTAB (objfile
) = NULL
;
737 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
739 perror_with_name (name
);
741 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
742 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
745 perror_with_name (name
);
749 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
750 EOF if there is no string table, and attempting to read the size
751 from EOF will read zero bytes. */
752 DBX_STRINGTAB_SIZE (objfile
) = 0;
753 DBX_STRINGTAB (objfile
) = NULL
;
757 /* Read some data that would appear to be the string table size.
758 If there really is a string table, then it is probably the right
759 size. Byteswap if necessary and validate the size. Note that
760 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
761 random data that happened to be at STRING_TABLE_OFFSET, because
762 bfd can't tell us there is no string table, the sanity checks may
763 or may not catch this. */
764 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
766 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
767 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
768 error ("ridiculous string table size (%d bytes).",
769 DBX_STRINGTAB_SIZE (objfile
));
771 DBX_STRINGTAB (objfile
) =
772 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
773 DBX_STRINGTAB_SIZE (objfile
));
774 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
776 /* Now read in the string table in one big gulp. */
778 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
780 perror_with_name (name
);
781 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
783 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
784 perror_with_name (name
);
789 /* Perform any local cleanups required when we are done with a particular
790 objfile. I.E, we are in the process of discarding all symbol information
791 for an objfile, freeing up all memory held for it, and unlinking the
792 objfile struct from the global list of known objfiles. */
795 dbx_symfile_finish (objfile
)
796 struct objfile
*objfile
;
798 if (objfile
->sym_stab_info
!= NULL
)
800 if (HEADER_FILES (objfile
) != NULL
)
802 register int i
= N_HEADER_FILES (objfile
);
803 register struct header_file
*hfiles
= HEADER_FILES (objfile
);
807 free (hfiles
[i
].name
);
808 free (hfiles
[i
].vector
);
812 mfree (objfile
->md
, objfile
->sym_stab_info
);
814 free_header_files ();
818 /* Buffer for reading the symbol table entries. */
819 static struct external_nlist symbuf
[4096];
820 static int symbuf_idx
;
821 static int symbuf_end
;
823 /* cont_elem is used for continuing information in cfront.
824 It saves information about which types need to be fixed up and
825 completed after all the stabs are read. */
828 /* sym and stabsstring for continuing information in cfront */
831 /* state dependancies (statics that must be preserved) */
835 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
836 /* other state dependancies include:
837 (assumption is that these will not change since process_now FIXME!!)
844 static struct cont_elem
*cont_list
= 0;
845 static int cont_limit
= 0;
846 static int cont_count
= 0;
848 /* Arrange for function F to be called with arguments SYM and P later
849 in the stabs reading process. */
851 process_later (sym
, p
, f
)
854 int (*f
) PARAMS ((struct objfile
*, struct symbol
*, char *));
857 /* Allocate more space for the deferred list. */
858 if (cont_count
>= cont_limit
- 1)
860 cont_limit
+= 32; /* chunk size */
863 = (struct cont_elem
*) xrealloc (cont_list
,
865 * sizeof (struct cont_elem
)));
867 error ("Virtual memory exhausted\n");
870 /* Save state variables so we can process these stabs later. */
871 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
872 cont_list
[cont_count
].sym_end
= symbuf_end
;
873 cont_list
[cont_count
].symnum
= symnum
;
874 cont_list
[cont_count
].sym
= sym
;
875 cont_list
[cont_count
].stabs
= p
;
876 cont_list
[cont_count
].func
= f
;
880 /* Call deferred funtions in CONT_LIST. */
883 process_now (objfile
)
884 struct objfile
*objfile
;
893 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
895 /* Save the state of our caller, we'll want to restore it before
897 save_symbuf_idx
= symbuf_idx
;
898 save_symbuf_end
= symbuf_end
;
899 save_symnum
= symnum
;
901 /* Iterate over all the deferred stabs. */
902 for (i
= 0; i
< cont_count
; i
++)
904 /* Restore the state for this deferred stab. */
905 symbuf_idx
= cont_list
[i
].sym_idx
;
906 symbuf_end
= cont_list
[i
].sym_end
;
907 symnum
= cont_list
[i
].symnum
;
908 sym
= cont_list
[i
].sym
;
909 stabs
= cont_list
[i
].stabs
;
910 func
= cont_list
[i
].func
;
912 /* Call the function to handle this deferrd stab. */
913 err
= (*func
) (objfile
, sym
, stabs
);
915 error ("Internal error: unable to resolve stab.\n");
918 /* Restore our caller's state. */
919 symbuf_idx
= save_symbuf_idx
;
920 symbuf_end
= save_symbuf_end
;
921 symnum
= save_symnum
;
926 /* Name of last function encountered. Used in Solaris to approximate
927 object file boundaries. */
928 static char *last_function_name
;
930 /* The address in memory of the string table of the object file we are
931 reading (which might not be the "main" object file, but might be a
932 shared library or some other dynamically loaded thing). This is
933 set by read_dbx_symtab when building psymtabs, and by
934 read_ofile_symtab when building symtabs, and is used only by
935 next_symbol_text. FIXME: If that is true, we don't need it when
936 building psymtabs, right? */
937 static char *stringtab_global
;
939 /* These variables are used to control fill_symbuf when the stabs
940 symbols are not contiguous (as may be the case when a COFF file is
941 linked using --split-by-reloc). */
942 static struct stab_section_list
*symbuf_sections
;
943 static unsigned int symbuf_left
;
944 static unsigned int symbuf_read
;
946 /* Refill the symbol table input buffer
947 and set the variables that control fetching entries from it.
948 Reports an error if no data available.
949 This function can read past the end of the symbol table
950 (into the string table) but this does no harm. */
953 fill_symbuf (sym_bfd
)
959 if (symbuf_sections
== NULL
)
960 count
= sizeof (symbuf
);
963 if (symbuf_left
<= 0)
965 file_ptr filepos
= symbuf_sections
->section
->filepos
;
966 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
967 perror_with_name (bfd_get_filename (sym_bfd
));
968 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
969 symbol_table_offset
= filepos
- symbuf_read
;
970 symbuf_sections
= symbuf_sections
->next
;
974 if (count
> sizeof (symbuf
))
975 count
= sizeof (symbuf
);
978 nbytes
= bfd_read ((PTR
) symbuf
, count
, 1, sym_bfd
);
980 perror_with_name (bfd_get_filename (sym_bfd
));
981 else if (nbytes
== 0)
982 error ("Premature end of file reading symbol table");
983 symbuf_end
= nbytes
/ symbol_size
;
985 symbuf_left
-= nbytes
;
986 symbuf_read
+= nbytes
;
989 #define SWAP_SYMBOL(symp, abfd) \
991 (symp)->n_strx = bfd_h_get_32(abfd, \
992 (unsigned char *)&(symp)->n_strx); \
993 (symp)->n_desc = bfd_h_get_16 (abfd, \
994 (unsigned char *)&(symp)->n_desc); \
995 (symp)->n_value = bfd_h_get_32 (abfd, \
996 (unsigned char *)&(symp)->n_value); \
999 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
1001 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
1002 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
1003 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
1004 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
1007 /* Invariant: The symbol pointed to by symbuf_idx is the first one
1008 that hasn't been swapped. Swap the symbol at the same time
1009 that symbuf_idx is incremented. */
1011 /* dbx allows the text of a symbol name to be continued into the
1012 next symbol name! When such a continuation is encountered
1013 (a \ at the end of the text of a name)
1014 call this function to get the continuation. */
1017 dbx_next_symbol_text (objfile
)
1018 struct objfile
*objfile
;
1020 struct internal_nlist nlist
;
1022 if (symbuf_idx
== symbuf_end
)
1023 fill_symbuf (symfile_bfd
);
1026 INTERNALIZE_SYMBOL (nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
1027 OBJSTAT (objfile
, n_stabs
++);
1031 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
1034 /* Initialize the list of bincls to contain none and have some
1038 init_bincl_list (number
, objfile
)
1040 struct objfile
*objfile
;
1042 bincls_allocated
= number
;
1043 next_bincl
= bincl_list
= (struct header_file_location
*)
1044 xmmalloc (objfile
->md
, bincls_allocated
* sizeof (struct header_file_location
));
1047 /* Add a bincl to the list. */
1050 add_bincl_to_list (pst
, name
, instance
)
1051 struct partial_symtab
*pst
;
1055 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1057 int offset
= next_bincl
- bincl_list
;
1058 bincls_allocated
*= 2;
1059 bincl_list
= (struct header_file_location
*)
1060 xmrealloc (pst
->objfile
->md
, (char *) bincl_list
,
1061 bincls_allocated
* sizeof (struct header_file_location
));
1062 next_bincl
= bincl_list
+ offset
;
1064 next_bincl
->pst
= pst
;
1065 next_bincl
->instance
= instance
;
1066 next_bincl
++->name
= name
;
1069 /* Given a name, value pair, find the corresponding
1070 bincl in the list. Return the partial symtab associated
1071 with that header_file_location. */
1073 static struct partial_symtab
*
1074 find_corresponding_bincl_psymtab (name
, instance
)
1078 struct header_file_location
*bincl
;
1080 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1081 if (bincl
->instance
== instance
1082 && STREQ (name
, bincl
->name
))
1085 complain (&repeated_header_complaint
, name
, symnum
);
1086 return (struct partial_symtab
*) 0;
1089 /* Free the storage allocated for the bincl list. */
1092 free_bincl_list (objfile
)
1093 struct objfile
*objfile
;
1095 mfree (objfile
->md
, (PTR
) bincl_list
);
1096 bincls_allocated
= 0;
1099 /* Scan a SunOs dynamic symbol table for symbols of interest and
1100 add them to the minimal symbol table. */
1103 read_dbx_dynamic_symtab (objfile
)
1104 struct objfile
*objfile
;
1106 bfd
*abfd
= objfile
->obfd
;
1107 struct cleanup
*back_to
;
1117 CORE_ADDR sym_value
;
1120 /* Check that the symbol file has dynamic symbols that we know about.
1121 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1122 on a sun4 host (and vice versa) and bfd is not configured
1123 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1124 so we ignore the dynamic symbols in this case. */
1125 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
1126 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
1127 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1130 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1131 if (dynsym_size
< 0)
1134 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1135 back_to
= make_cleanup (free
, dynsyms
);
1137 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1138 if (dynsym_count
< 0)
1140 do_cleanups (back_to
);
1144 /* Enter dynamic symbols into the minimal symbol table
1145 if this is a stripped executable. */
1146 if (bfd_get_symcount (abfd
) <= 0)
1149 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1151 asymbol
*sym
= *symptr
;
1155 sec
= bfd_get_section (sym
);
1157 /* BFD symbols are section relative. */
1158 sym_value
= sym
->value
+ sec
->vma
;
1160 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1162 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT
);
1165 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1167 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA
);
1170 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1172 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS
);
1178 if (sym
->flags
& BSF_GLOBAL
)
1181 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1186 /* Symbols from shared libraries have a dynamic relocation entry
1187 that points to the associated slot in the procedure linkage table.
1188 We make a mininal symbol table entry with type mst_solib_trampoline
1189 at the address in the procedure linkage table. */
1190 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1191 if (dynrel_size
< 0)
1193 do_cleanups (back_to
);
1197 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1198 make_cleanup (free
, dynrels
);
1200 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1201 if (dynrel_count
< 0)
1203 do_cleanups (back_to
);
1207 for (counter
= 0, relptr
= dynrels
;
1208 counter
< dynrel_count
;
1209 counter
++, relptr
++)
1211 arelent
*rel
= *relptr
;
1213 rel
->address
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA
);
1215 switch (bfd_get_arch (abfd
))
1217 case bfd_arch_sparc
:
1218 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1222 /* `16' is the type BFD produces for a jump table relocation. */
1223 if (rel
->howto
->type
!= 16)
1226 /* Adjust address in the jump table to point to
1227 the start of the bsr instruction. */
1234 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1235 prim_record_minimal_symbol (name
, address
, mst_solib_trampoline
,
1239 do_cleanups (back_to
);
1242 /* Given pointers to an a.out symbol table in core containing dbx
1243 style data, setup partial_symtab's describing each source file for
1244 which debugging information is available.
1245 SYMFILE_NAME is the name of the file we are reading from
1246 and SECTION_OFFSETS is the set of offsets for the various sections
1247 of the file (a set of zeros if the mainline program). */
1250 read_dbx_symtab (objfile
, text_addr
, text_size
)
1251 struct objfile
*objfile
;
1252 CORE_ADDR text_addr
;
1255 register struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1256 struct internal_nlist nlist
;
1258 register char *namestring
;
1260 int past_first_source_file
= 0;
1261 CORE_ADDR last_o_file_start
= 0;
1262 CORE_ADDR last_function_start
= 0;
1263 struct cleanup
*back_to
;
1265 int textlow_not_set
;
1267 /* Current partial symtab */
1268 struct partial_symtab
*pst
;
1270 /* List of current psymtab's include files */
1271 char **psymtab_include_list
;
1272 int includes_allocated
;
1275 /* Index within current psymtab dependency list */
1276 struct partial_symtab
**dependency_list
;
1277 int dependencies_used
, dependencies_allocated
;
1279 /* FIXME. We probably want to change stringtab_global rather than add this
1280 while processing every symbol entry. FIXME. */
1281 file_string_table_offset
= 0;
1282 next_file_string_table_offset
= 0;
1284 stringtab_global
= DBX_STRINGTAB (objfile
);
1286 pst
= (struct partial_symtab
*) 0;
1288 includes_allocated
= 30;
1290 psymtab_include_list
= (char **) alloca (includes_allocated
*
1293 dependencies_allocated
= 30;
1294 dependencies_used
= 0;
1296 (struct partial_symtab
**) alloca (dependencies_allocated
*
1297 sizeof (struct partial_symtab
*));
1299 /* Init bincl list */
1300 init_bincl_list (20, objfile
);
1301 back_to
= make_cleanup ((make_cleanup_func
) free_bincl_list
, objfile
);
1303 last_source_file
= NULL
;
1305 lowest_text_address
= (CORE_ADDR
) -1;
1307 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1308 abfd
= objfile
->obfd
;
1309 symbuf_end
= symbuf_idx
= 0;
1310 next_symbol_text_func
= dbx_next_symbol_text
;
1311 textlow_not_set
= 1;
1312 has_line_numbers
= 0;
1314 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1316 /* Get the symbol for this run and pull out some info */
1317 QUIT
; /* allow this to be interruptable */
1318 if (symbuf_idx
== symbuf_end
)
1320 bufp
= &symbuf
[symbuf_idx
++];
1323 * Special case to speed up readin.
1325 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1327 has_line_numbers
= 1;
1331 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1332 OBJSTAT (objfile
, n_stabs
++);
1334 /* Ok. There is a lot of code duplicated in the rest of this
1335 switch statement (for efficiency reasons). Since I don't
1336 like duplicating code, I will do my penance here, and
1337 describe the code which is duplicated:
1339 *) The assignment to namestring.
1340 *) The call to strchr.
1341 *) The addition of a partial symbol the the two partial
1342 symbol lists. This last is a large section of code, so
1343 I've imbedded it in the following macro.
1346 /* Set namestring based on nlist. If the string table index is invalid,
1347 give a fake name, and print a single error message per symbol file read,
1348 rather than abort the symbol reading or flood the user with messages. */
1350 /*FIXME: Too many adds and indirections in here for the inner loop. */
1351 #define SET_NAMESTRING()\
1352 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1353 DBX_STRINGTAB_SIZE (objfile)) { \
1354 complain (&string_table_offset_complaint, symnum); \
1355 namestring = "<bad string table offset>"; \
1357 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1358 DBX_STRINGTAB (objfile)
1360 #define CUR_SYMBOL_TYPE nlist.n_type
1361 #define CUR_SYMBOL_VALUE nlist.n_value
1362 #define CUR_SYMBOL_STRX nlist.n_strx
1363 #define DBXREAD_ONLY
1364 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1365 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1366 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1367 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1369 #include "partial-stab.h"
1372 /* If there's stuff to be cleaned up, clean it up. */
1373 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1374 /*FIXME, does this have a bug at start address 0? */
1375 && last_o_file_start
1376 && objfile
->ei
.entry_point
< nlist
.n_value
1377 && objfile
->ei
.entry_point
>= last_o_file_start
)
1379 objfile
->ei
.entry_file_lowpc
= last_o_file_start
;
1380 objfile
->ei
.entry_file_highpc
= nlist
.n_value
;
1385 /* Don't set pst->texthigh lower than it already is. */
1386 CORE_ADDR text_end
=
1387 (lowest_text_address
== (CORE_ADDR
) -1
1388 ? (text_addr
+ objfile
->section_offsets
->offsets
[SECT_OFF_TEXT
])
1389 : lowest_text_address
)
1392 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1393 symnum
* symbol_size
,
1394 text_end
> pst
->texthigh
? text_end
: pst
->texthigh
,
1395 dependency_list
, dependencies_used
, textlow_not_set
);
1398 do_cleanups (back_to
);
1401 /* Allocate and partially fill a partial symtab. It will be
1402 completely filled at the end of the symbol list.
1404 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1405 is the address relative to which its symbols are (incremental) or 0
1409 struct partial_symtab
*
1410 start_psymtab (objfile
, section_offsets
,
1411 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1412 struct objfile
*objfile
;
1413 struct section_offsets
*section_offsets
;
1417 struct partial_symbol
**global_syms
;
1418 struct partial_symbol
**static_syms
;
1420 struct partial_symtab
*result
=
1421 start_psymtab_common (objfile
, section_offsets
,
1422 filename
, textlow
, global_syms
, static_syms
);
1424 result
->read_symtab_private
= (char *)
1425 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1426 LDSYMOFF (result
) = ldsymoff
;
1427 result
->read_symtab
= dbx_psymtab_to_symtab
;
1428 SYMBOL_SIZE (result
) = symbol_size
;
1429 SYMBOL_OFFSET (result
) = symbol_table_offset
;
1430 STRING_OFFSET (result
) = string_table_offset
;
1431 FILE_STRING_OFFSET (result
) = file_string_table_offset
;
1433 /* If we're handling an ELF file, drag some section-relocation info
1434 for this source file out of the ELF symbol table, to compensate for
1435 Sun brain death. This replaces the section_offsets in this psymtab,
1437 elfstab_offset_sections (objfile
, result
);
1439 /* Deduce the source language from the filename for this psymtab. */
1440 psymtab_language
= deduce_language_from_filename (filename
);
1445 /* Close off the current usage of PST.
1446 Returns PST or NULL if the partial symtab was empty and thrown away.
1448 FIXME: List variables and peculiarities of same. */
1450 struct partial_symtab
*
1451 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1452 capping_text
, dependency_list
, number_dependencies
, textlow_not_set
)
1453 struct partial_symtab
*pst
;
1454 char **include_list
;
1456 int capping_symbol_offset
;
1457 CORE_ADDR capping_text
;
1458 struct partial_symtab
**dependency_list
;
1459 int number_dependencies
;
1460 int textlow_not_set
;
1463 struct objfile
*objfile
= pst
->objfile
;
1465 if (capping_symbol_offset
!= -1)
1466 LDSYMLEN (pst
) = capping_symbol_offset
- LDSYMOFF (pst
);
1467 pst
->texthigh
= capping_text
;
1469 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1470 /* Under Solaris, the N_SO symbols always have a value of 0,
1471 instead of the usual address of the .o file. Therefore,
1472 we have to do some tricks to fill in texthigh and textlow.
1473 The first trick is in partial-stab.h: if we see a static
1474 or global function, and the textlow for the current pst
1475 is not set (ie: textlow_not_set), then we use that function's
1476 address for the textlow of the pst. */
1478 /* Now, to fill in texthigh, we remember the last function seen
1479 in the .o file (also in partial-stab.h). Also, there's a hack in
1480 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1481 to here via the misc_info field. Therefore, we can fill in
1482 a reliable texthigh by taking the address plus size of the
1483 last function in the file. */
1485 if (pst
->texthigh
== 0 && last_function_name
)
1489 struct minimal_symbol
*minsym
;
1491 p
= strchr (last_function_name
, ':');
1493 p
= last_function_name
;
1494 n
= p
- last_function_name
;
1496 strncpy (p
, last_function_name
, n
);
1499 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1502 /* Sun Fortran appends an underscore to the minimal symbol name,
1503 try again with an appended underscore if the minimal symbol
1507 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1511 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) + MSYMBOL_SIZE (minsym
);
1513 last_function_name
= NULL
;
1516 /* this test will be true if the last .o file is only data */
1517 if (textlow_not_set
)
1518 pst
->textlow
= pst
->texthigh
;
1521 struct partial_symtab
*p1
;
1523 /* If we know our own starting text address, then walk through all other
1524 psymtabs for this objfile, and if any didn't know their ending text
1525 address, set it to our starting address. Take care to not set our
1526 own ending address to our starting address, nor to set addresses on
1527 `dependency' files that have both textlow and texthigh zero. */
1529 ALL_OBJFILE_PSYMTABS (objfile
, p1
)
1531 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
)
1533 p1
->texthigh
= pst
->textlow
;
1534 /* if this file has only data, then make textlow match texthigh */
1535 if (p1
->textlow
== 0)
1536 p1
->textlow
= p1
->texthigh
;
1541 /* End of kludge for patching Solaris textlow and texthigh. */
1542 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1544 pst
->n_global_syms
=
1545 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1546 pst
->n_static_syms
=
1547 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1549 pst
->number_of_dependencies
= number_dependencies
;
1550 if (number_dependencies
)
1552 pst
->dependencies
= (struct partial_symtab
**)
1553 obstack_alloc (&objfile
->psymbol_obstack
,
1554 number_dependencies
* sizeof (struct partial_symtab
*));
1555 memcpy (pst
->dependencies
, dependency_list
,
1556 number_dependencies
* sizeof (struct partial_symtab
*));
1559 pst
->dependencies
= 0;
1561 for (i
= 0; i
< num_includes
; i
++)
1563 struct partial_symtab
*subpst
=
1564 allocate_psymtab (include_list
[i
], objfile
);
1566 subpst
->section_offsets
= pst
->section_offsets
;
1567 subpst
->read_symtab_private
=
1568 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1569 sizeof (struct symloc
));
1573 subpst
->texthigh
= 0;
1575 /* We could save slight bits of space by only making one of these,
1576 shared by the entire set of include files. FIXME-someday. */
1577 subpst
->dependencies
= (struct partial_symtab
**)
1578 obstack_alloc (&objfile
->psymbol_obstack
,
1579 sizeof (struct partial_symtab
*));
1580 subpst
->dependencies
[0] = pst
;
1581 subpst
->number_of_dependencies
= 1;
1583 subpst
->globals_offset
=
1584 subpst
->n_global_syms
=
1585 subpst
->statics_offset
=
1586 subpst
->n_static_syms
= 0;
1590 subpst
->read_symtab
= pst
->read_symtab
;
1593 sort_pst_symbols (pst
);
1595 /* If there is already a psymtab or symtab for a file of this name, remove it.
1596 (If there is a symtab, more drastic things also happen.)
1597 This happens in VxWorks. */
1598 free_named_symtabs (pst
->filename
);
1600 if (num_includes
== 0
1601 && number_dependencies
== 0
1602 && pst
->n_global_syms
== 0
1603 && pst
->n_static_syms
== 0
1604 && has_line_numbers
== 0)
1606 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1607 it is on the obstack, but we can forget to chain it on the list. */
1608 /* Empty psymtabs happen as a result of header files which don't have
1609 any symbols in them. There can be a lot of them. But this check
1610 is wrong, in that a psymtab with N_SLINE entries but nothing else
1611 is not empty, but we don't realize that. Fixing that without slowing
1612 things down might be tricky. */
1614 discard_psymtab (pst
);
1616 /* Indicate that psymtab was thrown away. */
1617 pst
= (struct partial_symtab
*) NULL
;
1623 dbx_psymtab_to_symtab_1 (pst
)
1624 struct partial_symtab
*pst
;
1626 struct cleanup
*old_chain
;
1634 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1639 /* Read in all partial symtabs on which this one is dependent */
1640 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1641 if (!pst
->dependencies
[i
]->readin
)
1643 /* Inform about additional files that need to be read in. */
1646 fputs_filtered (" ", gdb_stdout
);
1648 fputs_filtered ("and ", gdb_stdout
);
1650 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1651 wrap_here (""); /* Flush output */
1652 gdb_flush (gdb_stdout
);
1654 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1657 if (LDSYMLEN (pst
)) /* Otherwise it's a dummy */
1659 /* Init stuff necessary for reading in symbols */
1662 old_chain
= make_cleanup (really_free_pendings
, 0);
1663 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1664 symbol_size
= SYMBOL_SIZE (pst
);
1666 /* Read in this file's symbols */
1667 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1668 read_ofile_symtab (pst
);
1669 sort_symtab_syms (pst
->symtab
);
1671 do_cleanups (old_chain
);
1677 /* Read in all of the symbols for a given psymtab for real.
1678 Be verbose about it if the user wants that. */
1681 dbx_psymtab_to_symtab (pst
)
1682 struct partial_symtab
*pst
;
1691 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1696 if (LDSYMLEN (pst
) || pst
->number_of_dependencies
)
1698 /* Print the message now, before reading the string table,
1699 to avoid disconcerting pauses. */
1702 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1703 gdb_flush (gdb_stdout
);
1706 sym_bfd
= pst
->objfile
->obfd
;
1708 next_symbol_text_func
= dbx_next_symbol_text
;
1710 dbx_psymtab_to_symtab_1 (pst
);
1712 /* Match with global symbols. This only needs to be done once,
1713 after all of the symtabs and dependencies have been read in. */
1714 scan_file_globals (pst
->objfile
);
1716 /* Finish up the debug error message. */
1718 printf_filtered ("done.\n");
1722 /* Read in a defined section of a specific object file's symbols. */
1725 read_ofile_symtab (pst
)
1726 struct partial_symtab
*pst
;
1728 register char *namestring
;
1729 register struct external_nlist
*bufp
;
1730 struct internal_nlist nlist
;
1732 unsigned max_symnum
;
1734 struct objfile
*objfile
;
1735 int sym_offset
; /* Offset to start of symbols to read */
1736 int sym_size
; /* Size of symbols to read */
1737 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1738 int text_size
; /* Size of text segment for symbols */
1739 struct section_offsets
*section_offsets
;
1741 objfile
= pst
->objfile
;
1742 sym_offset
= LDSYMOFF (pst
);
1743 sym_size
= LDSYMLEN (pst
);
1744 text_offset
= pst
->textlow
;
1745 text_size
= pst
->texthigh
- pst
->textlow
;
1746 section_offsets
= pst
->section_offsets
;
1748 current_objfile
= objfile
;
1749 subfile_stack
= NULL
;
1751 stringtab_global
= DBX_STRINGTAB (objfile
);
1752 last_source_file
= NULL
;
1754 abfd
= objfile
->obfd
;
1755 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1756 symbuf_end
= symbuf_idx
= 0;
1758 /* It is necessary to actually read one symbol *before* the start
1759 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1760 occurs before the N_SO symbol.
1762 Detecting this in read_dbx_symtab
1763 would slow down initial readin, so we look for it here instead. */
1764 if (!processing_acc_compilation
&& sym_offset
>= (int) symbol_size
)
1766 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1768 bufp
= &symbuf
[symbuf_idx
++];
1769 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1770 OBJSTAT (objfile
, n_stabs
++);
1774 processing_gcc_compilation
= 0;
1775 if (nlist
.n_type
== N_TEXT
)
1777 const char *tempstring
= namestring
;
1779 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1780 processing_gcc_compilation
= 1;
1781 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1782 processing_gcc_compilation
= 2;
1783 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1785 if (STREQN (tempstring
, "__gnu_compiled", 14))
1786 processing_gcc_compilation
= 2;
1789 /* Try to select a C++ demangling based on the compilation unit
1792 if (processing_gcc_compilation
)
1794 if (AUTO_DEMANGLING
)
1796 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1802 /* The N_SO starting this symtab is the first symbol, so we
1803 better not check the symbol before it. I'm not this can
1804 happen, but it doesn't hurt to check for it. */
1805 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1806 processing_gcc_compilation
= 0;
1809 if (symbuf_idx
== symbuf_end
)
1811 bufp
= &symbuf
[symbuf_idx
];
1812 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
1813 error ("First symbol in segment of executable not a source symbol");
1815 max_symnum
= sym_size
/ symbol_size
;
1818 symnum
< max_symnum
;
1821 QUIT
; /* Allow this to be interruptable */
1822 if (symbuf_idx
== symbuf_end
)
1824 bufp
= &symbuf
[symbuf_idx
++];
1825 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1826 OBJSTAT (objfile
, n_stabs
++);
1828 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
1834 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
1835 namestring
, section_offsets
, objfile
);
1837 /* We skip checking for a new .o or -l file; that should never
1838 happen in this routine. */
1839 else if (type
== N_TEXT
)
1841 /* I don't think this code will ever be executed, because
1842 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1843 the N_SO symbol which starts this source file.
1844 However, there is no reason not to accept
1845 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1847 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1848 processing_gcc_compilation
= 1;
1849 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1850 processing_gcc_compilation
= 2;
1852 if (AUTO_DEMANGLING
)
1854 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1857 else if (type
& N_EXT
|| type
== (unsigned char) N_TEXT
1858 || type
== (unsigned char) N_NBTEXT
1861 /* Global symbol: see if we came across a dbx defintion for
1862 a corresponding symbol. If so, store the value. Remove
1863 syms from the chain when their values are stored, but
1864 search the whole chain, as there may be several syms from
1865 different files with the same name. */
1866 /* This is probably not true. Since the files will be read
1867 in one at a time, each reference to a global symbol will
1868 be satisfied in each file as it appears. So we skip this
1874 current_objfile
= NULL
;
1876 /* In a Solaris elf file, this variable, which comes from the
1877 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1878 which comes from pst->textlow is correct. */
1879 if (last_source_start_addr
== 0)
1880 last_source_start_addr
= text_offset
;
1882 /* In reordered executables last_source_start_addr may not be the
1883 lower bound for this symtab, instead use text_offset which comes
1884 from pst->textlow which is correct. */
1885 if (last_source_start_addr
> text_offset
)
1886 last_source_start_addr
= text_offset
;
1888 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1890 /* Process items which we had to "process_later" due to dependancies
1892 process_now (objfile
);
1898 /* This handles a single symbol from the symbol-file, building symbols
1899 into a GDB symtab. It takes these arguments and an implicit argument.
1901 TYPE is the type field of the ".stab" symbol entry.
1902 DESC is the desc field of the ".stab" entry.
1903 VALU is the value field of the ".stab" entry.
1904 NAME is the symbol name, in our address space.
1905 SECTION_OFFSETS is a set of amounts by which the sections of this object
1906 file were relocated when it was loaded into memory.
1907 All symbols that refer
1908 to memory locations need to be offset by these amounts.
1909 OBJFILE is the object file from which we are reading symbols.
1910 It is used in end_symtab. */
1913 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1917 struct section_offsets
*section_offsets
;
1918 struct objfile
*objfile
;
1920 #ifdef SUN_FIXED_LBRAC_BUG
1921 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1922 to correct the address of N_LBRAC's. If it is not defined, then
1923 we never need to correct the addresses. */
1925 /* This records the last pc address we've seen. We depend on there being
1926 an SLINE or FUN or SO before the first LBRAC, since the variable does
1927 not get reset in between reads of different symbol files. */
1928 static CORE_ADDR last_pc_address
;
1931 register struct context_stack
*new;
1932 /* This remembers the address of the start of a function. It is used
1933 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1934 relative to the current function's start address. On systems
1935 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1936 used to relocate these symbol types rather than SECTION_OFFSETS. */
1937 static CORE_ADDR function_start_offset
;
1939 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1940 file. Used to detect the SunPRO solaris compiler. */
1941 static int n_opt_found
;
1943 /* The stab type used for the definition of the last function.
1944 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1945 static int function_stab_type
= 0;
1947 if (!block_address_function_relative
)
1948 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1949 function start address, so just use the text offset. */
1950 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1952 /* Something is wrong if we see real data before
1953 seeing a source file name. */
1955 if (last_source_file
== NULL
&& type
!= (unsigned char) N_SO
)
1957 /* Ignore any symbols which appear before an N_SO symbol.
1958 Currently no one puts symbols there, but we should deal
1959 gracefully with the case. A complain()t might be in order,
1960 but this should not be an error (). */
1969 if (*name
== '\000')
1971 /* This N_FUN marks the end of a function. This closes off the
1973 within_function
= 0;
1974 new = pop_context ();
1976 /* Make a block for the local symbols within. */
1977 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1978 new->start_addr
, new->start_addr
+ valu
,
1981 /* May be switching to an assembler file which may not be using
1982 block relative stabs, so reset the offset. */
1983 if (block_address_function_relative
)
1984 function_start_offset
= 0;
1989 /* Relocate for dynamic loading */
1990 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1991 #ifdef SMASH_TEXT_ADDRESS
1992 SMASH_TEXT_ADDRESS (valu
);
1994 goto define_a_symbol
;
1997 /* This "symbol" just indicates the start of an inner lexical
1998 context within a function. */
2000 /* Ignore extra outermost context from SunPRO cc and acc. */
2001 if (n_opt_found
&& desc
== 1)
2004 if (block_address_function_relative
)
2005 /* Relocate for Sun ELF acc fn-relative syms. */
2006 valu
+= function_start_offset
;
2008 /* On most machines, the block addresses are relative to the
2009 N_SO, the linker did not relocate them (sigh). */
2010 valu
+= last_source_start_addr
;
2012 #ifdef SUN_FIXED_LBRAC_BUG
2013 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
)
2015 /* Patch current LBRAC pc value to match last handy pc value */
2016 complain (&lbrac_complaint
);
2017 valu
= last_pc_address
;
2020 new = push_context (desc
, valu
);
2024 /* This "symbol" just indicates the end of an inner lexical
2025 context that was started with N_LBRAC. */
2027 /* Ignore extra outermost context from SunPRO cc and acc. */
2028 if (n_opt_found
&& desc
== 1)
2031 if (block_address_function_relative
)
2032 /* Relocate for Sun ELF acc fn-relative syms. */
2033 valu
+= function_start_offset
;
2035 /* On most machines, the block addresses are relative to the
2036 N_SO, the linker did not relocate them (sigh). */
2037 valu
+= last_source_start_addr
;
2039 new = pop_context ();
2040 if (desc
!= new->depth
)
2041 complain (&lbrac_mismatch_complaint
, symnum
);
2043 /* Some compilers put the variable decls inside of an
2044 LBRAC/RBRAC block. This macro should be nonzero if this
2045 is true. DESC is N_DESC from the N_RBRAC symbol.
2046 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
2047 or the GCC2_COMPILED_SYMBOL. */
2048 #if !defined (VARIABLES_INSIDE_BLOCK)
2049 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2052 /* Can only use new->locals as local symbols here if we're in
2053 gcc or on a machine that puts them before the lbrack. */
2054 if (!VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2055 local_symbols
= new->locals
;
2057 if (context_stack_depth
2058 > !VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2060 /* This is not the outermost LBRAC...RBRAC pair in the function,
2061 its local symbols preceded it, and are the ones just recovered
2062 from the context stack. Define the block for them (but don't
2063 bother if the block contains no symbols. Should we complain
2064 on blocks without symbols? I can't think of any useful purpose
2066 if (local_symbols
!= NULL
)
2068 /* Muzzle a compiler bug that makes end < start. (which
2069 compilers? Is this ever harmful?). */
2070 if (new->start_addr
> valu
)
2072 complain (&lbrac_rbrac_complaint
);
2073 new->start_addr
= valu
;
2075 /* Make a block for the local symbols within. */
2076 finish_block (0, &local_symbols
, new->old_blocks
,
2077 new->start_addr
, valu
, objfile
);
2082 /* This is the outermost LBRAC...RBRAC pair. There is no
2083 need to do anything; leave the symbols that preceded it
2084 to be attached to the function's own block. We need to
2085 indicate that we just moved outside of the function. */
2086 within_function
= 0;
2089 if (VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2090 /* Now pop locals of block just finished. */
2091 local_symbols
= new->locals
;
2096 /* This kind of symbol indicates the start of an object file. */
2097 /* Relocate for dynamic loading */
2098 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2102 /* This type of symbol indicates the start of data
2103 for one source file.
2104 Finish the symbol table of the previous source file
2105 (if any) and start accumulating a new symbol table. */
2106 /* Relocate for dynamic loading */
2107 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2111 #ifdef SUN_FIXED_LBRAC_BUG
2112 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2115 #ifdef PCC_SOL_BROKEN
2116 /* pcc bug, occasionally puts out SO for SOL. */
2117 if (context_stack_depth
> 0)
2119 start_subfile (name
, NULL
);
2123 if (last_source_file
)
2125 /* Check if previous symbol was also an N_SO (with some
2126 sanity checks). If so, that one was actually the directory
2127 name, and the current one is the real file name.
2129 if (previous_stab_code
== (unsigned char) N_SO
)
2131 patch_subfile_names (current_subfile
, name
);
2132 break; /* Ignore repeated SOs */
2134 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
2138 /* Null name means this just marks the end of text for this .o file.
2139 Don't start a new symtab in this case. */
2140 if (*name
== '\000')
2143 if (block_address_function_relative
)
2144 function_start_offset
= 0;
2147 start_symtab (name
, NULL
, valu
);
2148 record_debugformat ("stabs");
2152 /* This type of symbol indicates the start of data for
2153 a sub-source-file, one whose contents were copied or
2154 included in the compilation of the main source file
2155 (whose name was given in the N_SO symbol.) */
2156 /* Relocate for dynamic loading */
2157 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2158 start_subfile (name
, current_subfile
->dirname
);
2163 add_new_header_file (name
, valu
);
2164 start_subfile (name
, current_subfile
->dirname
);
2168 start_subfile (pop_subfile (), current_subfile
->dirname
);
2172 add_old_header_file (name
, valu
);
2176 /* This type of "symbol" really just records
2177 one line-number -- core-address correspondence.
2178 Enter it in the line list for this symbol table. */
2180 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2181 valu
+= function_start_offset
;
2183 #ifdef SUN_FIXED_LBRAC_BUG
2184 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2186 record_line (current_subfile
, desc
, valu
);
2190 common_block_start (name
, objfile
);
2194 common_block_end (objfile
);
2197 /* The following symbol types need to have the appropriate offset added
2198 to their value; then we process symbol definitions in the name. */
2200 case N_STSYM
: /* Static symbol in data seg */
2201 case N_LCSYM
: /* Static symbol in BSS seg */
2202 case N_ROSYM
: /* Static symbol in Read-only data seg */
2203 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2204 Solaris2's stabs-in-elf makes *most* symbols relative
2205 but leaves a few absolute (at least for Solaris 2.1 and version
2206 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2207 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2208 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2209 This leaves us no choice but to search for the 'S' or 'V'...
2210 (or pass the whole section_offsets stuff down ONE MORE function
2211 call level, which we really don't want to do). */
2215 /* .o files and NLMs have non-zero text seg offsets, but don't need
2216 their static syms offset in this fashion. XXX - This is really a
2217 crock that should be fixed in the solib handling code so that I
2218 don't have to work around it here. */
2220 if (!symfile_relocatable
)
2222 p
= strchr (name
, ':');
2223 if (p
!= 0 && p
[1] == 'S')
2225 /* The linker relocated it. We don't want to add an
2226 elfstab_offset_sections-type offset, but we *do* want
2227 to add whatever solib.c passed to symbol_file_add as
2228 addr (this is known to affect SunOS4, and I suspect ELF
2229 too). Since elfstab_offset_sections currently does not
2230 muck with the text offset (there is no Ttext.text
2231 symbol), we can get addr from the text offset. If
2232 elfstab_offset_sections ever starts dealing with the
2233 text offset, and we still need to do this, we need to
2234 invent a SECT_OFF_ADDR_KLUDGE or something. */
2235 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2236 goto define_a_symbol
;
2239 /* Since it's not the kludge case, re-dispatch to the right handler. */
2253 case_N_STSYM
: /* Static symbol in data seg */
2254 case N_DSLINE
: /* Source line number, data seg */
2255 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2256 goto define_a_symbol
;
2258 case_N_LCSYM
: /* Static symbol in BSS seg */
2259 case N_BSLINE
: /* Source line number, bss seg */
2260 /* N_BROWS: overlaps with N_BSLINE */
2261 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2262 goto define_a_symbol
;
2264 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2265 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2266 goto define_a_symbol
;
2268 case N_ENTRY
: /* Alternate entry point */
2269 /* Relocate for dynamic loading */
2270 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2271 goto define_a_symbol
;
2273 /* The following symbol types we don't know how to process. Handle
2274 them in a "default" way, but complain to people who care. */
2276 case N_CATCH
: /* Exception handler catcher */
2277 case N_EHDECL
: /* Exception handler name */
2278 case N_PC
: /* Global symbol in Pascal */
2279 case N_M2C
: /* Modula-2 compilation unit */
2280 /* N_MOD2: overlaps with N_EHDECL */
2281 case N_SCOPE
: /* Modula-2 scope information */
2282 case N_ECOML
: /* End common (local name) */
2283 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2288 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2291 /* The following symbol types don't need the address field relocated,
2292 since it is either unused, or is absolute. */
2294 case N_GSYM
: /* Global variable */
2295 case N_NSYMS
: /* Number of symbols (ultrix) */
2296 case N_NOMAP
: /* No map? (ultrix) */
2297 case N_RSYM
: /* Register variable */
2298 case N_DEFD
: /* Modula-2 GNU module dependency */
2299 case N_SSYM
: /* Struct or union element */
2300 case N_LSYM
: /* Local symbol in stack */
2301 case N_PSYM
: /* Parameter variable */
2302 case N_LENG
: /* Length of preceding symbol type */
2306 char *colon_pos
= strchr (name
, ':');
2307 if (colon_pos
== NULL
)
2310 deftype
= colon_pos
[1];
2316 function_stab_type
= type
;
2318 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2319 /* Deal with the SunPRO 3.0 compiler which omits the address
2320 from N_FUN symbols. */
2322 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2324 struct minimal_symbol
*msym
;
2328 p
= strchr (name
, ':');
2333 strncpy (p
, name
, n
);
2336 msym
= lookup_minimal_symbol (p
, last_source_file
,
2340 /* Sun Fortran appends an underscore to the minimal
2341 symbol name, try again with an appended underscore
2342 if the minimal symbol was not found. */
2345 msym
= lookup_minimal_symbol (p
, last_source_file
,
2349 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2353 #ifdef SUN_FIXED_LBRAC_BUG
2354 /* The Sun acc compiler, under SunOS4, puts out
2355 functions with N_GSYM or N_STSYM. The problem is
2356 that the address of the symbol is no good (for N_GSYM
2357 it doesn't even attept an address; for N_STSYM it
2358 puts out an address but then it gets relocated
2359 relative to the data segment, not the text segment).
2360 Currently we can't fix this up later as we do for
2361 some types of symbol in scan_file_globals.
2362 Fortunately we do have a way of finding the address -
2363 we know that the value in last_pc_address is either
2364 the one we want (if we're dealing with the first
2365 function in an object file), or somewhere in the
2366 previous function. This means that we can use the
2367 minimal symbol table to get the address. */
2369 /* Starting with release 3.0, the Sun acc compiler,
2370 under SunOS4, puts out functions with N_FUN and a value
2371 of zero. This gets relocated to the start of the text
2372 segment of the module, which is no good either.
2373 Under SunOS4 we can deal with this as N_SLINE and N_SO
2374 entries contain valid absolute addresses.
2375 Release 3.0 acc also puts out N_OPT entries, which makes
2376 it possible to discern acc from cc or gcc. */
2378 if (type
== N_GSYM
|| type
== N_STSYM
2380 && n_opt_found
&& !block_address_function_relative
))
2382 struct minimal_symbol
*m
;
2383 int l
= colon_pos
- name
;
2385 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2386 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2387 && SYMBOL_NAME (m
)[l
] == '\0')
2388 /* last_pc_address was in this function */
2389 valu
= SYMBOL_VALUE (m
);
2390 else if (m
&& SYMBOL_NAME (m
+ 1)
2391 && STREQN (SYMBOL_NAME (m
+ 1), name
, l
)
2392 && SYMBOL_NAME (m
+ 1)[l
] == '\0')
2393 /* last_pc_address was in last function */
2394 valu
= SYMBOL_VALUE (m
+ 1);
2396 /* Not found - use last_pc_address (for finish_block) */
2397 valu
= last_pc_address
;
2400 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2403 if (block_address_function_relative
)
2404 /* For Solaris 2.0 compilers, the block addresses and
2405 N_SLINE's are relative to the start of the
2406 function. On normal systems, and when using gcc on
2407 Solaris 2.0, these addresses are just absolute, or
2408 relative to the N_SO, depending on
2409 BLOCK_ADDRESS_ABSOLUTE. */
2410 function_start_offset
= valu
;
2412 within_function
= 1;
2413 if (context_stack_depth
> 0)
2415 new = pop_context ();
2416 /* Make a block for the local symbols within. */
2417 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2418 new->start_addr
, valu
, objfile
);
2420 /* Stack must be empty now. */
2421 if (context_stack_depth
!= 0)
2422 complain (&lbrac_unmatched_complaint
, symnum
);
2424 new = push_context (0, valu
);
2425 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2429 define_symbol (valu
, name
, desc
, type
, objfile
);
2435 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2436 for a bunch of other flags, too. Someday we may parse their
2437 flags; for now we ignore theirs and hope they'll ignore ours. */
2438 case N_OPT
: /* Solaris 2: Compiler options */
2441 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2443 processing_gcc_compilation
= 2;
2444 #if 1 /* Works, but is experimental. -fnf */
2445 if (AUTO_DEMANGLING
)
2447 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2456 /* The following symbol types can be ignored. */
2457 case N_OBJ
: /* Solaris 2: Object file dir and name */
2458 /* N_UNDF: Solaris 2: file separator mark */
2459 /* N_UNDF: -- we will never encounter it, since we only process one
2460 file's symbols at once. */
2461 case N_ENDM
: /* Solaris 2: End of module */
2462 case N_MAIN
: /* Name of main routine. */
2463 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
2467 /* '#' is a GNU C extension to allow one symbol to refer to another
2470 Generally this is used so that an alias can refer to its main
2474 /* Initialize symbol reference names and determine if this is
2475 a definition. If symbol reference is being defined, go
2476 ahead and add it. Otherwise, just return sym. */
2481 /* If this stab defines a new reference ID that is not on the
2482 reference list, then put it on the reference list.
2484 We go ahead and advance NAME past the reference, even though
2485 it is not strictly necessary at this time. */
2486 refnum
= symbol_reference_defined (&s
);
2488 if (!ref_search (refnum
))
2489 ref_add (refnum
, 0, name
, valu
);
2494 previous_stab_code
= type
;
2497 /* FIXME: The only difference between this and elfstab_build_psymtabs
2498 is the call to install_minimal_symbols for elf, and the support for
2499 split sections. If the differences are really that small, the code
2500 should be shared. */
2502 /* Scan and build partial symbols for an coff symbol file.
2503 The coff file has already been processed to get its minimal symbols.
2505 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2508 OBJFILE is the object file we are reading symbols from.
2509 ADDR is the address relative to which the symbols are (e.g.
2510 the base address of the text segment).
2511 MAINLINE is true if we are reading the main symbol
2512 table (as opposed to a shared lib or dynamically loaded file).
2513 TEXTADDR is the address of the text section.
2514 TEXTSIZE is the size of the text section.
2515 STABSECTS is the list of .stab sections in OBJFILE.
2516 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2517 .stabstr section exists.
2519 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2520 adjusted for coff details. */
2523 coffstab_build_psymtabs (objfile
, mainline
,
2524 textaddr
, textsize
, stabsects
,
2525 stabstroffset
, stabstrsize
)
2526 struct objfile
*objfile
;
2529 unsigned int textsize
;
2530 struct stab_section_list
*stabsects
;
2531 file_ptr stabstroffset
;
2532 unsigned int stabstrsize
;
2535 bfd
*sym_bfd
= objfile
->obfd
;
2536 char *name
= bfd_get_filename (sym_bfd
);
2537 struct dbx_symfile_info
*info
;
2538 unsigned int stabsize
;
2540 /* There is already a dbx_symfile_info allocated by our caller.
2541 It might even contain some info from the coff symtab to help us. */
2542 info
= objfile
->sym_stab_info
;
2544 DBX_TEXT_ADDR (objfile
) = textaddr
;
2545 DBX_TEXT_SIZE (objfile
) = textsize
;
2547 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2548 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2549 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2551 if (stabstrsize
> bfd_get_size (sym_bfd
))
2552 error ("ridiculous string table size: %d bytes", stabstrsize
);
2553 DBX_STRINGTAB (objfile
) = (char *)
2554 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+ 1);
2555 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
2557 /* Now read in the string table in one big gulp. */
2559 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2561 perror_with_name (name
);
2562 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2563 if (val
!= stabstrsize
)
2564 perror_with_name (name
);
2566 stabsread_new_init ();
2567 buildsym_new_init ();
2568 free_header_files ();
2569 init_header_files ();
2571 processing_acc_compilation
= 1;
2573 /* In a coff file, we've already installed the minimal symbols that came
2574 from the coff (non-stab) symbol table, so always act like an
2575 incremental load here. */
2576 if (stabsects
->next
== NULL
)
2578 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2579 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2580 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2584 struct stab_section_list
*stabsect
;
2586 DBX_SYMCOUNT (objfile
) = 0;
2587 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2589 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2590 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2593 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2595 symbuf_sections
= stabsects
->next
;
2596 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2600 dbx_symfile_read (objfile
, 0);
2603 /* Scan and build partial symbols for an ELF symbol file.
2604 This ELF file has already been processed to get its minimal symbols,
2605 and any DWARF symbols that were in it.
2607 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2610 OBJFILE is the object file we are reading symbols from.
2611 ADDR is the address relative to which the symbols are (e.g.
2612 the base address of the text segment).
2613 MAINLINE is true if we are reading the main symbol
2614 table (as opposed to a shared lib or dynamically loaded file).
2615 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2617 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2618 .stabstr section exists.
2620 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2621 adjusted for elf details. */
2624 elfstab_build_psymtabs (objfile
, mainline
,
2625 staboffset
, stabsize
,
2626 stabstroffset
, stabstrsize
)
2627 struct objfile
*objfile
;
2629 file_ptr staboffset
;
2630 unsigned int stabsize
;
2631 file_ptr stabstroffset
;
2632 unsigned int stabstrsize
;
2635 bfd
*sym_bfd
= objfile
->obfd
;
2636 char *name
= bfd_get_filename (sym_bfd
);
2637 struct dbx_symfile_info
*info
;
2638 asection
*text_sect
;
2640 /* There is already a dbx_symfile_info allocated by our caller.
2641 It might even contain some info from the ELF symtab to help us. */
2642 info
= objfile
->sym_stab_info
;
2644 /* Find the first and last text address. dbx_symfile_read seems to
2646 find_text_range (sym_bfd
, objfile
);
2648 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2649 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2650 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2651 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2652 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2654 if (stabstrsize
> bfd_get_size (sym_bfd
))
2655 error ("ridiculous string table size: %d bytes", stabstrsize
);
2656 DBX_STRINGTAB (objfile
) = (char *)
2657 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+ 1);
2658 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
2660 /* Now read in the string table in one big gulp. */
2662 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2664 perror_with_name (name
);
2665 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2666 if (val
!= stabstrsize
)
2667 perror_with_name (name
);
2669 stabsread_new_init ();
2670 buildsym_new_init ();
2671 free_header_files ();
2672 init_header_files ();
2673 install_minimal_symbols (objfile
);
2675 processing_acc_compilation
= 1;
2677 /* In an elf file, we've already installed the minimal symbols that came
2678 from the elf (non-stab) symbol table, so always act like an
2679 incremental load here. */
2680 dbx_symfile_read (objfile
, 0);
2683 /* Scan and build partial symbols for a file with special sections for stabs
2684 and stabstrings. The file has already been processed to get its minimal
2685 symbols, and any other symbols that might be necessary to resolve GSYMs.
2687 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2690 OBJFILE is the object file we are reading symbols from.
2691 ADDR is the address relative to which the symbols are (e.g. the base address
2692 of the text segment).
2693 MAINLINE is true if we are reading the main symbol table (as opposed to a
2694 shared lib or dynamically loaded file).
2695 STAB_NAME is the name of the section that contains the stabs.
2696 STABSTR_NAME is the name of the section that contains the stab strings.
2698 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2701 stabsect_build_psymtabs (objfile
, mainline
, stab_name
,
2702 stabstr_name
, text_name
)
2703 struct objfile
*objfile
;
2710 bfd
*sym_bfd
= objfile
->obfd
;
2711 char *name
= bfd_get_filename (sym_bfd
);
2713 asection
*stabstrsect
;
2714 asection
*text_sect
;
2716 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2717 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2723 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2724 stab_name
, stabstr_name
);
2726 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
2727 xmalloc (sizeof (struct dbx_symfile_info
));
2728 memset (objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
2730 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2732 error ("Can't find %s section in symbol file", text_name
);
2733 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2734 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2736 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2737 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2738 / DBX_SYMBOL_SIZE (objfile
);
2739 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2740 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2742 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2743 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2744 DBX_STRINGTAB (objfile
) = (char *)
2745 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2746 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2748 /* Now read in the string table in one big gulp. */
2750 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2751 stabstrsect
, /* bfd section */
2752 DBX_STRINGTAB (objfile
), /* input buffer */
2753 0, /* offset into section */
2754 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2757 perror_with_name (name
);
2759 stabsread_new_init ();
2760 buildsym_new_init ();
2761 free_header_files ();
2762 init_header_files ();
2763 install_minimal_symbols (objfile
);
2765 /* Now, do an incremental load */
2767 processing_acc_compilation
= 1;
2768 dbx_symfile_read (objfile
, 0);
2771 static struct sym_fns aout_sym_fns
=
2773 bfd_target_aout_flavour
,
2774 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2775 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2776 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2777 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2778 default_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2779 NULL
/* next: pointer to next struct sym_fns */
2783 _initialize_dbxread ()
2785 add_symtab_fns (&aout_sym_fns
);