1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
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 read_symtab() function to use when expanding a partial symbol table entry
75 to a full symbol table entry.
77 For dbxread this structure contains the offset within the file symbol table
78 of first local symbol for this file, and length (in bytes) of the section
79 of the symbol table devoted to this file's symbols (actually, the section
80 bracketed may contain more than just this file's symbols). It also contains
81 further information needed to locate the symbols if they are in an ELF file.
83 If ldsymlen is 0, the only reason for this thing's existence is the
84 dependency list. Nothing else will happen when it is read in. */
86 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
87 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
88 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
89 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
90 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
91 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
92 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
100 int file_string_offset
;
103 /* Macro to determine which symbols to ignore when reading the first symbol
104 of a file. Some machines override this definition. */
105 #ifndef IGNORE_SYMBOL
106 /* This code is used on Ultrix systems. Ignore it */
107 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
110 /* Remember what we deduced to be the source language of this psymtab. */
112 static enum language psymtab_language
= language_unknown
;
114 /* Nonzero means give verbose info on gdb action. From main.c. */
115 extern int info_verbose
;
117 /* The BFD for this file -- implicit parameter to next_symbol_text. */
119 static bfd
*symfile_bfd
;
121 /* The size of each symbol in the symbol file (in external form).
122 This is set by dbx_symfile_read when building psymtabs, and by
123 dbx_psymtab_to_symtab when building symtabs. */
125 static unsigned symbol_size
;
127 /* This is the offset of the symbol table in the executable file */
128 static unsigned symbol_table_offset
;
130 /* This is the offset of the string table in the executable file */
131 static unsigned string_table_offset
;
133 /* For elf+stab executables, the n_strx field is not a simple index
134 into the string table. Instead, each .o file has a base offset
135 in the string table, and the associated symbols contain offsets
136 from this base. The following two variables contain the base
137 offset for the current and next .o files. */
138 static unsigned int file_string_table_offset
;
139 static unsigned int next_file_string_table_offset
;
141 /* .o and NLM files contain unrelocated addresses which are based at 0. When
142 non-zero, this flag disables some of the special cases for Solaris elf+stab
143 text addresses at location 0. */
145 static int symfile_relocatable
= 0;
147 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
148 to the function start address. */
150 static int block_address_function_relative
= 0;
152 /* This is the lowest text address we have yet encountered. */
153 static CORE_ADDR lowest_text_address
;
155 /* Complaints about the symbols we have encountered. */
157 struct complaint lbrac_complaint
=
158 {"bad block start address patched", 0, 0};
160 struct complaint string_table_offset_complaint
=
161 {"bad string table offset in symbol %d", 0, 0};
163 struct complaint unknown_symtype_complaint
=
164 {"unknown symbol type %s", 0, 0};
166 struct complaint unknown_symchar_complaint
=
167 {"unknown symbol descriptor `%c'", 0, 0};
169 struct complaint lbrac_rbrac_complaint
=
170 {"block start larger than block end", 0, 0};
172 struct complaint lbrac_unmatched_complaint
=
173 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
175 struct complaint lbrac_mismatch_complaint
=
176 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
178 struct complaint repeated_header_complaint
=
179 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
181 /* During initial symbol readin, we need to have a structure to keep
182 track of which psymtabs have which bincls in them. This structure
183 is used during readin to setup the list of dependencies within each
184 partial symbol table. */
186 struct header_file_location
188 char *name
; /* Name of header file */
189 int instance
; /* See above */
190 struct partial_symtab
*pst
; /* Partial symtab that has the
191 BINCL/EINCL defs for this file */
194 /* The actual list and controling variables */
195 static struct header_file_location
*bincl_list
, *next_bincl
;
196 static int bincls_allocated
;
198 /* Local function prototypes */
201 free_header_files
PARAMS ((void));
204 init_header_files
PARAMS ((void));
207 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
210 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
213 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
216 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
217 struct objfile
*objfile
));
220 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
224 free_bincl_list
PARAMS ((struct objfile
*));
226 static struct partial_symtab
*
227 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
230 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
233 init_bincl_list
PARAMS ((int, struct objfile
*));
236 init_psymbol_list
PARAMS ((struct objfile
*));
239 dbx_next_symbol_text
PARAMS ((void));
242 fill_symbuf
PARAMS ((bfd
*));
245 dbx_symfile_init
PARAMS ((struct objfile
*));
248 dbx_new_init
PARAMS ((struct objfile
*));
251 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
254 dbx_symfile_finish
PARAMS ((struct objfile
*));
257 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
260 add_new_header_file
PARAMS ((char *, int));
263 add_old_header_file
PARAMS ((char *, int));
266 add_this_object_header_file
PARAMS ((int));
268 /* Free up old header file tables */
275 if (header_files
!= NULL
)
277 for (i
= 0; i
< n_header_files
; i
++)
279 free (header_files
[i
].name
);
281 free ((PTR
)header_files
);
285 if (this_object_header_files
)
287 free ((PTR
)this_object_header_files
);
288 this_object_header_files
= NULL
;
290 n_allocated_header_files
= 0;
291 n_allocated_this_object_header_files
= 0;
294 /* Allocate new header file tables */
300 n_allocated_header_files
= 10;
301 header_files
= (struct header_file
*)
302 xmalloc (10 * sizeof (struct header_file
));
304 n_allocated_this_object_header_files
= 10;
305 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
308 /* Add header file number I for this object file
309 at the next successive FILENUM. */
312 add_this_object_header_file (i
)
315 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
317 n_allocated_this_object_header_files
*= 2;
318 this_object_header_files
319 = (int *) xrealloc ((char *) this_object_header_files
,
320 n_allocated_this_object_header_files
* sizeof (int));
323 this_object_header_files
[n_this_object_header_files
++] = i
;
326 /* Add to this file an "old" header file, one already seen in
327 a previous object file. NAME is the header file's name.
328 INSTANCE is its instance code, to select among multiple
329 symbol tables for the same header file. */
332 add_old_header_file (name
, instance
)
336 register struct header_file
*p
= header_files
;
339 for (i
= 0; i
< n_header_files
; i
++)
340 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
342 add_this_object_header_file (i
);
345 complain (&repeated_header_complaint
, name
, symnum
);
348 /* Add to this file a "new" header file: definitions for its types follow.
349 NAME is the header file's name.
350 Most often this happens only once for each distinct header file,
351 but not necessarily. If it happens more than once, INSTANCE has
352 a different value each time, and references to the header file
353 use INSTANCE values to select among them.
355 dbx output contains "begin" and "end" markers for each new header file,
356 but at this level we just need to know which files there have been;
357 so we record the file when its "begin" is seen and ignore the "end". */
360 add_new_header_file (name
, instance
)
366 /* Make sure there is room for one more header file. */
368 if (n_header_files
== n_allocated_header_files
)
370 n_allocated_header_files
*= 2;
371 header_files
= (struct header_file
*)
372 xrealloc ((char *) header_files
,
373 (n_allocated_header_files
* sizeof (struct header_file
)));
376 /* Create an entry for this header file. */
378 i
= n_header_files
++;
379 header_files
[i
].name
= savestring (name
, strlen(name
));
380 header_files
[i
].instance
= instance
;
381 header_files
[i
].length
= 10;
382 header_files
[i
].vector
383 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
384 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
386 add_this_object_header_file (i
);
390 static struct type
**
391 explicit_lookup_type (real_filenum
, index
)
392 int real_filenum
, index
;
394 register struct header_file
*f
= &header_files
[real_filenum
];
396 if (index
>= f
->length
)
399 f
->vector
= (struct type
**)
400 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
401 memset (&f
->vector
[f
->length
/ 2],
402 '\0', f
->length
* sizeof (struct type
*) / 2);
404 return &f
->vector
[index
];
409 record_minimal_symbol (name
, address
, type
, objfile
)
413 struct objfile
*objfile
;
415 enum minimal_symbol_type ms_type
;
422 section
= SECT_OFF_TEXT
;
426 section
= SECT_OFF_DATA
;
430 section
= SECT_OFF_BSS
;
439 section
= SECT_OFF_DATA
;
442 /* I don't think this type actually exists; since a N_SETV is the result
443 of going over many .o files, it doesn't make sense to have one
445 ms_type
= mst_file_data
;
446 section
= SECT_OFF_DATA
;
453 ms_type
= mst_file_text
;
454 section
= SECT_OFF_TEXT
;
457 ms_type
= mst_file_data
;
459 /* Check for __DYNAMIC, which is used by Sun shared libraries.
460 Record it as global even if it's local, not global, so
461 lookup_minimal_symbol can find it. We don't check symbol_leading_char
462 because for SunOS4 it always is '_'. */
463 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
466 /* Same with virtual function tables, both global and static. */
468 char *tempstring
= name
;
469 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
471 if (VTBL_PREFIX_P ((tempstring
)))
474 section
= SECT_OFF_DATA
;
477 ms_type
= mst_file_bss
;
478 section
= SECT_OFF_BSS
;
481 ms_type
= mst_unknown
;
486 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
487 && address
< lowest_text_address
)
488 lowest_text_address
= address
;
490 prim_record_minimal_symbol_and_info
491 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
499 /* Scan and build partial symbols for a symbol file.
500 We have been initialized by a call to dbx_symfile_init, which
501 put all the relevant info into a "struct dbx_symfile_info",
502 hung off the objfile structure.
504 SECTION_OFFSETS contains offsets relative to which the symbols in the
505 various sections are (depending where the sections were actually loaded).
506 MAINLINE is true if we are reading the main symbol
507 table (as opposed to a shared lib or dynamically loaded file). */
510 dbx_symfile_read (objfile
, section_offsets
, mainline
)
511 struct objfile
*objfile
;
512 struct section_offsets
*section_offsets
;
513 int mainline
; /* FIXME comments above */
517 struct cleanup
*back_to
;
519 val
= strlen (objfile
->name
);
521 /* .o and .nlm files are relocatables with text, data and bss segs based at
522 0. This flag disables special (Solaris stabs-in-elf only) fixups for
523 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
524 should be fixed to determine pst->textlow without using this text seg of
527 if (strcmp (&objfile
->name
[val
-2], ".o") == 0
528 || strcmp (&objfile
->name
[val
-4], ".nlm") == 0)
529 symfile_relocatable
= 1;
531 /* This is true for Solaris (and all other systems which put stabs
532 in sections, hopefully, since it would be silly to do things
533 differently from Solaris), and false for SunOS4 and other a.out
535 block_address_function_relative
=
536 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
537 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
538 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4))
539 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "nlm", 3)));
541 sym_bfd
= objfile
->obfd
;
542 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
544 perror_with_name (objfile
->name
);
546 /* If we are reinitializing, or if we have never loaded syms yet, init */
547 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
548 init_psymbol_list (objfile
);
550 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
551 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
554 back_to
= make_cleanup (really_free_pendings
, 0);
556 init_minimal_symbol_collection ();
557 make_cleanup (discard_minimal_symbols
, 0);
559 /* Now that the symbol table data of the executable file are all in core,
560 process them and define symbols accordingly. */
562 read_dbx_symtab (section_offsets
, objfile
,
563 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
564 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
566 /* Add the dynamic symbols. */
568 read_dbx_dynamic_symtab (section_offsets
, objfile
);
570 /* Install any minimal symbols that have been collected as the current
571 minimal symbols for this objfile. */
573 install_minimal_symbols (objfile
);
575 do_cleanups (back_to
);
578 /* Initialize anything that needs initializing when a completely new
579 symbol file is specified (not just adding some symbols from another
580 file, e.g. a shared library). */
583 dbx_new_init (ignore
)
584 struct objfile
*ignore
;
586 stabsread_new_init ();
587 buildsym_new_init ();
588 init_header_files ();
592 /* dbx_symfile_init ()
593 is the dbx-specific initialization routine for reading symbols.
594 It is passed a struct objfile which contains, among other things,
595 the BFD for the file whose symbols are being read, and a slot for a pointer
596 to "private data" which we fill with goodies.
598 We read the string table into malloc'd space and stash a pointer to it.
600 Since BFD doesn't know how to read debug symbols in a format-independent
601 way (and may never do so...), we have to do it ourselves. We will never
602 be called unless this is an a.out (or very similar) file.
603 FIXME, there should be a cleaner peephole into the BFD environment here. */
605 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
608 dbx_symfile_init (objfile
)
609 struct objfile
*objfile
;
612 bfd
*sym_bfd
= objfile
->obfd
;
613 char *name
= bfd_get_filename (sym_bfd
);
614 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
616 /* Allocate struct to keep track of the symfile */
617 objfile
->sym_stab_info
= (PTR
)
618 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
620 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
621 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
622 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
624 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
626 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
627 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
628 if (!DBX_TEXT_SECT (objfile
))
629 error ("Can't find .text section in symbol file");
631 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
632 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
633 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
635 /* Read the string table and stash it away in the psymbol_obstack. It is
636 only needed as long as we need to expand psymbols into full symbols,
637 so when we blow away the psymbol the string table goes away as well.
638 Note that gdb used to use the results of attempting to malloc the
639 string table, based on the size it read, as a form of sanity check
640 for botched byte swapping, on the theory that a byte swapped string
641 table size would be so totally bogus that the malloc would fail. Now
642 that we put in on the psymbol_obstack, we can't do this since gdb gets
643 a fatal error (out of virtual memory) if the size is bogus. We can
644 however at least check to see if the size is less than the size of
645 the size field itself, or larger than the size of the entire file.
646 Note that all valid string tables have a size greater than zero, since
647 the bytes used to hold the size are included in the count. */
649 if (STRING_TABLE_OFFSET
== 0)
651 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
652 will never be zero, even when there is no string table. This
653 would appear to be a bug in bfd. */
654 DBX_STRINGTAB_SIZE (objfile
) = 0;
655 DBX_STRINGTAB (objfile
) = NULL
;
659 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
661 perror_with_name (name
);
663 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
664 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
667 perror_with_name (name
);
671 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
672 EOF if there is no string table, and attempting to read the size
673 from EOF will read zero bytes. */
674 DBX_STRINGTAB_SIZE (objfile
) = 0;
675 DBX_STRINGTAB (objfile
) = NULL
;
679 /* Read some data that would appear to be the string table size.
680 If there really is a string table, then it is probably the right
681 size. Byteswap if necessary and validate the size. Note that
682 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
683 random data that happened to be at STRING_TABLE_OFFSET, because
684 bfd can't tell us there is no string table, the sanity checks may
685 or may not catch this. */
686 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
688 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
689 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
690 error ("ridiculous string table size (%d bytes).",
691 DBX_STRINGTAB_SIZE (objfile
));
693 DBX_STRINGTAB (objfile
) =
694 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
695 DBX_STRINGTAB_SIZE (objfile
));
697 /* Now read in the string table in one big gulp. */
699 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
701 perror_with_name (name
);
702 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
704 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
705 perror_with_name (name
);
710 /* Perform any local cleanups required when we are done with a particular
711 objfile. I.E, we are in the process of discarding all symbol information
712 for an objfile, freeing up all memory held for it, and unlinking the
713 objfile struct from the global list of known objfiles. */
716 dbx_symfile_finish (objfile
)
717 struct objfile
*objfile
;
719 if (objfile
->sym_stab_info
!= NULL
)
721 mfree (objfile
-> md
, objfile
->sym_stab_info
);
723 free_header_files ();
727 /* Buffer for reading the symbol table entries. */
728 static struct internal_nlist symbuf
[4096];
729 static int symbuf_idx
;
730 static int symbuf_end
;
732 /* Name of last function encountered. Used in Solaris to approximate
733 object file boundaries. */
734 static char *last_function_name
;
736 /* The address in memory of the string table of the object file we are
737 reading (which might not be the "main" object file, but might be a
738 shared library or some other dynamically loaded thing). This is set
739 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
740 when building symtabs, and is used only by next_symbol_text. */
741 static char *stringtab_global
;
743 /* Refill the symbol table input buffer
744 and set the variables that control fetching entries from it.
745 Reports an error if no data available.
746 This function can read past the end of the symbol table
747 (into the string table) but this does no harm. */
750 fill_symbuf (sym_bfd
)
753 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
755 perror_with_name (bfd_get_filename (sym_bfd
));
756 else if (nbytes
== 0)
757 error ("Premature end of file reading symbol table");
758 symbuf_end
= nbytes
/ symbol_size
;
762 #define SWAP_SYMBOL(symp, abfd) \
764 (symp)->n_strx = bfd_h_get_32(abfd, \
765 (unsigned char *)&(symp)->n_strx); \
766 (symp)->n_desc = bfd_h_get_16 (abfd, \
767 (unsigned char *)&(symp)->n_desc); \
768 (symp)->n_value = bfd_h_get_32 (abfd, \
769 (unsigned char *)&(symp)->n_value); \
772 /* Invariant: The symbol pointed to by symbuf_idx is the first one
773 that hasn't been swapped. Swap the symbol at the same time
774 that symbuf_idx is incremented. */
776 /* dbx allows the text of a symbol name to be continued into the
777 next symbol name! When such a continuation is encountered
778 (a \ at the end of the text of a name)
779 call this function to get the continuation. */
782 dbx_next_symbol_text ()
784 if (symbuf_idx
== symbuf_end
)
785 fill_symbuf (symfile_bfd
);
787 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
788 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
789 + file_string_table_offset
;
792 /* Initializes storage for all of the partial symbols that will be
793 created by read_dbx_symtab and subsidiaries. */
796 init_psymbol_list (objfile
)
797 struct objfile
*objfile
;
799 /* Free any previously allocated psymbol lists. */
800 if (objfile
-> global_psymbols
.list
)
801 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
802 if (objfile
-> static_psymbols
.list
)
803 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
805 /* Current best guess is that there are approximately a twentieth
806 of the total symbols (in a debugging file) are global or static
808 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
809 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
810 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
811 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
812 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
813 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
816 /* Initialize the list of bincls to contain none and have some
820 init_bincl_list (number
, objfile
)
822 struct objfile
*objfile
;
824 bincls_allocated
= number
;
825 next_bincl
= bincl_list
= (struct header_file_location
*)
826 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
829 /* Add a bincl to the list. */
832 add_bincl_to_list (pst
, name
, instance
)
833 struct partial_symtab
*pst
;
837 if (next_bincl
>= bincl_list
+ bincls_allocated
)
839 int offset
= next_bincl
- bincl_list
;
840 bincls_allocated
*= 2;
841 bincl_list
= (struct header_file_location
*)
842 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
843 bincls_allocated
* sizeof (struct header_file_location
));
844 next_bincl
= bincl_list
+ offset
;
846 next_bincl
->pst
= pst
;
847 next_bincl
->instance
= instance
;
848 next_bincl
++->name
= name
;
851 /* Given a name, value pair, find the corresponding
852 bincl in the list. Return the partial symtab associated
853 with that header_file_location. */
855 static struct partial_symtab
*
856 find_corresponding_bincl_psymtab (name
, instance
)
860 struct header_file_location
*bincl
;
862 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
863 if (bincl
->instance
== instance
864 && STREQ (name
, bincl
->name
))
867 complain (&repeated_header_complaint
, name
, symnum
);
868 return (struct partial_symtab
*) 0;
871 /* Free the storage allocated for the bincl list. */
874 free_bincl_list (objfile
)
875 struct objfile
*objfile
;
877 mfree (objfile
-> md
, (PTR
)bincl_list
);
878 bincls_allocated
= 0;
881 /* Scan a SunOs dynamic symbol table for symbols of interest and
882 add them to the minimal symbol table. */
885 read_dbx_dynamic_symtab (section_offsets
, objfile
)
886 struct section_offsets
*section_offsets
;
887 struct objfile
*objfile
;
889 bfd
*abfd
= objfile
->obfd
;
890 struct cleanup
*back_to
;
902 /* Check that the symbol file has dynamic symbols that we know about.
903 bfd_arch_unknown can happen if we are reading a sun3 symbol file
904 on a sun4 host (and vice versa) and bfd is not configured
905 --with-target=all. This would trigger an assertion in bfd/sunos.c,
906 so we ignore the dynamic symbols in this case. */
907 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
908 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
909 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
912 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
916 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
917 back_to
= make_cleanup (free
, dynsyms
);
919 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
920 if (dynsym_count
< 0)
922 do_cleanups (back_to
);
926 /* Enter dynamic symbols into the minimal symbol table
927 if this is a stripped executable. */
928 if (bfd_get_symcount (abfd
) <= 0)
931 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
933 asymbol
*sym
= *symptr
;
937 sec
= bfd_get_section (sym
);
939 /* BFD symbols are section relative. */
940 sym_value
= sym
->value
+ sec
->vma
;
942 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
944 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
947 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
949 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
952 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
954 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
960 if (sym
->flags
& BSF_GLOBAL
)
963 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
968 /* Symbols from shared libraries have a dynamic relocation entry
969 that points to the associated slot in the procedure linkage table.
970 We make a mininal symbol table entry with type mst_solib_trampoline
971 at the address in the procedure linkage table. */
972 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
975 do_cleanups (back_to
);
979 dynrels
= (arelent
**) xmalloc (dynrel_size
);
980 make_cleanup (free
, dynrels
);
982 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
983 if (dynrel_count
< 0)
985 do_cleanups (back_to
);
989 for (counter
= 0, relptr
= dynrels
;
990 counter
< dynrel_count
;
993 arelent
*rel
= *relptr
;
995 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
997 switch (bfd_get_arch (abfd
))
1000 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1004 /* `16' is the type BFD produces for a jump table relocation. */
1005 if (rel
->howto
->type
!= 16)
1008 /* Adjust address in the jump table to point to
1009 the start of the bsr instruction. */
1016 prim_record_minimal_symbol (bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1018 mst_solib_trampoline
,
1022 do_cleanups (back_to
);
1025 /* Given pointers to an a.out symbol table in core containing dbx
1026 style data, setup partial_symtab's describing each source file for
1027 which debugging information is available.
1028 SYMFILE_NAME is the name of the file we are reading from
1029 and SECTION_OFFSETS is the set of offsets for the various sections
1030 of the file (a set of zeros if the mainline program). */
1033 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1034 struct section_offsets
*section_offsets
;
1035 struct objfile
*objfile
;
1036 CORE_ADDR text_addr
;
1039 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1040 register char *namestring
;
1042 int past_first_source_file
= 0;
1043 CORE_ADDR last_o_file_start
= 0;
1044 struct cleanup
*back_to
;
1047 /* Current partial symtab */
1048 struct partial_symtab
*pst
;
1050 /* List of current psymtab's include files */
1051 char **psymtab_include_list
;
1052 int includes_allocated
;
1055 /* Index within current psymtab dependency list */
1056 struct partial_symtab
**dependency_list
;
1057 int dependencies_used
, dependencies_allocated
;
1059 /* FIXME. We probably want to change stringtab_global rather than add this
1060 while processing every symbol entry. FIXME. */
1061 file_string_table_offset
= 0;
1062 next_file_string_table_offset
= 0;
1064 stringtab_global
= DBX_STRINGTAB (objfile
);
1066 pst
= (struct partial_symtab
*) 0;
1068 includes_allocated
= 30;
1070 psymtab_include_list
= (char **) alloca (includes_allocated
*
1073 dependencies_allocated
= 30;
1074 dependencies_used
= 0;
1076 (struct partial_symtab
**) alloca (dependencies_allocated
*
1077 sizeof (struct partial_symtab
*));
1079 /* Init bincl list */
1080 init_bincl_list (20, objfile
);
1081 back_to
= make_cleanup (free_bincl_list
, objfile
);
1083 last_source_file
= NULL
;
1085 lowest_text_address
= (CORE_ADDR
)-1;
1087 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1088 abfd
= objfile
->obfd
;
1089 symbuf_end
= symbuf_idx
= 0;
1090 next_symbol_text_func
= dbx_next_symbol_text
;
1092 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1094 /* Get the symbol for this run and pull out some info */
1095 QUIT
; /* allow this to be interruptable */
1096 if (symbuf_idx
== symbuf_end
)
1098 bufp
= &symbuf
[symbuf_idx
++];
1101 * Special case to speed up readin.
1103 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1105 SWAP_SYMBOL (bufp
, abfd
);
1107 /* Ok. There is a lot of code duplicated in the rest of this
1108 switch statement (for efficiency reasons). Since I don't
1109 like duplicating code, I will do my penance here, and
1110 describe the code which is duplicated:
1112 *) The assignment to namestring.
1113 *) The call to strchr.
1114 *) The addition of a partial symbol the the two partial
1115 symbol lists. This last is a large section of code, so
1116 I've imbedded it in the following macro.
1119 /* Set namestring based on bufp. If the string table index is invalid,
1120 give a fake name, and print a single error message per symbol file read,
1121 rather than abort the symbol reading or flood the user with messages. */
1123 /*FIXME: Too many adds and indirections in here for the inner loop. */
1124 #define SET_NAMESTRING()\
1125 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1126 DBX_STRINGTAB_SIZE (objfile)) { \
1127 complain (&string_table_offset_complaint, symnum); \
1128 namestring = "<bad string table offset>"; \
1130 namestring = bufp->n_strx + file_string_table_offset + \
1131 DBX_STRINGTAB (objfile)
1133 #define CUR_SYMBOL_TYPE bufp->n_type
1134 #define CUR_SYMBOL_VALUE bufp->n_value
1135 #define DBXREAD_ONLY
1136 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1137 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1138 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1139 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1141 #include "partial-stab.h"
1144 /* If there's stuff to be cleaned up, clean it up. */
1145 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1146 /*FIXME, does this have a bug at start address 0? */
1147 && last_o_file_start
1148 && objfile
-> ei
.entry_point
< bufp
->n_value
1149 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1151 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1152 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1157 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1158 symnum
* symbol_size
,
1159 (lowest_text_address
== (CORE_ADDR
)-1
1160 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1161 : lowest_text_address
)
1163 dependency_list
, dependencies_used
);
1166 do_cleanups (back_to
);
1169 /* Allocate and partially fill a partial symtab. It will be
1170 completely filled at the end of the symbol list.
1172 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1173 is the address relative to which its symbols are (incremental) or 0
1177 struct partial_symtab
*
1178 start_psymtab (objfile
, section_offsets
,
1179 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1180 struct objfile
*objfile
;
1181 struct section_offsets
*section_offsets
;
1185 struct partial_symbol
*global_syms
;
1186 struct partial_symbol
*static_syms
;
1188 struct partial_symtab
*result
=
1189 start_psymtab_common(objfile
, section_offsets
,
1190 filename
, textlow
, global_syms
, static_syms
);
1192 result
->read_symtab_private
= (char *)
1193 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1194 LDSYMOFF(result
) = ldsymoff
;
1195 result
->read_symtab
= dbx_psymtab_to_symtab
;
1196 SYMBOL_SIZE(result
) = symbol_size
;
1197 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1198 STRING_OFFSET(result
) = string_table_offset
;
1199 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1201 /* If we're handling an ELF file, drag some section-relocation info
1202 for this source file out of the ELF symbol table, to compensate for
1203 Sun brain death. This replaces the section_offsets in this psymtab,
1205 elfstab_offset_sections (objfile
, result
);
1207 /* Deduce the source language from the filename for this psymtab. */
1208 psymtab_language
= deduce_language_from_filename (filename
);
1213 /* Close off the current usage of PST.
1214 Returns PST or NULL if the partial symtab was empty and thrown away.
1216 FIXME: List variables and peculiarities of same. */
1218 struct partial_symtab
*
1219 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1220 capping_text
, dependency_list
, number_dependencies
)
1221 struct partial_symtab
*pst
;
1222 char **include_list
;
1224 int capping_symbol_offset
;
1225 CORE_ADDR capping_text
;
1226 struct partial_symtab
**dependency_list
;
1227 int number_dependencies
;
1230 struct objfile
*objfile
= pst
-> objfile
;
1232 if (capping_symbol_offset
!= -1)
1233 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1234 pst
->texthigh
= capping_text
;
1236 #ifdef N_SO_ADDRESS_MAYBE_MISSING
1237 /* Under Solaris, the N_SO symbols always have a value of 0,
1238 instead of the usual address of the .o file. Therefore,
1239 we have to do some tricks to fill in texthigh and textlow.
1240 The first trick is in partial-stab.h: if we see a static
1241 or global function, and the textlow for the current pst
1242 is still 0, then we use that function's address for
1243 the textlow of the pst.
1245 Now, to fill in texthigh, we remember the last function seen
1246 in the .o file (also in partial-stab.h). Also, there's a hack in
1247 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1248 to here via the misc_info field. Therefore, we can fill in
1249 a reliable texthigh by taking the address plus size of the
1250 last function in the file.
1252 Unfortunately, that does not cover the case where the last function
1253 in the file is static. See the paragraph below for more comments
1256 Finally, if we have a valid textlow for the current file, we run
1257 down the partial_symtab_list filling in previous texthighs that
1258 are still unknown. */
1260 if (pst
->texthigh
== 0 && last_function_name
) {
1263 struct minimal_symbol
*minsym
;
1265 p
= strchr (last_function_name
, ':');
1267 p
= last_function_name
;
1268 n
= p
- last_function_name
;
1270 strncpy (p
, last_function_name
, n
);
1273 minsym
= lookup_minimal_symbol (p
, objfile
);
1276 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1277 (long) MSYMBOL_INFO (minsym
);
1279 /* This file ends with a static function, and it's
1280 difficult to imagine how hard it would be to track down
1281 the elf symbol. Luckily, most of the time no one will notice,
1282 since the next file will likely be compiled with -g, so
1283 the code below will copy the first fuction's start address
1284 back to our texthigh variable. (Also, if this file is the
1285 last one in a dynamically linked program, texthigh already
1286 has the right value.) If the next file isn't compiled
1287 with -g, then the last function in this file winds up owning
1288 all of the text space up to the next -g file, or the end (minus
1289 shared libraries). This only matters for single stepping,
1290 and even then it will still work, except that it will single
1291 step through all of the covered functions, instead of setting
1292 breakpoints around them as it usualy does. This makes it
1293 pretty slow, but at least it doesn't fail.
1295 We can fix this with a fairly big change to bfd, but we need
1296 to coordinate better with Cygnus if we want to do that. FIXME. */
1298 last_function_name
= NULL
;
1301 /* this test will be true if the last .o file is only data */
1302 if (pst
->textlow
== 0)
1303 /* This loses if the text section really starts at address zero
1304 (generally true when we are debugging a .o file, for example).
1305 That is why this whole thing is inside N_SO_ADDRESS_MAYBE_MISSING. */
1306 pst
->textlow
= pst
->texthigh
;
1308 /* If we know our own starting text address, then walk through all other
1309 psymtabs for this objfile, and if any didn't know their ending text
1310 address, set it to our starting address. Take care to not set our
1311 own ending address to our starting address, nor to set addresses on
1312 `dependency' files that have both textlow and texthigh zero. */
1314 struct partial_symtab
*p1
;
1316 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1317 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1318 p1
->texthigh
= pst
->textlow
;
1319 /* if this file has only data, then make textlow match texthigh */
1320 if (p1
->textlow
== 0)
1321 p1
->textlow
= p1
->texthigh
;
1326 /* End of kludge for patching Solaris textlow and texthigh. */
1327 #endif /* N_SO_ADDRESS_MAYBE_MISSING. */
1329 pst
->n_global_syms
=
1330 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1331 pst
->n_static_syms
=
1332 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1334 pst
->number_of_dependencies
= number_dependencies
;
1335 if (number_dependencies
)
1337 pst
->dependencies
= (struct partial_symtab
**)
1338 obstack_alloc (&objfile
->psymbol_obstack
,
1339 number_dependencies
* sizeof (struct partial_symtab
*));
1340 memcpy (pst
->dependencies
, dependency_list
,
1341 number_dependencies
* sizeof (struct partial_symtab
*));
1344 pst
->dependencies
= 0;
1346 for (i
= 0; i
< num_includes
; i
++)
1348 struct partial_symtab
*subpst
=
1349 allocate_psymtab (include_list
[i
], objfile
);
1351 subpst
->section_offsets
= pst
->section_offsets
;
1352 subpst
->read_symtab_private
=
1353 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1354 sizeof (struct symloc
));
1358 subpst
->texthigh
= 0;
1360 /* We could save slight bits of space by only making one of these,
1361 shared by the entire set of include files. FIXME-someday. */
1362 subpst
->dependencies
= (struct partial_symtab
**)
1363 obstack_alloc (&objfile
->psymbol_obstack
,
1364 sizeof (struct partial_symtab
*));
1365 subpst
->dependencies
[0] = pst
;
1366 subpst
->number_of_dependencies
= 1;
1368 subpst
->globals_offset
=
1369 subpst
->n_global_syms
=
1370 subpst
->statics_offset
=
1371 subpst
->n_static_syms
= 0;
1375 subpst
->read_symtab
= pst
->read_symtab
;
1378 sort_pst_symbols (pst
);
1380 /* If there is already a psymtab or symtab for a file of this name, remove it.
1381 (If there is a symtab, more drastic things also happen.)
1382 This happens in VxWorks. */
1383 free_named_symtabs (pst
->filename
);
1385 if (num_includes
== 0
1386 && number_dependencies
== 0
1387 && pst
->n_global_syms
== 0
1388 && pst
->n_static_syms
== 0)
1390 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1391 it is on the obstack, but we can forget to chain it on the list. */
1392 /* Empty psymtabs happen as a result of header files which don't have
1393 any symbols in them. There can be a lot of them. But this check
1394 is wrong, in that a psymtab with N_SLINE entries but nothing else
1395 is not empty, but we don't realize that. Fixing that without slowing
1396 things down might be tricky. */
1397 struct partial_symtab
*prev_pst
;
1399 /* First, snip it out of the psymtab chain */
1401 if (pst
->objfile
->psymtabs
== pst
)
1402 pst
->objfile
->psymtabs
= pst
->next
;
1404 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1405 if (prev_pst
->next
== pst
)
1406 prev_pst
->next
= pst
->next
;
1408 /* Next, put it on a free list for recycling */
1410 pst
->next
= pst
->objfile
->free_psymtabs
;
1411 pst
->objfile
->free_psymtabs
= pst
;
1413 /* Indicate that psymtab was thrown away. */
1414 pst
= (struct partial_symtab
*)NULL
;
1420 dbx_psymtab_to_symtab_1 (pst
)
1421 struct partial_symtab
*pst
;
1423 struct cleanup
*old_chain
;
1431 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1436 /* Read in all partial symtabs on which this one is dependent */
1437 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1438 if (!pst
->dependencies
[i
]->readin
)
1440 /* Inform about additional files that need to be read in. */
1443 fputs_filtered (" ", gdb_stdout
);
1445 fputs_filtered ("and ", gdb_stdout
);
1447 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1448 wrap_here (""); /* Flush output */
1449 gdb_flush (gdb_stdout
);
1451 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1454 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1456 /* Init stuff necessary for reading in symbols */
1459 old_chain
= make_cleanup (really_free_pendings
, 0);
1460 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1461 symbol_size
= SYMBOL_SIZE (pst
);
1463 /* Read in this file's symbols */
1464 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1465 read_ofile_symtab (pst
);
1466 sort_symtab_syms (pst
->symtab
);
1468 do_cleanups (old_chain
);
1474 /* Read in all of the symbols for a given psymtab for real.
1475 Be verbose about it if the user wants that. */
1478 dbx_psymtab_to_symtab (pst
)
1479 struct partial_symtab
*pst
;
1488 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1493 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1495 /* Print the message now, before reading the string table,
1496 to avoid disconcerting pauses. */
1499 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1500 gdb_flush (gdb_stdout
);
1503 sym_bfd
= pst
->objfile
->obfd
;
1505 next_symbol_text_func
= dbx_next_symbol_text
;
1507 dbx_psymtab_to_symtab_1 (pst
);
1509 /* Match with global symbols. This only needs to be done once,
1510 after all of the symtabs and dependencies have been read in. */
1511 scan_file_globals (pst
->objfile
);
1513 /* Finish up the debug error message. */
1515 printf_filtered ("done.\n");
1519 /* Read in a defined section of a specific object file's symbols. */
1522 read_ofile_symtab (pst
)
1523 struct partial_symtab
*pst
;
1525 register char *namestring
;
1526 register struct internal_nlist
*bufp
;
1528 unsigned max_symnum
;
1530 struct objfile
*objfile
;
1531 int sym_offset
; /* Offset to start of symbols to read */
1532 int sym_size
; /* Size of symbols to read */
1533 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1534 int text_size
; /* Size of text segment for symbols */
1535 struct section_offsets
*section_offsets
;
1537 objfile
= pst
->objfile
;
1538 sym_offset
= LDSYMOFF(pst
);
1539 sym_size
= LDSYMLEN(pst
);
1540 text_offset
= pst
->textlow
;
1541 text_size
= pst
->texthigh
- pst
->textlow
;
1542 section_offsets
= pst
->section_offsets
;
1544 current_objfile
= objfile
;
1545 subfile_stack
= NULL
;
1547 stringtab_global
= DBX_STRINGTAB (objfile
);
1548 last_source_file
= NULL
;
1550 abfd
= objfile
->obfd
;
1551 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1552 symbuf_end
= symbuf_idx
= 0;
1554 /* It is necessary to actually read one symbol *before* the start
1555 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1556 occurs before the N_SO symbol.
1558 Detecting this in read_dbx_symtab
1559 would slow down initial readin, so we look for it here instead. */
1560 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1562 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1564 bufp
= &symbuf
[symbuf_idx
++];
1565 SWAP_SYMBOL (bufp
, abfd
);
1569 processing_gcc_compilation
= 0;
1570 if (bufp
->n_type
== N_TEXT
)
1572 const char *tempstring
= namestring
;
1574 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1575 processing_gcc_compilation
= 1;
1576 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1577 processing_gcc_compilation
= 2;
1578 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1580 if (STREQN (tempstring
, "__gnu_compiled", 14))
1581 processing_gcc_compilation
= 2;
1584 /* Try to select a C++ demangling based on the compilation unit
1587 if (processing_gcc_compilation
)
1589 if (AUTO_DEMANGLING
)
1591 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1597 /* The N_SO starting this symtab is the first symbol, so we
1598 better not check the symbol before it. I'm not this can
1599 happen, but it doesn't hurt to check for it. */
1600 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1601 processing_gcc_compilation
= 0;
1604 if (symbuf_idx
== symbuf_end
)
1606 bufp
= &symbuf
[symbuf_idx
];
1607 if (bufp
->n_type
!= (unsigned char)N_SO
)
1608 error("First symbol in segment of executable not a source symbol");
1610 max_symnum
= sym_size
/ symbol_size
;
1613 symnum
< max_symnum
;
1616 QUIT
; /* Allow this to be interruptable */
1617 if (symbuf_idx
== symbuf_end
)
1619 bufp
= &symbuf
[symbuf_idx
++];
1620 SWAP_SYMBOL (bufp
, abfd
);
1622 type
= bufp
->n_type
;
1626 if (type
& N_STAB
) {
1627 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1628 namestring
, section_offsets
, objfile
);
1630 /* We skip checking for a new .o or -l file; that should never
1631 happen in this routine. */
1632 else if (type
== N_TEXT
)
1634 /* I don't think this code will ever be executed, because
1635 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1636 the N_SO symbol which starts this source file.
1637 However, there is no reason not to accept
1638 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1640 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1641 processing_gcc_compilation
= 1;
1642 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1643 processing_gcc_compilation
= 2;
1645 if (AUTO_DEMANGLING
)
1647 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1650 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1651 || type
== (unsigned char)N_NBTEXT
1653 /* Global symbol: see if we came across a dbx defintion for
1654 a corresponding symbol. If so, store the value. Remove
1655 syms from the chain when their values are stored, but
1656 search the whole chain, as there may be several syms from
1657 different files with the same name. */
1658 /* This is probably not true. Since the files will be read
1659 in one at a time, each reference to a global symbol will
1660 be satisfied in each file as it appears. So we skip this
1666 current_objfile
= NULL
;
1668 /* In a Solaris elf file, this variable, which comes from the
1669 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1670 which comes from pst->textlow is correct. */
1671 if (last_source_start_addr
== 0)
1672 last_source_start_addr
= text_offset
;
1674 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1680 /* This handles a single symbol from the symbol-file, building symbols
1681 into a GDB symtab. It takes these arguments and an implicit argument.
1683 TYPE is the type field of the ".stab" symbol entry.
1684 DESC is the desc field of the ".stab" entry.
1685 VALU is the value field of the ".stab" entry.
1686 NAME is the symbol name, in our address space.
1687 SECTION_OFFSETS is a set of amounts by which the sections of this object
1688 file were relocated when it was loaded into memory.
1689 All symbols that refer
1690 to memory locations need to be offset by these amounts.
1691 OBJFILE is the object file from which we are reading symbols.
1692 It is used in end_symtab. */
1695 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1699 struct section_offsets
*section_offsets
;
1700 struct objfile
*objfile
;
1702 #ifdef SUN_FIXED_LBRAC_BUG
1703 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1704 to correct the address of N_LBRAC's. If it is not defined, then
1705 we never need to correct the addresses. */
1707 /* This records the last pc address we've seen. We depend on there being
1708 an SLINE or FUN or SO before the first LBRAC, since the variable does
1709 not get reset in between reads of different symbol files. */
1710 static CORE_ADDR last_pc_address
;
1713 register struct context_stack
*new;
1714 /* This remembers the address of the start of a function. It is used
1715 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1716 relative to the current function's start address. On systems
1717 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1718 used to relocate these symbol types rather than SECTION_OFFSETS. */
1719 static CORE_ADDR function_start_offset
;
1721 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1722 file. Used to detect the SunPRO solaris compiler. */
1723 static int n_opt_found
;
1725 /* The stab type used for the definition of the last function.
1726 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1727 static int function_stab_type
= 0;
1729 if (!block_address_function_relative
)
1730 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1731 function start address, so just use the text offset. */
1732 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1734 /* Something is wrong if we see real data before
1735 seeing a source file name. */
1737 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1739 /* Ignore any symbols which appear before an N_SO symbol. Currently
1740 no one puts symbols there, but we should deal gracefully with the
1741 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1742 but this should not be an error (). */
1750 /* Relocate for dynamic loading */
1751 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1752 goto define_a_symbol
;
1755 /* This "symbol" just indicates the start of an inner lexical
1756 context within a function. */
1758 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1759 /* Relocate for dynamic loading (?). */
1760 valu
+= function_start_offset
;
1762 if (block_address_function_relative
)
1763 /* Relocate for Sun ELF acc fn-relative syms. */
1764 valu
+= function_start_offset
;
1766 /* On most machines, the block addresses are relative to the
1767 N_SO, the linker did not relocate them (sigh). */
1768 valu
+= last_source_start_addr
;
1771 #ifdef SUN_FIXED_LBRAC_BUG
1772 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1773 /* Patch current LBRAC pc value to match last handy pc value */
1774 complain (&lbrac_complaint
);
1775 valu
= last_pc_address
;
1778 new = push_context (desc
, valu
);
1782 /* This "symbol" just indicates the end of an inner lexical
1783 context that was started with N_LBRAC. */
1785 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1786 /* Relocate for dynamic loading (?). */
1787 valu
+= function_start_offset
;
1789 if (block_address_function_relative
)
1790 /* Relocate for Sun ELF acc fn-relative syms. */
1791 valu
+= function_start_offset
;
1793 /* On most machines, the block addresses are relative to the
1794 N_SO, the linker did not relocate them (sigh). */
1795 valu
+= last_source_start_addr
;
1798 new = pop_context();
1799 if (desc
!= new->depth
)
1800 complain (&lbrac_mismatch_complaint
, symnum
);
1802 /* Some compilers put the variable decls inside of an
1803 LBRAC/RBRAC block. This macro should be nonzero if this
1804 is true. DESC is N_DESC from the N_RBRAC symbol.
1805 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1806 or the GCC2_COMPILED_SYMBOL. */
1807 #if !defined (VARIABLES_INSIDE_BLOCK)
1808 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1811 /* Can only use new->locals as local symbols here if we're in
1812 gcc or on a machine that puts them before the lbrack. */
1813 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1814 local_symbols
= new->locals
;
1816 if (context_stack_depth
1817 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1819 /* This is not the outermost LBRAC...RBRAC pair in the function,
1820 its local symbols preceded it, and are the ones just recovered
1821 from the context stack. Define the block for them (but don't
1822 bother if the block contains no symbols. Should we complain
1823 on blocks without symbols? I can't think of any useful purpose
1825 if (local_symbols
!= NULL
)
1827 /* Muzzle a compiler bug that makes end < start. (which
1828 compilers? Is this ever harmful?). */
1829 if (new->start_addr
> valu
)
1831 complain (&lbrac_rbrac_complaint
);
1832 new->start_addr
= valu
;
1834 /* Make a block for the local symbols within. */
1835 finish_block (0, &local_symbols
, new->old_blocks
,
1836 new->start_addr
, valu
, objfile
);
1841 /* This is the outermost LBRAC...RBRAC pair. There is no
1842 need to do anything; leave the symbols that preceded it
1843 to be attached to the function's own block. We need to
1844 indicate that we just moved outside of the function. */
1845 within_function
= 0;
1848 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1849 /* Now pop locals of block just finished. */
1850 local_symbols
= new->locals
;
1855 /* This kind of symbol indicates the start of an object file. */
1856 /* Relocate for dynamic loading */
1857 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1861 /* This type of symbol indicates the start of data
1862 for one source file.
1863 Finish the symbol table of the previous source file
1864 (if any) and start accumulating a new symbol table. */
1865 /* Relocate for dynamic loading */
1866 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1870 #ifdef SUN_FIXED_LBRAC_BUG
1871 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1874 #ifdef PCC_SOL_BROKEN
1875 /* pcc bug, occasionally puts out SO for SOL. */
1876 if (context_stack_depth
> 0)
1878 start_subfile (name
, NULL
);
1882 if (last_source_file
)
1884 /* Check if previous symbol was also an N_SO (with some
1885 sanity checks). If so, that one was actually the directory
1886 name, and the current one is the real file name.
1888 if (previous_stab_code
== (unsigned char) N_SO
)
1890 patch_subfile_names (current_subfile
, name
);
1891 break; /* Ignore repeated SOs */
1893 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1897 /* Null name means this just marks the end of text for this .o file.
1898 Don't start a new symtab in this case. */
1899 if (*name
== '\000')
1903 start_symtab (name
, NULL
, valu
);
1907 /* This type of symbol indicates the start of data for
1908 a sub-source-file, one whose contents were copied or
1909 included in the compilation of the main source file
1910 (whose name was given in the N_SO symbol.) */
1911 /* Relocate for dynamic loading */
1912 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1913 start_subfile (name
, current_subfile
->dirname
);
1918 add_new_header_file (name
, valu
);
1919 start_subfile (name
, current_subfile
->dirname
);
1923 start_subfile (pop_subfile (), current_subfile
->dirname
);
1927 add_old_header_file (name
, valu
);
1931 /* This type of "symbol" really just records
1932 one line-number -- core-address correspondence.
1933 Enter it in the line list for this symbol table. */
1934 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1935 valu
+= function_start_offset
;
1936 #ifdef SUN_FIXED_LBRAC_BUG
1937 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1939 record_line (current_subfile
, desc
, valu
);
1943 common_block_start (name
, objfile
);
1947 common_block_end (objfile
);
1950 /* The following symbol types need to have the appropriate offset added
1951 to their value; then we process symbol definitions in the name. */
1953 case N_STSYM
: /* Static symbol in data seg */
1954 case N_LCSYM
: /* Static symbol in BSS seg */
1955 case N_ROSYM
: /* Static symbol in Read-only data seg */
1956 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1957 Solaris2's stabs-in-elf makes *most* symbols relative
1958 but leaves a few absolute (at least for Solaris 2.1 and version
1959 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1960 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1961 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1962 This leaves us no choice but to search for the 'S' or 'V'...
1963 (or pass the whole section_offsets stuff down ONE MORE function
1964 call level, which we really don't want to do). */
1968 /* .o files and NLMs have non-zero text seg offsets, but don't need
1969 their static syms offset in this fashion. XXX - This is really a
1970 crock that should be fixed in the solib handling code so that I
1971 don't have to work around it here. */
1973 if (!symfile_relocatable
)
1975 p
= strchr (name
, ':');
1976 if (p
!= 0 && p
[1] == 'S')
1978 /* The linker relocated it. We don't want to add an
1979 elfstab_offset_sections-type offset, but we *do* want
1980 to add whatever solib.c passed to symbol_file_add as
1981 addr (this is known to affect SunOS4, and I suspect ELF
1982 too). Since elfstab_offset_sections currently does not
1983 muck with the text offset (there is no Ttext.text
1984 symbol), we can get addr from the text offset. If
1985 elfstab_offset_sections ever starts dealing with the
1986 text offset, and we still need to do this, we need to
1987 invent a SECT_OFF_ADDR_KLUDGE or something. */
1988 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1989 goto define_a_symbol
;
1992 /* Since it's not the kludge case, re-dispatch to the right handler. */
1994 case N_STSYM
: goto case_N_STSYM
;
1995 case N_LCSYM
: goto case_N_LCSYM
;
1996 case N_ROSYM
: goto case_N_ROSYM
;
2001 case_N_STSYM
: /* Static symbol in data seg */
2002 case N_DSLINE
: /* Source line number, data seg */
2003 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2004 goto define_a_symbol
;
2006 case_N_LCSYM
: /* Static symbol in BSS seg */
2007 case N_BSLINE
: /* Source line number, bss seg */
2008 /* N_BROWS: overlaps with N_BSLINE */
2009 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2010 goto define_a_symbol
;
2012 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2013 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2014 goto define_a_symbol
;
2016 case N_ENTRY
: /* Alternate entry point */
2017 /* Relocate for dynamic loading */
2018 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2019 goto define_a_symbol
;
2021 /* The following symbol types we don't know how to process. Handle
2022 them in a "default" way, but complain to people who care. */
2024 case N_CATCH
: /* Exception handler catcher */
2025 case N_EHDECL
: /* Exception handler name */
2026 case N_PC
: /* Global symbol in Pascal */
2027 case N_M2C
: /* Modula-2 compilation unit */
2028 /* N_MOD2: overlaps with N_EHDECL */
2029 case N_SCOPE
: /* Modula-2 scope information */
2030 case N_ECOML
: /* End common (local name) */
2031 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2036 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2039 /* The following symbol types don't need the address field relocated,
2040 since it is either unused, or is absolute. */
2042 case N_GSYM
: /* Global variable */
2043 case N_NSYMS
: /* Number of symbols (ultrix) */
2044 case N_NOMAP
: /* No map? (ultrix) */
2045 case N_RSYM
: /* Register variable */
2046 case N_DEFD
: /* Modula-2 GNU module dependency */
2047 case N_SSYM
: /* Struct or union element */
2048 case N_LSYM
: /* Local symbol in stack */
2049 case N_PSYM
: /* Parameter variable */
2050 case N_LENG
: /* Length of preceding symbol type */
2054 char *colon_pos
= strchr (name
, ':');
2055 if (colon_pos
== NULL
)
2058 deftype
= colon_pos
[1];
2064 function_stab_type
= type
;
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 /* On solaris up to 2.2, the N_FUN stab gets relocated.
2083 On Solaris 2.3, ld no longer relocates stabs (which
2084 is good), and the N_FUN's value is now always zero.
2085 The following code can't deal with this, because
2086 last_pc_address depends on getting the address from a
2087 N_SLINE or some such and in Solaris those are function
2088 relative. Best fix is probably to create a Ttext.text symbol
2089 and handle this like Ddata.data and so on. */
2091 if (type
== N_GSYM
|| type
== N_STSYM
)
2093 struct minimal_symbol
*m
;
2094 int l
= colon_pos
- name
;
2096 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2097 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
2098 /* last_pc_address was in this function */
2099 valu
= SYMBOL_VALUE (m
);
2100 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
2101 /* last_pc_address was in last function */
2102 valu
= SYMBOL_VALUE (m
+1);
2104 /* Not found - use last_pc_address (for finish_block) */
2105 valu
= last_pc_address
;
2108 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2111 if (block_address_function_relative
)
2112 /* For Solaris 2.0 compilers, the block addresses and
2113 N_SLINE's are relative to the start of the
2114 function. On normal systems, and when using gcc on
2115 Solaris 2.0, these addresses are just absolute, or
2116 relative to the N_SO, depending on
2117 BLOCK_ADDRESS_ABSOLUTE. */
2118 function_start_offset
= valu
;
2120 within_function
= 1;
2121 if (context_stack_depth
> 0)
2123 new = pop_context ();
2124 /* Make a block for the local symbols within. */
2125 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2126 new->start_addr
, valu
, objfile
);
2128 /* Stack must be empty now. */
2129 if (context_stack_depth
!= 0)
2130 complain (&lbrac_unmatched_complaint
, symnum
);
2132 new = push_context (0, valu
);
2133 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2137 define_symbol (valu
, name
, desc
, type
, objfile
);
2143 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2144 for a bunch of other flags, too. Someday we may parse their
2145 flags; for now we ignore theirs and hope they'll ignore ours. */
2146 case N_OPT
: /* Solaris 2: Compiler options */
2149 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2151 processing_gcc_compilation
= 2;
2152 #if 1 /* Works, but is experimental. -fnf */
2153 if (AUTO_DEMANGLING
)
2155 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2164 /* The following symbol types can be ignored. */
2165 case N_OBJ
: /* Solaris 2: Object file dir and name */
2166 /* N_UNDF: Solaris 2: file separator mark */
2167 /* N_UNDF: -- we will never encounter it, since we only process one
2168 file's symbols at once. */
2169 case N_ENDM
: /* Solaris 2: End of module */
2170 case N_MAIN
: /* Name of main routine. */
2174 previous_stab_code
= type
;
2177 /* FIXME: The only difference between this and elfstab_build_psymtabs is
2178 the call to install_minimal_symbols for elf. If the differences are
2179 really that small, the code should be shared. */
2181 /* Scan and build partial symbols for an coff symbol file.
2182 The coff file has already been processed to get its minimal symbols.
2184 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2187 OBJFILE is the object file we are reading symbols from.
2188 ADDR is the address relative to which the symbols are (e.g.
2189 the base address of the text segment).
2190 MAINLINE is true if we are reading the main symbol
2191 table (as opposed to a shared lib or dynamically loaded file).
2192 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2194 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2195 .stabstr section exists.
2197 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2198 adjusted for coff details. */
2201 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2202 staboffset
, stabsize
,
2203 stabstroffset
, stabstrsize
)
2204 struct objfile
*objfile
;
2205 struct section_offsets
*section_offsets
;
2207 file_ptr staboffset
;
2208 unsigned int stabsize
;
2209 file_ptr stabstroffset
;
2210 unsigned int stabstrsize
;
2213 bfd
*sym_bfd
= objfile
->obfd
;
2214 char *name
= bfd_get_filename (sym_bfd
);
2215 struct dbx_symfile_info
*info
;
2217 /* There is already a dbx_symfile_info allocated by our caller.
2218 It might even contain some info from the coff symtab to help us. */
2219 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2221 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2222 if (!DBX_TEXT_SECT (objfile
))
2223 error ("Can't find .text section in symbol file");
2225 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2226 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2227 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2228 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2229 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2231 if (stabstrsize
> bfd_get_size (sym_bfd
))
2232 error ("ridiculous string table size: %d bytes", stabstrsize
);
2233 DBX_STRINGTAB (objfile
) = (char *)
2234 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2236 /* Now read in the string table in one big gulp. */
2238 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2240 perror_with_name (name
);
2241 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2242 if (val
!= stabstrsize
)
2243 perror_with_name (name
);
2245 stabsread_new_init ();
2246 buildsym_new_init ();
2247 free_header_files ();
2248 init_header_files ();
2250 processing_acc_compilation
= 1;
2252 /* In a coff file, we've already installed the minimal symbols that came
2253 from the coff (non-stab) symbol table, so always act like an
2254 incremental load here. */
2255 dbx_symfile_read (objfile
, section_offsets
, 0);
2258 /* Scan and build partial symbols for an ELF symbol file.
2259 This ELF file has already been processed to get its minimal symbols,
2260 and any DWARF symbols that were in it.
2262 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2265 OBJFILE is the object file we are reading symbols from.
2266 ADDR is the address relative to which the symbols are (e.g.
2267 the base address of the text segment).
2268 MAINLINE is true if we are reading the main symbol
2269 table (as opposed to a shared lib or dynamically loaded file).
2270 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2272 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2273 .stabstr section exists.
2275 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2276 adjusted for elf details. */
2279 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2280 staboffset
, stabsize
,
2281 stabstroffset
, stabstrsize
)
2282 struct objfile
*objfile
;
2283 struct section_offsets
*section_offsets
;
2285 file_ptr staboffset
;
2286 unsigned int stabsize
;
2287 file_ptr stabstroffset
;
2288 unsigned int stabstrsize
;
2291 bfd
*sym_bfd
= objfile
->obfd
;
2292 char *name
= bfd_get_filename (sym_bfd
);
2293 struct dbx_symfile_info
*info
;
2295 /* There is already a dbx_symfile_info allocated by our caller.
2296 It might even contain some info from the ELF symtab to help us. */
2297 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2299 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2300 if (!DBX_TEXT_SECT (objfile
))
2301 error ("Can't find .text section in symbol file");
2303 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2304 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2305 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2306 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2307 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2309 if (stabstrsize
> bfd_get_size (sym_bfd
))
2310 error ("ridiculous string table size: %d bytes", stabstrsize
);
2311 DBX_STRINGTAB (objfile
) = (char *)
2312 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2314 /* Now read in the string table in one big gulp. */
2316 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2318 perror_with_name (name
);
2319 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2320 if (val
!= stabstrsize
)
2321 perror_with_name (name
);
2323 stabsread_new_init ();
2324 buildsym_new_init ();
2325 free_header_files ();
2326 init_header_files ();
2327 install_minimal_symbols (objfile
);
2329 processing_acc_compilation
= 1;
2331 /* In an elf file, we've already installed the minimal symbols that came
2332 from the elf (non-stab) symbol table, so always act like an
2333 incremental load here. */
2334 dbx_symfile_read (objfile
, section_offsets
, 0);
2337 /* Scan and build partial symbols for a file with special sections for stabs
2338 and stabstrings. The file has already been processed to get its minimal
2339 symbols, and any other symbols that might be necessary to resolve GSYMs.
2341 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2344 OBJFILE is the object file we are reading symbols from.
2345 ADDR is the address relative to which the symbols are (e.g. the base address
2346 of the text segment).
2347 MAINLINE is true if we are reading the main symbol table (as opposed to a
2348 shared lib or dynamically loaded file).
2349 STAB_NAME is the name of the section that contains the stabs.
2350 STABSTR_NAME is the name of the section that contains the stab strings.
2352 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2355 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2356 stabstr_name
, text_name
)
2357 struct objfile
*objfile
;
2358 struct section_offsets
*section_offsets
;
2365 bfd
*sym_bfd
= objfile
->obfd
;
2366 char *name
= bfd_get_filename (sym_bfd
);
2368 asection
*stabstrsect
;
2370 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2371 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2377 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2378 stab_name
, stabstr_name
);
2380 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2381 memset (DBX_SYMFILE_INFO (objfile
), 0, sizeof (struct dbx_symfile_info
));
2383 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, text_name
);
2384 if (!DBX_TEXT_SECT (objfile
))
2385 error ("Can't find %s section in symbol file", text_name
);
2387 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2388 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2389 / DBX_SYMBOL_SIZE (objfile
);
2390 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2391 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2393 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2394 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2395 DBX_STRINGTAB (objfile
) = (char *)
2396 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2398 /* Now read in the string table in one big gulp. */
2400 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2401 stabstrsect
, /* bfd section */
2402 DBX_STRINGTAB (objfile
), /* input buffer */
2403 0, /* offset into section */
2404 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2407 perror_with_name (name
);
2409 stabsread_new_init ();
2410 buildsym_new_init ();
2411 free_header_files ();
2412 init_header_files ();
2413 install_minimal_symbols (objfile
);
2415 /* Now, do an incremental load */
2417 processing_acc_compilation
= 1;
2418 dbx_symfile_read (objfile
, section_offsets
, 0);
2421 /* Parse the user's idea of an offset for dynamic linking, into our idea
2422 of how to represent it for fast symbol reading. */
2424 static struct section_offsets
*
2425 dbx_symfile_offsets (objfile
, addr
)
2426 struct objfile
*objfile
;
2429 struct section_offsets
*section_offsets
;
2432 objfile
->num_sections
= SECT_OFF_MAX
;
2433 section_offsets
= (struct section_offsets
*)
2434 obstack_alloc (&objfile
-> psymbol_obstack
,
2435 sizeof (struct section_offsets
)
2436 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2438 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2439 ANOFFSET (section_offsets
, i
) = addr
;
2441 return section_offsets
;
2444 static struct sym_fns aout_sym_fns
=
2446 bfd_target_aout_flavour
,
2447 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2448 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2449 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2450 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2451 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2452 NULL
/* next: pointer to next struct sym_fns */
2456 _initialize_dbxread ()
2458 add_symtab_fns(&aout_sym_fns
);