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 init_psymbol_list
PARAMS ((struct objfile
*));
253 dbx_next_symbol_text
PARAMS ((void));
256 fill_symbuf
PARAMS ((bfd
*));
259 dbx_symfile_init
PARAMS ((struct objfile
*));
262 dbx_new_init
PARAMS ((struct objfile
*));
265 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
268 dbx_symfile_finish
PARAMS ((struct objfile
*));
271 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
274 add_new_header_file
PARAMS ((char *, int));
277 add_old_header_file
PARAMS ((char *, int));
280 add_this_object_header_file
PARAMS ((int));
282 /* Free up old header file tables */
289 if (header_files
!= NULL
)
291 for (i
= 0; i
< n_header_files
; i
++)
293 free (header_files
[i
].name
);
295 free ((PTR
)header_files
);
299 if (this_object_header_files
)
301 free ((PTR
)this_object_header_files
);
302 this_object_header_files
= NULL
;
304 n_allocated_header_files
= 0;
305 n_allocated_this_object_header_files
= 0;
308 /* Allocate new header file tables */
314 n_allocated_header_files
= 10;
315 header_files
= (struct header_file
*)
316 xmalloc (10 * sizeof (struct header_file
));
318 n_allocated_this_object_header_files
= 10;
319 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
322 /* Add header file number I for this object file
323 at the next successive FILENUM. */
326 add_this_object_header_file (i
)
329 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
331 n_allocated_this_object_header_files
*= 2;
332 this_object_header_files
333 = (int *) xrealloc ((char *) this_object_header_files
,
334 n_allocated_this_object_header_files
* sizeof (int));
337 this_object_header_files
[n_this_object_header_files
++] = i
;
340 /* Add to this file an "old" header file, one already seen in
341 a previous object file. NAME is the header file's name.
342 INSTANCE is its instance code, to select among multiple
343 symbol tables for the same header file. */
346 add_old_header_file (name
, instance
)
350 register struct header_file
*p
= header_files
;
353 for (i
= 0; i
< n_header_files
; i
++)
354 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
356 add_this_object_header_file (i
);
359 complain (&repeated_header_complaint
, name
, symnum
);
362 /* Add to this file a "new" header file: definitions for its types follow.
363 NAME is the header file's name.
364 Most often this happens only once for each distinct header file,
365 but not necessarily. If it happens more than once, INSTANCE has
366 a different value each time, and references to the header file
367 use INSTANCE values to select among them.
369 dbx output contains "begin" and "end" markers for each new header file,
370 but at this level we just need to know which files there have been;
371 so we record the file when its "begin" is seen and ignore the "end". */
374 add_new_header_file (name
, instance
)
380 /* Make sure there is room for one more header file. */
382 if (n_header_files
== n_allocated_header_files
)
384 n_allocated_header_files
*= 2;
385 header_files
= (struct header_file
*)
386 xrealloc ((char *) header_files
,
387 (n_allocated_header_files
* sizeof (struct header_file
)));
390 /* Create an entry for this header file. */
392 i
= n_header_files
++;
393 header_files
[i
].name
= savestring (name
, strlen(name
));
394 header_files
[i
].instance
= instance
;
395 header_files
[i
].length
= 10;
396 header_files
[i
].vector
397 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
398 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
400 add_this_object_header_file (i
);
404 static struct type
**
405 explicit_lookup_type (real_filenum
, index
)
406 int real_filenum
, index
;
408 register struct header_file
*f
= &header_files
[real_filenum
];
410 if (index
>= f
->length
)
413 f
->vector
= (struct type
**)
414 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
415 memset (&f
->vector
[f
->length
/ 2],
416 '\0', f
->length
* sizeof (struct type
*) / 2);
418 return &f
->vector
[index
];
423 record_minimal_symbol (name
, address
, type
, objfile
)
427 struct objfile
*objfile
;
429 enum minimal_symbol_type ms_type
;
436 section
= SECT_OFF_TEXT
;
440 section
= SECT_OFF_DATA
;
444 section
= SECT_OFF_BSS
;
453 section
= SECT_OFF_DATA
;
456 /* I don't think this type actually exists; since a N_SETV is the result
457 of going over many .o files, it doesn't make sense to have one
459 ms_type
= mst_file_data
;
460 section
= SECT_OFF_DATA
;
467 ms_type
= mst_file_text
;
468 section
= SECT_OFF_TEXT
;
471 ms_type
= mst_file_data
;
473 /* Check for __DYNAMIC, which is used by Sun shared libraries.
474 Record it as global even if it's local, not global, so
475 lookup_minimal_symbol can find it. We don't check symbol_leading_char
476 because for SunOS4 it always is '_'. */
477 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
480 /* Same with virtual function tables, both global and static. */
482 char *tempstring
= name
;
483 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
485 if (VTBL_PREFIX_P ((tempstring
)))
488 section
= SECT_OFF_DATA
;
491 ms_type
= mst_file_bss
;
492 section
= SECT_OFF_BSS
;
495 ms_type
= mst_unknown
;
500 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
501 && address
< lowest_text_address
)
502 lowest_text_address
= address
;
504 prim_record_minimal_symbol_and_info
505 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
513 /* Scan and build partial symbols for a symbol file.
514 We have been initialized by a call to dbx_symfile_init, which
515 put all the relevant info into a "struct dbx_symfile_info",
516 hung off the objfile structure.
518 SECTION_OFFSETS contains offsets relative to which the symbols in the
519 various sections are (depending where the sections were actually loaded).
520 MAINLINE is true if we are reading the main symbol
521 table (as opposed to a shared lib or dynamically loaded file). */
524 dbx_symfile_read (objfile
, section_offsets
, mainline
)
525 struct objfile
*objfile
;
526 struct section_offsets
*section_offsets
;
527 int mainline
; /* FIXME comments above */
531 struct cleanup
*back_to
;
533 val
= strlen (objfile
->name
);
535 /* .o and .nlm files are relocatables with text, data and bss segs based at
536 0. This flag disables special (Solaris stabs-in-elf only) fixups for
537 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
538 should be fixed to determine pst->textlow without using this text seg of
541 if (strcmp (&objfile
->name
[val
-2], ".o") == 0
542 || strcmp (&objfile
->name
[val
-4], ".nlm") == 0)
543 symfile_relocatable
= 1;
545 /* This is true for Solaris (and all other systems which put stabs
546 in sections, hopefully, since it would be silly to do things
547 differently from Solaris), and false for SunOS4 and other a.out
549 block_address_function_relative
=
550 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
551 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
552 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4))
553 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "nlm", 3)));
555 sym_bfd
= objfile
->obfd
;
556 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
558 perror_with_name (objfile
->name
);
560 /* If we are reinitializing, or if we have never loaded syms yet, init */
561 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
562 init_psymbol_list (objfile
);
564 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
565 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
568 back_to
= make_cleanup (really_free_pendings
, 0);
570 init_minimal_symbol_collection ();
571 make_cleanup (discard_minimal_symbols
, 0);
573 /* Now that the symbol table data of the executable file are all in core,
574 process them and define symbols accordingly. */
576 read_dbx_symtab (section_offsets
, objfile
,
577 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
578 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
580 /* Add the dynamic symbols. */
582 read_dbx_dynamic_symtab (section_offsets
, objfile
);
584 /* Install any minimal symbols that have been collected as the current
585 minimal symbols for this objfile. */
587 install_minimal_symbols (objfile
);
589 do_cleanups (back_to
);
592 /* Initialize anything that needs initializing when a completely new
593 symbol file is specified (not just adding some symbols from another
594 file, e.g. a shared library). */
597 dbx_new_init (ignore
)
598 struct objfile
*ignore
;
600 stabsread_new_init ();
601 buildsym_new_init ();
602 init_header_files ();
606 /* dbx_symfile_init ()
607 is the dbx-specific initialization routine for reading symbols.
608 It is passed a struct objfile which contains, among other things,
609 the BFD for the file whose symbols are being read, and a slot for a pointer
610 to "private data" which we fill with goodies.
612 We read the string table into malloc'd space and stash a pointer to it.
614 Since BFD doesn't know how to read debug symbols in a format-independent
615 way (and may never do so...), we have to do it ourselves. We will never
616 be called unless this is an a.out (or very similar) file.
617 FIXME, there should be a cleaner peephole into the BFD environment here. */
619 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
622 dbx_symfile_init (objfile
)
623 struct objfile
*objfile
;
626 bfd
*sym_bfd
= objfile
->obfd
;
627 char *name
= bfd_get_filename (sym_bfd
);
628 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
630 /* Allocate struct to keep track of the symfile */
631 objfile
->sym_stab_info
= (PTR
)
632 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
634 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
635 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
636 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
638 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
640 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
641 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
642 if (!DBX_TEXT_SECT (objfile
))
643 error ("Can't find .text section in symbol file");
645 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
646 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
647 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
649 /* Read the string table and stash it away in the psymbol_obstack. It is
650 only needed as long as we need to expand psymbols into full symbols,
651 so when we blow away the psymbol the string table goes away as well.
652 Note that gdb used to use the results of attempting to malloc the
653 string table, based on the size it read, as a form of sanity check
654 for botched byte swapping, on the theory that a byte swapped string
655 table size would be so totally bogus that the malloc would fail. Now
656 that we put in on the psymbol_obstack, we can't do this since gdb gets
657 a fatal error (out of virtual memory) if the size is bogus. We can
658 however at least check to see if the size is less than the size of
659 the size field itself, or larger than the size of the entire file.
660 Note that all valid string tables have a size greater than zero, since
661 the bytes used to hold the size are included in the count. */
663 if (STRING_TABLE_OFFSET
== 0)
665 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
666 will never be zero, even when there is no string table. This
667 would appear to be a bug in bfd. */
668 DBX_STRINGTAB_SIZE (objfile
) = 0;
669 DBX_STRINGTAB (objfile
) = NULL
;
673 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
675 perror_with_name (name
);
677 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
678 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
681 perror_with_name (name
);
685 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
686 EOF if there is no string table, and attempting to read the size
687 from EOF will read zero bytes. */
688 DBX_STRINGTAB_SIZE (objfile
) = 0;
689 DBX_STRINGTAB (objfile
) = NULL
;
693 /* Read some data that would appear to be the string table size.
694 If there really is a string table, then it is probably the right
695 size. Byteswap if necessary and validate the size. Note that
696 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
697 random data that happened to be at STRING_TABLE_OFFSET, because
698 bfd can't tell us there is no string table, the sanity checks may
699 or may not catch this. */
700 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
702 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
703 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
704 error ("ridiculous string table size (%d bytes).",
705 DBX_STRINGTAB_SIZE (objfile
));
707 DBX_STRINGTAB (objfile
) =
708 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
709 DBX_STRINGTAB_SIZE (objfile
));
711 /* Now read in the string table in one big gulp. */
713 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
715 perror_with_name (name
);
716 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
718 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
719 perror_with_name (name
);
724 /* Perform any local cleanups required when we are done with a particular
725 objfile. I.E, we are in the process of discarding all symbol information
726 for an objfile, freeing up all memory held for it, and unlinking the
727 objfile struct from the global list of known objfiles. */
730 dbx_symfile_finish (objfile
)
731 struct objfile
*objfile
;
733 if (objfile
->sym_stab_info
!= NULL
)
735 mfree (objfile
-> md
, objfile
->sym_stab_info
);
737 free_header_files ();
741 /* Buffer for reading the symbol table entries. */
742 static struct internal_nlist symbuf
[4096];
743 static int symbuf_idx
;
744 static int symbuf_end
;
746 /* Name of last function encountered. Used in Solaris to approximate
747 object file boundaries. */
748 static char *last_function_name
;
750 /* The address in memory of the string table of the object file we are
751 reading (which might not be the "main" object file, but might be a
752 shared library or some other dynamically loaded thing). This is set
753 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
754 when building symtabs, and is used only by next_symbol_text. */
755 static char *stringtab_global
;
757 /* Refill the symbol table input buffer
758 and set the variables that control fetching entries from it.
759 Reports an error if no data available.
760 This function can read past the end of the symbol table
761 (into the string table) but this does no harm. */
764 fill_symbuf (sym_bfd
)
767 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
769 perror_with_name (bfd_get_filename (sym_bfd
));
770 else if (nbytes
== 0)
771 error ("Premature end of file reading symbol table");
772 symbuf_end
= nbytes
/ symbol_size
;
776 #define SWAP_SYMBOL(symp, abfd) \
778 (symp)->n_strx = bfd_h_get_32(abfd, \
779 (unsigned char *)&(symp)->n_strx); \
780 (symp)->n_desc = bfd_h_get_16 (abfd, \
781 (unsigned char *)&(symp)->n_desc); \
782 (symp)->n_value = bfd_h_get_32 (abfd, \
783 (unsigned char *)&(symp)->n_value); \
786 /* Invariant: The symbol pointed to by symbuf_idx is the first one
787 that hasn't been swapped. Swap the symbol at the same time
788 that symbuf_idx is incremented. */
790 /* dbx allows the text of a symbol name to be continued into the
791 next symbol name! When such a continuation is encountered
792 (a \ at the end of the text of a name)
793 call this function to get the continuation. */
796 dbx_next_symbol_text ()
798 if (symbuf_idx
== symbuf_end
)
799 fill_symbuf (symfile_bfd
);
801 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
802 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
803 + file_string_table_offset
;
806 /* Initializes storage for all of the partial symbols that will be
807 created by read_dbx_symtab and subsidiaries. */
810 init_psymbol_list (objfile
)
811 struct objfile
*objfile
;
813 /* Free any previously allocated psymbol lists. */
814 if (objfile
-> global_psymbols
.list
)
815 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
816 if (objfile
-> static_psymbols
.list
)
817 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
819 /* Current best guess is that there are approximately a twentieth
820 of the total symbols (in a debugging file) are global or static
822 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
823 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
824 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
825 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
826 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
827 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
830 /* Initialize the list of bincls to contain none and have some
834 init_bincl_list (number
, objfile
)
836 struct objfile
*objfile
;
838 bincls_allocated
= number
;
839 next_bincl
= bincl_list
= (struct header_file_location
*)
840 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
843 /* Add a bincl to the list. */
846 add_bincl_to_list (pst
, name
, instance
)
847 struct partial_symtab
*pst
;
851 if (next_bincl
>= bincl_list
+ bincls_allocated
)
853 int offset
= next_bincl
- bincl_list
;
854 bincls_allocated
*= 2;
855 bincl_list
= (struct header_file_location
*)
856 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
857 bincls_allocated
* sizeof (struct header_file_location
));
858 next_bincl
= bincl_list
+ offset
;
860 next_bincl
->pst
= pst
;
861 next_bincl
->instance
= instance
;
862 next_bincl
++->name
= name
;
865 /* Given a name, value pair, find the corresponding
866 bincl in the list. Return the partial symtab associated
867 with that header_file_location. */
869 static struct partial_symtab
*
870 find_corresponding_bincl_psymtab (name
, instance
)
874 struct header_file_location
*bincl
;
876 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
877 if (bincl
->instance
== instance
878 && STREQ (name
, bincl
->name
))
881 complain (&repeated_header_complaint
, name
, symnum
);
882 return (struct partial_symtab
*) 0;
885 /* Free the storage allocated for the bincl list. */
888 free_bincl_list (objfile
)
889 struct objfile
*objfile
;
891 mfree (objfile
-> md
, (PTR
)bincl_list
);
892 bincls_allocated
= 0;
895 /* Scan a SunOs dynamic symbol table for symbols of interest and
896 add them to the minimal symbol table. */
899 read_dbx_dynamic_symtab (section_offsets
, objfile
)
900 struct section_offsets
*section_offsets
;
901 struct objfile
*objfile
;
903 bfd
*abfd
= objfile
->obfd
;
904 struct cleanup
*back_to
;
917 /* Check that the symbol file has dynamic symbols that we know about.
918 bfd_arch_unknown can happen if we are reading a sun3 symbol file
919 on a sun4 host (and vice versa) and bfd is not configured
920 --with-target=all. This would trigger an assertion in bfd/sunos.c,
921 so we ignore the dynamic symbols in this case. */
922 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
923 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
924 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
927 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
931 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
932 back_to
= make_cleanup (free
, dynsyms
);
934 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
935 if (dynsym_count
< 0)
937 do_cleanups (back_to
);
941 /* Enter dynamic symbols into the minimal symbol table
942 if this is a stripped executable. */
943 if (bfd_get_symcount (abfd
) <= 0)
946 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
948 asymbol
*sym
= *symptr
;
952 sec
= bfd_get_section (sym
);
954 /* BFD symbols are section relative. */
955 sym_value
= sym
->value
+ sec
->vma
;
957 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
959 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
962 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
964 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
967 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
969 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
975 if (sym
->flags
& BSF_GLOBAL
)
978 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
983 /* Symbols from shared libraries have a dynamic relocation entry
984 that points to the associated slot in the procedure linkage table.
985 We make a mininal symbol table entry with type mst_solib_trampoline
986 at the address in the procedure linkage table. */
987 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
990 do_cleanups (back_to
);
994 dynrels
= (arelent
**) xmalloc (dynrel_size
);
995 make_cleanup (free
, dynrels
);
997 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
998 if (dynrel_count
< 0)
1000 do_cleanups (back_to
);
1004 for (counter
= 0, relptr
= dynrels
;
1005 counter
< dynrel_count
;
1006 counter
++, relptr
++)
1008 arelent
*rel
= *relptr
;
1010 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1012 switch (bfd_get_arch (abfd
))
1014 case bfd_arch_sparc
:
1015 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1019 /* `16' is the type BFD produces for a jump table relocation. */
1020 if (rel
->howto
->type
!= 16)
1023 /* Adjust address in the jump table to point to
1024 the start of the bsr instruction. */
1031 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1032 prim_record_minimal_symbol
1033 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
1035 mst_solib_trampoline
,
1039 do_cleanups (back_to
);
1042 /* Given pointers to an a.out symbol table in core containing dbx
1043 style data, setup partial_symtab's describing each source file for
1044 which debugging information is available.
1045 SYMFILE_NAME is the name of the file we are reading from
1046 and SECTION_OFFSETS is the set of offsets for the various sections
1047 of the file (a set of zeros if the mainline program). */
1050 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1051 struct section_offsets
*section_offsets
;
1052 struct objfile
*objfile
;
1053 CORE_ADDR text_addr
;
1056 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1057 register char *namestring
;
1059 int past_first_source_file
= 0;
1060 CORE_ADDR last_o_file_start
= 0;
1061 struct cleanup
*back_to
;
1064 /* Current partial symtab */
1065 struct partial_symtab
*pst
;
1067 /* List of current psymtab's include files */
1068 char **psymtab_include_list
;
1069 int includes_allocated
;
1072 /* Index within current psymtab dependency list */
1073 struct partial_symtab
**dependency_list
;
1074 int dependencies_used
, dependencies_allocated
;
1076 /* FIXME. We probably want to change stringtab_global rather than add this
1077 while processing every symbol entry. FIXME. */
1078 file_string_table_offset
= 0;
1079 next_file_string_table_offset
= 0;
1081 stringtab_global
= DBX_STRINGTAB (objfile
);
1083 pst
= (struct partial_symtab
*) 0;
1085 includes_allocated
= 30;
1087 psymtab_include_list
= (char **) alloca (includes_allocated
*
1090 dependencies_allocated
= 30;
1091 dependencies_used
= 0;
1093 (struct partial_symtab
**) alloca (dependencies_allocated
*
1094 sizeof (struct partial_symtab
*));
1096 /* Init bincl list */
1097 init_bincl_list (20, objfile
);
1098 back_to
= make_cleanup (free_bincl_list
, objfile
);
1100 last_source_file
= NULL
;
1102 lowest_text_address
= (CORE_ADDR
)-1;
1104 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1105 abfd
= objfile
->obfd
;
1106 symbuf_end
= symbuf_idx
= 0;
1107 next_symbol_text_func
= dbx_next_symbol_text
;
1109 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1111 /* Get the symbol for this run and pull out some info */
1112 QUIT
; /* allow this to be interruptable */
1113 if (symbuf_idx
== symbuf_end
)
1115 bufp
= &symbuf
[symbuf_idx
++];
1118 * Special case to speed up readin.
1120 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1122 SWAP_SYMBOL (bufp
, abfd
);
1124 /* Ok. There is a lot of code duplicated in the rest of this
1125 switch statement (for efficiency reasons). Since I don't
1126 like duplicating code, I will do my penance here, and
1127 describe the code which is duplicated:
1129 *) The assignment to namestring.
1130 *) The call to strchr.
1131 *) The addition of a partial symbol the the two partial
1132 symbol lists. This last is a large section of code, so
1133 I've imbedded it in the following macro.
1136 /* Set namestring based on bufp. If the string table index is invalid,
1137 give a fake name, and print a single error message per symbol file read,
1138 rather than abort the symbol reading or flood the user with messages. */
1140 /*FIXME: Too many adds and indirections in here for the inner loop. */
1141 #define SET_NAMESTRING()\
1142 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1143 DBX_STRINGTAB_SIZE (objfile)) { \
1144 complain (&string_table_offset_complaint, symnum); \
1145 namestring = "<bad string table offset>"; \
1147 namestring = bufp->n_strx + file_string_table_offset + \
1148 DBX_STRINGTAB (objfile)
1150 #define CUR_SYMBOL_TYPE bufp->n_type
1151 #define CUR_SYMBOL_VALUE bufp->n_value
1152 #define DBXREAD_ONLY
1153 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1154 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1155 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1156 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1158 #include "partial-stab.h"
1161 /* If there's stuff to be cleaned up, clean it up. */
1162 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1163 /*FIXME, does this have a bug at start address 0? */
1164 && last_o_file_start
1165 && objfile
-> ei
.entry_point
< bufp
->n_value
1166 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1168 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1169 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1174 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1175 symnum
* symbol_size
,
1176 (lowest_text_address
== (CORE_ADDR
)-1
1177 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1178 : lowest_text_address
)
1180 dependency_list
, dependencies_used
);
1183 do_cleanups (back_to
);
1186 /* Allocate and partially fill a partial symtab. It will be
1187 completely filled at the end of the symbol list.
1189 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1190 is the address relative to which its symbols are (incremental) or 0
1194 struct partial_symtab
*
1195 start_psymtab (objfile
, section_offsets
,
1196 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1197 struct objfile
*objfile
;
1198 struct section_offsets
*section_offsets
;
1202 struct partial_symbol
*global_syms
;
1203 struct partial_symbol
*static_syms
;
1205 struct partial_symtab
*result
=
1206 start_psymtab_common(objfile
, section_offsets
,
1207 filename
, textlow
, global_syms
, static_syms
);
1209 result
->read_symtab_private
= (char *)
1210 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1211 LDSYMOFF(result
) = ldsymoff
;
1212 result
->read_symtab
= dbx_psymtab_to_symtab
;
1213 SYMBOL_SIZE(result
) = symbol_size
;
1214 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1215 STRING_OFFSET(result
) = string_table_offset
;
1216 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1218 /* If we're handling an ELF file, drag some section-relocation info
1219 for this source file out of the ELF symbol table, to compensate for
1220 Sun brain death. This replaces the section_offsets in this psymtab,
1222 elfstab_offset_sections (objfile
, result
);
1224 /* Deduce the source language from the filename for this psymtab. */
1225 psymtab_language
= deduce_language_from_filename (filename
);
1230 /* Close off the current usage of PST.
1231 Returns PST or NULL if the partial symtab was empty and thrown away.
1233 FIXME: List variables and peculiarities of same. */
1235 struct partial_symtab
*
1236 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1237 capping_text
, dependency_list
, number_dependencies
)
1238 struct partial_symtab
*pst
;
1239 char **include_list
;
1241 int capping_symbol_offset
;
1242 CORE_ADDR capping_text
;
1243 struct partial_symtab
**dependency_list
;
1244 int number_dependencies
;
1247 struct objfile
*objfile
= pst
-> objfile
;
1249 if (capping_symbol_offset
!= -1)
1250 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1251 pst
->texthigh
= capping_text
;
1253 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1254 /* Under Solaris, the N_SO symbols always have a value of 0,
1255 instead of the usual address of the .o file. Therefore,
1256 we have to do some tricks to fill in texthigh and textlow.
1257 The first trick is in partial-stab.h: if we see a static
1258 or global function, and the textlow for the current pst
1259 is still 0, then we use that function's address for
1260 the textlow of the pst. */
1262 /* Now, to fill in texthigh, we remember the last function seen
1263 in the .o file (also in partial-stab.h). Also, there's a hack in
1264 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1265 to here via the misc_info field. Therefore, we can fill in
1266 a reliable texthigh by taking the address plus size of the
1267 last function in the file. */
1269 if (pst
->texthigh
== 0 && last_function_name
) {
1272 struct minimal_symbol
*minsym
;
1274 p
= strchr (last_function_name
, ':');
1276 p
= last_function_name
;
1277 n
= p
- last_function_name
;
1279 strncpy (p
, last_function_name
, n
);
1282 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1285 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1286 (long) MSYMBOL_INFO (minsym
);
1288 last_function_name
= NULL
;
1291 /* this test will be true if the last .o file is only data */
1292 if (pst
->textlow
== 0)
1293 /* This loses if the text section really starts at address zero
1294 (generally true when we are debugging a .o file, for example).
1295 That is why this whole thing is inside SOFUN_ADDRESS_MAYBE_MISSING. */
1296 pst
->textlow
= pst
->texthigh
;
1298 /* If we know our own starting text address, then walk through all other
1299 psymtabs for this objfile, and if any didn't know their ending text
1300 address, set it to our starting address. Take care to not set our
1301 own ending address to our starting address, nor to set addresses on
1302 `dependency' files that have both textlow and texthigh zero. */
1304 struct partial_symtab
*p1
;
1306 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1307 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1308 p1
->texthigh
= pst
->textlow
;
1309 /* if this file has only data, then make textlow match texthigh */
1310 if (p1
->textlow
== 0)
1311 p1
->textlow
= p1
->texthigh
;
1316 /* End of kludge for patching Solaris textlow and texthigh. */
1317 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1319 pst
->n_global_syms
=
1320 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1321 pst
->n_static_syms
=
1322 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1324 pst
->number_of_dependencies
= number_dependencies
;
1325 if (number_dependencies
)
1327 pst
->dependencies
= (struct partial_symtab
**)
1328 obstack_alloc (&objfile
->psymbol_obstack
,
1329 number_dependencies
* sizeof (struct partial_symtab
*));
1330 memcpy (pst
->dependencies
, dependency_list
,
1331 number_dependencies
* sizeof (struct partial_symtab
*));
1334 pst
->dependencies
= 0;
1336 for (i
= 0; i
< num_includes
; i
++)
1338 struct partial_symtab
*subpst
=
1339 allocate_psymtab (include_list
[i
], objfile
);
1341 subpst
->section_offsets
= pst
->section_offsets
;
1342 subpst
->read_symtab_private
=
1343 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1344 sizeof (struct symloc
));
1348 subpst
->texthigh
= 0;
1350 /* We could save slight bits of space by only making one of these,
1351 shared by the entire set of include files. FIXME-someday. */
1352 subpst
->dependencies
= (struct partial_symtab
**)
1353 obstack_alloc (&objfile
->psymbol_obstack
,
1354 sizeof (struct partial_symtab
*));
1355 subpst
->dependencies
[0] = pst
;
1356 subpst
->number_of_dependencies
= 1;
1358 subpst
->globals_offset
=
1359 subpst
->n_global_syms
=
1360 subpst
->statics_offset
=
1361 subpst
->n_static_syms
= 0;
1365 subpst
->read_symtab
= pst
->read_symtab
;
1368 sort_pst_symbols (pst
);
1370 /* If there is already a psymtab or symtab for a file of this name, remove it.
1371 (If there is a symtab, more drastic things also happen.)
1372 This happens in VxWorks. */
1373 free_named_symtabs (pst
->filename
);
1375 if (num_includes
== 0
1376 && number_dependencies
== 0
1377 && pst
->n_global_syms
== 0
1378 && pst
->n_static_syms
== 0)
1380 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1381 it is on the obstack, but we can forget to chain it on the list. */
1382 /* Empty psymtabs happen as a result of header files which don't have
1383 any symbols in them. There can be a lot of them. But this check
1384 is wrong, in that a psymtab with N_SLINE entries but nothing else
1385 is not empty, but we don't realize that. Fixing that without slowing
1386 things down might be tricky. */
1387 struct partial_symtab
*prev_pst
;
1389 /* First, snip it out of the psymtab chain */
1391 if (pst
->objfile
->psymtabs
== pst
)
1392 pst
->objfile
->psymtabs
= pst
->next
;
1394 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1395 if (prev_pst
->next
== pst
)
1396 prev_pst
->next
= pst
->next
;
1398 /* Next, put it on a free list for recycling */
1400 pst
->next
= pst
->objfile
->free_psymtabs
;
1401 pst
->objfile
->free_psymtabs
= pst
;
1403 /* Indicate that psymtab was thrown away. */
1404 pst
= (struct partial_symtab
*)NULL
;
1410 dbx_psymtab_to_symtab_1 (pst
)
1411 struct partial_symtab
*pst
;
1413 struct cleanup
*old_chain
;
1421 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1426 /* Read in all partial symtabs on which this one is dependent */
1427 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1428 if (!pst
->dependencies
[i
]->readin
)
1430 /* Inform about additional files that need to be read in. */
1433 fputs_filtered (" ", gdb_stdout
);
1435 fputs_filtered ("and ", gdb_stdout
);
1437 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1438 wrap_here (""); /* Flush output */
1439 gdb_flush (gdb_stdout
);
1441 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1444 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1446 /* Init stuff necessary for reading in symbols */
1449 old_chain
= make_cleanup (really_free_pendings
, 0);
1450 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1451 symbol_size
= SYMBOL_SIZE (pst
);
1453 /* Read in this file's symbols */
1454 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1455 read_ofile_symtab (pst
);
1456 sort_symtab_syms (pst
->symtab
);
1458 do_cleanups (old_chain
);
1464 /* Read in all of the symbols for a given psymtab for real.
1465 Be verbose about it if the user wants that. */
1468 dbx_psymtab_to_symtab (pst
)
1469 struct partial_symtab
*pst
;
1478 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1483 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1485 /* Print the message now, before reading the string table,
1486 to avoid disconcerting pauses. */
1489 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1490 gdb_flush (gdb_stdout
);
1493 sym_bfd
= pst
->objfile
->obfd
;
1495 next_symbol_text_func
= dbx_next_symbol_text
;
1497 dbx_psymtab_to_symtab_1 (pst
);
1499 /* Match with global symbols. This only needs to be done once,
1500 after all of the symtabs and dependencies have been read in. */
1501 scan_file_globals (pst
->objfile
);
1503 /* Finish up the debug error message. */
1505 printf_filtered ("done.\n");
1509 /* Read in a defined section of a specific object file's symbols. */
1512 read_ofile_symtab (pst
)
1513 struct partial_symtab
*pst
;
1515 register char *namestring
;
1516 register struct internal_nlist
*bufp
;
1518 unsigned max_symnum
;
1520 struct objfile
*objfile
;
1521 int sym_offset
; /* Offset to start of symbols to read */
1522 int sym_size
; /* Size of symbols to read */
1523 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1524 int text_size
; /* Size of text segment for symbols */
1525 struct section_offsets
*section_offsets
;
1527 objfile
= pst
->objfile
;
1528 sym_offset
= LDSYMOFF(pst
);
1529 sym_size
= LDSYMLEN(pst
);
1530 text_offset
= pst
->textlow
;
1531 text_size
= pst
->texthigh
- pst
->textlow
;
1532 section_offsets
= pst
->section_offsets
;
1534 current_objfile
= objfile
;
1535 subfile_stack
= NULL
;
1537 stringtab_global
= DBX_STRINGTAB (objfile
);
1538 last_source_file
= NULL
;
1540 abfd
= objfile
->obfd
;
1541 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1542 symbuf_end
= symbuf_idx
= 0;
1544 /* It is necessary to actually read one symbol *before* the start
1545 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1546 occurs before the N_SO symbol.
1548 Detecting this in read_dbx_symtab
1549 would slow down initial readin, so we look for it here instead. */
1550 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1552 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1554 bufp
= &symbuf
[symbuf_idx
++];
1555 SWAP_SYMBOL (bufp
, abfd
);
1559 processing_gcc_compilation
= 0;
1560 if (bufp
->n_type
== N_TEXT
)
1562 const char *tempstring
= namestring
;
1564 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1565 processing_gcc_compilation
= 1;
1566 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1567 processing_gcc_compilation
= 2;
1568 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1570 if (STREQN (tempstring
, "__gnu_compiled", 14))
1571 processing_gcc_compilation
= 2;
1574 /* Try to select a C++ demangling based on the compilation unit
1577 if (processing_gcc_compilation
)
1579 if (AUTO_DEMANGLING
)
1581 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1587 /* The N_SO starting this symtab is the first symbol, so we
1588 better not check the symbol before it. I'm not this can
1589 happen, but it doesn't hurt to check for it. */
1590 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1591 processing_gcc_compilation
= 0;
1594 if (symbuf_idx
== symbuf_end
)
1596 bufp
= &symbuf
[symbuf_idx
];
1597 if (bufp
->n_type
!= (unsigned char)N_SO
)
1598 error("First symbol in segment of executable not a source symbol");
1600 max_symnum
= sym_size
/ symbol_size
;
1603 symnum
< max_symnum
;
1606 QUIT
; /* Allow this to be interruptable */
1607 if (symbuf_idx
== symbuf_end
)
1609 bufp
= &symbuf
[symbuf_idx
++];
1610 SWAP_SYMBOL (bufp
, abfd
);
1612 type
= bufp
->n_type
;
1616 if (type
& N_STAB
) {
1617 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1618 namestring
, section_offsets
, objfile
);
1620 /* We skip checking for a new .o or -l file; that should never
1621 happen in this routine. */
1622 else if (type
== N_TEXT
)
1624 /* I don't think this code will ever be executed, because
1625 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1626 the N_SO symbol which starts this source file.
1627 However, there is no reason not to accept
1628 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1630 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1631 processing_gcc_compilation
= 1;
1632 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1633 processing_gcc_compilation
= 2;
1635 if (AUTO_DEMANGLING
)
1637 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1640 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1641 || type
== (unsigned char)N_NBTEXT
1643 /* Global symbol: see if we came across a dbx defintion for
1644 a corresponding symbol. If so, store the value. Remove
1645 syms from the chain when their values are stored, but
1646 search the whole chain, as there may be several syms from
1647 different files with the same name. */
1648 /* This is probably not true. Since the files will be read
1649 in one at a time, each reference to a global symbol will
1650 be satisfied in each file as it appears. So we skip this
1656 current_objfile
= NULL
;
1658 /* In a Solaris elf file, this variable, which comes from the
1659 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1660 which comes from pst->textlow is correct. */
1661 if (last_source_start_addr
== 0)
1662 last_source_start_addr
= text_offset
;
1664 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1670 /* This handles a single symbol from the symbol-file, building symbols
1671 into a GDB symtab. It takes these arguments and an implicit argument.
1673 TYPE is the type field of the ".stab" symbol entry.
1674 DESC is the desc field of the ".stab" entry.
1675 VALU is the value field of the ".stab" entry.
1676 NAME is the symbol name, in our address space.
1677 SECTION_OFFSETS is a set of amounts by which the sections of this object
1678 file were relocated when it was loaded into memory.
1679 All symbols that refer
1680 to memory locations need to be offset by these amounts.
1681 OBJFILE is the object file from which we are reading symbols.
1682 It is used in end_symtab. */
1685 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1689 struct section_offsets
*section_offsets
;
1690 struct objfile
*objfile
;
1692 #ifdef SUN_FIXED_LBRAC_BUG
1693 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1694 to correct the address of N_LBRAC's. If it is not defined, then
1695 we never need to correct the addresses. */
1697 /* This records the last pc address we've seen. We depend on there being
1698 an SLINE or FUN or SO before the first LBRAC, since the variable does
1699 not get reset in between reads of different symbol files. */
1700 static CORE_ADDR last_pc_address
;
1703 register struct context_stack
*new;
1704 /* This remembers the address of the start of a function. It is used
1705 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1706 relative to the current function's start address. On systems
1707 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1708 used to relocate these symbol types rather than SECTION_OFFSETS. */
1709 static CORE_ADDR function_start_offset
;
1711 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1712 file. Used to detect the SunPRO solaris compiler. */
1713 static int n_opt_found
;
1715 /* The stab type used for the definition of the last function.
1716 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1717 static int function_stab_type
= 0;
1719 if (!block_address_function_relative
)
1720 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1721 function start address, so just use the text offset. */
1722 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1724 /* Something is wrong if we see real data before
1725 seeing a source file name. */
1727 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1729 /* Ignore any symbols which appear before an N_SO symbol. Currently
1730 no one puts symbols there, but we should deal gracefully with the
1731 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1732 but this should not be an error (). */
1740 /* Relocate for dynamic loading */
1741 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1742 goto define_a_symbol
;
1745 /* This "symbol" just indicates the start of an inner lexical
1746 context within a function. */
1748 /* Ignore extra outermost context from SunPRO cc and acc. */
1749 if (n_opt_found
&& desc
== 1)
1752 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1753 /* Relocate for dynamic loading (?). */
1754 valu
+= function_start_offset
;
1756 if (block_address_function_relative
)
1757 /* Relocate for Sun ELF acc fn-relative syms. */
1758 valu
+= function_start_offset
;
1760 /* On most machines, the block addresses are relative to the
1761 N_SO, the linker did not relocate them (sigh). */
1762 valu
+= last_source_start_addr
;
1765 #ifdef SUN_FIXED_LBRAC_BUG
1766 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1767 /* Patch current LBRAC pc value to match last handy pc value */
1768 complain (&lbrac_complaint
);
1769 valu
= last_pc_address
;
1772 new = push_context (desc
, valu
);
1776 /* This "symbol" just indicates the end of an inner lexical
1777 context that was started with N_LBRAC. */
1779 /* Ignore extra outermost context from SunPRO cc and acc. */
1780 if (n_opt_found
&& desc
== 1)
1783 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1784 /* Relocate for dynamic loading (?). */
1785 valu
+= function_start_offset
;
1787 if (block_address_function_relative
)
1788 /* Relocate for Sun ELF acc fn-relative syms. */
1789 valu
+= function_start_offset
;
1791 /* On most machines, the block addresses are relative to the
1792 N_SO, the linker did not relocate them (sigh). */
1793 valu
+= last_source_start_addr
;
1796 new = pop_context();
1797 if (desc
!= new->depth
)
1798 complain (&lbrac_mismatch_complaint
, symnum
);
1800 /* Some compilers put the variable decls inside of an
1801 LBRAC/RBRAC block. This macro should be nonzero if this
1802 is true. DESC is N_DESC from the N_RBRAC symbol.
1803 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1804 or the GCC2_COMPILED_SYMBOL. */
1805 #if !defined (VARIABLES_INSIDE_BLOCK)
1806 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1809 /* Can only use new->locals as local symbols here if we're in
1810 gcc or on a machine that puts them before the lbrack. */
1811 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1812 local_symbols
= new->locals
;
1814 if (context_stack_depth
1815 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1817 /* This is not the outermost LBRAC...RBRAC pair in the function,
1818 its local symbols preceded it, and are the ones just recovered
1819 from the context stack. Define the block for them (but don't
1820 bother if the block contains no symbols. Should we complain
1821 on blocks without symbols? I can't think of any useful purpose
1823 if (local_symbols
!= NULL
)
1825 /* Muzzle a compiler bug that makes end < start. (which
1826 compilers? Is this ever harmful?). */
1827 if (new->start_addr
> valu
)
1829 complain (&lbrac_rbrac_complaint
);
1830 new->start_addr
= valu
;
1832 /* Make a block for the local symbols within. */
1833 finish_block (0, &local_symbols
, new->old_blocks
,
1834 new->start_addr
, valu
, objfile
);
1839 /* This is the outermost LBRAC...RBRAC pair. There is no
1840 need to do anything; leave the symbols that preceded it
1841 to be attached to the function's own block. We need to
1842 indicate that we just moved outside of the function. */
1843 within_function
= 0;
1846 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1847 /* Now pop locals of block just finished. */
1848 local_symbols
= new->locals
;
1853 /* This kind of symbol indicates the start of an object file. */
1854 /* Relocate for dynamic loading */
1855 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1859 /* This type of symbol indicates the start of data
1860 for one source file.
1861 Finish the symbol table of the previous source file
1862 (if any) and start accumulating a new symbol table. */
1863 /* Relocate for dynamic loading */
1864 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1868 #ifdef SUN_FIXED_LBRAC_BUG
1869 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1872 #ifdef PCC_SOL_BROKEN
1873 /* pcc bug, occasionally puts out SO for SOL. */
1874 if (context_stack_depth
> 0)
1876 start_subfile (name
, NULL
);
1880 if (last_source_file
)
1882 /* Check if previous symbol was also an N_SO (with some
1883 sanity checks). If so, that one was actually the directory
1884 name, and the current one is the real file name.
1886 if (previous_stab_code
== (unsigned char) N_SO
)
1888 patch_subfile_names (current_subfile
, name
);
1889 break; /* Ignore repeated SOs */
1891 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1895 /* Null name means this just marks the end of text for this .o file.
1896 Don't start a new symtab in this case. */
1897 if (*name
== '\000')
1901 start_symtab (name
, NULL
, valu
);
1905 /* This type of symbol indicates the start of data for
1906 a sub-source-file, one whose contents were copied or
1907 included in the compilation of the main source file
1908 (whose name was given in the N_SO symbol.) */
1909 /* Relocate for dynamic loading */
1910 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1911 start_subfile (name
, current_subfile
->dirname
);
1916 add_new_header_file (name
, valu
);
1917 start_subfile (name
, current_subfile
->dirname
);
1921 start_subfile (pop_subfile (), current_subfile
->dirname
);
1925 add_old_header_file (name
, valu
);
1929 /* This type of "symbol" really just records
1930 one line-number -- core-address correspondence.
1931 Enter it in the line list for this symbol table. */
1932 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1933 valu
+= function_start_offset
;
1934 #ifdef SUN_FIXED_LBRAC_BUG
1935 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1937 record_line (current_subfile
, desc
, valu
);
1941 common_block_start (name
, objfile
);
1945 common_block_end (objfile
);
1948 /* The following symbol types need to have the appropriate offset added
1949 to their value; then we process symbol definitions in the name. */
1951 case N_STSYM
: /* Static symbol in data seg */
1952 case N_LCSYM
: /* Static symbol in BSS seg */
1953 case N_ROSYM
: /* Static symbol in Read-only data seg */
1954 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1955 Solaris2's stabs-in-elf makes *most* symbols relative
1956 but leaves a few absolute (at least for Solaris 2.1 and version
1957 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1958 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1959 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1960 This leaves us no choice but to search for the 'S' or 'V'...
1961 (or pass the whole section_offsets stuff down ONE MORE function
1962 call level, which we really don't want to do). */
1966 /* .o files and NLMs have non-zero text seg offsets, but don't need
1967 their static syms offset in this fashion. XXX - This is really a
1968 crock that should be fixed in the solib handling code so that I
1969 don't have to work around it here. */
1971 if (!symfile_relocatable
)
1973 p
= strchr (name
, ':');
1974 if (p
!= 0 && p
[1] == 'S')
1976 /* The linker relocated it. We don't want to add an
1977 elfstab_offset_sections-type offset, but we *do* want
1978 to add whatever solib.c passed to symbol_file_add as
1979 addr (this is known to affect SunOS4, and I suspect ELF
1980 too). Since elfstab_offset_sections currently does not
1981 muck with the text offset (there is no Ttext.text
1982 symbol), we can get addr from the text offset. If
1983 elfstab_offset_sections ever starts dealing with the
1984 text offset, and we still need to do this, we need to
1985 invent a SECT_OFF_ADDR_KLUDGE or something. */
1986 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1987 goto define_a_symbol
;
1990 /* Since it's not the kludge case, re-dispatch to the right handler. */
1992 case N_STSYM
: goto case_N_STSYM
;
1993 case N_LCSYM
: goto case_N_LCSYM
;
1994 case N_ROSYM
: goto case_N_ROSYM
;
1999 case_N_STSYM
: /* Static symbol in data seg */
2000 case N_DSLINE
: /* Source line number, data seg */
2001 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2002 goto define_a_symbol
;
2004 case_N_LCSYM
: /* Static symbol in BSS seg */
2005 case N_BSLINE
: /* Source line number, bss seg */
2006 /* N_BROWS: overlaps with N_BSLINE */
2007 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2008 goto define_a_symbol
;
2010 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2011 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2012 goto define_a_symbol
;
2014 case N_ENTRY
: /* Alternate entry point */
2015 /* Relocate for dynamic loading */
2016 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2017 goto define_a_symbol
;
2019 /* The following symbol types we don't know how to process. Handle
2020 them in a "default" way, but complain to people who care. */
2022 case N_CATCH
: /* Exception handler catcher */
2023 case N_EHDECL
: /* Exception handler name */
2024 case N_PC
: /* Global symbol in Pascal */
2025 case N_M2C
: /* Modula-2 compilation unit */
2026 /* N_MOD2: overlaps with N_EHDECL */
2027 case N_SCOPE
: /* Modula-2 scope information */
2028 case N_ECOML
: /* End common (local name) */
2029 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2034 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2037 /* The following symbol types don't need the address field relocated,
2038 since it is either unused, or is absolute. */
2040 case N_GSYM
: /* Global variable */
2041 case N_NSYMS
: /* Number of symbols (ultrix) */
2042 case N_NOMAP
: /* No map? (ultrix) */
2043 case N_RSYM
: /* Register variable */
2044 case N_DEFD
: /* Modula-2 GNU module dependency */
2045 case N_SSYM
: /* Struct or union element */
2046 case N_LSYM
: /* Local symbol in stack */
2047 case N_PSYM
: /* Parameter variable */
2048 case N_LENG
: /* Length of preceding symbol type */
2052 char *colon_pos
= strchr (name
, ':');
2053 if (colon_pos
== NULL
)
2056 deftype
= colon_pos
[1];
2062 function_stab_type
= type
;
2064 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2065 /* Deal with the SunPRO 3.0 compiler which omits the address
2066 from N_FUN symbols. */
2068 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2070 struct minimal_symbol
*msym
;
2074 p
= strchr (name
, ':');
2079 strncpy (p
, name
, n
);
2082 msym
= lookup_minimal_symbol (p
, last_source_file
,
2085 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2089 #ifdef SUN_FIXED_LBRAC_BUG
2090 /* The Sun acc compiler, under SunOS4, puts out
2091 functions with N_GSYM or N_STSYM. The problem is
2092 that the address of the symbol is no good (for N_GSYM
2093 it doesn't even attept an address; for N_STSYM it
2094 puts out an address but then it gets relocated
2095 relative to the data segment, not the text segment).
2096 Currently we can't fix this up later as we do for
2097 some types of symbol in scan_file_globals.
2098 Fortunately we do have a way of finding the address -
2099 we know that the value in last_pc_address is either
2100 the one we want (if we're dealing with the first
2101 function in an object file), or somewhere in the
2102 previous function. This means that we can use the
2103 minimal symbol table to get the address. */
2105 /* Starting with release 3.0, the Sun acc compiler,
2106 under SunOS4, puts out functions with N_FUN and a value
2107 of zero. This gets relocated to the start of the text
2108 segment of the module, which is no good either.
2109 Under SunOS4 we can deal with this as N_SLINE and N_SO
2110 entries contain valid absolute addresses.
2111 Release 3.0 acc also puts out N_OPT entries, which makes
2112 it possible to discern acc from cc or gcc. */
2114 if (type
== N_GSYM
|| type
== N_STSYM
2116 && n_opt_found
&& !block_address_function_relative
))
2118 struct minimal_symbol
*m
;
2119 int l
= colon_pos
- name
;
2121 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2122 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
2123 /* last_pc_address was in this function */
2124 valu
= SYMBOL_VALUE (m
);
2125 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
2126 /* last_pc_address was in last function */
2127 valu
= SYMBOL_VALUE (m
+1);
2129 /* Not found - use last_pc_address (for finish_block) */
2130 valu
= last_pc_address
;
2133 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2136 if (block_address_function_relative
)
2137 /* For Solaris 2.0 compilers, the block addresses and
2138 N_SLINE's are relative to the start of the
2139 function. On normal systems, and when using gcc on
2140 Solaris 2.0, these addresses are just absolute, or
2141 relative to the N_SO, depending on
2142 BLOCK_ADDRESS_ABSOLUTE. */
2143 function_start_offset
= valu
;
2145 within_function
= 1;
2146 if (context_stack_depth
> 0)
2148 new = pop_context ();
2149 /* Make a block for the local symbols within. */
2150 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2151 new->start_addr
, valu
, objfile
);
2153 /* Stack must be empty now. */
2154 if (context_stack_depth
!= 0)
2155 complain (&lbrac_unmatched_complaint
, symnum
);
2157 new = push_context (0, valu
);
2158 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2162 define_symbol (valu
, name
, desc
, type
, objfile
);
2168 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2169 for a bunch of other flags, too. Someday we may parse their
2170 flags; for now we ignore theirs and hope they'll ignore ours. */
2171 case N_OPT
: /* Solaris 2: Compiler options */
2174 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2176 processing_gcc_compilation
= 2;
2177 #if 1 /* Works, but is experimental. -fnf */
2178 if (AUTO_DEMANGLING
)
2180 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2189 /* The following symbol types can be ignored. */
2190 case N_OBJ
: /* Solaris 2: Object file dir and name */
2191 /* N_UNDF: Solaris 2: file separator mark */
2192 /* N_UNDF: -- we will never encounter it, since we only process one
2193 file's symbols at once. */
2194 case N_ENDM
: /* Solaris 2: End of module */
2195 case N_MAIN
: /* Name of main routine. */
2199 previous_stab_code
= type
;
2202 /* FIXME: The only difference between this and elfstab_build_psymtabs is
2203 the call to install_minimal_symbols for elf. If the differences are
2204 really that small, the code should be shared. */
2206 /* Scan and build partial symbols for an coff symbol file.
2207 The coff file has already been processed to get its minimal symbols.
2209 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2212 OBJFILE is the object file we are reading symbols from.
2213 ADDR is the address relative to which the symbols are (e.g.
2214 the base address of the text segment).
2215 MAINLINE is true if we are reading the main symbol
2216 table (as opposed to a shared lib or dynamically loaded file).
2217 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2219 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2220 .stabstr section exists.
2222 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2223 adjusted for coff details. */
2226 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2227 staboffset
, stabsize
,
2228 stabstroffset
, stabstrsize
)
2229 struct objfile
*objfile
;
2230 struct section_offsets
*section_offsets
;
2232 file_ptr staboffset
;
2233 unsigned int stabsize
;
2234 file_ptr stabstroffset
;
2235 unsigned int stabstrsize
;
2238 bfd
*sym_bfd
= objfile
->obfd
;
2239 char *name
= bfd_get_filename (sym_bfd
);
2240 struct dbx_symfile_info
*info
;
2242 /* There is already a dbx_symfile_info allocated by our caller.
2243 It might even contain some info from the coff symtab to help us. */
2244 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2246 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2247 if (!DBX_TEXT_SECT (objfile
))
2248 error ("Can't find .text section in symbol file");
2250 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2251 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2252 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2253 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2254 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2256 if (stabstrsize
> bfd_get_size (sym_bfd
))
2257 error ("ridiculous string table size: %d bytes", stabstrsize
);
2258 DBX_STRINGTAB (objfile
) = (char *)
2259 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2261 /* Now read in the string table in one big gulp. */
2263 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2265 perror_with_name (name
);
2266 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2267 if (val
!= stabstrsize
)
2268 perror_with_name (name
);
2270 stabsread_new_init ();
2271 buildsym_new_init ();
2272 free_header_files ();
2273 init_header_files ();
2275 processing_acc_compilation
= 1;
2277 /* In a coff file, we've already installed the minimal symbols that came
2278 from the coff (non-stab) symbol table, so always act like an
2279 incremental load here. */
2280 dbx_symfile_read (objfile
, section_offsets
, 0);
2283 /* Scan and build partial symbols for an ELF symbol file.
2284 This ELF file has already been processed to get its minimal symbols,
2285 and any DWARF symbols that were in it.
2287 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2290 OBJFILE is the object file we are reading symbols from.
2291 ADDR is the address relative to which the symbols are (e.g.
2292 the base address of the text segment).
2293 MAINLINE is true if we are reading the main symbol
2294 table (as opposed to a shared lib or dynamically loaded file).
2295 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2297 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2298 .stabstr section exists.
2300 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2301 adjusted for elf details. */
2304 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2305 staboffset
, stabsize
,
2306 stabstroffset
, stabstrsize
)
2307 struct objfile
*objfile
;
2308 struct section_offsets
*section_offsets
;
2310 file_ptr staboffset
;
2311 unsigned int stabsize
;
2312 file_ptr stabstroffset
;
2313 unsigned int stabstrsize
;
2316 bfd
*sym_bfd
= objfile
->obfd
;
2317 char *name
= bfd_get_filename (sym_bfd
);
2318 struct dbx_symfile_info
*info
;
2320 /* There is already a dbx_symfile_info allocated by our caller.
2321 It might even contain some info from the ELF symtab to help us. */
2322 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2324 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2325 if (!DBX_TEXT_SECT (objfile
))
2326 error ("Can't find .text section in symbol file");
2328 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2329 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2330 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2331 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2332 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2334 if (stabstrsize
> bfd_get_size (sym_bfd
))
2335 error ("ridiculous string table size: %d bytes", stabstrsize
);
2336 DBX_STRINGTAB (objfile
) = (char *)
2337 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2339 /* Now read in the string table in one big gulp. */
2341 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2343 perror_with_name (name
);
2344 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2345 if (val
!= stabstrsize
)
2346 perror_with_name (name
);
2348 stabsread_new_init ();
2349 buildsym_new_init ();
2350 free_header_files ();
2351 init_header_files ();
2352 install_minimal_symbols (objfile
);
2354 processing_acc_compilation
= 1;
2356 /* In an elf file, we've already installed the minimal symbols that came
2357 from the elf (non-stab) symbol table, so always act like an
2358 incremental load here. */
2359 dbx_symfile_read (objfile
, section_offsets
, 0);
2362 /* Scan and build partial symbols for a file with special sections for stabs
2363 and stabstrings. The file has already been processed to get its minimal
2364 symbols, and any other symbols that might be necessary to resolve GSYMs.
2366 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2369 OBJFILE is the object file we are reading symbols from.
2370 ADDR is the address relative to which the symbols are (e.g. the base address
2371 of the text segment).
2372 MAINLINE is true if we are reading the main symbol table (as opposed to a
2373 shared lib or dynamically loaded file).
2374 STAB_NAME is the name of the section that contains the stabs.
2375 STABSTR_NAME is the name of the section that contains the stab strings.
2377 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2380 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2381 stabstr_name
, text_name
)
2382 struct objfile
*objfile
;
2383 struct section_offsets
*section_offsets
;
2390 bfd
*sym_bfd
= objfile
->obfd
;
2391 char *name
= bfd_get_filename (sym_bfd
);
2393 asection
*stabstrsect
;
2395 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2396 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2402 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2403 stab_name
, stabstr_name
);
2405 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2406 memset (DBX_SYMFILE_INFO (objfile
), 0, sizeof (struct dbx_symfile_info
));
2408 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, text_name
);
2409 if (!DBX_TEXT_SECT (objfile
))
2410 error ("Can't find %s section in symbol file", text_name
);
2412 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2413 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2414 / DBX_SYMBOL_SIZE (objfile
);
2415 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2416 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2418 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2419 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2420 DBX_STRINGTAB (objfile
) = (char *)
2421 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2423 /* Now read in the string table in one big gulp. */
2425 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2426 stabstrsect
, /* bfd section */
2427 DBX_STRINGTAB (objfile
), /* input buffer */
2428 0, /* offset into section */
2429 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2432 perror_with_name (name
);
2434 stabsread_new_init ();
2435 buildsym_new_init ();
2436 free_header_files ();
2437 init_header_files ();
2438 install_minimal_symbols (objfile
);
2440 /* Now, do an incremental load */
2442 processing_acc_compilation
= 1;
2443 dbx_symfile_read (objfile
, section_offsets
, 0);
2446 /* Parse the user's idea of an offset for dynamic linking, into our idea
2447 of how to represent it for fast symbol reading. */
2449 static struct section_offsets
*
2450 dbx_symfile_offsets (objfile
, addr
)
2451 struct objfile
*objfile
;
2454 struct section_offsets
*section_offsets
;
2457 objfile
->num_sections
= SECT_OFF_MAX
;
2458 section_offsets
= (struct section_offsets
*)
2459 obstack_alloc (&objfile
-> psymbol_obstack
,
2460 sizeof (struct section_offsets
)
2461 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2463 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2464 ANOFFSET (section_offsets
, i
) = addr
;
2466 return section_offsets
;
2469 static struct sym_fns aout_sym_fns
=
2471 bfd_target_aout_flavour
,
2472 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2473 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2474 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2475 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2476 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2477 NULL
/* next: pointer to next struct sym_fns */
2481 _initialize_dbxread ()
2483 add_symtab_fns(&aout_sym_fns
);