1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995
3 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This module provides three functions: dbx_symfile_init,
22 which initializes to read a symbol file; dbx_new_init, which
23 discards existing cached information when all symbols are being
24 discarded; and dbx_symfile_read, which reads a symbol table
27 dbx_symfile_read only does the minimum work necessary for letting the
28 user "name" things symbolically; it does not read the entire symtab.
29 Instead, it reads the external and static symbols and puts them in partial
30 symbol tables. When more extensive information is requested of a
31 file, the corresponding partial symbol table is mutated into a full
32 fledged symbol table by going back and reading the symbols
33 for real. dbx_psymtab_to_symtab() is the function that does this */
38 #if defined(USG) || defined(__CYGNUSCLIB__)
39 #include <sys/types.h>
44 #include <sys/param.h>
51 #include "breakpoint.h"
54 #include "gdbcore.h" /* for bfd stuff */
55 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
59 #include "stabsread.h"
60 #include "gdb-stabs.h"
62 #include "language.h" /* Needed inside partial-stab.h */
63 #include "complaints.h"
65 #include "aout/aout64.h"
66 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
68 #if !defined (SEEK_SET)
73 /* Each partial symbol table entry contains a pointer to private data for the
74 sym_read function to use when expanding a partial symbol table entry
75 to a full symbol table entry. */
79 /* Offset within the file symbol table of first local symbol for this
84 /* Length (in bytes) of the section of the symbol table devoted to
85 this file's symbols (actually, the section bracketed may contain
86 more than just this file's symbols). If ldsymlen is 0, the only
87 reason for this thing's existence is the dependency list. Nothing
88 else will happen when it is read in. */
92 /* The size of each symbol in the symbol file (in external form). */
96 /* Further information needed to locate the symbols if they are in
101 int file_string_offset
;
104 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
105 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
106 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
107 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
108 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
109 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
110 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
113 /* Macro to determine which symbols to ignore when reading the first symbol
114 of a file. Some machines override this definition. */
115 #ifndef IGNORE_SYMBOL
116 /* This code is used on Ultrix systems. Ignore it */
117 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
120 /* Remember what we deduced to be the source language of this psymtab. */
122 static enum language psymtab_language
= language_unknown
;
124 /* Nonzero means give verbose info on gdb action. From main.c. */
125 extern int info_verbose
;
127 /* The BFD for this file -- implicit parameter to next_symbol_text. */
129 static bfd
*symfile_bfd
;
131 /* The size of each symbol in the symbol file (in external form).
132 This is set by dbx_symfile_read when building psymtabs, and by
133 dbx_psymtab_to_symtab when building symtabs. */
135 static unsigned symbol_size
;
137 /* This is the offset of the symbol table in the executable file */
138 static unsigned symbol_table_offset
;
140 /* This is the offset of the string table in the executable file */
141 static unsigned string_table_offset
;
143 /* For elf+stab executables, the n_strx field is not a simple index
144 into the string table. Instead, each .o file has a base offset
145 in the string table, and the associated symbols contain offsets
146 from this base. The following two variables contain the base
147 offset for the current and next .o files. */
148 static unsigned int file_string_table_offset
;
149 static unsigned int next_file_string_table_offset
;
151 /* .o and NLM files contain unrelocated addresses which are based at 0. When
152 non-zero, this flag disables some of the special cases for Solaris elf+stab
153 text addresses at location 0. */
155 static int symfile_relocatable
= 0;
157 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
158 to the function start address. */
160 static int block_address_function_relative
= 0;
162 /* The lowest text address we have yet encountered. This is needed
163 because in an a.out file, there is no header field which tells us
164 what address the program is actually going to be loaded at, so we
165 need to make guesses based on the symbols (which *are* relocated to
166 reflect the address it will be loaded at). */
167 static CORE_ADDR lowest_text_address
;
169 /* Complaints about the symbols we have encountered. */
171 struct complaint lbrac_complaint
=
172 {"bad block start address patched", 0, 0};
174 struct complaint string_table_offset_complaint
=
175 {"bad string table offset in symbol %d", 0, 0};
177 struct complaint unknown_symtype_complaint
=
178 {"unknown symbol type %s", 0, 0};
180 struct complaint unknown_symchar_complaint
=
181 {"unknown symbol descriptor `%c'", 0, 0};
183 struct complaint lbrac_rbrac_complaint
=
184 {"block start larger than block end", 0, 0};
186 struct complaint lbrac_unmatched_complaint
=
187 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
189 struct complaint lbrac_mismatch_complaint
=
190 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
192 struct complaint repeated_header_complaint
=
193 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
195 /* During initial symbol readin, we need to have a structure to keep
196 track of which psymtabs have which bincls in them. This structure
197 is used during readin to setup the list of dependencies within each
198 partial symbol table. */
200 struct header_file_location
202 char *name
; /* Name of header file */
203 int instance
; /* See above */
204 struct partial_symtab
*pst
; /* Partial symtab that has the
205 BINCL/EINCL defs for this file */
208 /* The actual list and controling variables */
209 static struct header_file_location
*bincl_list
, *next_bincl
;
210 static int bincls_allocated
;
212 /* Local function prototypes */
215 free_header_files
PARAMS ((void));
218 init_header_files
PARAMS ((void));
221 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
224 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
227 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
230 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
231 struct objfile
*objfile
));
234 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
238 free_bincl_list
PARAMS ((struct objfile
*));
240 static struct partial_symtab
*
241 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
244 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
247 init_bincl_list
PARAMS ((int, struct objfile
*));
250 dbx_next_symbol_text
PARAMS ((void));
253 fill_symbuf
PARAMS ((bfd
*));
256 dbx_symfile_init
PARAMS ((struct objfile
*));
259 dbx_new_init
PARAMS ((struct objfile
*));
262 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
265 dbx_symfile_finish
PARAMS ((struct objfile
*));
268 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
271 add_new_header_file
PARAMS ((char *, int));
274 add_old_header_file
PARAMS ((char *, int));
277 add_this_object_header_file
PARAMS ((int));
279 /* Free up old header file tables */
286 if (header_files
!= NULL
)
288 for (i
= 0; i
< n_header_files
; i
++)
290 free (header_files
[i
].name
);
292 free ((PTR
)header_files
);
296 if (this_object_header_files
)
298 free ((PTR
)this_object_header_files
);
299 this_object_header_files
= NULL
;
301 n_allocated_header_files
= 0;
302 n_allocated_this_object_header_files
= 0;
305 /* Allocate new header file tables */
311 n_allocated_header_files
= 10;
312 header_files
= (struct header_file
*)
313 xmalloc (10 * sizeof (struct header_file
));
315 n_allocated_this_object_header_files
= 10;
316 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
319 /* Add header file number I for this object file
320 at the next successive FILENUM. */
323 add_this_object_header_file (i
)
326 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
328 n_allocated_this_object_header_files
*= 2;
329 this_object_header_files
330 = (int *) xrealloc ((char *) this_object_header_files
,
331 n_allocated_this_object_header_files
* sizeof (int));
334 this_object_header_files
[n_this_object_header_files
++] = i
;
337 /* Add to this file an "old" header file, one already seen in
338 a previous object file. NAME is the header file's name.
339 INSTANCE is its instance code, to select among multiple
340 symbol tables for the same header file. */
343 add_old_header_file (name
, instance
)
347 register struct header_file
*p
= header_files
;
350 for (i
= 0; i
< n_header_files
; i
++)
351 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
353 add_this_object_header_file (i
);
356 complain (&repeated_header_complaint
, name
, symnum
);
359 /* Add to this file a "new" header file: definitions for its types follow.
360 NAME is the header file's name.
361 Most often this happens only once for each distinct header file,
362 but not necessarily. If it happens more than once, INSTANCE has
363 a different value each time, and references to the header file
364 use INSTANCE values to select among them.
366 dbx output contains "begin" and "end" markers for each new header file,
367 but at this level we just need to know which files there have been;
368 so we record the file when its "begin" is seen and ignore the "end". */
371 add_new_header_file (name
, instance
)
377 /* Make sure there is room for one more header file. */
379 if (n_header_files
== n_allocated_header_files
)
381 n_allocated_header_files
*= 2;
382 header_files
= (struct header_file
*)
383 xrealloc ((char *) header_files
,
384 (n_allocated_header_files
* sizeof (struct header_file
)));
387 /* Create an entry for this header file. */
389 i
= n_header_files
++;
390 header_files
[i
].name
= savestring (name
, strlen(name
));
391 header_files
[i
].instance
= instance
;
392 header_files
[i
].length
= 10;
393 header_files
[i
].vector
394 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
395 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
397 add_this_object_header_file (i
);
401 static struct type
**
402 explicit_lookup_type (real_filenum
, index
)
403 int real_filenum
, index
;
405 register struct header_file
*f
= &header_files
[real_filenum
];
407 if (index
>= f
->length
)
410 f
->vector
= (struct type
**)
411 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
412 memset (&f
->vector
[f
->length
/ 2],
413 '\0', f
->length
* sizeof (struct type
*) / 2);
415 return &f
->vector
[index
];
420 record_minimal_symbol (name
, address
, type
, objfile
)
424 struct objfile
*objfile
;
426 enum minimal_symbol_type ms_type
;
433 section
= SECT_OFF_TEXT
;
437 section
= SECT_OFF_DATA
;
441 section
= SECT_OFF_BSS
;
450 section
= SECT_OFF_DATA
;
453 /* I don't think this type actually exists; since a N_SETV is the result
454 of going over many .o files, it doesn't make sense to have one
456 ms_type
= mst_file_data
;
457 section
= SECT_OFF_DATA
;
464 ms_type
= mst_file_text
;
465 section
= SECT_OFF_TEXT
;
468 ms_type
= mst_file_data
;
470 /* Check for __DYNAMIC, which is used by Sun shared libraries.
471 Record it as global even if it's local, not global, so
472 lookup_minimal_symbol can find it. We don't check symbol_leading_char
473 because for SunOS4 it always is '_'. */
474 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
477 /* Same with virtual function tables, both global and static. */
479 char *tempstring
= name
;
480 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
482 if (VTBL_PREFIX_P ((tempstring
)))
485 section
= SECT_OFF_DATA
;
488 ms_type
= mst_file_bss
;
489 section
= SECT_OFF_BSS
;
492 ms_type
= mst_unknown
;
497 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
498 && address
< lowest_text_address
)
499 lowest_text_address
= address
;
501 prim_record_minimal_symbol_and_info
502 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
510 /* Scan and build partial symbols for a symbol file.
511 We have been initialized by a call to dbx_symfile_init, which
512 put all the relevant info into a "struct dbx_symfile_info",
513 hung off the objfile structure.
515 SECTION_OFFSETS contains offsets relative to which the symbols in the
516 various sections are (depending where the sections were actually loaded).
517 MAINLINE is true if we are reading the main symbol
518 table (as opposed to a shared lib or dynamically loaded file). */
521 dbx_symfile_read (objfile
, section_offsets
, mainline
)
522 struct objfile
*objfile
;
523 struct section_offsets
*section_offsets
;
524 int mainline
; /* FIXME comments above */
528 struct cleanup
*back_to
;
530 val
= strlen (objfile
->name
);
532 /* .o and .nlm files are relocatables with text, data and bss segs based at
533 0. This flag disables special (Solaris stabs-in-elf only) fixups for
534 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
535 should be fixed to determine pst->textlow without using this text seg of
538 if (strcmp (&objfile
->name
[val
-2], ".o") == 0
539 || strcmp (&objfile
->name
[val
-4], ".nlm") == 0)
540 symfile_relocatable
= 1;
542 /* This is true for Solaris (and all other systems which put stabs
543 in sections, hopefully, since it would be silly to do things
544 differently from Solaris), and false for SunOS4 and other a.out
546 block_address_function_relative
=
547 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
548 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
549 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4))
550 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "nlm", 3)));
552 sym_bfd
= objfile
->obfd
;
553 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
555 perror_with_name (objfile
->name
);
557 /* If we are reinitializing, or if we have never loaded syms yet, init */
559 || objfile
->global_psymbols
.size
== 0
560 || objfile
->static_psymbols
.size
== 0)
561 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
563 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
564 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
567 back_to
= make_cleanup (really_free_pendings
, 0);
569 init_minimal_symbol_collection ();
570 make_cleanup (discard_minimal_symbols
, 0);
572 /* Now that the symbol table data of the executable file are all in core,
573 process them and define symbols accordingly. */
575 read_dbx_symtab (section_offsets
, objfile
,
576 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
577 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
579 /* Add the dynamic symbols. */
581 read_dbx_dynamic_symtab (section_offsets
, objfile
);
583 /* Install any minimal symbols that have been collected as the current
584 minimal symbols for this objfile. */
586 install_minimal_symbols (objfile
);
588 do_cleanups (back_to
);
591 /* Initialize anything that needs initializing when a completely new
592 symbol file is specified (not just adding some symbols from another
593 file, e.g. a shared library). */
596 dbx_new_init (ignore
)
597 struct objfile
*ignore
;
599 stabsread_new_init ();
600 buildsym_new_init ();
601 init_header_files ();
605 /* dbx_symfile_init ()
606 is the dbx-specific initialization routine for reading symbols.
607 It is passed a struct objfile which contains, among other things,
608 the BFD for the file whose symbols are being read, and a slot for a pointer
609 to "private data" which we fill with goodies.
611 We read the string table into malloc'd space and stash a pointer to it.
613 Since BFD doesn't know how to read debug symbols in a format-independent
614 way (and may never do so...), we have to do it ourselves. We will never
615 be called unless this is an a.out (or very similar) file.
616 FIXME, there should be a cleaner peephole into the BFD environment here. */
618 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
621 dbx_symfile_init (objfile
)
622 struct objfile
*objfile
;
625 bfd
*sym_bfd
= objfile
->obfd
;
626 char *name
= bfd_get_filename (sym_bfd
);
627 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
629 /* Allocate struct to keep track of the symfile */
630 objfile
->sym_stab_info
= (PTR
)
631 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
633 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
634 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
635 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
637 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
639 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
640 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
641 if (!DBX_TEXT_SECT (objfile
))
642 error ("Can't find .text section in symbol file");
644 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
645 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
646 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
648 /* Read the string table and stash it away in the psymbol_obstack. It is
649 only needed as long as we need to expand psymbols into full symbols,
650 so when we blow away the psymbol the string table goes away as well.
651 Note that gdb used to use the results of attempting to malloc the
652 string table, based on the size it read, as a form of sanity check
653 for botched byte swapping, on the theory that a byte swapped string
654 table size would be so totally bogus that the malloc would fail. Now
655 that we put in on the psymbol_obstack, we can't do this since gdb gets
656 a fatal error (out of virtual memory) if the size is bogus. We can
657 however at least check to see if the size is less than the size of
658 the size field itself, or larger than the size of the entire file.
659 Note that all valid string tables have a size greater than zero, since
660 the bytes used to hold the size are included in the count. */
662 if (STRING_TABLE_OFFSET
== 0)
664 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
665 will never be zero, even when there is no string table. This
666 would appear to be a bug in bfd. */
667 DBX_STRINGTAB_SIZE (objfile
) = 0;
668 DBX_STRINGTAB (objfile
) = NULL
;
672 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
674 perror_with_name (name
);
676 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
677 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
680 perror_with_name (name
);
684 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
685 EOF if there is no string table, and attempting to read the size
686 from EOF will read zero bytes. */
687 DBX_STRINGTAB_SIZE (objfile
) = 0;
688 DBX_STRINGTAB (objfile
) = NULL
;
692 /* Read some data that would appear to be the string table size.
693 If there really is a string table, then it is probably the right
694 size. Byteswap if necessary and validate the size. Note that
695 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
696 random data that happened to be at STRING_TABLE_OFFSET, because
697 bfd can't tell us there is no string table, the sanity checks may
698 or may not catch this. */
699 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
701 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
702 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
703 error ("ridiculous string table size (%d bytes).",
704 DBX_STRINGTAB_SIZE (objfile
));
706 DBX_STRINGTAB (objfile
) =
707 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
708 DBX_STRINGTAB_SIZE (objfile
));
710 /* Now read in the string table in one big gulp. */
712 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
714 perror_with_name (name
);
715 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
717 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
718 perror_with_name (name
);
723 /* Perform any local cleanups required when we are done with a particular
724 objfile. I.E, we are in the process of discarding all symbol information
725 for an objfile, freeing up all memory held for it, and unlinking the
726 objfile struct from the global list of known objfiles. */
729 dbx_symfile_finish (objfile
)
730 struct objfile
*objfile
;
732 if (objfile
->sym_stab_info
!= NULL
)
734 mfree (objfile
-> md
, objfile
->sym_stab_info
);
736 free_header_files ();
740 /* Buffer for reading the symbol table entries. */
741 static struct internal_nlist symbuf
[4096];
742 static int symbuf_idx
;
743 static int symbuf_end
;
745 /* Name of last function encountered. Used in Solaris to approximate
746 object file boundaries. */
747 static char *last_function_name
;
749 /* The address in memory of the string table of the object file we are
750 reading (which might not be the "main" object file, but might be a
751 shared library or some other dynamically loaded thing). This is
752 set by read_dbx_symtab when building psymtabs, and by
753 read_ofile_symtab when building symtabs, and is used only by
754 next_symbol_text. FIXME: If that is true, we don't need it when
755 building psymtabs, right? */
756 static char *stringtab_global
;
758 /* Refill the symbol table input buffer
759 and set the variables that control fetching entries from it.
760 Reports an error if no data available.
761 This function can read past the end of the symbol table
762 (into the string table) but this does no harm. */
765 fill_symbuf (sym_bfd
)
768 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
770 perror_with_name (bfd_get_filename (sym_bfd
));
771 else if (nbytes
== 0)
772 error ("Premature end of file reading symbol table");
773 symbuf_end
= nbytes
/ symbol_size
;
777 #define SWAP_SYMBOL(symp, abfd) \
779 (symp)->n_strx = bfd_h_get_32(abfd, \
780 (unsigned char *)&(symp)->n_strx); \
781 (symp)->n_desc = bfd_h_get_16 (abfd, \
782 (unsigned char *)&(symp)->n_desc); \
783 (symp)->n_value = bfd_h_get_32 (abfd, \
784 (unsigned char *)&(symp)->n_value); \
787 /* Invariant: The symbol pointed to by symbuf_idx is the first one
788 that hasn't been swapped. Swap the symbol at the same time
789 that symbuf_idx is incremented. */
791 /* dbx allows the text of a symbol name to be continued into the
792 next symbol name! When such a continuation is encountered
793 (a \ at the end of the text of a name)
794 call this function to get the continuation. */
797 dbx_next_symbol_text ()
799 if (symbuf_idx
== symbuf_end
)
800 fill_symbuf (symfile_bfd
);
802 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
803 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
804 + file_string_table_offset
;
807 /* Initialize the list of bincls to contain none and have some
811 init_bincl_list (number
, objfile
)
813 struct objfile
*objfile
;
815 bincls_allocated
= number
;
816 next_bincl
= bincl_list
= (struct header_file_location
*)
817 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
820 /* Add a bincl to the list. */
823 add_bincl_to_list (pst
, name
, instance
)
824 struct partial_symtab
*pst
;
828 if (next_bincl
>= bincl_list
+ bincls_allocated
)
830 int offset
= next_bincl
- bincl_list
;
831 bincls_allocated
*= 2;
832 bincl_list
= (struct header_file_location
*)
833 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
834 bincls_allocated
* sizeof (struct header_file_location
));
835 next_bincl
= bincl_list
+ offset
;
837 next_bincl
->pst
= pst
;
838 next_bincl
->instance
= instance
;
839 next_bincl
++->name
= name
;
842 /* Given a name, value pair, find the corresponding
843 bincl in the list. Return the partial symtab associated
844 with that header_file_location. */
846 static struct partial_symtab
*
847 find_corresponding_bincl_psymtab (name
, instance
)
851 struct header_file_location
*bincl
;
853 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
854 if (bincl
->instance
== instance
855 && STREQ (name
, bincl
->name
))
858 complain (&repeated_header_complaint
, name
, symnum
);
859 return (struct partial_symtab
*) 0;
862 /* Free the storage allocated for the bincl list. */
865 free_bincl_list (objfile
)
866 struct objfile
*objfile
;
868 mfree (objfile
-> md
, (PTR
)bincl_list
);
869 bincls_allocated
= 0;
872 /* Scan a SunOs dynamic symbol table for symbols of interest and
873 add them to the minimal symbol table. */
876 read_dbx_dynamic_symtab (section_offsets
, objfile
)
877 struct section_offsets
*section_offsets
;
878 struct objfile
*objfile
;
880 bfd
*abfd
= objfile
->obfd
;
881 struct cleanup
*back_to
;
894 /* Check that the symbol file has dynamic symbols that we know about.
895 bfd_arch_unknown can happen if we are reading a sun3 symbol file
896 on a sun4 host (and vice versa) and bfd is not configured
897 --with-target=all. This would trigger an assertion in bfd/sunos.c,
898 so we ignore the dynamic symbols in this case. */
899 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
900 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
901 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
904 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
908 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
909 back_to
= make_cleanup (free
, dynsyms
);
911 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
912 if (dynsym_count
< 0)
914 do_cleanups (back_to
);
918 /* Enter dynamic symbols into the minimal symbol table
919 if this is a stripped executable. */
920 if (bfd_get_symcount (abfd
) <= 0)
923 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
925 asymbol
*sym
= *symptr
;
929 sec
= bfd_get_section (sym
);
931 /* BFD symbols are section relative. */
932 sym_value
= sym
->value
+ sec
->vma
;
934 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
936 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
939 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
941 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
944 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
946 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
952 if (sym
->flags
& BSF_GLOBAL
)
955 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
960 /* Symbols from shared libraries have a dynamic relocation entry
961 that points to the associated slot in the procedure linkage table.
962 We make a mininal symbol table entry with type mst_solib_trampoline
963 at the address in the procedure linkage table. */
964 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
967 do_cleanups (back_to
);
971 dynrels
= (arelent
**) xmalloc (dynrel_size
);
972 make_cleanup (free
, dynrels
);
974 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
975 if (dynrel_count
< 0)
977 do_cleanups (back_to
);
981 for (counter
= 0, relptr
= dynrels
;
982 counter
< dynrel_count
;
985 arelent
*rel
= *relptr
;
987 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
989 switch (bfd_get_arch (abfd
))
992 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
996 /* `16' is the type BFD produces for a jump table relocation. */
997 if (rel
->howto
->type
!= 16)
1000 /* Adjust address in the jump table to point to
1001 the start of the bsr instruction. */
1008 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1009 prim_record_minimal_symbol
1010 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
1012 mst_solib_trampoline
,
1016 do_cleanups (back_to
);
1019 /* Given pointers to an a.out symbol table in core containing dbx
1020 style data, setup partial_symtab's describing each source file for
1021 which debugging information is available.
1022 SYMFILE_NAME is the name of the file we are reading from
1023 and SECTION_OFFSETS is the set of offsets for the various sections
1024 of the file (a set of zeros if the mainline program). */
1027 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1028 struct section_offsets
*section_offsets
;
1029 struct objfile
*objfile
;
1030 CORE_ADDR text_addr
;
1033 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1034 register char *namestring
;
1036 int past_first_source_file
= 0;
1037 CORE_ADDR last_o_file_start
= 0;
1038 struct cleanup
*back_to
;
1041 /* Current partial symtab */
1042 struct partial_symtab
*pst
;
1044 /* List of current psymtab's include files */
1045 char **psymtab_include_list
;
1046 int includes_allocated
;
1049 /* Index within current psymtab dependency list */
1050 struct partial_symtab
**dependency_list
;
1051 int dependencies_used
, dependencies_allocated
;
1053 /* FIXME. We probably want to change stringtab_global rather than add this
1054 while processing every symbol entry. FIXME. */
1055 file_string_table_offset
= 0;
1056 next_file_string_table_offset
= 0;
1058 stringtab_global
= DBX_STRINGTAB (objfile
);
1060 pst
= (struct partial_symtab
*) 0;
1062 includes_allocated
= 30;
1064 psymtab_include_list
= (char **) alloca (includes_allocated
*
1067 dependencies_allocated
= 30;
1068 dependencies_used
= 0;
1070 (struct partial_symtab
**) alloca (dependencies_allocated
*
1071 sizeof (struct partial_symtab
*));
1073 /* Init bincl list */
1074 init_bincl_list (20, objfile
);
1075 back_to
= make_cleanup (free_bincl_list
, objfile
);
1077 last_source_file
= NULL
;
1079 lowest_text_address
= (CORE_ADDR
)-1;
1081 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1082 abfd
= objfile
->obfd
;
1083 symbuf_end
= symbuf_idx
= 0;
1084 next_symbol_text_func
= dbx_next_symbol_text
;
1086 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1088 /* Get the symbol for this run and pull out some info */
1089 QUIT
; /* allow this to be interruptable */
1090 if (symbuf_idx
== symbuf_end
)
1092 bufp
= &symbuf
[symbuf_idx
++];
1095 * Special case to speed up readin.
1097 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1099 SWAP_SYMBOL (bufp
, abfd
);
1101 /* Ok. There is a lot of code duplicated in the rest of this
1102 switch statement (for efficiency reasons). Since I don't
1103 like duplicating code, I will do my penance here, and
1104 describe the code which is duplicated:
1106 *) The assignment to namestring.
1107 *) The call to strchr.
1108 *) The addition of a partial symbol the the two partial
1109 symbol lists. This last is a large section of code, so
1110 I've imbedded it in the following macro.
1113 /* Set namestring based on bufp. If the string table index is invalid,
1114 give a fake name, and print a single error message per symbol file read,
1115 rather than abort the symbol reading or flood the user with messages. */
1117 /*FIXME: Too many adds and indirections in here for the inner loop. */
1118 #define SET_NAMESTRING()\
1119 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1120 DBX_STRINGTAB_SIZE (objfile)) { \
1121 complain (&string_table_offset_complaint, symnum); \
1122 namestring = "<bad string table offset>"; \
1124 namestring = bufp->n_strx + file_string_table_offset + \
1125 DBX_STRINGTAB (objfile)
1127 #define CUR_SYMBOL_TYPE bufp->n_type
1128 #define CUR_SYMBOL_VALUE bufp->n_value
1129 #define DBXREAD_ONLY
1130 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1131 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1132 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1133 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1135 #include "partial-stab.h"
1138 /* If there's stuff to be cleaned up, clean it up. */
1139 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1140 /*FIXME, does this have a bug at start address 0? */
1141 && last_o_file_start
1142 && objfile
-> ei
.entry_point
< bufp
->n_value
1143 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1145 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1146 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1151 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1152 symnum
* symbol_size
,
1153 (lowest_text_address
== (CORE_ADDR
)-1
1154 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1155 : lowest_text_address
)
1157 dependency_list
, dependencies_used
);
1160 do_cleanups (back_to
);
1163 /* Allocate and partially fill a partial symtab. It will be
1164 completely filled at the end of the symbol list.
1166 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1167 is the address relative to which its symbols are (incremental) or 0
1171 struct partial_symtab
*
1172 start_psymtab (objfile
, section_offsets
,
1173 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1174 struct objfile
*objfile
;
1175 struct section_offsets
*section_offsets
;
1179 struct partial_symbol
*global_syms
;
1180 struct partial_symbol
*static_syms
;
1182 struct partial_symtab
*result
=
1183 start_psymtab_common(objfile
, section_offsets
,
1184 filename
, textlow
, global_syms
, static_syms
);
1186 result
->read_symtab_private
= (char *)
1187 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1188 LDSYMOFF(result
) = ldsymoff
;
1189 result
->read_symtab
= dbx_psymtab_to_symtab
;
1190 SYMBOL_SIZE(result
) = symbol_size
;
1191 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1192 STRING_OFFSET(result
) = string_table_offset
;
1193 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1195 /* If we're handling an ELF file, drag some section-relocation info
1196 for this source file out of the ELF symbol table, to compensate for
1197 Sun brain death. This replaces the section_offsets in this psymtab,
1199 elfstab_offset_sections (objfile
, result
);
1201 /* Deduce the source language from the filename for this psymtab. */
1202 psymtab_language
= deduce_language_from_filename (filename
);
1207 /* Close off the current usage of PST.
1208 Returns PST or NULL if the partial symtab was empty and thrown away.
1210 FIXME: List variables and peculiarities of same. */
1212 struct partial_symtab
*
1213 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1214 capping_text
, dependency_list
, number_dependencies
)
1215 struct partial_symtab
*pst
;
1216 char **include_list
;
1218 int capping_symbol_offset
;
1219 CORE_ADDR capping_text
;
1220 struct partial_symtab
**dependency_list
;
1221 int number_dependencies
;
1224 struct objfile
*objfile
= pst
-> objfile
;
1226 if (capping_symbol_offset
!= -1)
1227 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1228 pst
->texthigh
= capping_text
;
1230 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1231 /* Under Solaris, the N_SO symbols always have a value of 0,
1232 instead of the usual address of the .o file. Therefore,
1233 we have to do some tricks to fill in texthigh and textlow.
1234 The first trick is in partial-stab.h: if we see a static
1235 or global function, and the textlow for the current pst
1236 is still 0, then we use that function's address for
1237 the textlow of the pst. */
1239 /* Now, to fill in texthigh, we remember the last function seen
1240 in the .o file (also in partial-stab.h). Also, there's a hack in
1241 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1242 to here via the misc_info field. Therefore, we can fill in
1243 a reliable texthigh by taking the address plus size of the
1244 last function in the file. */
1246 if (pst
->texthigh
== 0 && last_function_name
) {
1249 struct minimal_symbol
*minsym
;
1251 p
= strchr (last_function_name
, ':');
1253 p
= last_function_name
;
1254 n
= p
- last_function_name
;
1256 strncpy (p
, last_function_name
, n
);
1259 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1262 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1263 (long) MSYMBOL_INFO (minsym
);
1265 last_function_name
= NULL
;
1268 /* this test will be true if the last .o file is only data */
1269 if (pst
->textlow
== 0)
1270 /* This loses if the text section really starts at address zero
1271 (generally true when we are debugging a .o file, for example).
1272 That is why this whole thing is inside SOFUN_ADDRESS_MAYBE_MISSING. */
1273 pst
->textlow
= pst
->texthigh
;
1275 /* If we know our own starting text address, then walk through all other
1276 psymtabs for this objfile, and if any didn't know their ending text
1277 address, set it to our starting address. Take care to not set our
1278 own ending address to our starting address, nor to set addresses on
1279 `dependency' files that have both textlow and texthigh zero. */
1281 struct partial_symtab
*p1
;
1283 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1284 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1285 p1
->texthigh
= pst
->textlow
;
1286 /* if this file has only data, then make textlow match texthigh */
1287 if (p1
->textlow
== 0)
1288 p1
->textlow
= p1
->texthigh
;
1293 /* End of kludge for patching Solaris textlow and texthigh. */
1294 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1296 pst
->n_global_syms
=
1297 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1298 pst
->n_static_syms
=
1299 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1301 pst
->number_of_dependencies
= number_dependencies
;
1302 if (number_dependencies
)
1304 pst
->dependencies
= (struct partial_symtab
**)
1305 obstack_alloc (&objfile
->psymbol_obstack
,
1306 number_dependencies
* sizeof (struct partial_symtab
*));
1307 memcpy (pst
->dependencies
, dependency_list
,
1308 number_dependencies
* sizeof (struct partial_symtab
*));
1311 pst
->dependencies
= 0;
1313 for (i
= 0; i
< num_includes
; i
++)
1315 struct partial_symtab
*subpst
=
1316 allocate_psymtab (include_list
[i
], objfile
);
1318 subpst
->section_offsets
= pst
->section_offsets
;
1319 subpst
->read_symtab_private
=
1320 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1321 sizeof (struct symloc
));
1325 subpst
->texthigh
= 0;
1327 /* We could save slight bits of space by only making one of these,
1328 shared by the entire set of include files. FIXME-someday. */
1329 subpst
->dependencies
= (struct partial_symtab
**)
1330 obstack_alloc (&objfile
->psymbol_obstack
,
1331 sizeof (struct partial_symtab
*));
1332 subpst
->dependencies
[0] = pst
;
1333 subpst
->number_of_dependencies
= 1;
1335 subpst
->globals_offset
=
1336 subpst
->n_global_syms
=
1337 subpst
->statics_offset
=
1338 subpst
->n_static_syms
= 0;
1342 subpst
->read_symtab
= pst
->read_symtab
;
1345 sort_pst_symbols (pst
);
1347 /* If there is already a psymtab or symtab for a file of this name, remove it.
1348 (If there is a symtab, more drastic things also happen.)
1349 This happens in VxWorks. */
1350 free_named_symtabs (pst
->filename
);
1352 if (num_includes
== 0
1353 && number_dependencies
== 0
1354 && pst
->n_global_syms
== 0
1355 && pst
->n_static_syms
== 0)
1357 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1358 it is on the obstack, but we can forget to chain it on the list. */
1359 /* Empty psymtabs happen as a result of header files which don't have
1360 any symbols in them. There can be a lot of them. But this check
1361 is wrong, in that a psymtab with N_SLINE entries but nothing else
1362 is not empty, but we don't realize that. Fixing that without slowing
1363 things down might be tricky. */
1364 struct partial_symtab
*prev_pst
;
1366 /* First, snip it out of the psymtab chain */
1368 if (pst
->objfile
->psymtabs
== pst
)
1369 pst
->objfile
->psymtabs
= pst
->next
;
1371 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1372 if (prev_pst
->next
== pst
)
1373 prev_pst
->next
= pst
->next
;
1375 /* Next, put it on a free list for recycling */
1377 pst
->next
= pst
->objfile
->free_psymtabs
;
1378 pst
->objfile
->free_psymtabs
= pst
;
1380 /* Indicate that psymtab was thrown away. */
1381 pst
= (struct partial_symtab
*)NULL
;
1387 dbx_psymtab_to_symtab_1 (pst
)
1388 struct partial_symtab
*pst
;
1390 struct cleanup
*old_chain
;
1398 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1403 /* Read in all partial symtabs on which this one is dependent */
1404 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1405 if (!pst
->dependencies
[i
]->readin
)
1407 /* Inform about additional files that need to be read in. */
1410 fputs_filtered (" ", gdb_stdout
);
1412 fputs_filtered ("and ", gdb_stdout
);
1414 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1415 wrap_here (""); /* Flush output */
1416 gdb_flush (gdb_stdout
);
1418 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1421 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1423 /* Init stuff necessary for reading in symbols */
1426 old_chain
= make_cleanup (really_free_pendings
, 0);
1427 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1428 symbol_size
= SYMBOL_SIZE (pst
);
1430 /* Read in this file's symbols */
1431 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1432 read_ofile_symtab (pst
);
1433 sort_symtab_syms (pst
->symtab
);
1435 do_cleanups (old_chain
);
1441 /* Read in all of the symbols for a given psymtab for real.
1442 Be verbose about it if the user wants that. */
1445 dbx_psymtab_to_symtab (pst
)
1446 struct partial_symtab
*pst
;
1455 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1460 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1462 /* Print the message now, before reading the string table,
1463 to avoid disconcerting pauses. */
1466 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1467 gdb_flush (gdb_stdout
);
1470 sym_bfd
= pst
->objfile
->obfd
;
1472 next_symbol_text_func
= dbx_next_symbol_text
;
1474 dbx_psymtab_to_symtab_1 (pst
);
1476 /* Match with global symbols. This only needs to be done once,
1477 after all of the symtabs and dependencies have been read in. */
1478 scan_file_globals (pst
->objfile
);
1480 /* Finish up the debug error message. */
1482 printf_filtered ("done.\n");
1486 /* Read in a defined section of a specific object file's symbols. */
1489 read_ofile_symtab (pst
)
1490 struct partial_symtab
*pst
;
1492 register char *namestring
;
1493 register struct internal_nlist
*bufp
;
1495 unsigned max_symnum
;
1497 struct objfile
*objfile
;
1498 int sym_offset
; /* Offset to start of symbols to read */
1499 int sym_size
; /* Size of symbols to read */
1500 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1501 int text_size
; /* Size of text segment for symbols */
1502 struct section_offsets
*section_offsets
;
1504 objfile
= pst
->objfile
;
1505 sym_offset
= LDSYMOFF(pst
);
1506 sym_size
= LDSYMLEN(pst
);
1507 text_offset
= pst
->textlow
;
1508 text_size
= pst
->texthigh
- pst
->textlow
;
1509 section_offsets
= pst
->section_offsets
;
1511 current_objfile
= objfile
;
1512 subfile_stack
= NULL
;
1514 stringtab_global
= DBX_STRINGTAB (objfile
);
1515 last_source_file
= NULL
;
1517 abfd
= objfile
->obfd
;
1518 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1519 symbuf_end
= symbuf_idx
= 0;
1521 /* It is necessary to actually read one symbol *before* the start
1522 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1523 occurs before the N_SO symbol.
1525 Detecting this in read_dbx_symtab
1526 would slow down initial readin, so we look for it here instead. */
1527 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1529 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1531 bufp
= &symbuf
[symbuf_idx
++];
1532 SWAP_SYMBOL (bufp
, abfd
);
1536 processing_gcc_compilation
= 0;
1537 if (bufp
->n_type
== N_TEXT
)
1539 const char *tempstring
= namestring
;
1541 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1542 processing_gcc_compilation
= 1;
1543 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1544 processing_gcc_compilation
= 2;
1545 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1547 if (STREQN (tempstring
, "__gnu_compiled", 14))
1548 processing_gcc_compilation
= 2;
1551 /* Try to select a C++ demangling based on the compilation unit
1554 if (processing_gcc_compilation
)
1556 if (AUTO_DEMANGLING
)
1558 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1564 /* The N_SO starting this symtab is the first symbol, so we
1565 better not check the symbol before it. I'm not this can
1566 happen, but it doesn't hurt to check for it. */
1567 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1568 processing_gcc_compilation
= 0;
1571 if (symbuf_idx
== symbuf_end
)
1573 bufp
= &symbuf
[symbuf_idx
];
1574 if (bufp
->n_type
!= (unsigned char)N_SO
)
1575 error("First symbol in segment of executable not a source symbol");
1577 max_symnum
= sym_size
/ symbol_size
;
1580 symnum
< max_symnum
;
1583 QUIT
; /* Allow this to be interruptable */
1584 if (symbuf_idx
== symbuf_end
)
1586 bufp
= &symbuf
[symbuf_idx
++];
1587 SWAP_SYMBOL (bufp
, abfd
);
1589 type
= bufp
->n_type
;
1593 if (type
& N_STAB
) {
1594 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1595 namestring
, section_offsets
, objfile
);
1597 /* We skip checking for a new .o or -l file; that should never
1598 happen in this routine. */
1599 else if (type
== N_TEXT
)
1601 /* I don't think this code will ever be executed, because
1602 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1603 the N_SO symbol which starts this source file.
1604 However, there is no reason not to accept
1605 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1607 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1608 processing_gcc_compilation
= 1;
1609 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1610 processing_gcc_compilation
= 2;
1612 if (AUTO_DEMANGLING
)
1614 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1617 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1618 || type
== (unsigned char)N_NBTEXT
1620 /* Global symbol: see if we came across a dbx defintion for
1621 a corresponding symbol. If so, store the value. Remove
1622 syms from the chain when their values are stored, but
1623 search the whole chain, as there may be several syms from
1624 different files with the same name. */
1625 /* This is probably not true. Since the files will be read
1626 in one at a time, each reference to a global symbol will
1627 be satisfied in each file as it appears. So we skip this
1633 current_objfile
= NULL
;
1635 /* In a Solaris elf file, this variable, which comes from the
1636 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1637 which comes from pst->textlow is correct. */
1638 if (last_source_start_addr
== 0)
1639 last_source_start_addr
= text_offset
;
1641 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1647 /* This handles a single symbol from the symbol-file, building symbols
1648 into a GDB symtab. It takes these arguments and an implicit argument.
1650 TYPE is the type field of the ".stab" symbol entry.
1651 DESC is the desc field of the ".stab" entry.
1652 VALU is the value field of the ".stab" entry.
1653 NAME is the symbol name, in our address space.
1654 SECTION_OFFSETS is a set of amounts by which the sections of this object
1655 file were relocated when it was loaded into memory.
1656 All symbols that refer
1657 to memory locations need to be offset by these amounts.
1658 OBJFILE is the object file from which we are reading symbols.
1659 It is used in end_symtab. */
1662 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1666 struct section_offsets
*section_offsets
;
1667 struct objfile
*objfile
;
1669 #ifdef SUN_FIXED_LBRAC_BUG
1670 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1671 to correct the address of N_LBRAC's. If it is not defined, then
1672 we never need to correct the addresses. */
1674 /* This records the last pc address we've seen. We depend on there being
1675 an SLINE or FUN or SO before the first LBRAC, since the variable does
1676 not get reset in between reads of different symbol files. */
1677 static CORE_ADDR last_pc_address
;
1680 register struct context_stack
*new;
1681 /* This remembers the address of the start of a function. It is used
1682 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1683 relative to the current function's start address. On systems
1684 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1685 used to relocate these symbol types rather than SECTION_OFFSETS. */
1686 static CORE_ADDR function_start_offset
;
1688 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1689 file. Used to detect the SunPRO solaris compiler. */
1690 static int n_opt_found
;
1692 /* The stab type used for the definition of the last function.
1693 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1694 static int function_stab_type
= 0;
1696 if (!block_address_function_relative
)
1697 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1698 function start address, so just use the text offset. */
1699 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1701 /* Something is wrong if we see real data before
1702 seeing a source file name. */
1704 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1706 /* Ignore any symbols which appear before an N_SO symbol. Currently
1707 no one puts symbols there, but we should deal gracefully with the
1708 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1709 but this should not be an error (). */
1717 /* Relocate for dynamic loading */
1718 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1719 goto define_a_symbol
;
1722 /* This "symbol" just indicates the start of an inner lexical
1723 context within a function. */
1725 /* Ignore extra outermost context from SunPRO cc and acc. */
1726 if (n_opt_found
&& desc
== 1)
1729 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1730 /* Relocate for dynamic loading (?). */
1731 valu
+= function_start_offset
;
1733 if (block_address_function_relative
)
1734 /* Relocate for Sun ELF acc fn-relative syms. */
1735 valu
+= function_start_offset
;
1737 /* On most machines, the block addresses are relative to the
1738 N_SO, the linker did not relocate them (sigh). */
1739 valu
+= last_source_start_addr
;
1742 #ifdef SUN_FIXED_LBRAC_BUG
1743 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1744 /* Patch current LBRAC pc value to match last handy pc value */
1745 complain (&lbrac_complaint
);
1746 valu
= last_pc_address
;
1749 new = push_context (desc
, valu
);
1753 /* This "symbol" just indicates the end of an inner lexical
1754 context that was started with N_LBRAC. */
1756 /* Ignore extra outermost context from SunPRO cc and acc. */
1757 if (n_opt_found
&& desc
== 1)
1760 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1761 /* Relocate for dynamic loading (?). */
1762 valu
+= function_start_offset
;
1764 if (block_address_function_relative
)
1765 /* Relocate for Sun ELF acc fn-relative syms. */
1766 valu
+= function_start_offset
;
1768 /* On most machines, the block addresses are relative to the
1769 N_SO, the linker did not relocate them (sigh). */
1770 valu
+= last_source_start_addr
;
1773 new = pop_context();
1774 if (desc
!= new->depth
)
1775 complain (&lbrac_mismatch_complaint
, symnum
);
1777 /* Some compilers put the variable decls inside of an
1778 LBRAC/RBRAC block. This macro should be nonzero if this
1779 is true. DESC is N_DESC from the N_RBRAC symbol.
1780 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1781 or the GCC2_COMPILED_SYMBOL. */
1782 #if !defined (VARIABLES_INSIDE_BLOCK)
1783 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1786 /* Can only use new->locals as local symbols here if we're in
1787 gcc or on a machine that puts them before the lbrack. */
1788 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1789 local_symbols
= new->locals
;
1791 if (context_stack_depth
1792 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1794 /* This is not the outermost LBRAC...RBRAC pair in the function,
1795 its local symbols preceded it, and are the ones just recovered
1796 from the context stack. Define the block for them (but don't
1797 bother if the block contains no symbols. Should we complain
1798 on blocks without symbols? I can't think of any useful purpose
1800 if (local_symbols
!= NULL
)
1802 /* Muzzle a compiler bug that makes end < start. (which
1803 compilers? Is this ever harmful?). */
1804 if (new->start_addr
> valu
)
1806 complain (&lbrac_rbrac_complaint
);
1807 new->start_addr
= valu
;
1809 /* Make a block for the local symbols within. */
1810 finish_block (0, &local_symbols
, new->old_blocks
,
1811 new->start_addr
, valu
, objfile
);
1816 /* This is the outermost LBRAC...RBRAC pair. There is no
1817 need to do anything; leave the symbols that preceded it
1818 to be attached to the function's own block. We need to
1819 indicate that we just moved outside of the function. */
1820 within_function
= 0;
1823 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1824 /* Now pop locals of block just finished. */
1825 local_symbols
= new->locals
;
1830 /* This kind of symbol indicates the start of an object file. */
1831 /* Relocate for dynamic loading */
1832 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1836 /* This type of symbol indicates the start of data
1837 for one source file.
1838 Finish the symbol table of the previous source file
1839 (if any) and start accumulating a new symbol table. */
1840 /* Relocate for dynamic loading */
1841 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1845 #ifdef SUN_FIXED_LBRAC_BUG
1846 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1849 #ifdef PCC_SOL_BROKEN
1850 /* pcc bug, occasionally puts out SO for SOL. */
1851 if (context_stack_depth
> 0)
1853 start_subfile (name
, NULL
);
1857 if (last_source_file
)
1859 /* Check if previous symbol was also an N_SO (with some
1860 sanity checks). If so, that one was actually the directory
1861 name, and the current one is the real file name.
1863 if (previous_stab_code
== (unsigned char) N_SO
)
1865 patch_subfile_names (current_subfile
, name
);
1866 break; /* Ignore repeated SOs */
1868 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1872 /* Null name means this just marks the end of text for this .o file.
1873 Don't start a new symtab in this case. */
1874 if (*name
== '\000')
1878 start_symtab (name
, NULL
, valu
);
1882 /* This type of symbol indicates the start of data for
1883 a sub-source-file, one whose contents were copied or
1884 included in the compilation of the main source file
1885 (whose name was given in the N_SO symbol.) */
1886 /* Relocate for dynamic loading */
1887 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1888 start_subfile (name
, current_subfile
->dirname
);
1893 add_new_header_file (name
, valu
);
1894 start_subfile (name
, current_subfile
->dirname
);
1898 start_subfile (pop_subfile (), current_subfile
->dirname
);
1902 add_old_header_file (name
, valu
);
1906 /* This type of "symbol" really just records
1907 one line-number -- core-address correspondence.
1908 Enter it in the line list for this symbol table. */
1909 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1910 valu
+= function_start_offset
;
1911 #ifdef SUN_FIXED_LBRAC_BUG
1912 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1914 record_line (current_subfile
, desc
, valu
);
1918 common_block_start (name
, objfile
);
1922 common_block_end (objfile
);
1925 /* The following symbol types need to have the appropriate offset added
1926 to their value; then we process symbol definitions in the name. */
1928 case N_STSYM
: /* Static symbol in data seg */
1929 case N_LCSYM
: /* Static symbol in BSS seg */
1930 case N_ROSYM
: /* Static symbol in Read-only data seg */
1931 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1932 Solaris2's stabs-in-elf makes *most* symbols relative
1933 but leaves a few absolute (at least for Solaris 2.1 and version
1934 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1935 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1936 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1937 This leaves us no choice but to search for the 'S' or 'V'...
1938 (or pass the whole section_offsets stuff down ONE MORE function
1939 call level, which we really don't want to do). */
1943 /* .o files and NLMs have non-zero text seg offsets, but don't need
1944 their static syms offset in this fashion. XXX - This is really a
1945 crock that should be fixed in the solib handling code so that I
1946 don't have to work around it here. */
1948 if (!symfile_relocatable
)
1950 p
= strchr (name
, ':');
1951 if (p
!= 0 && p
[1] == 'S')
1953 /* The linker relocated it. We don't want to add an
1954 elfstab_offset_sections-type offset, but we *do* want
1955 to add whatever solib.c passed to symbol_file_add as
1956 addr (this is known to affect SunOS4, and I suspect ELF
1957 too). Since elfstab_offset_sections currently does not
1958 muck with the text offset (there is no Ttext.text
1959 symbol), we can get addr from the text offset. If
1960 elfstab_offset_sections ever starts dealing with the
1961 text offset, and we still need to do this, we need to
1962 invent a SECT_OFF_ADDR_KLUDGE or something. */
1963 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1964 goto define_a_symbol
;
1967 /* Since it's not the kludge case, re-dispatch to the right handler. */
1969 case N_STSYM
: goto case_N_STSYM
;
1970 case N_LCSYM
: goto case_N_LCSYM
;
1971 case N_ROSYM
: goto case_N_ROSYM
;
1976 case_N_STSYM
: /* Static symbol in data seg */
1977 case N_DSLINE
: /* Source line number, data seg */
1978 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1979 goto define_a_symbol
;
1981 case_N_LCSYM
: /* Static symbol in BSS seg */
1982 case N_BSLINE
: /* Source line number, bss seg */
1983 /* N_BROWS: overlaps with N_BSLINE */
1984 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1985 goto define_a_symbol
;
1987 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1988 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1989 goto define_a_symbol
;
1991 case N_ENTRY
: /* Alternate entry point */
1992 /* Relocate for dynamic loading */
1993 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1994 goto define_a_symbol
;
1996 /* The following symbol types we don't know how to process. Handle
1997 them in a "default" way, but complain to people who care. */
1999 case N_CATCH
: /* Exception handler catcher */
2000 case N_EHDECL
: /* Exception handler name */
2001 case N_PC
: /* Global symbol in Pascal */
2002 case N_M2C
: /* Modula-2 compilation unit */
2003 /* N_MOD2: overlaps with N_EHDECL */
2004 case N_SCOPE
: /* Modula-2 scope information */
2005 case N_ECOML
: /* End common (local name) */
2006 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2011 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2014 /* The following symbol types don't need the address field relocated,
2015 since it is either unused, or is absolute. */
2017 case N_GSYM
: /* Global variable */
2018 case N_NSYMS
: /* Number of symbols (ultrix) */
2019 case N_NOMAP
: /* No map? (ultrix) */
2020 case N_RSYM
: /* Register variable */
2021 case N_DEFD
: /* Modula-2 GNU module dependency */
2022 case N_SSYM
: /* Struct or union element */
2023 case N_LSYM
: /* Local symbol in stack */
2024 case N_PSYM
: /* Parameter variable */
2025 case N_LENG
: /* Length of preceding symbol type */
2029 char *colon_pos
= strchr (name
, ':');
2030 if (colon_pos
== NULL
)
2033 deftype
= colon_pos
[1];
2039 function_stab_type
= type
;
2041 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2042 /* Deal with the SunPRO 3.0 compiler which omits the address
2043 from N_FUN symbols. */
2045 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2047 struct minimal_symbol
*msym
;
2051 p
= strchr (name
, ':');
2056 strncpy (p
, name
, n
);
2059 msym
= lookup_minimal_symbol (p
, last_source_file
,
2062 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2066 #ifdef SUN_FIXED_LBRAC_BUG
2067 /* The Sun acc compiler, under SunOS4, puts out
2068 functions with N_GSYM or N_STSYM. The problem is
2069 that the address of the symbol is no good (for N_GSYM
2070 it doesn't even attept an address; for N_STSYM it
2071 puts out an address but then it gets relocated
2072 relative to the data segment, not the text segment).
2073 Currently we can't fix this up later as we do for
2074 some types of symbol in scan_file_globals.
2075 Fortunately we do have a way of finding the address -
2076 we know that the value in last_pc_address is either
2077 the one we want (if we're dealing with the first
2078 function in an object file), or somewhere in the
2079 previous function. This means that we can use the
2080 minimal symbol table to get the address. */
2082 /* Starting with release 3.0, the Sun acc compiler,
2083 under SunOS4, puts out functions with N_FUN and a value
2084 of zero. This gets relocated to the start of the text
2085 segment of the module, which is no good either.
2086 Under SunOS4 we can deal with this as N_SLINE and N_SO
2087 entries contain valid absolute addresses.
2088 Release 3.0 acc also puts out N_OPT entries, which makes
2089 it possible to discern acc from cc or gcc. */
2091 if (type
== N_GSYM
|| type
== N_STSYM
2093 && n_opt_found
&& !block_address_function_relative
))
2095 struct minimal_symbol
*m
;
2096 int l
= colon_pos
- name
;
2098 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2099 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
2100 /* last_pc_address was in this function */
2101 valu
= SYMBOL_VALUE (m
);
2102 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
2103 /* last_pc_address was in last function */
2104 valu
= SYMBOL_VALUE (m
+1);
2106 /* Not found - use last_pc_address (for finish_block) */
2107 valu
= last_pc_address
;
2110 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2113 if (block_address_function_relative
)
2114 /* For Solaris 2.0 compilers, the block addresses and
2115 N_SLINE's are relative to the start of the
2116 function. On normal systems, and when using gcc on
2117 Solaris 2.0, these addresses are just absolute, or
2118 relative to the N_SO, depending on
2119 BLOCK_ADDRESS_ABSOLUTE. */
2120 function_start_offset
= valu
;
2122 within_function
= 1;
2123 if (context_stack_depth
> 0)
2125 new = pop_context ();
2126 /* Make a block for the local symbols within. */
2127 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2128 new->start_addr
, valu
, objfile
);
2130 /* Stack must be empty now. */
2131 if (context_stack_depth
!= 0)
2132 complain (&lbrac_unmatched_complaint
, symnum
);
2134 new = push_context (0, valu
);
2135 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2139 define_symbol (valu
, name
, desc
, type
, objfile
);
2145 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2146 for a bunch of other flags, too. Someday we may parse their
2147 flags; for now we ignore theirs and hope they'll ignore ours. */
2148 case N_OPT
: /* Solaris 2: Compiler options */
2151 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2153 processing_gcc_compilation
= 2;
2154 #if 1 /* Works, but is experimental. -fnf */
2155 if (AUTO_DEMANGLING
)
2157 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2166 /* The following symbol types can be ignored. */
2167 case N_OBJ
: /* Solaris 2: Object file dir and name */
2168 /* N_UNDF: Solaris 2: file separator mark */
2169 /* N_UNDF: -- we will never encounter it, since we only process one
2170 file's symbols at once. */
2171 case N_ENDM
: /* Solaris 2: End of module */
2172 case N_MAIN
: /* Name of main routine. */
2176 previous_stab_code
= type
;
2179 /* FIXME: The only difference between this and elfstab_build_psymtabs is
2180 the call to install_minimal_symbols for elf. If the differences are
2181 really that small, the code should be shared. */
2183 /* Scan and build partial symbols for an coff symbol file.
2184 The coff file has already been processed to get its minimal symbols.
2186 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2189 OBJFILE is the object file we are reading symbols from.
2190 ADDR is the address relative to which the symbols are (e.g.
2191 the base address of the text segment).
2192 MAINLINE is true if we are reading the main symbol
2193 table (as opposed to a shared lib or dynamically loaded file).
2194 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2196 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2197 .stabstr section exists.
2199 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2200 adjusted for coff details. */
2203 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2204 staboffset
, stabsize
,
2205 stabstroffset
, stabstrsize
)
2206 struct objfile
*objfile
;
2207 struct section_offsets
*section_offsets
;
2209 file_ptr staboffset
;
2210 unsigned int stabsize
;
2211 file_ptr stabstroffset
;
2212 unsigned int stabstrsize
;
2215 bfd
*sym_bfd
= objfile
->obfd
;
2216 char *name
= bfd_get_filename (sym_bfd
);
2217 struct dbx_symfile_info
*info
;
2219 /* There is already a dbx_symfile_info allocated by our caller.
2220 It might even contain some info from the coff symtab to help us. */
2221 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2223 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2224 if (!DBX_TEXT_SECT (objfile
))
2225 error ("Can't find .text section in symbol file");
2227 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2228 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2229 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2230 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2231 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2233 if (stabstrsize
> bfd_get_size (sym_bfd
))
2234 error ("ridiculous string table size: %d bytes", stabstrsize
);
2235 DBX_STRINGTAB (objfile
) = (char *)
2236 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2238 /* Now read in the string table in one big gulp. */
2240 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2242 perror_with_name (name
);
2243 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2244 if (val
!= stabstrsize
)
2245 perror_with_name (name
);
2247 stabsread_new_init ();
2248 buildsym_new_init ();
2249 free_header_files ();
2250 init_header_files ();
2252 processing_acc_compilation
= 1;
2254 /* In a coff file, we've already installed the minimal symbols that came
2255 from the coff (non-stab) symbol table, so always act like an
2256 incremental load here. */
2257 dbx_symfile_read (objfile
, section_offsets
, 0);
2260 /* Scan and build partial symbols for an ELF symbol file.
2261 This ELF file has already been processed to get its minimal symbols,
2262 and any DWARF symbols that were in it.
2264 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2267 OBJFILE is the object file we are reading symbols from.
2268 ADDR is the address relative to which the symbols are (e.g.
2269 the base address of the text segment).
2270 MAINLINE is true if we are reading the main symbol
2271 table (as opposed to a shared lib or dynamically loaded file).
2272 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2274 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2275 .stabstr section exists.
2277 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2278 adjusted for elf details. */
2281 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2282 staboffset
, stabsize
,
2283 stabstroffset
, stabstrsize
)
2284 struct objfile
*objfile
;
2285 struct section_offsets
*section_offsets
;
2287 file_ptr staboffset
;
2288 unsigned int stabsize
;
2289 file_ptr stabstroffset
;
2290 unsigned int stabstrsize
;
2293 bfd
*sym_bfd
= objfile
->obfd
;
2294 char *name
= bfd_get_filename (sym_bfd
);
2295 struct dbx_symfile_info
*info
;
2297 /* There is already a dbx_symfile_info allocated by our caller.
2298 It might even contain some info from the ELF symtab to help us. */
2299 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2301 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2302 if (!DBX_TEXT_SECT (objfile
))
2303 error ("Can't find .text section in symbol file");
2305 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2306 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2307 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2308 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2309 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2311 if (stabstrsize
> bfd_get_size (sym_bfd
))
2312 error ("ridiculous string table size: %d bytes", stabstrsize
);
2313 DBX_STRINGTAB (objfile
) = (char *)
2314 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2316 /* Now read in the string table in one big gulp. */
2318 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2320 perror_with_name (name
);
2321 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2322 if (val
!= stabstrsize
)
2323 perror_with_name (name
);
2325 stabsread_new_init ();
2326 buildsym_new_init ();
2327 free_header_files ();
2328 init_header_files ();
2329 install_minimal_symbols (objfile
);
2331 processing_acc_compilation
= 1;
2333 /* In an elf file, we've already installed the minimal symbols that came
2334 from the elf (non-stab) symbol table, so always act like an
2335 incremental load here. */
2336 dbx_symfile_read (objfile
, section_offsets
, 0);
2339 /* Scan and build partial symbols for a file with special sections for stabs
2340 and stabstrings. The file has already been processed to get its minimal
2341 symbols, and any other symbols that might be necessary to resolve GSYMs.
2343 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2346 OBJFILE is the object file we are reading symbols from.
2347 ADDR is the address relative to which the symbols are (e.g. the base address
2348 of the text segment).
2349 MAINLINE is true if we are reading the main symbol table (as opposed to a
2350 shared lib or dynamically loaded file).
2351 STAB_NAME is the name of the section that contains the stabs.
2352 STABSTR_NAME is the name of the section that contains the stab strings.
2354 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2357 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2358 stabstr_name
, text_name
)
2359 struct objfile
*objfile
;
2360 struct section_offsets
*section_offsets
;
2367 bfd
*sym_bfd
= objfile
->obfd
;
2368 char *name
= bfd_get_filename (sym_bfd
);
2370 asection
*stabstrsect
;
2372 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2373 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2379 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2380 stab_name
, stabstr_name
);
2382 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2383 memset (DBX_SYMFILE_INFO (objfile
), 0, sizeof (struct dbx_symfile_info
));
2385 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, text_name
);
2386 if (!DBX_TEXT_SECT (objfile
))
2387 error ("Can't find %s section in symbol file", text_name
);
2389 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2390 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2391 / DBX_SYMBOL_SIZE (objfile
);
2392 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2393 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2395 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2396 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2397 DBX_STRINGTAB (objfile
) = (char *)
2398 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2400 /* Now read in the string table in one big gulp. */
2402 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2403 stabstrsect
, /* bfd section */
2404 DBX_STRINGTAB (objfile
), /* input buffer */
2405 0, /* offset into section */
2406 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2409 perror_with_name (name
);
2411 stabsread_new_init ();
2412 buildsym_new_init ();
2413 free_header_files ();
2414 init_header_files ();
2415 install_minimal_symbols (objfile
);
2417 /* Now, do an incremental load */
2419 processing_acc_compilation
= 1;
2420 dbx_symfile_read (objfile
, section_offsets
, 0);
2423 /* Parse the user's idea of an offset for dynamic linking, into our idea
2424 of how to represent it for fast symbol reading. */
2426 static struct section_offsets
*
2427 dbx_symfile_offsets (objfile
, addr
)
2428 struct objfile
*objfile
;
2431 struct section_offsets
*section_offsets
;
2434 objfile
->num_sections
= SECT_OFF_MAX
;
2435 section_offsets
= (struct section_offsets
*)
2436 obstack_alloc (&objfile
-> psymbol_obstack
,
2437 sizeof (struct section_offsets
)
2438 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2440 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2441 ANOFFSET (section_offsets
, i
) = addr
;
2443 return section_offsets
;
2446 static struct sym_fns aout_sym_fns
=
2448 bfd_target_aout_flavour
,
2449 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2450 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2451 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2452 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2453 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2454 NULL
/* next: pointer to next struct sym_fns */
2458 _initialize_dbxread ()
2460 add_symtab_fns(&aout_sym_fns
);