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
*));
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 static struct partial_symtab
*
337 start_psymtab
PARAMS ((struct objfile
*, char *, CORE_ADDR
, int,
338 struct partial_symbol
**, struct partial_symbol
**));
340 /* Free up old header file tables */
345 if (this_object_header_files
)
347 free ((PTR
) this_object_header_files
);
348 this_object_header_files
= NULL
;
350 n_allocated_this_object_header_files
= 0;
353 /* Allocate new header file tables */
358 n_allocated_this_object_header_files
= 10;
359 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
362 /* Add header file number I for this object file
363 at the next successive FILENUM. */
366 add_this_object_header_file (i
)
369 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
371 n_allocated_this_object_header_files
*= 2;
372 this_object_header_files
373 = (int *) xrealloc ((char *) this_object_header_files
,
374 n_allocated_this_object_header_files
* sizeof (int));
377 this_object_header_files
[n_this_object_header_files
++] = i
;
380 /* Add to this file an "old" header file, one already seen in
381 a previous object file. NAME is the header file's name.
382 INSTANCE is its instance code, to select among multiple
383 symbol tables for the same header file. */
386 add_old_header_file (name
, instance
)
390 register struct header_file
*p
= HEADER_FILES (current_objfile
);
393 for (i
= 0; i
< N_HEADER_FILES (current_objfile
); i
++)
394 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
396 add_this_object_header_file (i
);
399 complain (&repeated_header_complaint
, name
, symnum
);
402 /* Add to this file a "new" header file: definitions for its types follow.
403 NAME is the header file's name.
404 Most often this happens only once for each distinct header file,
405 but not necessarily. If it happens more than once, INSTANCE has
406 a different value each time, and references to the header file
407 use INSTANCE values to select among them.
409 dbx output contains "begin" and "end" markers for each new header file,
410 but at this level we just need to know which files there have been;
411 so we record the file when its "begin" is seen and ignore the "end". */
414 add_new_header_file (name
, instance
)
419 register struct header_file
*hfile
;
421 /* Make sure there is room for one more header file. */
423 i
= N_ALLOCATED_HEADER_FILES (current_objfile
);
425 if (N_HEADER_FILES (current_objfile
) == i
)
429 N_ALLOCATED_HEADER_FILES (current_objfile
) = 10;
430 HEADER_FILES (current_objfile
) = (struct header_file
*)
431 xmalloc (10 * sizeof (struct header_file
));
436 N_ALLOCATED_HEADER_FILES (current_objfile
) = i
;
437 HEADER_FILES (current_objfile
) = (struct header_file
*)
438 xrealloc ((char *) HEADER_FILES (current_objfile
),
439 (i
* sizeof (struct header_file
)));
443 /* Create an entry for this header file. */
445 i
= N_HEADER_FILES (current_objfile
)++;
446 hfile
= HEADER_FILES (current_objfile
) + i
;
447 hfile
->name
= savestring (name
, strlen (name
));
448 hfile
->instance
= instance
;
451 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
452 memset (hfile
->vector
, 0, 10 * sizeof (struct type
*));
454 add_this_object_header_file (i
);
458 static struct type
**
459 explicit_lookup_type (real_filenum
, index
)
460 int real_filenum
, index
;
462 register struct header_file
*f
= &HEADER_FILES (current_objfile
)[real_filenum
];
464 if (index
>= f
->length
)
467 f
->vector
= (struct type
**)
468 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
469 memset (&f
->vector
[f
->length
/ 2],
470 '\0', f
->length
* sizeof (struct type
*) / 2);
472 return &f
->vector
[index
];
477 record_minimal_symbol (name
, address
, type
, objfile
)
481 struct objfile
*objfile
;
483 enum minimal_symbol_type ms_type
;
485 asection
*bfd_section
;
491 section
= SECT_OFF_TEXT
;
492 bfd_section
= DBX_TEXT_SECTION (objfile
);
496 section
= SECT_OFF_DATA
;
497 bfd_section
= DBX_DATA_SECTION (objfile
);
501 section
= SECT_OFF_BSS
;
502 bfd_section
= DBX_BSS_SECTION (objfile
);
512 section
= SECT_OFF_DATA
;
513 bfd_section
= DBX_DATA_SECTION (objfile
);
516 /* I don't think this type actually exists; since a N_SETV is the result
517 of going over many .o files, it doesn't make sense to have one
519 ms_type
= mst_file_data
;
520 section
= SECT_OFF_DATA
;
521 bfd_section
= DBX_DATA_SECTION (objfile
);
528 ms_type
= mst_file_text
;
529 section
= SECT_OFF_TEXT
;
530 bfd_section
= DBX_TEXT_SECTION (objfile
);
533 ms_type
= mst_file_data
;
535 /* Check for __DYNAMIC, which is used by Sun shared libraries.
536 Record it as global even if it's local, not global, so
537 lookup_minimal_symbol can find it. We don't check symbol_leading_char
538 because for SunOS4 it always is '_'. */
539 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
542 /* Same with virtual function tables, both global and static. */
544 char *tempstring
= name
;
545 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
547 if (VTBL_PREFIX_P ((tempstring
)))
550 section
= SECT_OFF_DATA
;
551 bfd_section
= DBX_DATA_SECTION (objfile
);
554 ms_type
= mst_file_bss
;
555 section
= SECT_OFF_BSS
;
556 bfd_section
= DBX_BSS_SECTION (objfile
);
559 ms_type
= mst_unknown
;
565 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
566 && address
< lowest_text_address
)
567 lowest_text_address
= address
;
569 prim_record_minimal_symbol_and_info
570 (name
, address
, ms_type
, NULL
, section
, bfd_section
, objfile
);
573 /* Scan and build partial symbols for a symbol file.
574 We have been initialized by a call to dbx_symfile_init, which
575 put all the relevant info into a "struct dbx_symfile_info",
576 hung off the objfile structure.
578 MAINLINE is true if we are reading the main symbol
579 table (as opposed to a shared lib or dynamically loaded file). */
582 dbx_symfile_read (objfile
, mainline
)
583 struct objfile
*objfile
;
584 int mainline
; /* FIXME comments above */
588 struct cleanup
*back_to
;
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
), "epoc-pe", 7))
608 || (0 == strncmp (bfd_get_target (sym_bfd
), "nlm", 3)));
610 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
612 perror_with_name (objfile
->name
);
614 /* If we are reinitializing, or if we have never loaded syms yet, init */
616 || objfile
->global_psymbols
.size
== 0
617 || objfile
->static_psymbols
.size
== 0)
618 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
620 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
621 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
623 free_pending_blocks ();
624 back_to
= make_cleanup (really_free_pendings
, 0);
626 init_minimal_symbol_collection ();
627 make_cleanup ((make_cleanup_func
) discard_minimal_symbols
, 0);
629 /* Read stabs data from executable file and define symbols. */
631 read_dbx_symtab (objfile
);
633 /* Add the dynamic symbols. */
635 read_dbx_dynamic_symtab (objfile
);
637 /* Install any minimal symbols that have been collected as the current
638 minimal symbols for this objfile. */
640 install_minimal_symbols (objfile
);
642 do_cleanups (back_to
);
645 /* Initialize anything that needs initializing when a completely new
646 symbol file is specified (not just adding some symbols from another
647 file, e.g. a shared library). */
650 dbx_new_init (ignore
)
651 struct objfile
*ignore
;
653 stabsread_new_init ();
654 buildsym_new_init ();
655 init_header_files ();
659 /* dbx_symfile_init ()
660 is the dbx-specific initialization routine for reading symbols.
661 It is passed a struct objfile which contains, among other things,
662 the BFD for the file whose symbols are being read, and a slot for a pointer
663 to "private data" which we fill with goodies.
665 We read the string table into malloc'd space and stash a pointer to it.
667 Since BFD doesn't know how to read debug symbols in a format-independent
668 way (and may never do so...), we have to do it ourselves. We will never
669 be called unless this is an a.out (or very similar) file.
670 FIXME, there should be a cleaner peephole into the BFD environment here. */
672 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
675 dbx_symfile_init (objfile
)
676 struct objfile
*objfile
;
679 bfd
*sym_bfd
= objfile
->obfd
;
680 char *name
= bfd_get_filename (sym_bfd
);
682 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
684 /* Allocate struct to keep track of the symfile */
685 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
686 xmmalloc (objfile
->md
, sizeof (struct dbx_symfile_info
));
687 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
689 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
690 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
691 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
693 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
694 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
695 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
697 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
699 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
701 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
703 error ("Can't find .text section in symbol file");
704 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
705 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
707 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
708 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
709 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
711 /* Read the string table and stash it away in the psymbol_obstack. It is
712 only needed as long as we need to expand psymbols into full symbols,
713 so when we blow away the psymbol the string table goes away as well.
714 Note that gdb used to use the results of attempting to malloc the
715 string table, based on the size it read, as a form of sanity check
716 for botched byte swapping, on the theory that a byte swapped string
717 table size would be so totally bogus that the malloc would fail. Now
718 that we put in on the psymbol_obstack, we can't do this since gdb gets
719 a fatal error (out of virtual memory) if the size is bogus. We can
720 however at least check to see if the size is less than the size of
721 the size field itself, or larger than the size of the entire file.
722 Note that all valid string tables have a size greater than zero, since
723 the bytes used to hold the size are included in the count. */
725 if (STRING_TABLE_OFFSET
== 0)
727 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
728 will never be zero, even when there is no string table. This
729 would appear to be a bug in bfd. */
730 DBX_STRINGTAB_SIZE (objfile
) = 0;
731 DBX_STRINGTAB (objfile
) = NULL
;
735 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
737 perror_with_name (name
);
739 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
740 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
743 perror_with_name (name
);
747 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
748 EOF if there is no string table, and attempting to read the size
749 from EOF will read zero bytes. */
750 DBX_STRINGTAB_SIZE (objfile
) = 0;
751 DBX_STRINGTAB (objfile
) = NULL
;
755 /* Read some data that would appear to be the string table size.
756 If there really is a string table, then it is probably the right
757 size. Byteswap if necessary and validate the size. Note that
758 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
759 random data that happened to be at STRING_TABLE_OFFSET, because
760 bfd can't tell us there is no string table, the sanity checks may
761 or may not catch this. */
762 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
764 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
765 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
766 error ("ridiculous string table size (%d bytes).",
767 DBX_STRINGTAB_SIZE (objfile
));
769 DBX_STRINGTAB (objfile
) =
770 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
771 DBX_STRINGTAB_SIZE (objfile
));
772 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
774 /* Now read in the string table in one big gulp. */
776 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
778 perror_with_name (name
);
779 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
781 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
782 perror_with_name (name
);
787 /* Perform any local cleanups required when we are done with a particular
788 objfile. I.E, we are in the process of discarding all symbol information
789 for an objfile, freeing up all memory held for it, and unlinking the
790 objfile struct from the global list of known objfiles. */
793 dbx_symfile_finish (objfile
)
794 struct objfile
*objfile
;
796 if (objfile
->sym_stab_info
!= NULL
)
798 if (HEADER_FILES (objfile
) != NULL
)
800 register int i
= N_HEADER_FILES (objfile
);
801 register struct header_file
*hfiles
= HEADER_FILES (objfile
);
805 free (hfiles
[i
].name
);
806 free (hfiles
[i
].vector
);
810 mfree (objfile
->md
, objfile
->sym_stab_info
);
812 free_header_files ();
816 /* Buffer for reading the symbol table entries. */
817 static struct external_nlist symbuf
[4096];
818 static int symbuf_idx
;
819 static int symbuf_end
;
821 /* cont_elem is used for continuing information in cfront.
822 It saves information about which types need to be fixed up and
823 completed after all the stabs are read. */
826 /* sym and stabsstring for continuing information in cfront */
829 /* state dependancies (statics that must be preserved) */
833 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
834 /* other state dependancies include:
835 (assumption is that these will not change since process_now FIXME!!)
842 static struct cont_elem
*cont_list
= 0;
843 static int cont_limit
= 0;
844 static int cont_count
= 0;
846 /* Arrange for function F to be called with arguments SYM and P later
847 in the stabs reading process. */
849 process_later (sym
, p
, f
)
852 int (*f
) PARAMS ((struct objfile
*, struct symbol
*, char *));
855 /* Allocate more space for the deferred list. */
856 if (cont_count
>= cont_limit
- 1)
858 cont_limit
+= 32; /* chunk size */
861 = (struct cont_elem
*) xrealloc (cont_list
,
863 * sizeof (struct cont_elem
)));
865 error ("Virtual memory exhausted\n");
868 /* Save state variables so we can process these stabs later. */
869 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
870 cont_list
[cont_count
].sym_end
= symbuf_end
;
871 cont_list
[cont_count
].symnum
= symnum
;
872 cont_list
[cont_count
].sym
= sym
;
873 cont_list
[cont_count
].stabs
= p
;
874 cont_list
[cont_count
].func
= f
;
878 /* Call deferred funtions in CONT_LIST. */
881 process_now (objfile
)
882 struct objfile
*objfile
;
891 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
893 /* Save the state of our caller, we'll want to restore it before
895 save_symbuf_idx
= symbuf_idx
;
896 save_symbuf_end
= symbuf_end
;
897 save_symnum
= symnum
;
899 /* Iterate over all the deferred stabs. */
900 for (i
= 0; i
< cont_count
; i
++)
902 /* Restore the state for this deferred stab. */
903 symbuf_idx
= cont_list
[i
].sym_idx
;
904 symbuf_end
= cont_list
[i
].sym_end
;
905 symnum
= cont_list
[i
].symnum
;
906 sym
= cont_list
[i
].sym
;
907 stabs
= cont_list
[i
].stabs
;
908 func
= cont_list
[i
].func
;
910 /* Call the function to handle this deferrd stab. */
911 err
= (*func
) (objfile
, sym
, stabs
);
913 error ("Internal error: unable to resolve stab.\n");
916 /* Restore our caller's state. */
917 symbuf_idx
= save_symbuf_idx
;
918 symbuf_end
= save_symbuf_end
;
919 symnum
= save_symnum
;
924 /* Name of last function encountered. Used in Solaris to approximate
925 object file boundaries. */
926 static char *last_function_name
;
928 /* The address in memory of the string table of the object file we are
929 reading (which might not be the "main" object file, but might be a
930 shared library or some other dynamically loaded thing). This is
931 set by read_dbx_symtab when building psymtabs, and by
932 read_ofile_symtab when building symtabs, and is used only by
933 next_symbol_text. FIXME: If that is true, we don't need it when
934 building psymtabs, right? */
935 static char *stringtab_global
;
937 /* These variables are used to control fill_symbuf when the stabs
938 symbols are not contiguous (as may be the case when a COFF file is
939 linked using --split-by-reloc). */
940 static struct stab_section_list
*symbuf_sections
;
941 static unsigned int symbuf_left
;
942 static unsigned int symbuf_read
;
944 /* Refill the symbol table input buffer
945 and set the variables that control fetching entries from it.
946 Reports an error if no data available.
947 This function can read past the end of the symbol table
948 (into the string table) but this does no harm. */
951 fill_symbuf (sym_bfd
)
957 if (symbuf_sections
== NULL
)
958 count
= sizeof (symbuf
);
961 if (symbuf_left
<= 0)
963 file_ptr filepos
= symbuf_sections
->section
->filepos
;
964 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
965 perror_with_name (bfd_get_filename (sym_bfd
));
966 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
967 symbol_table_offset
= filepos
- symbuf_read
;
968 symbuf_sections
= symbuf_sections
->next
;
972 if (count
> sizeof (symbuf
))
973 count
= sizeof (symbuf
);
976 nbytes
= bfd_read ((PTR
) symbuf
, count
, 1, sym_bfd
);
978 perror_with_name (bfd_get_filename (sym_bfd
));
979 else if (nbytes
== 0)
980 error ("Premature end of file reading symbol table");
981 symbuf_end
= nbytes
/ symbol_size
;
983 symbuf_left
-= nbytes
;
984 symbuf_read
+= nbytes
;
987 #define SWAP_SYMBOL(symp, abfd) \
989 (symp)->n_strx = bfd_h_get_32(abfd, \
990 (unsigned char *)&(symp)->n_strx); \
991 (symp)->n_desc = bfd_h_get_16 (abfd, \
992 (unsigned char *)&(symp)->n_desc); \
993 (symp)->n_value = bfd_h_get_32 (abfd, \
994 (unsigned char *)&(symp)->n_value); \
997 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
999 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
1000 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
1001 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
1002 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
1005 /* Invariant: The symbol pointed to by symbuf_idx is the first one
1006 that hasn't been swapped. Swap the symbol at the same time
1007 that symbuf_idx is incremented. */
1009 /* dbx allows the text of a symbol name to be continued into the
1010 next symbol name! When such a continuation is encountered
1011 (a \ at the end of the text of a name)
1012 call this function to get the continuation. */
1015 dbx_next_symbol_text (objfile
)
1016 struct objfile
*objfile
;
1018 struct internal_nlist nlist
;
1020 if (symbuf_idx
== symbuf_end
)
1021 fill_symbuf (symfile_bfd
);
1024 INTERNALIZE_SYMBOL (nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
1025 OBJSTAT (objfile
, n_stabs
++);
1029 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
1032 /* Initialize the list of bincls to contain none and have some
1036 init_bincl_list (number
, objfile
)
1038 struct objfile
*objfile
;
1040 bincls_allocated
= number
;
1041 next_bincl
= bincl_list
= (struct header_file_location
*)
1042 xmmalloc (objfile
->md
, bincls_allocated
* sizeof (struct header_file_location
));
1045 /* Add a bincl to the list. */
1048 add_bincl_to_list (pst
, name
, instance
)
1049 struct partial_symtab
*pst
;
1053 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1055 int offset
= next_bincl
- bincl_list
;
1056 bincls_allocated
*= 2;
1057 bincl_list
= (struct header_file_location
*)
1058 xmrealloc (pst
->objfile
->md
, (char *) bincl_list
,
1059 bincls_allocated
* sizeof (struct header_file_location
));
1060 next_bincl
= bincl_list
+ offset
;
1062 next_bincl
->pst
= pst
;
1063 next_bincl
->instance
= instance
;
1064 next_bincl
++->name
= name
;
1067 /* Given a name, value pair, find the corresponding
1068 bincl in the list. Return the partial symtab associated
1069 with that header_file_location. */
1071 static struct partial_symtab
*
1072 find_corresponding_bincl_psymtab (name
, instance
)
1076 struct header_file_location
*bincl
;
1078 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1079 if (bincl
->instance
== instance
1080 && STREQ (name
, bincl
->name
))
1083 complain (&repeated_header_complaint
, name
, symnum
);
1084 return (struct partial_symtab
*) 0;
1087 /* Free the storage allocated for the bincl list. */
1090 free_bincl_list (objfile
)
1091 struct objfile
*objfile
;
1093 mfree (objfile
->md
, (PTR
) bincl_list
);
1094 bincls_allocated
= 0;
1097 /* Scan a SunOs dynamic symbol table for symbols of interest and
1098 add them to the minimal symbol table. */
1101 read_dbx_dynamic_symtab (objfile
)
1102 struct objfile
*objfile
;
1104 bfd
*abfd
= objfile
->obfd
;
1105 struct cleanup
*back_to
;
1115 CORE_ADDR sym_value
;
1118 /* Check that the symbol file has dynamic symbols that we know about.
1119 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1120 on a sun4 host (and vice versa) and bfd is not configured
1121 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1122 so we ignore the dynamic symbols in this case. */
1123 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
1124 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
1125 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1128 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1129 if (dynsym_size
< 0)
1132 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1133 back_to
= make_cleanup (free
, dynsyms
);
1135 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1136 if (dynsym_count
< 0)
1138 do_cleanups (back_to
);
1142 /* Enter dynamic symbols into the minimal symbol table
1143 if this is a stripped executable. */
1144 if (bfd_get_symcount (abfd
) <= 0)
1147 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1149 asymbol
*sym
= *symptr
;
1153 sec
= bfd_get_section (sym
);
1155 /* BFD symbols are section relative. */
1156 sym_value
= sym
->value
+ sec
->vma
;
1158 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1160 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT
);
1163 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1165 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA
);
1168 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1170 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS
);
1176 if (sym
->flags
& BSF_GLOBAL
)
1179 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1184 /* Symbols from shared libraries have a dynamic relocation entry
1185 that points to the associated slot in the procedure linkage table.
1186 We make a mininal symbol table entry with type mst_solib_trampoline
1187 at the address in the procedure linkage table. */
1188 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1189 if (dynrel_size
< 0)
1191 do_cleanups (back_to
);
1195 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1196 make_cleanup (free
, dynrels
);
1198 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1199 if (dynrel_count
< 0)
1201 do_cleanups (back_to
);
1205 for (counter
= 0, relptr
= dynrels
;
1206 counter
< dynrel_count
;
1207 counter
++, relptr
++)
1209 arelent
*rel
= *relptr
;
1211 rel
->address
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA
);
1213 switch (bfd_get_arch (abfd
))
1215 case bfd_arch_sparc
:
1216 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1220 /* `16' is the type BFD produces for a jump table relocation. */
1221 if (rel
->howto
->type
!= 16)
1224 /* Adjust address in the jump table to point to
1225 the start of the bsr instruction. */
1232 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1233 prim_record_minimal_symbol (name
, address
, mst_solib_trampoline
,
1237 do_cleanups (back_to
);
1240 /* Setup partial_symtab's describing each source file for which
1241 debugging information is available. */
1244 read_dbx_symtab (objfile
)
1245 struct objfile
*objfile
;
1247 register struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1248 struct internal_nlist nlist
;
1249 CORE_ADDR text_addr
;
1252 register char *namestring
;
1254 int past_first_source_file
= 0;
1255 CORE_ADDR last_o_file_start
= 0;
1256 CORE_ADDR last_function_start
= 0;
1257 struct cleanup
*back_to
;
1259 int textlow_not_set
;
1261 /* Current partial symtab */
1262 struct partial_symtab
*pst
;
1264 /* List of current psymtab's include files */
1265 char **psymtab_include_list
;
1266 int includes_allocated
;
1269 /* Index within current psymtab dependency list */
1270 struct partial_symtab
**dependency_list
;
1271 int dependencies_used
, dependencies_allocated
;
1273 text_addr
= DBX_TEXT_ADDR (objfile
);
1274 text_size
= DBX_TEXT_SIZE (objfile
);
1276 /* FIXME. We probably want to change stringtab_global rather than add this
1277 while processing every symbol entry. FIXME. */
1278 file_string_table_offset
= 0;
1279 next_file_string_table_offset
= 0;
1281 stringtab_global
= DBX_STRINGTAB (objfile
);
1283 pst
= (struct partial_symtab
*) 0;
1285 includes_allocated
= 30;
1287 psymtab_include_list
= (char **) alloca (includes_allocated
*
1290 dependencies_allocated
= 30;
1291 dependencies_used
= 0;
1293 (struct partial_symtab
**) alloca (dependencies_allocated
*
1294 sizeof (struct partial_symtab
*));
1296 /* Init bincl list */
1297 init_bincl_list (20, objfile
);
1298 back_to
= make_cleanup ((make_cleanup_func
) free_bincl_list
, objfile
);
1300 last_source_file
= NULL
;
1302 lowest_text_address
= (CORE_ADDR
) -1;
1304 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1305 abfd
= objfile
->obfd
;
1306 symbuf_end
= symbuf_idx
= 0;
1307 next_symbol_text_func
= dbx_next_symbol_text
;
1308 textlow_not_set
= 1;
1309 has_line_numbers
= 0;
1311 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1313 /* Get the symbol for this run and pull out some info */
1314 QUIT
; /* allow this to be interruptable */
1315 if (symbuf_idx
== symbuf_end
)
1317 bufp
= &symbuf
[symbuf_idx
++];
1320 * Special case to speed up readin.
1322 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1324 has_line_numbers
= 1;
1328 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1329 OBJSTAT (objfile
, n_stabs
++);
1331 /* Ok. There is a lot of code duplicated in the rest of this
1332 switch statement (for efficiency reasons). Since I don't
1333 like duplicating code, I will do my penance here, and
1334 describe the code which is duplicated:
1336 *) The assignment to namestring.
1337 *) The call to strchr.
1338 *) The addition of a partial symbol the the two partial
1339 symbol lists. This last is a large section of code, so
1340 I've imbedded it in the following macro.
1343 /* Set namestring based on nlist. If the string table index is invalid,
1344 give a fake name, and print a single error message per symbol file read,
1345 rather than abort the symbol reading or flood the user with messages. */
1347 /*FIXME: Too many adds and indirections in here for the inner loop. */
1348 #define SET_NAMESTRING()\
1349 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1350 DBX_STRINGTAB_SIZE (objfile)) { \
1351 complain (&string_table_offset_complaint, symnum); \
1352 namestring = "<bad string table offset>"; \
1354 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1355 DBX_STRINGTAB (objfile)
1357 #define CUR_SYMBOL_TYPE nlist.n_type
1358 #define CUR_SYMBOL_VALUE nlist.n_value
1359 #define CUR_SYMBOL_STRX nlist.n_strx
1360 #define DBXREAD_ONLY
1361 #define START_PSYMTAB(ofile,fname,low,symoff,global_syms,static_syms)\
1362 start_psymtab(ofile, fname, low, symoff, global_syms, static_syms)
1363 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1364 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1366 #include "partial-stab.h"
1369 /* If there's stuff to be cleaned up, clean it up. */
1370 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1371 /*FIXME, does this have a bug at start address 0? */
1372 && last_o_file_start
1373 && objfile
->ei
.entry_point
< nlist
.n_value
1374 && objfile
->ei
.entry_point
>= last_o_file_start
)
1376 objfile
->ei
.entry_file_lowpc
= last_o_file_start
;
1377 objfile
->ei
.entry_file_highpc
= nlist
.n_value
;
1382 /* Don't set pst->texthigh lower than it already is. */
1383 CORE_ADDR text_end
=
1384 (lowest_text_address
== (CORE_ADDR
) -1
1385 ? (text_addr
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT
))
1386 : lowest_text_address
)
1389 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1390 symnum
* symbol_size
,
1391 text_end
> pst
->texthigh
? text_end
: pst
->texthigh
,
1392 dependency_list
, dependencies_used
, textlow_not_set
);
1395 do_cleanups (back_to
);
1398 /* Allocate and partially fill a partial symtab. It will be
1399 completely filled at the end of the symbol list.
1401 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1402 is the address relative to which its symbols are (incremental) or 0
1406 static struct partial_symtab
*
1407 start_psymtab (objfile
, filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1408 struct objfile
*objfile
;
1412 struct partial_symbol
**global_syms
;
1413 struct partial_symbol
**static_syms
;
1415 struct partial_symtab
*result
=
1416 start_psymtab_common (objfile
, objfile
->section_offsets
,
1417 filename
, textlow
, global_syms
, static_syms
);
1419 result
->read_symtab_private
= (char *)
1420 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1421 LDSYMOFF (result
) = ldsymoff
;
1422 result
->read_symtab
= dbx_psymtab_to_symtab
;
1423 SYMBOL_SIZE (result
) = symbol_size
;
1424 SYMBOL_OFFSET (result
) = symbol_table_offset
;
1425 STRING_OFFSET (result
) = string_table_offset
;
1426 FILE_STRING_OFFSET (result
) = file_string_table_offset
;
1428 /* If we're handling an ELF file, drag some section-relocation info
1429 for this source file out of the ELF symbol table, to compensate for
1430 Sun brain death. This replaces the section_offsets in this psymtab,
1432 elfstab_offset_sections (objfile
, result
);
1434 /* Deduce the source language from the filename for this psymtab. */
1435 psymtab_language
= deduce_language_from_filename (filename
);
1440 /* Close off the current usage of PST.
1441 Returns PST or NULL if the partial symtab was empty and thrown away.
1443 FIXME: List variables and peculiarities of same. */
1445 struct partial_symtab
*
1446 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1447 capping_text
, dependency_list
, number_dependencies
, textlow_not_set
)
1448 struct partial_symtab
*pst
;
1449 char **include_list
;
1451 int capping_symbol_offset
;
1452 CORE_ADDR capping_text
;
1453 struct partial_symtab
**dependency_list
;
1454 int number_dependencies
;
1455 int textlow_not_set
;
1458 struct objfile
*objfile
= pst
->objfile
;
1460 if (capping_symbol_offset
!= -1)
1461 LDSYMLEN (pst
) = capping_symbol_offset
- LDSYMOFF (pst
);
1462 pst
->texthigh
= capping_text
;
1464 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1465 /* Under Solaris, the N_SO symbols always have a value of 0,
1466 instead of the usual address of the .o file. Therefore,
1467 we have to do some tricks to fill in texthigh and textlow.
1468 The first trick is in partial-stab.h: if we see a static
1469 or global function, and the textlow for the current pst
1470 is not set (ie: textlow_not_set), then we use that function's
1471 address for the textlow of the pst. */
1473 /* Now, to fill in texthigh, we remember the last function seen
1474 in the .o file (also in partial-stab.h). Also, there's a hack in
1475 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1476 to here via the misc_info field. Therefore, we can fill in
1477 a reliable texthigh by taking the address plus size of the
1478 last function in the file. */
1480 if (pst
->texthigh
== 0 && last_function_name
)
1484 struct minimal_symbol
*minsym
;
1486 p
= strchr (last_function_name
, ':');
1488 p
= last_function_name
;
1489 n
= p
- last_function_name
;
1491 strncpy (p
, last_function_name
, n
);
1494 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1497 /* Sun Fortran appends an underscore to the minimal symbol name,
1498 try again with an appended underscore if the minimal symbol
1502 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1506 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) + MSYMBOL_SIZE (minsym
);
1508 last_function_name
= NULL
;
1511 /* this test will be true if the last .o file is only data */
1512 if (textlow_not_set
)
1513 pst
->textlow
= pst
->texthigh
;
1516 struct partial_symtab
*p1
;
1518 /* If we know our own starting text address, then walk through all other
1519 psymtabs for this objfile, and if any didn't know their ending text
1520 address, set it to our starting address. Take care to not set our
1521 own ending address to our starting address, nor to set addresses on
1522 `dependency' files that have both textlow and texthigh zero. */
1524 ALL_OBJFILE_PSYMTABS (objfile
, p1
)
1526 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
)
1528 p1
->texthigh
= pst
->textlow
;
1529 /* if this file has only data, then make textlow match texthigh */
1530 if (p1
->textlow
== 0)
1531 p1
->textlow
= p1
->texthigh
;
1536 /* End of kludge for patching Solaris textlow and texthigh. */
1537 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1539 pst
->n_global_syms
=
1540 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1541 pst
->n_static_syms
=
1542 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1544 pst
->number_of_dependencies
= number_dependencies
;
1545 if (number_dependencies
)
1547 pst
->dependencies
= (struct partial_symtab
**)
1548 obstack_alloc (&objfile
->psymbol_obstack
,
1549 number_dependencies
* sizeof (struct partial_symtab
*));
1550 memcpy (pst
->dependencies
, dependency_list
,
1551 number_dependencies
* sizeof (struct partial_symtab
*));
1554 pst
->dependencies
= 0;
1556 for (i
= 0; i
< num_includes
; i
++)
1558 struct partial_symtab
*subpst
=
1559 allocate_psymtab (include_list
[i
], objfile
);
1561 subpst
->section_offsets
= pst
->section_offsets
;
1562 subpst
->read_symtab_private
=
1563 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1564 sizeof (struct symloc
));
1568 subpst
->texthigh
= 0;
1570 /* We could save slight bits of space by only making one of these,
1571 shared by the entire set of include files. FIXME-someday. */
1572 subpst
->dependencies
= (struct partial_symtab
**)
1573 obstack_alloc (&objfile
->psymbol_obstack
,
1574 sizeof (struct partial_symtab
*));
1575 subpst
->dependencies
[0] = pst
;
1576 subpst
->number_of_dependencies
= 1;
1578 subpst
->globals_offset
=
1579 subpst
->n_global_syms
=
1580 subpst
->statics_offset
=
1581 subpst
->n_static_syms
= 0;
1585 subpst
->read_symtab
= pst
->read_symtab
;
1588 sort_pst_symbols (pst
);
1590 /* If there is already a psymtab or symtab for a file of this name, remove it.
1591 (If there is a symtab, more drastic things also happen.)
1592 This happens in VxWorks. */
1593 free_named_symtabs (pst
->filename
);
1595 if (num_includes
== 0
1596 && number_dependencies
== 0
1597 && pst
->n_global_syms
== 0
1598 && pst
->n_static_syms
== 0
1599 && has_line_numbers
== 0)
1601 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1602 it is on the obstack, but we can forget to chain it on the list. */
1603 /* Empty psymtabs happen as a result of header files which don't have
1604 any symbols in them. There can be a lot of them. But this check
1605 is wrong, in that a psymtab with N_SLINE entries but nothing else
1606 is not empty, but we don't realize that. Fixing that without slowing
1607 things down might be tricky. */
1609 discard_psymtab (pst
);
1611 /* Indicate that psymtab was thrown away. */
1612 pst
= (struct partial_symtab
*) NULL
;
1618 dbx_psymtab_to_symtab_1 (pst
)
1619 struct partial_symtab
*pst
;
1621 struct cleanup
*old_chain
;
1629 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1634 /* Read in all partial symtabs on which this one is dependent */
1635 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1636 if (!pst
->dependencies
[i
]->readin
)
1638 /* Inform about additional files that need to be read in. */
1641 fputs_filtered (" ", gdb_stdout
);
1643 fputs_filtered ("and ", gdb_stdout
);
1645 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1646 wrap_here (""); /* Flush output */
1647 gdb_flush (gdb_stdout
);
1649 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1652 if (LDSYMLEN (pst
)) /* Otherwise it's a dummy */
1654 /* Init stuff necessary for reading in symbols */
1657 old_chain
= make_cleanup (really_free_pendings
, 0);
1658 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1659 symbol_size
= SYMBOL_SIZE (pst
);
1661 /* Read in this file's symbols */
1662 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1663 read_ofile_symtab (pst
);
1664 sort_symtab_syms (pst
->symtab
);
1666 do_cleanups (old_chain
);
1672 /* Read in all of the symbols for a given psymtab for real.
1673 Be verbose about it if the user wants that. */
1676 dbx_psymtab_to_symtab (pst
)
1677 struct partial_symtab
*pst
;
1686 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1691 if (LDSYMLEN (pst
) || pst
->number_of_dependencies
)
1693 /* Print the message now, before reading the string table,
1694 to avoid disconcerting pauses. */
1697 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1698 gdb_flush (gdb_stdout
);
1701 sym_bfd
= pst
->objfile
->obfd
;
1703 next_symbol_text_func
= dbx_next_symbol_text
;
1705 dbx_psymtab_to_symtab_1 (pst
);
1707 /* Match with global symbols. This only needs to be done once,
1708 after all of the symtabs and dependencies have been read in. */
1709 scan_file_globals (pst
->objfile
);
1711 /* Finish up the debug error message. */
1713 printf_filtered ("done.\n");
1717 /* Read in a defined section of a specific object file's symbols. */
1720 read_ofile_symtab (pst
)
1721 struct partial_symtab
*pst
;
1723 register char *namestring
;
1724 register struct external_nlist
*bufp
;
1725 struct internal_nlist nlist
;
1727 unsigned max_symnum
;
1729 struct objfile
*objfile
;
1730 int sym_offset
; /* Offset to start of symbols to read */
1731 int sym_size
; /* Size of symbols to read */
1732 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1733 int text_size
; /* Size of text segment for symbols */
1734 struct section_offsets
*section_offsets
;
1736 objfile
= pst
->objfile
;
1737 sym_offset
= LDSYMOFF (pst
);
1738 sym_size
= LDSYMLEN (pst
);
1739 text_offset
= pst
->textlow
;
1740 text_size
= pst
->texthigh
- pst
->textlow
;
1741 section_offsets
= pst
->section_offsets
;
1743 current_objfile
= objfile
;
1744 subfile_stack
= NULL
;
1746 stringtab_global
= DBX_STRINGTAB (objfile
);
1747 last_source_file
= NULL
;
1749 abfd
= objfile
->obfd
;
1750 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1751 symbuf_end
= symbuf_idx
= 0;
1753 /* It is necessary to actually read one symbol *before* the start
1754 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1755 occurs before the N_SO symbol.
1757 Detecting this in read_dbx_symtab
1758 would slow down initial readin, so we look for it here instead. */
1759 if (!processing_acc_compilation
&& sym_offset
>= (int) symbol_size
)
1761 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1763 bufp
= &symbuf
[symbuf_idx
++];
1764 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1765 OBJSTAT (objfile
, n_stabs
++);
1769 processing_gcc_compilation
= 0;
1770 if (nlist
.n_type
== N_TEXT
)
1772 const char *tempstring
= namestring
;
1774 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1775 processing_gcc_compilation
= 1;
1776 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1777 processing_gcc_compilation
= 2;
1778 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1780 if (STREQN (tempstring
, "__gnu_compiled", 14))
1781 processing_gcc_compilation
= 2;
1784 /* Try to select a C++ demangling based on the compilation unit
1787 if (processing_gcc_compilation
)
1789 if (AUTO_DEMANGLING
)
1791 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1797 /* The N_SO starting this symtab is the first symbol, so we
1798 better not check the symbol before it. I'm not this can
1799 happen, but it doesn't hurt to check for it. */
1800 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1801 processing_gcc_compilation
= 0;
1804 if (symbuf_idx
== symbuf_end
)
1806 bufp
= &symbuf
[symbuf_idx
];
1807 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
1808 error ("First symbol in segment of executable not a source symbol");
1810 max_symnum
= sym_size
/ symbol_size
;
1813 symnum
< max_symnum
;
1816 QUIT
; /* Allow this to be interruptable */
1817 if (symbuf_idx
== symbuf_end
)
1819 bufp
= &symbuf
[symbuf_idx
++];
1820 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1821 OBJSTAT (objfile
, n_stabs
++);
1823 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
1829 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
1830 namestring
, section_offsets
, objfile
);
1832 /* We skip checking for a new .o or -l file; that should never
1833 happen in this routine. */
1834 else if (type
== N_TEXT
)
1836 /* I don't think this code will ever be executed, because
1837 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1838 the N_SO symbol which starts this source file.
1839 However, there is no reason not to accept
1840 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1842 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1843 processing_gcc_compilation
= 1;
1844 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1845 processing_gcc_compilation
= 2;
1847 if (AUTO_DEMANGLING
)
1849 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1852 else if (type
& N_EXT
|| type
== (unsigned char) N_TEXT
1853 || type
== (unsigned char) N_NBTEXT
1856 /* Global symbol: see if we came across a dbx defintion for
1857 a corresponding symbol. If so, store the value. Remove
1858 syms from the chain when their values are stored, but
1859 search the whole chain, as there may be several syms from
1860 different files with the same name. */
1861 /* This is probably not true. Since the files will be read
1862 in one at a time, each reference to a global symbol will
1863 be satisfied in each file as it appears. So we skip this
1869 current_objfile
= NULL
;
1871 /* In a Solaris elf file, this variable, which comes from the
1872 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1873 which comes from pst->textlow is correct. */
1874 if (last_source_start_addr
== 0)
1875 last_source_start_addr
= text_offset
;
1877 /* In reordered executables last_source_start_addr may not be the
1878 lower bound for this symtab, instead use text_offset which comes
1879 from pst->textlow which is correct. */
1880 if (last_source_start_addr
> text_offset
)
1881 last_source_start_addr
= text_offset
;
1883 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1885 /* Process items which we had to "process_later" due to dependancies
1887 process_now (objfile
);
1893 /* This handles a single symbol from the symbol-file, building symbols
1894 into a GDB symtab. It takes these arguments and an implicit argument.
1896 TYPE is the type field of the ".stab" symbol entry.
1897 DESC is the desc field of the ".stab" entry.
1898 VALU is the value field of the ".stab" entry.
1899 NAME is the symbol name, in our address space.
1900 SECTION_OFFSETS is a set of amounts by which the sections of this object
1901 file were relocated when it was loaded into memory.
1902 All symbols that refer
1903 to memory locations need to be offset by these amounts.
1904 OBJFILE is the object file from which we are reading symbols.
1905 It is used in end_symtab. */
1908 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1912 struct section_offsets
*section_offsets
;
1913 struct objfile
*objfile
;
1915 #ifdef SUN_FIXED_LBRAC_BUG
1916 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1917 to correct the address of N_LBRAC's. If it is not defined, then
1918 we never need to correct the addresses. */
1920 /* This records the last pc address we've seen. We depend on there being
1921 an SLINE or FUN or SO before the first LBRAC, since the variable does
1922 not get reset in between reads of different symbol files. */
1923 static CORE_ADDR last_pc_address
;
1926 register struct context_stack
*new;
1927 /* This remembers the address of the start of a function. It is used
1928 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1929 relative to the current function's start address. On systems
1930 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1931 used to relocate these symbol types rather than SECTION_OFFSETS. */
1932 static CORE_ADDR function_start_offset
;
1934 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1935 file. Used to detect the SunPRO solaris compiler. */
1936 static int n_opt_found
;
1938 /* The stab type used for the definition of the last function.
1939 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1940 static int function_stab_type
= 0;
1942 if (!block_address_function_relative
)
1943 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1944 function start address, so just use the text offset. */
1945 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1947 /* Something is wrong if we see real data before
1948 seeing a source file name. */
1950 if (last_source_file
== NULL
&& type
!= (unsigned char) N_SO
)
1952 /* Ignore any symbols which appear before an N_SO symbol.
1953 Currently no one puts symbols there, but we should deal
1954 gracefully with the case. A complain()t might be in order,
1955 but this should not be an error (). */
1964 if (*name
== '\000')
1966 /* This N_FUN marks the end of a function. This closes off the
1968 within_function
= 0;
1969 new = pop_context ();
1971 /* Make a block for the local symbols within. */
1972 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1973 new->start_addr
, new->start_addr
+ valu
,
1976 /* May be switching to an assembler file which may not be using
1977 block relative stabs, so reset the offset. */
1978 if (block_address_function_relative
)
1979 function_start_offset
= 0;
1984 /* Relocate for dynamic loading */
1985 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1986 #ifdef SMASH_TEXT_ADDRESS
1987 SMASH_TEXT_ADDRESS (valu
);
1989 goto define_a_symbol
;
1992 /* This "symbol" just indicates the start of an inner lexical
1993 context within a function. */
1995 /* Ignore extra outermost context from SunPRO cc and acc. */
1996 if (n_opt_found
&& desc
== 1)
1999 if (block_address_function_relative
)
2000 /* Relocate for Sun ELF acc fn-relative syms. */
2001 valu
+= function_start_offset
;
2003 /* On most machines, the block addresses are relative to the
2004 N_SO, the linker did not relocate them (sigh). */
2005 valu
+= last_source_start_addr
;
2007 #ifdef SUN_FIXED_LBRAC_BUG
2008 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
)
2010 /* Patch current LBRAC pc value to match last handy pc value */
2011 complain (&lbrac_complaint
);
2012 valu
= last_pc_address
;
2015 new = push_context (desc
, valu
);
2019 /* This "symbol" just indicates the end of an inner lexical
2020 context that was started with N_LBRAC. */
2022 /* Ignore extra outermost context from SunPRO cc and acc. */
2023 if (n_opt_found
&& desc
== 1)
2026 if (block_address_function_relative
)
2027 /* Relocate for Sun ELF acc fn-relative syms. */
2028 valu
+= function_start_offset
;
2030 /* On most machines, the block addresses are relative to the
2031 N_SO, the linker did not relocate them (sigh). */
2032 valu
+= last_source_start_addr
;
2034 new = pop_context ();
2035 if (desc
!= new->depth
)
2036 complain (&lbrac_mismatch_complaint
, symnum
);
2038 /* Some compilers put the variable decls inside of an
2039 LBRAC/RBRAC block. This macro should be nonzero if this
2040 is true. DESC is N_DESC from the N_RBRAC symbol.
2041 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
2042 or the GCC2_COMPILED_SYMBOL. */
2043 #if !defined (VARIABLES_INSIDE_BLOCK)
2044 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2047 /* Can only use new->locals as local symbols here if we're in
2048 gcc or on a machine that puts them before the lbrack. */
2049 if (!VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2050 local_symbols
= new->locals
;
2052 if (context_stack_depth
2053 > !VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2055 /* This is not the outermost LBRAC...RBRAC pair in the function,
2056 its local symbols preceded it, and are the ones just recovered
2057 from the context stack. Define the block for them (but don't
2058 bother if the block contains no symbols. Should we complain
2059 on blocks without symbols? I can't think of any useful purpose
2061 if (local_symbols
!= NULL
)
2063 /* Muzzle a compiler bug that makes end < start. (which
2064 compilers? Is this ever harmful?). */
2065 if (new->start_addr
> valu
)
2067 complain (&lbrac_rbrac_complaint
);
2068 new->start_addr
= valu
;
2070 /* Make a block for the local symbols within. */
2071 finish_block (0, &local_symbols
, new->old_blocks
,
2072 new->start_addr
, valu
, objfile
);
2077 /* This is the outermost LBRAC...RBRAC pair. There is no
2078 need to do anything; leave the symbols that preceded it
2079 to be attached to the function's own block. We need to
2080 indicate that we just moved outside of the function. */
2081 within_function
= 0;
2084 if (VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2085 /* Now pop locals of block just finished. */
2086 local_symbols
= new->locals
;
2091 /* This kind of symbol indicates the start of an object file. */
2092 /* Relocate for dynamic loading */
2093 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2097 /* This type of symbol indicates the start of data
2098 for one source file.
2099 Finish the symbol table of the previous source file
2100 (if any) and start accumulating a new symbol table. */
2101 /* Relocate for dynamic loading */
2102 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2106 #ifdef SUN_FIXED_LBRAC_BUG
2107 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2110 #ifdef PCC_SOL_BROKEN
2111 /* pcc bug, occasionally puts out SO for SOL. */
2112 if (context_stack_depth
> 0)
2114 start_subfile (name
, NULL
);
2118 if (last_source_file
)
2120 /* Check if previous symbol was also an N_SO (with some
2121 sanity checks). If so, that one was actually the directory
2122 name, and the current one is the real file name.
2124 if (previous_stab_code
== (unsigned char) N_SO
)
2126 patch_subfile_names (current_subfile
, name
);
2127 break; /* Ignore repeated SOs */
2129 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
2133 /* Null name means this just marks the end of text for this .o file.
2134 Don't start a new symtab in this case. */
2135 if (*name
== '\000')
2138 if (block_address_function_relative
)
2139 function_start_offset
= 0;
2142 start_symtab (name
, NULL
, valu
);
2143 record_debugformat ("stabs");
2147 /* This type of symbol indicates the start of data for
2148 a sub-source-file, one whose contents were copied or
2149 included in the compilation of the main source file
2150 (whose name was given in the N_SO symbol.) */
2151 /* Relocate for dynamic loading */
2152 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2153 start_subfile (name
, current_subfile
->dirname
);
2158 add_new_header_file (name
, valu
);
2159 start_subfile (name
, current_subfile
->dirname
);
2163 start_subfile (pop_subfile (), current_subfile
->dirname
);
2167 add_old_header_file (name
, valu
);
2171 /* This type of "symbol" really just records
2172 one line-number -- core-address correspondence.
2173 Enter it in the line list for this symbol table. */
2175 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2176 valu
+= function_start_offset
;
2178 #ifdef SUN_FIXED_LBRAC_BUG
2179 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2181 record_line (current_subfile
, desc
, valu
);
2185 common_block_start (name
, objfile
);
2189 common_block_end (objfile
);
2192 /* The following symbol types need to have the appropriate offset added
2193 to their value; then we process symbol definitions in the name. */
2195 case N_STSYM
: /* Static symbol in data seg */
2196 case N_LCSYM
: /* Static symbol in BSS seg */
2197 case N_ROSYM
: /* Static symbol in Read-only data seg */
2198 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2199 Solaris2's stabs-in-elf makes *most* symbols relative
2200 but leaves a few absolute (at least for Solaris 2.1 and version
2201 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2202 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2203 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2204 This leaves us no choice but to search for the 'S' or 'V'...
2205 (or pass the whole section_offsets stuff down ONE MORE function
2206 call level, which we really don't want to do). */
2210 /* .o files and NLMs have non-zero text seg offsets, but don't need
2211 their static syms offset in this fashion. XXX - This is really a
2212 crock that should be fixed in the solib handling code so that I
2213 don't have to work around it here. */
2215 if (!symfile_relocatable
)
2217 p
= strchr (name
, ':');
2218 if (p
!= 0 && p
[1] == 'S')
2220 /* The linker relocated it. We don't want to add an
2221 elfstab_offset_sections-type offset, but we *do* want
2222 to add whatever solib.c passed to symbol_file_add as
2223 addr (this is known to affect SunOS4, and I suspect ELF
2224 too). Since elfstab_offset_sections currently does not
2225 muck with the text offset (there is no Ttext.text
2226 symbol), we can get addr from the text offset. If
2227 elfstab_offset_sections ever starts dealing with the
2228 text offset, and we still need to do this, we need to
2229 invent a SECT_OFF_ADDR_KLUDGE or something. */
2230 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2231 goto define_a_symbol
;
2234 /* Since it's not the kludge case, re-dispatch to the right handler. */
2248 case_N_STSYM
: /* Static symbol in data seg */
2249 case N_DSLINE
: /* Source line number, data seg */
2250 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2251 goto define_a_symbol
;
2253 case_N_LCSYM
: /* Static symbol in BSS seg */
2254 case N_BSLINE
: /* Source line number, bss seg */
2255 /* N_BROWS: overlaps with N_BSLINE */
2256 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2257 goto define_a_symbol
;
2259 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2260 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2261 goto define_a_symbol
;
2263 case N_ENTRY
: /* Alternate entry point */
2264 /* Relocate for dynamic loading */
2265 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2266 goto define_a_symbol
;
2268 /* The following symbol types we don't know how to process. Handle
2269 them in a "default" way, but complain to people who care. */
2271 case N_CATCH
: /* Exception handler catcher */
2272 case N_EHDECL
: /* Exception handler name */
2273 case N_PC
: /* Global symbol in Pascal */
2274 case N_M2C
: /* Modula-2 compilation unit */
2275 /* N_MOD2: overlaps with N_EHDECL */
2276 case N_SCOPE
: /* Modula-2 scope information */
2277 case N_ECOML
: /* End common (local name) */
2278 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2283 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2286 /* The following symbol types don't need the address field relocated,
2287 since it is either unused, or is absolute. */
2289 case N_GSYM
: /* Global variable */
2290 case N_NSYMS
: /* Number of symbols (ultrix) */
2291 case N_NOMAP
: /* No map? (ultrix) */
2292 case N_RSYM
: /* Register variable */
2293 case N_DEFD
: /* Modula-2 GNU module dependency */
2294 case N_SSYM
: /* Struct or union element */
2295 case N_LSYM
: /* Local symbol in stack */
2296 case N_PSYM
: /* Parameter variable */
2297 case N_LENG
: /* Length of preceding symbol type */
2301 char *colon_pos
= strchr (name
, ':');
2302 if (colon_pos
== NULL
)
2305 deftype
= colon_pos
[1];
2311 function_stab_type
= type
;
2313 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2314 /* Deal with the SunPRO 3.0 compiler which omits the address
2315 from N_FUN symbols. */
2317 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2319 find_stab_function_addr (name
, last_source_file
, objfile
);
2322 #ifdef SUN_FIXED_LBRAC_BUG
2323 /* The Sun acc compiler, under SunOS4, puts out
2324 functions with N_GSYM or N_STSYM. The problem is
2325 that the address of the symbol is no good (for N_GSYM
2326 it doesn't even attept an address; for N_STSYM it
2327 puts out an address but then it gets relocated
2328 relative to the data segment, not the text segment).
2329 Currently we can't fix this up later as we do for
2330 some types of symbol in scan_file_globals.
2331 Fortunately we do have a way of finding the address -
2332 we know that the value in last_pc_address is either
2333 the one we want (if we're dealing with the first
2334 function in an object file), or somewhere in the
2335 previous function. This means that we can use the
2336 minimal symbol table to get the address. */
2338 /* Starting with release 3.0, the Sun acc compiler,
2339 under SunOS4, puts out functions with N_FUN and a value
2340 of zero. This gets relocated to the start of the text
2341 segment of the module, which is no good either.
2342 Under SunOS4 we can deal with this as N_SLINE and N_SO
2343 entries contain valid absolute addresses.
2344 Release 3.0 acc also puts out N_OPT entries, which makes
2345 it possible to discern acc from cc or gcc. */
2347 if (type
== N_GSYM
|| type
== N_STSYM
2349 && n_opt_found
&& !block_address_function_relative
))
2351 struct minimal_symbol
*m
;
2352 int l
= colon_pos
- name
;
2354 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2355 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2356 && SYMBOL_NAME (m
)[l
] == '\0')
2357 /* last_pc_address was in this function */
2358 valu
= SYMBOL_VALUE (m
);
2359 else if (m
&& SYMBOL_NAME (m
+ 1)
2360 && STREQN (SYMBOL_NAME (m
+ 1), name
, l
)
2361 && SYMBOL_NAME (m
+ 1)[l
] == '\0')
2362 /* last_pc_address was in last function */
2363 valu
= SYMBOL_VALUE (m
+ 1);
2365 /* Not found - use last_pc_address (for finish_block) */
2366 valu
= last_pc_address
;
2369 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2372 if (block_address_function_relative
)
2373 /* For Solaris 2.0 compilers, the block addresses and
2374 N_SLINE's are relative to the start of the
2375 function. On normal systems, and when using gcc on
2376 Solaris 2.0, these addresses are just absolute, or
2377 relative to the N_SO, depending on
2378 BLOCK_ADDRESS_ABSOLUTE. */
2379 function_start_offset
= valu
;
2381 within_function
= 1;
2383 if (context_stack_depth
> 1)
2385 complain (&lbrac_unmatched_complaint
, symnum
);
2389 if (context_stack_depth
> 0)
2391 new = pop_context ();
2392 /* Make a block for the local symbols within. */
2393 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2394 new->start_addr
, valu
, objfile
);
2397 new = push_context (0, valu
);
2398 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2402 define_symbol (valu
, name
, desc
, type
, objfile
);
2408 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2409 for a bunch of other flags, too. Someday we may parse their
2410 flags; for now we ignore theirs and hope they'll ignore ours. */
2411 case N_OPT
: /* Solaris 2: Compiler options */
2414 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2416 processing_gcc_compilation
= 2;
2417 #if 1 /* Works, but is experimental. -fnf */
2418 if (AUTO_DEMANGLING
)
2420 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2429 /* The following symbol types can be ignored. */
2430 case N_OBJ
: /* Solaris 2: Object file dir and name */
2431 /* N_UNDF: Solaris 2: file separator mark */
2432 /* N_UNDF: -- we will never encounter it, since we only process one
2433 file's symbols at once. */
2434 case N_ENDM
: /* Solaris 2: End of module */
2435 case N_MAIN
: /* Name of main routine. */
2436 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
2440 /* '#' is a GNU C extension to allow one symbol to refer to another
2443 Generally this is used so that an alias can refer to its main
2447 /* Initialize symbol reference names and determine if this is
2448 a definition. If symbol reference is being defined, go
2449 ahead and add it. Otherwise, just return sym. */
2454 /* If this stab defines a new reference ID that is not on the
2455 reference list, then put it on the reference list.
2457 We go ahead and advance NAME past the reference, even though
2458 it is not strictly necessary at this time. */
2459 refnum
= symbol_reference_defined (&s
);
2461 if (!ref_search (refnum
))
2462 ref_add (refnum
, 0, name
, valu
);
2467 previous_stab_code
= type
;
2470 /* FIXME: The only difference between this and elfstab_build_psymtabs
2471 is the call to install_minimal_symbols for elf, and the support for
2472 split sections. If the differences are really that small, the code
2473 should be shared. */
2475 /* Scan and build partial symbols for an coff symbol file.
2476 The coff file has already been processed to get its minimal symbols.
2478 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2481 OBJFILE is the object file we are reading symbols from.
2482 ADDR is the address relative to which the symbols are (e.g.
2483 the base address of the text segment).
2484 MAINLINE is true if we are reading the main symbol
2485 table (as opposed to a shared lib or dynamically loaded file).
2486 TEXTADDR is the address of the text section.
2487 TEXTSIZE is the size of the text section.
2488 STABSECTS is the list of .stab sections in OBJFILE.
2489 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2490 .stabstr section exists.
2492 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2493 adjusted for coff details. */
2496 coffstab_build_psymtabs (objfile
, mainline
,
2497 textaddr
, textsize
, stabsects
,
2498 stabstroffset
, stabstrsize
)
2499 struct objfile
*objfile
;
2502 unsigned int textsize
;
2503 struct stab_section_list
*stabsects
;
2504 file_ptr stabstroffset
;
2505 unsigned int stabstrsize
;
2508 bfd
*sym_bfd
= objfile
->obfd
;
2509 char *name
= bfd_get_filename (sym_bfd
);
2510 struct dbx_symfile_info
*info
;
2511 unsigned int stabsize
;
2513 /* There is already a dbx_symfile_info allocated by our caller.
2514 It might even contain some info from the coff symtab to help us. */
2515 info
= objfile
->sym_stab_info
;
2517 DBX_TEXT_ADDR (objfile
) = textaddr
;
2518 DBX_TEXT_SIZE (objfile
) = textsize
;
2520 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2521 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2522 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2524 if (stabstrsize
> bfd_get_size (sym_bfd
))
2525 error ("ridiculous string table size: %d bytes", stabstrsize
);
2526 DBX_STRINGTAB (objfile
) = (char *)
2527 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+ 1);
2528 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
2530 /* Now read in the string table in one big gulp. */
2532 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2534 perror_with_name (name
);
2535 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2536 if (val
!= stabstrsize
)
2537 perror_with_name (name
);
2539 stabsread_new_init ();
2540 buildsym_new_init ();
2541 free_header_files ();
2542 init_header_files ();
2544 processing_acc_compilation
= 1;
2546 /* In a coff file, we've already installed the minimal symbols that came
2547 from the coff (non-stab) symbol table, so always act like an
2548 incremental load here. */
2549 if (stabsects
->next
== NULL
)
2551 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2552 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2553 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2557 struct stab_section_list
*stabsect
;
2559 DBX_SYMCOUNT (objfile
) = 0;
2560 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2562 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2563 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2566 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2568 symbuf_sections
= stabsects
->next
;
2569 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2573 dbx_symfile_read (objfile
, 0);
2576 /* Scan and build partial symbols for an ELF symbol file.
2577 This ELF file has already been processed to get its minimal symbols,
2578 and any DWARF symbols that were in it.
2580 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2583 OBJFILE is the object file we are reading symbols from.
2584 ADDR is the address relative to which the symbols are (e.g.
2585 the base address of the text segment).
2586 MAINLINE is true if we are reading the main symbol
2587 table (as opposed to a shared lib or dynamically loaded file).
2588 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2590 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2591 .stabstr section exists.
2593 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2594 adjusted for elf details. */
2597 elfstab_build_psymtabs (objfile
, mainline
,
2598 staboffset
, stabsize
,
2599 stabstroffset
, stabstrsize
)
2600 struct objfile
*objfile
;
2602 file_ptr staboffset
;
2603 unsigned int stabsize
;
2604 file_ptr stabstroffset
;
2605 unsigned int stabstrsize
;
2608 bfd
*sym_bfd
= objfile
->obfd
;
2609 char *name
= bfd_get_filename (sym_bfd
);
2610 struct dbx_symfile_info
*info
;
2612 /* There is already a dbx_symfile_info allocated by our caller.
2613 It might even contain some info from the ELF symtab to help us. */
2614 info
= objfile
->sym_stab_info
;
2616 /* Find the first and last text address. dbx_symfile_read seems to
2618 find_text_range (sym_bfd
, objfile
);
2620 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2621 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2622 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2623 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2624 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2626 if (stabstrsize
> bfd_get_size (sym_bfd
))
2627 error ("ridiculous string table size: %d bytes", stabstrsize
);
2628 DBX_STRINGTAB (objfile
) = (char *)
2629 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+ 1);
2630 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
2632 /* Now read in the string table in one big gulp. */
2634 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2636 perror_with_name (name
);
2637 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2638 if (val
!= stabstrsize
)
2639 perror_with_name (name
);
2641 stabsread_new_init ();
2642 buildsym_new_init ();
2643 free_header_files ();
2644 init_header_files ();
2645 install_minimal_symbols (objfile
);
2647 processing_acc_compilation
= 1;
2649 /* In an elf file, we've already installed the minimal symbols that came
2650 from the elf (non-stab) symbol table, so always act like an
2651 incremental load here. */
2652 dbx_symfile_read (objfile
, 0);
2655 /* Scan and build partial symbols for a file with special sections for stabs
2656 and stabstrings. The file has already been processed to get its minimal
2657 symbols, and any other symbols that might be necessary to resolve GSYMs.
2659 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2662 OBJFILE is the object file we are reading symbols from.
2663 ADDR is the address relative to which the symbols are (e.g. the base address
2664 of the text segment).
2665 MAINLINE is true if we are reading the main symbol table (as opposed to a
2666 shared lib or dynamically loaded file).
2667 STAB_NAME is the name of the section that contains the stabs.
2668 STABSTR_NAME is the name of the section that contains the stab strings.
2670 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2673 stabsect_build_psymtabs (objfile
, mainline
, stab_name
,
2674 stabstr_name
, text_name
)
2675 struct objfile
*objfile
;
2682 bfd
*sym_bfd
= objfile
->obfd
;
2683 char *name
= bfd_get_filename (sym_bfd
);
2685 asection
*stabstrsect
;
2686 asection
*text_sect
;
2688 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2689 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2695 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2696 stab_name
, stabstr_name
);
2698 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
2699 xmalloc (sizeof (struct dbx_symfile_info
));
2700 memset (objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
2702 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2704 error ("Can't find %s section in symbol file", text_name
);
2705 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2706 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2708 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2709 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2710 / DBX_SYMBOL_SIZE (objfile
);
2711 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2712 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2714 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2715 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2716 DBX_STRINGTAB (objfile
) = (char *)
2717 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2718 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2720 /* Now read in the string table in one big gulp. */
2722 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2723 stabstrsect
, /* bfd section */
2724 DBX_STRINGTAB (objfile
), /* input buffer */
2725 0, /* offset into section */
2726 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2729 perror_with_name (name
);
2731 stabsread_new_init ();
2732 buildsym_new_init ();
2733 free_header_files ();
2734 init_header_files ();
2735 install_minimal_symbols (objfile
);
2737 /* Now, do an incremental load */
2739 processing_acc_compilation
= 1;
2740 dbx_symfile_read (objfile
, 0);
2743 static struct sym_fns aout_sym_fns
=
2745 bfd_target_aout_flavour
,
2746 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2747 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2748 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2749 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2750 default_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2751 NULL
/* next: pointer to next struct sym_fns */
2755 _initialize_dbxread ()
2757 add_symtab_fns (&aout_sym_fns
);