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 /* This is the lowest text address we have yet encountered. */
163 static CORE_ADDR lowest_text_address
;
165 /* Complaints about the symbols we have encountered. */
167 struct complaint lbrac_complaint
=
168 {"bad block start address patched", 0, 0};
170 struct complaint string_table_offset_complaint
=
171 {"bad string table offset in symbol %d", 0, 0};
173 struct complaint unknown_symtype_complaint
=
174 {"unknown symbol type %s", 0, 0};
176 struct complaint unknown_symchar_complaint
=
177 {"unknown symbol descriptor `%c'", 0, 0};
179 struct complaint lbrac_rbrac_complaint
=
180 {"block start larger than block end", 0, 0};
182 struct complaint lbrac_unmatched_complaint
=
183 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
185 struct complaint lbrac_mismatch_complaint
=
186 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
188 struct complaint repeated_header_complaint
=
189 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
191 /* During initial symbol readin, we need to have a structure to keep
192 track of which psymtabs have which bincls in them. This structure
193 is used during readin to setup the list of dependencies within each
194 partial symbol table. */
196 struct header_file_location
198 char *name
; /* Name of header file */
199 int instance
; /* See above */
200 struct partial_symtab
*pst
; /* Partial symtab that has the
201 BINCL/EINCL defs for this file */
204 /* The actual list and controling variables */
205 static struct header_file_location
*bincl_list
, *next_bincl
;
206 static int bincls_allocated
;
208 /* Local function prototypes */
211 free_header_files
PARAMS ((void));
214 init_header_files
PARAMS ((void));
217 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
220 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
223 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
226 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
227 struct objfile
*objfile
));
230 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
234 free_bincl_list
PARAMS ((struct objfile
*));
236 static struct partial_symtab
*
237 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
240 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
243 init_bincl_list
PARAMS ((int, struct objfile
*));
246 init_psymbol_list
PARAMS ((struct objfile
*));
249 dbx_next_symbol_text
PARAMS ((void));
252 fill_symbuf
PARAMS ((bfd
*));
255 dbx_symfile_init
PARAMS ((struct objfile
*));
258 dbx_new_init
PARAMS ((struct objfile
*));
261 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
264 dbx_symfile_finish
PARAMS ((struct objfile
*));
267 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
270 add_new_header_file
PARAMS ((char *, int));
273 add_old_header_file
PARAMS ((char *, int));
276 add_this_object_header_file
PARAMS ((int));
278 /* Free up old header file tables */
285 if (header_files
!= NULL
)
287 for (i
= 0; i
< n_header_files
; i
++)
289 free (header_files
[i
].name
);
291 free ((PTR
)header_files
);
295 if (this_object_header_files
)
297 free ((PTR
)this_object_header_files
);
298 this_object_header_files
= NULL
;
300 n_allocated_header_files
= 0;
301 n_allocated_this_object_header_files
= 0;
304 /* Allocate new header file tables */
310 n_allocated_header_files
= 10;
311 header_files
= (struct header_file
*)
312 xmalloc (10 * sizeof (struct header_file
));
314 n_allocated_this_object_header_files
= 10;
315 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
318 /* Add header file number I for this object file
319 at the next successive FILENUM. */
322 add_this_object_header_file (i
)
325 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
327 n_allocated_this_object_header_files
*= 2;
328 this_object_header_files
329 = (int *) xrealloc ((char *) this_object_header_files
,
330 n_allocated_this_object_header_files
* sizeof (int));
333 this_object_header_files
[n_this_object_header_files
++] = i
;
336 /* Add to this file an "old" header file, one already seen in
337 a previous object file. NAME is the header file's name.
338 INSTANCE is its instance code, to select among multiple
339 symbol tables for the same header file. */
342 add_old_header_file (name
, instance
)
346 register struct header_file
*p
= header_files
;
349 for (i
= 0; i
< n_header_files
; i
++)
350 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
352 add_this_object_header_file (i
);
355 complain (&repeated_header_complaint
, name
, symnum
);
358 /* Add to this file a "new" header file: definitions for its types follow.
359 NAME is the header file's name.
360 Most often this happens only once for each distinct header file,
361 but not necessarily. If it happens more than once, INSTANCE has
362 a different value each time, and references to the header file
363 use INSTANCE values to select among them.
365 dbx output contains "begin" and "end" markers for each new header file,
366 but at this level we just need to know which files there have been;
367 so we record the file when its "begin" is seen and ignore the "end". */
370 add_new_header_file (name
, instance
)
376 /* Make sure there is room for one more header file. */
378 if (n_header_files
== n_allocated_header_files
)
380 n_allocated_header_files
*= 2;
381 header_files
= (struct header_file
*)
382 xrealloc ((char *) header_files
,
383 (n_allocated_header_files
* sizeof (struct header_file
)));
386 /* Create an entry for this header file. */
388 i
= n_header_files
++;
389 header_files
[i
].name
= savestring (name
, strlen(name
));
390 header_files
[i
].instance
= instance
;
391 header_files
[i
].length
= 10;
392 header_files
[i
].vector
393 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
394 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
396 add_this_object_header_file (i
);
400 static struct type
**
401 explicit_lookup_type (real_filenum
, index
)
402 int real_filenum
, index
;
404 register struct header_file
*f
= &header_files
[real_filenum
];
406 if (index
>= f
->length
)
409 f
->vector
= (struct type
**)
410 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
411 memset (&f
->vector
[f
->length
/ 2],
412 '\0', f
->length
* sizeof (struct type
*) / 2);
414 return &f
->vector
[index
];
419 record_minimal_symbol (name
, address
, type
, objfile
)
423 struct objfile
*objfile
;
425 enum minimal_symbol_type ms_type
;
432 section
= SECT_OFF_TEXT
;
436 section
= SECT_OFF_DATA
;
440 section
= SECT_OFF_BSS
;
449 section
= SECT_OFF_DATA
;
452 /* I don't think this type actually exists; since a N_SETV is the result
453 of going over many .o files, it doesn't make sense to have one
455 ms_type
= mst_file_data
;
456 section
= SECT_OFF_DATA
;
463 ms_type
= mst_file_text
;
464 section
= SECT_OFF_TEXT
;
467 ms_type
= mst_file_data
;
469 /* Check for __DYNAMIC, which is used by Sun shared libraries.
470 Record it as global even if it's local, not global, so
471 lookup_minimal_symbol can find it. We don't check symbol_leading_char
472 because for SunOS4 it always is '_'. */
473 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
476 /* Same with virtual function tables, both global and static. */
478 char *tempstring
= name
;
479 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
481 if (VTBL_PREFIX_P ((tempstring
)))
484 section
= SECT_OFF_DATA
;
487 ms_type
= mst_file_bss
;
488 section
= SECT_OFF_BSS
;
491 ms_type
= mst_unknown
;
496 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
497 && address
< lowest_text_address
)
498 lowest_text_address
= address
;
500 prim_record_minimal_symbol_and_info
501 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
509 /* Scan and build partial symbols for a symbol file.
510 We have been initialized by a call to dbx_symfile_init, which
511 put all the relevant info into a "struct dbx_symfile_info",
512 hung off the objfile structure.
514 SECTION_OFFSETS contains offsets relative to which the symbols in the
515 various sections are (depending where the sections were actually loaded).
516 MAINLINE is true if we are reading the main symbol
517 table (as opposed to a shared lib or dynamically loaded file). */
520 dbx_symfile_read (objfile
, section_offsets
, mainline
)
521 struct objfile
*objfile
;
522 struct section_offsets
*section_offsets
;
523 int mainline
; /* FIXME comments above */
527 struct cleanup
*back_to
;
529 val
= strlen (objfile
->name
);
531 /* .o and .nlm files are relocatables with text, data and bss segs based at
532 0. This flag disables special (Solaris stabs-in-elf only) fixups for
533 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
534 should be fixed to determine pst->textlow without using this text seg of
537 if (strcmp (&objfile
->name
[val
-2], ".o") == 0
538 || strcmp (&objfile
->name
[val
-4], ".nlm") == 0)
539 symfile_relocatable
= 1;
541 /* This is true for Solaris (and all other systems which put stabs
542 in sections, hopefully, since it would be silly to do things
543 differently from Solaris), and false for SunOS4 and other a.out
545 block_address_function_relative
=
546 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
547 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
548 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4))
549 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "nlm", 3)));
551 sym_bfd
= objfile
->obfd
;
552 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
554 perror_with_name (objfile
->name
);
556 /* If we are reinitializing, or if we have never loaded syms yet, init */
557 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
558 init_psymbol_list (objfile
);
560 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
561 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
564 back_to
= make_cleanup (really_free_pendings
, 0);
566 init_minimal_symbol_collection ();
567 make_cleanup (discard_minimal_symbols
, 0);
569 /* Now that the symbol table data of the executable file are all in core,
570 process them and define symbols accordingly. */
572 read_dbx_symtab (section_offsets
, objfile
,
573 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
574 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
576 /* Add the dynamic symbols. */
578 read_dbx_dynamic_symtab (section_offsets
, objfile
);
580 /* Install any minimal symbols that have been collected as the current
581 minimal symbols for this objfile. */
583 install_minimal_symbols (objfile
);
585 do_cleanups (back_to
);
588 /* Initialize anything that needs initializing when a completely new
589 symbol file is specified (not just adding some symbols from another
590 file, e.g. a shared library). */
593 dbx_new_init (ignore
)
594 struct objfile
*ignore
;
596 stabsread_new_init ();
597 buildsym_new_init ();
598 init_header_files ();
602 /* dbx_symfile_init ()
603 is the dbx-specific initialization routine for reading symbols.
604 It is passed a struct objfile which contains, among other things,
605 the BFD for the file whose symbols are being read, and a slot for a pointer
606 to "private data" which we fill with goodies.
608 We read the string table into malloc'd space and stash a pointer to it.
610 Since BFD doesn't know how to read debug symbols in a format-independent
611 way (and may never do so...), we have to do it ourselves. We will never
612 be called unless this is an a.out (or very similar) file.
613 FIXME, there should be a cleaner peephole into the BFD environment here. */
615 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
618 dbx_symfile_init (objfile
)
619 struct objfile
*objfile
;
622 bfd
*sym_bfd
= objfile
->obfd
;
623 char *name
= bfd_get_filename (sym_bfd
);
624 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
626 /* Allocate struct to keep track of the symfile */
627 objfile
->sym_stab_info
= (PTR
)
628 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
630 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
631 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
632 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
634 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
636 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
637 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
638 if (!DBX_TEXT_SECT (objfile
))
639 error ("Can't find .text section in symbol file");
641 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
642 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
643 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
645 /* Read the string table and stash it away in the psymbol_obstack. It is
646 only needed as long as we need to expand psymbols into full symbols,
647 so when we blow away the psymbol the string table goes away as well.
648 Note that gdb used to use the results of attempting to malloc the
649 string table, based on the size it read, as a form of sanity check
650 for botched byte swapping, on the theory that a byte swapped string
651 table size would be so totally bogus that the malloc would fail. Now
652 that we put in on the psymbol_obstack, we can't do this since gdb gets
653 a fatal error (out of virtual memory) if the size is bogus. We can
654 however at least check to see if the size is less than the size of
655 the size field itself, or larger than the size of the entire file.
656 Note that all valid string tables have a size greater than zero, since
657 the bytes used to hold the size are included in the count. */
659 if (STRING_TABLE_OFFSET
== 0)
661 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
662 will never be zero, even when there is no string table. This
663 would appear to be a bug in bfd. */
664 DBX_STRINGTAB_SIZE (objfile
) = 0;
665 DBX_STRINGTAB (objfile
) = NULL
;
669 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
671 perror_with_name (name
);
673 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
674 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
677 perror_with_name (name
);
681 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
682 EOF if there is no string table, and attempting to read the size
683 from EOF will read zero bytes. */
684 DBX_STRINGTAB_SIZE (objfile
) = 0;
685 DBX_STRINGTAB (objfile
) = NULL
;
689 /* Read some data that would appear to be the string table size.
690 If there really is a string table, then it is probably the right
691 size. Byteswap if necessary and validate the size. Note that
692 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
693 random data that happened to be at STRING_TABLE_OFFSET, because
694 bfd can't tell us there is no string table, the sanity checks may
695 or may not catch this. */
696 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
698 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
699 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
700 error ("ridiculous string table size (%d bytes).",
701 DBX_STRINGTAB_SIZE (objfile
));
703 DBX_STRINGTAB (objfile
) =
704 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
705 DBX_STRINGTAB_SIZE (objfile
));
707 /* Now read in the string table in one big gulp. */
709 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
711 perror_with_name (name
);
712 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
714 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
715 perror_with_name (name
);
720 /* Perform any local cleanups required when we are done with a particular
721 objfile. I.E, we are in the process of discarding all symbol information
722 for an objfile, freeing up all memory held for it, and unlinking the
723 objfile struct from the global list of known objfiles. */
726 dbx_symfile_finish (objfile
)
727 struct objfile
*objfile
;
729 if (objfile
->sym_stab_info
!= NULL
)
731 mfree (objfile
-> md
, objfile
->sym_stab_info
);
733 free_header_files ();
737 /* Buffer for reading the symbol table entries. */
738 static struct internal_nlist symbuf
[4096];
739 static int symbuf_idx
;
740 static int symbuf_end
;
742 /* Name of last function encountered. Used in Solaris to approximate
743 object file boundaries. */
744 static char *last_function_name
;
746 /* The address in memory of the string table of the object file we are
747 reading (which might not be the "main" object file, but might be a
748 shared library or some other dynamically loaded thing). This is set
749 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
750 when building symtabs, and is used only by next_symbol_text. */
751 static char *stringtab_global
;
753 /* Refill the symbol table input buffer
754 and set the variables that control fetching entries from it.
755 Reports an error if no data available.
756 This function can read past the end of the symbol table
757 (into the string table) but this does no harm. */
760 fill_symbuf (sym_bfd
)
763 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
765 perror_with_name (bfd_get_filename (sym_bfd
));
766 else if (nbytes
== 0)
767 error ("Premature end of file reading symbol table");
768 symbuf_end
= nbytes
/ symbol_size
;
772 #define SWAP_SYMBOL(symp, abfd) \
774 (symp)->n_strx = bfd_h_get_32(abfd, \
775 (unsigned char *)&(symp)->n_strx); \
776 (symp)->n_desc = bfd_h_get_16 (abfd, \
777 (unsigned char *)&(symp)->n_desc); \
778 (symp)->n_value = bfd_h_get_32 (abfd, \
779 (unsigned char *)&(symp)->n_value); \
782 /* Invariant: The symbol pointed to by symbuf_idx is the first one
783 that hasn't been swapped. Swap the symbol at the same time
784 that symbuf_idx is incremented. */
786 /* dbx allows the text of a symbol name to be continued into the
787 next symbol name! When such a continuation is encountered
788 (a \ at the end of the text of a name)
789 call this function to get the continuation. */
792 dbx_next_symbol_text ()
794 if (symbuf_idx
== symbuf_end
)
795 fill_symbuf (symfile_bfd
);
797 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
798 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
799 + file_string_table_offset
;
802 /* Initializes storage for all of the partial symbols that will be
803 created by read_dbx_symtab and subsidiaries. */
806 init_psymbol_list (objfile
)
807 struct objfile
*objfile
;
809 /* Free any previously allocated psymbol lists. */
810 if (objfile
-> global_psymbols
.list
)
811 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
812 if (objfile
-> static_psymbols
.list
)
813 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
815 /* Current best guess is that there are approximately a twentieth
816 of the total symbols (in a debugging file) are global or static
818 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
819 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
820 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
821 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
822 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
823 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
826 /* Initialize the list of bincls to contain none and have some
830 init_bincl_list (number
, objfile
)
832 struct objfile
*objfile
;
834 bincls_allocated
= number
;
835 next_bincl
= bincl_list
= (struct header_file_location
*)
836 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
839 /* Add a bincl to the list. */
842 add_bincl_to_list (pst
, name
, instance
)
843 struct partial_symtab
*pst
;
847 if (next_bincl
>= bincl_list
+ bincls_allocated
)
849 int offset
= next_bincl
- bincl_list
;
850 bincls_allocated
*= 2;
851 bincl_list
= (struct header_file_location
*)
852 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
853 bincls_allocated
* sizeof (struct header_file_location
));
854 next_bincl
= bincl_list
+ offset
;
856 next_bincl
->pst
= pst
;
857 next_bincl
->instance
= instance
;
858 next_bincl
++->name
= name
;
861 /* Given a name, value pair, find the corresponding
862 bincl in the list. Return the partial symtab associated
863 with that header_file_location. */
865 static struct partial_symtab
*
866 find_corresponding_bincl_psymtab (name
, instance
)
870 struct header_file_location
*bincl
;
872 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
873 if (bincl
->instance
== instance
874 && STREQ (name
, bincl
->name
))
877 complain (&repeated_header_complaint
, name
, symnum
);
878 return (struct partial_symtab
*) 0;
881 /* Free the storage allocated for the bincl list. */
884 free_bincl_list (objfile
)
885 struct objfile
*objfile
;
887 mfree (objfile
-> md
, (PTR
)bincl_list
);
888 bincls_allocated
= 0;
891 /* Scan a SunOs dynamic symbol table for symbols of interest and
892 add them to the minimal symbol table. */
895 read_dbx_dynamic_symtab (section_offsets
, objfile
)
896 struct section_offsets
*section_offsets
;
897 struct objfile
*objfile
;
899 bfd
*abfd
= objfile
->obfd
;
900 struct cleanup
*back_to
;
913 /* Check that the symbol file has dynamic symbols that we know about.
914 bfd_arch_unknown can happen if we are reading a sun3 symbol file
915 on a sun4 host (and vice versa) and bfd is not configured
916 --with-target=all. This would trigger an assertion in bfd/sunos.c,
917 so we ignore the dynamic symbols in this case. */
918 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
919 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
920 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
923 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
927 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
928 back_to
= make_cleanup (free
, dynsyms
);
930 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
931 if (dynsym_count
< 0)
933 do_cleanups (back_to
);
937 /* Enter dynamic symbols into the minimal symbol table
938 if this is a stripped executable. */
939 if (bfd_get_symcount (abfd
) <= 0)
942 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
944 asymbol
*sym
= *symptr
;
948 sec
= bfd_get_section (sym
);
950 /* BFD symbols are section relative. */
951 sym_value
= sym
->value
+ sec
->vma
;
953 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
955 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
958 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
960 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
963 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
965 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
971 if (sym
->flags
& BSF_GLOBAL
)
974 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
979 /* Symbols from shared libraries have a dynamic relocation entry
980 that points to the associated slot in the procedure linkage table.
981 We make a mininal symbol table entry with type mst_solib_trampoline
982 at the address in the procedure linkage table. */
983 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
986 do_cleanups (back_to
);
990 dynrels
= (arelent
**) xmalloc (dynrel_size
);
991 make_cleanup (free
, dynrels
);
993 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
994 if (dynrel_count
< 0)
996 do_cleanups (back_to
);
1000 for (counter
= 0, relptr
= dynrels
;
1001 counter
< dynrel_count
;
1002 counter
++, relptr
++)
1004 arelent
*rel
= *relptr
;
1006 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1008 switch (bfd_get_arch (abfd
))
1010 case bfd_arch_sparc
:
1011 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1015 /* `16' is the type BFD produces for a jump table relocation. */
1016 if (rel
->howto
->type
!= 16)
1019 /* Adjust address in the jump table to point to
1020 the start of the bsr instruction. */
1027 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1028 prim_record_minimal_symbol
1029 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
1031 mst_solib_trampoline
,
1035 do_cleanups (back_to
);
1038 /* Given pointers to an a.out symbol table in core containing dbx
1039 style data, setup partial_symtab's describing each source file for
1040 which debugging information is available.
1041 SYMFILE_NAME is the name of the file we are reading from
1042 and SECTION_OFFSETS is the set of offsets for the various sections
1043 of the file (a set of zeros if the mainline program). */
1046 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1047 struct section_offsets
*section_offsets
;
1048 struct objfile
*objfile
;
1049 CORE_ADDR text_addr
;
1052 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1053 register char *namestring
;
1055 int past_first_source_file
= 0;
1056 CORE_ADDR last_o_file_start
= 0;
1057 struct cleanup
*back_to
;
1060 /* Current partial symtab */
1061 struct partial_symtab
*pst
;
1063 /* List of current psymtab's include files */
1064 char **psymtab_include_list
;
1065 int includes_allocated
;
1068 /* Index within current psymtab dependency list */
1069 struct partial_symtab
**dependency_list
;
1070 int dependencies_used
, dependencies_allocated
;
1072 /* FIXME. We probably want to change stringtab_global rather than add this
1073 while processing every symbol entry. FIXME. */
1074 file_string_table_offset
= 0;
1075 next_file_string_table_offset
= 0;
1077 stringtab_global
= DBX_STRINGTAB (objfile
);
1079 pst
= (struct partial_symtab
*) 0;
1081 includes_allocated
= 30;
1083 psymtab_include_list
= (char **) alloca (includes_allocated
*
1086 dependencies_allocated
= 30;
1087 dependencies_used
= 0;
1089 (struct partial_symtab
**) alloca (dependencies_allocated
*
1090 sizeof (struct partial_symtab
*));
1092 /* Init bincl list */
1093 init_bincl_list (20, objfile
);
1094 back_to
= make_cleanup (free_bincl_list
, objfile
);
1096 last_source_file
= NULL
;
1098 lowest_text_address
= (CORE_ADDR
)-1;
1100 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1101 abfd
= objfile
->obfd
;
1102 symbuf_end
= symbuf_idx
= 0;
1103 next_symbol_text_func
= dbx_next_symbol_text
;
1105 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1107 /* Get the symbol for this run and pull out some info */
1108 QUIT
; /* allow this to be interruptable */
1109 if (symbuf_idx
== symbuf_end
)
1111 bufp
= &symbuf
[symbuf_idx
++];
1114 * Special case to speed up readin.
1116 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1118 SWAP_SYMBOL (bufp
, abfd
);
1120 /* Ok. There is a lot of code duplicated in the rest of this
1121 switch statement (for efficiency reasons). Since I don't
1122 like duplicating code, I will do my penance here, and
1123 describe the code which is duplicated:
1125 *) The assignment to namestring.
1126 *) The call to strchr.
1127 *) The addition of a partial symbol the the two partial
1128 symbol lists. This last is a large section of code, so
1129 I've imbedded it in the following macro.
1132 /* Set namestring based on bufp. If the string table index is invalid,
1133 give a fake name, and print a single error message per symbol file read,
1134 rather than abort the symbol reading or flood the user with messages. */
1136 /*FIXME: Too many adds and indirections in here for the inner loop. */
1137 #define SET_NAMESTRING()\
1138 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1139 DBX_STRINGTAB_SIZE (objfile)) { \
1140 complain (&string_table_offset_complaint, symnum); \
1141 namestring = "<bad string table offset>"; \
1143 namestring = bufp->n_strx + file_string_table_offset + \
1144 DBX_STRINGTAB (objfile)
1146 #define CUR_SYMBOL_TYPE bufp->n_type
1147 #define CUR_SYMBOL_VALUE bufp->n_value
1148 #define DBXREAD_ONLY
1149 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1150 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1151 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1152 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1154 #include "partial-stab.h"
1157 /* If there's stuff to be cleaned up, clean it up. */
1158 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1159 /*FIXME, does this have a bug at start address 0? */
1160 && last_o_file_start
1161 && objfile
-> ei
.entry_point
< bufp
->n_value
1162 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1164 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1165 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1170 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1171 symnum
* symbol_size
,
1172 (lowest_text_address
== (CORE_ADDR
)-1
1173 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1174 : lowest_text_address
)
1176 dependency_list
, dependencies_used
);
1179 do_cleanups (back_to
);
1182 /* Allocate and partially fill a partial symtab. It will be
1183 completely filled at the end of the symbol list.
1185 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1186 is the address relative to which its symbols are (incremental) or 0
1190 struct partial_symtab
*
1191 start_psymtab (objfile
, section_offsets
,
1192 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1193 struct objfile
*objfile
;
1194 struct section_offsets
*section_offsets
;
1198 struct partial_symbol
*global_syms
;
1199 struct partial_symbol
*static_syms
;
1201 struct partial_symtab
*result
=
1202 start_psymtab_common(objfile
, section_offsets
,
1203 filename
, textlow
, global_syms
, static_syms
);
1205 result
->read_symtab_private
= (char *)
1206 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1207 LDSYMOFF(result
) = ldsymoff
;
1208 result
->read_symtab
= dbx_psymtab_to_symtab
;
1209 SYMBOL_SIZE(result
) = symbol_size
;
1210 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1211 STRING_OFFSET(result
) = string_table_offset
;
1212 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1214 /* If we're handling an ELF file, drag some section-relocation info
1215 for this source file out of the ELF symbol table, to compensate for
1216 Sun brain death. This replaces the section_offsets in this psymtab,
1218 elfstab_offset_sections (objfile
, result
);
1220 /* Deduce the source language from the filename for this psymtab. */
1221 psymtab_language
= deduce_language_from_filename (filename
);
1226 /* Close off the current usage of PST.
1227 Returns PST or NULL if the partial symtab was empty and thrown away.
1229 FIXME: List variables and peculiarities of same. */
1231 struct partial_symtab
*
1232 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1233 capping_text
, dependency_list
, number_dependencies
)
1234 struct partial_symtab
*pst
;
1235 char **include_list
;
1237 int capping_symbol_offset
;
1238 CORE_ADDR capping_text
;
1239 struct partial_symtab
**dependency_list
;
1240 int number_dependencies
;
1243 struct objfile
*objfile
= pst
-> objfile
;
1245 if (capping_symbol_offset
!= -1)
1246 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1247 pst
->texthigh
= capping_text
;
1249 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1250 /* Under Solaris, the N_SO symbols always have a value of 0,
1251 instead of the usual address of the .o file. Therefore,
1252 we have to do some tricks to fill in texthigh and textlow.
1253 The first trick is in partial-stab.h: if we see a static
1254 or global function, and the textlow for the current pst
1255 is still 0, then we use that function's address for
1256 the textlow of the pst. */
1258 /* Now, to fill in texthigh, we remember the last function seen
1259 in the .o file (also in partial-stab.h). Also, there's a hack in
1260 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1261 to here via the misc_info field. Therefore, we can fill in
1262 a reliable texthigh by taking the address plus size of the
1263 last function in the file. */
1265 if (pst
->texthigh
== 0 && last_function_name
) {
1268 struct minimal_symbol
*minsym
;
1270 p
= strchr (last_function_name
, ':');
1272 p
= last_function_name
;
1273 n
= p
- last_function_name
;
1275 strncpy (p
, last_function_name
, n
);
1278 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1281 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1282 (long) MSYMBOL_INFO (minsym
);
1284 last_function_name
= NULL
;
1287 /* this test will be true if the last .o file is only data */
1288 if (pst
->textlow
== 0)
1289 /* This loses if the text section really starts at address zero
1290 (generally true when we are debugging a .o file, for example).
1291 That is why this whole thing is inside SOFUN_ADDRESS_MAYBE_MISSING. */
1292 pst
->textlow
= pst
->texthigh
;
1294 /* If we know our own starting text address, then walk through all other
1295 psymtabs for this objfile, and if any didn't know their ending text
1296 address, set it to our starting address. Take care to not set our
1297 own ending address to our starting address, nor to set addresses on
1298 `dependency' files that have both textlow and texthigh zero. */
1300 struct partial_symtab
*p1
;
1302 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1303 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1304 p1
->texthigh
= pst
->textlow
;
1305 /* if this file has only data, then make textlow match texthigh */
1306 if (p1
->textlow
== 0)
1307 p1
->textlow
= p1
->texthigh
;
1312 /* End of kludge for patching Solaris textlow and texthigh. */
1313 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1315 pst
->n_global_syms
=
1316 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1317 pst
->n_static_syms
=
1318 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1320 pst
->number_of_dependencies
= number_dependencies
;
1321 if (number_dependencies
)
1323 pst
->dependencies
= (struct partial_symtab
**)
1324 obstack_alloc (&objfile
->psymbol_obstack
,
1325 number_dependencies
* sizeof (struct partial_symtab
*));
1326 memcpy (pst
->dependencies
, dependency_list
,
1327 number_dependencies
* sizeof (struct partial_symtab
*));
1330 pst
->dependencies
= 0;
1332 for (i
= 0; i
< num_includes
; i
++)
1334 struct partial_symtab
*subpst
=
1335 allocate_psymtab (include_list
[i
], objfile
);
1337 subpst
->section_offsets
= pst
->section_offsets
;
1338 subpst
->read_symtab_private
=
1339 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1340 sizeof (struct symloc
));
1344 subpst
->texthigh
= 0;
1346 /* We could save slight bits of space by only making one of these,
1347 shared by the entire set of include files. FIXME-someday. */
1348 subpst
->dependencies
= (struct partial_symtab
**)
1349 obstack_alloc (&objfile
->psymbol_obstack
,
1350 sizeof (struct partial_symtab
*));
1351 subpst
->dependencies
[0] = pst
;
1352 subpst
->number_of_dependencies
= 1;
1354 subpst
->globals_offset
=
1355 subpst
->n_global_syms
=
1356 subpst
->statics_offset
=
1357 subpst
->n_static_syms
= 0;
1361 subpst
->read_symtab
= pst
->read_symtab
;
1364 sort_pst_symbols (pst
);
1366 /* If there is already a psymtab or symtab for a file of this name, remove it.
1367 (If there is a symtab, more drastic things also happen.)
1368 This happens in VxWorks. */
1369 free_named_symtabs (pst
->filename
);
1371 if (num_includes
== 0
1372 && number_dependencies
== 0
1373 && pst
->n_global_syms
== 0
1374 && pst
->n_static_syms
== 0)
1376 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1377 it is on the obstack, but we can forget to chain it on the list. */
1378 /* Empty psymtabs happen as a result of header files which don't have
1379 any symbols in them. There can be a lot of them. But this check
1380 is wrong, in that a psymtab with N_SLINE entries but nothing else
1381 is not empty, but we don't realize that. Fixing that without slowing
1382 things down might be tricky. */
1383 struct partial_symtab
*prev_pst
;
1385 /* First, snip it out of the psymtab chain */
1387 if (pst
->objfile
->psymtabs
== pst
)
1388 pst
->objfile
->psymtabs
= pst
->next
;
1390 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1391 if (prev_pst
->next
== pst
)
1392 prev_pst
->next
= pst
->next
;
1394 /* Next, put it on a free list for recycling */
1396 pst
->next
= pst
->objfile
->free_psymtabs
;
1397 pst
->objfile
->free_psymtabs
= pst
;
1399 /* Indicate that psymtab was thrown away. */
1400 pst
= (struct partial_symtab
*)NULL
;
1406 dbx_psymtab_to_symtab_1 (pst
)
1407 struct partial_symtab
*pst
;
1409 struct cleanup
*old_chain
;
1417 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1422 /* Read in all partial symtabs on which this one is dependent */
1423 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1424 if (!pst
->dependencies
[i
]->readin
)
1426 /* Inform about additional files that need to be read in. */
1429 fputs_filtered (" ", gdb_stdout
);
1431 fputs_filtered ("and ", gdb_stdout
);
1433 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1434 wrap_here (""); /* Flush output */
1435 gdb_flush (gdb_stdout
);
1437 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1440 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1442 /* Init stuff necessary for reading in symbols */
1445 old_chain
= make_cleanup (really_free_pendings
, 0);
1446 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1447 symbol_size
= SYMBOL_SIZE (pst
);
1449 /* Read in this file's symbols */
1450 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1451 read_ofile_symtab (pst
);
1452 sort_symtab_syms (pst
->symtab
);
1454 do_cleanups (old_chain
);
1460 /* Read in all of the symbols for a given psymtab for real.
1461 Be verbose about it if the user wants that. */
1464 dbx_psymtab_to_symtab (pst
)
1465 struct partial_symtab
*pst
;
1474 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1479 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1481 /* Print the message now, before reading the string table,
1482 to avoid disconcerting pauses. */
1485 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1486 gdb_flush (gdb_stdout
);
1489 sym_bfd
= pst
->objfile
->obfd
;
1491 next_symbol_text_func
= dbx_next_symbol_text
;
1493 dbx_psymtab_to_symtab_1 (pst
);
1495 /* Match with global symbols. This only needs to be done once,
1496 after all of the symtabs and dependencies have been read in. */
1497 scan_file_globals (pst
->objfile
);
1499 /* Finish up the debug error message. */
1501 printf_filtered ("done.\n");
1505 /* Read in a defined section of a specific object file's symbols. */
1508 read_ofile_symtab (pst
)
1509 struct partial_symtab
*pst
;
1511 register char *namestring
;
1512 register struct internal_nlist
*bufp
;
1514 unsigned max_symnum
;
1516 struct objfile
*objfile
;
1517 int sym_offset
; /* Offset to start of symbols to read */
1518 int sym_size
; /* Size of symbols to read */
1519 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1520 int text_size
; /* Size of text segment for symbols */
1521 struct section_offsets
*section_offsets
;
1523 objfile
= pst
->objfile
;
1524 sym_offset
= LDSYMOFF(pst
);
1525 sym_size
= LDSYMLEN(pst
);
1526 text_offset
= pst
->textlow
;
1527 text_size
= pst
->texthigh
- pst
->textlow
;
1528 section_offsets
= pst
->section_offsets
;
1530 current_objfile
= objfile
;
1531 subfile_stack
= NULL
;
1533 stringtab_global
= DBX_STRINGTAB (objfile
);
1534 last_source_file
= NULL
;
1536 abfd
= objfile
->obfd
;
1537 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1538 symbuf_end
= symbuf_idx
= 0;
1540 /* It is necessary to actually read one symbol *before* the start
1541 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1542 occurs before the N_SO symbol.
1544 Detecting this in read_dbx_symtab
1545 would slow down initial readin, so we look for it here instead. */
1546 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1548 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1550 bufp
= &symbuf
[symbuf_idx
++];
1551 SWAP_SYMBOL (bufp
, abfd
);
1555 processing_gcc_compilation
= 0;
1556 if (bufp
->n_type
== N_TEXT
)
1558 const char *tempstring
= namestring
;
1560 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1561 processing_gcc_compilation
= 1;
1562 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1563 processing_gcc_compilation
= 2;
1564 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1566 if (STREQN (tempstring
, "__gnu_compiled", 14))
1567 processing_gcc_compilation
= 2;
1570 /* Try to select a C++ demangling based on the compilation unit
1573 if (processing_gcc_compilation
)
1575 if (AUTO_DEMANGLING
)
1577 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1583 /* The N_SO starting this symtab is the first symbol, so we
1584 better not check the symbol before it. I'm not this can
1585 happen, but it doesn't hurt to check for it. */
1586 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1587 processing_gcc_compilation
= 0;
1590 if (symbuf_idx
== symbuf_end
)
1592 bufp
= &symbuf
[symbuf_idx
];
1593 if (bufp
->n_type
!= (unsigned char)N_SO
)
1594 error("First symbol in segment of executable not a source symbol");
1596 max_symnum
= sym_size
/ symbol_size
;
1599 symnum
< max_symnum
;
1602 QUIT
; /* Allow this to be interruptable */
1603 if (symbuf_idx
== symbuf_end
)
1605 bufp
= &symbuf
[symbuf_idx
++];
1606 SWAP_SYMBOL (bufp
, abfd
);
1608 type
= bufp
->n_type
;
1612 if (type
& N_STAB
) {
1613 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1614 namestring
, section_offsets
, objfile
);
1616 /* We skip checking for a new .o or -l file; that should never
1617 happen in this routine. */
1618 else if (type
== N_TEXT
)
1620 /* I don't think this code will ever be executed, because
1621 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1622 the N_SO symbol which starts this source file.
1623 However, there is no reason not to accept
1624 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1626 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1627 processing_gcc_compilation
= 1;
1628 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1629 processing_gcc_compilation
= 2;
1631 if (AUTO_DEMANGLING
)
1633 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1636 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1637 || type
== (unsigned char)N_NBTEXT
1639 /* Global symbol: see if we came across a dbx defintion for
1640 a corresponding symbol. If so, store the value. Remove
1641 syms from the chain when their values are stored, but
1642 search the whole chain, as there may be several syms from
1643 different files with the same name. */
1644 /* This is probably not true. Since the files will be read
1645 in one at a time, each reference to a global symbol will
1646 be satisfied in each file as it appears. So we skip this
1652 current_objfile
= NULL
;
1654 /* In a Solaris elf file, this variable, which comes from the
1655 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1656 which comes from pst->textlow is correct. */
1657 if (last_source_start_addr
== 0)
1658 last_source_start_addr
= text_offset
;
1660 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1666 /* This handles a single symbol from the symbol-file, building symbols
1667 into a GDB symtab. It takes these arguments and an implicit argument.
1669 TYPE is the type field of the ".stab" symbol entry.
1670 DESC is the desc field of the ".stab" entry.
1671 VALU is the value field of the ".stab" entry.
1672 NAME is the symbol name, in our address space.
1673 SECTION_OFFSETS is a set of amounts by which the sections of this object
1674 file were relocated when it was loaded into memory.
1675 All symbols that refer
1676 to memory locations need to be offset by these amounts.
1677 OBJFILE is the object file from which we are reading symbols.
1678 It is used in end_symtab. */
1681 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1685 struct section_offsets
*section_offsets
;
1686 struct objfile
*objfile
;
1688 #ifdef SUN_FIXED_LBRAC_BUG
1689 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1690 to correct the address of N_LBRAC's. If it is not defined, then
1691 we never need to correct the addresses. */
1693 /* This records the last pc address we've seen. We depend on there being
1694 an SLINE or FUN or SO before the first LBRAC, since the variable does
1695 not get reset in between reads of different symbol files. */
1696 static CORE_ADDR last_pc_address
;
1699 register struct context_stack
*new;
1700 /* This remembers the address of the start of a function. It is used
1701 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1702 relative to the current function's start address. On systems
1703 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1704 used to relocate these symbol types rather than SECTION_OFFSETS. */
1705 static CORE_ADDR function_start_offset
;
1707 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1708 file. Used to detect the SunPRO solaris compiler. */
1709 static int n_opt_found
;
1711 /* The stab type used for the definition of the last function.
1712 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1713 static int function_stab_type
= 0;
1715 if (!block_address_function_relative
)
1716 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1717 function start address, so just use the text offset. */
1718 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1720 /* Something is wrong if we see real data before
1721 seeing a source file name. */
1723 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1725 /* Ignore any symbols which appear before an N_SO symbol. Currently
1726 no one puts symbols there, but we should deal gracefully with the
1727 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1728 but this should not be an error (). */
1736 /* Relocate for dynamic loading */
1737 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1738 goto define_a_symbol
;
1741 /* This "symbol" just indicates the start of an inner lexical
1742 context within a function. */
1744 /* Ignore extra outermost context from SunPRO cc and acc. */
1745 if (n_opt_found
&& desc
== 1)
1748 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1749 /* Relocate for dynamic loading (?). */
1750 valu
+= function_start_offset
;
1752 if (block_address_function_relative
)
1753 /* Relocate for Sun ELF acc fn-relative syms. */
1754 valu
+= function_start_offset
;
1756 /* On most machines, the block addresses are relative to the
1757 N_SO, the linker did not relocate them (sigh). */
1758 valu
+= last_source_start_addr
;
1761 #ifdef SUN_FIXED_LBRAC_BUG
1762 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1763 /* Patch current LBRAC pc value to match last handy pc value */
1764 complain (&lbrac_complaint
);
1765 valu
= last_pc_address
;
1768 new = push_context (desc
, valu
);
1772 /* This "symbol" just indicates the end of an inner lexical
1773 context that was started with N_LBRAC. */
1775 /* Ignore extra outermost context from SunPRO cc and acc. */
1776 if (n_opt_found
&& desc
== 1)
1779 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1780 /* Relocate for dynamic loading (?). */
1781 valu
+= function_start_offset
;
1783 if (block_address_function_relative
)
1784 /* Relocate for Sun ELF acc fn-relative syms. */
1785 valu
+= function_start_offset
;
1787 /* On most machines, the block addresses are relative to the
1788 N_SO, the linker did not relocate them (sigh). */
1789 valu
+= last_source_start_addr
;
1792 new = pop_context();
1793 if (desc
!= new->depth
)
1794 complain (&lbrac_mismatch_complaint
, symnum
);
1796 /* Some compilers put the variable decls inside of an
1797 LBRAC/RBRAC block. This macro should be nonzero if this
1798 is true. DESC is N_DESC from the N_RBRAC symbol.
1799 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1800 or the GCC2_COMPILED_SYMBOL. */
1801 #if !defined (VARIABLES_INSIDE_BLOCK)
1802 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1805 /* Can only use new->locals as local symbols here if we're in
1806 gcc or on a machine that puts them before the lbrack. */
1807 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1808 local_symbols
= new->locals
;
1810 if (context_stack_depth
1811 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1813 /* This is not the outermost LBRAC...RBRAC pair in the function,
1814 its local symbols preceded it, and are the ones just recovered
1815 from the context stack. Define the block for them (but don't
1816 bother if the block contains no symbols. Should we complain
1817 on blocks without symbols? I can't think of any useful purpose
1819 if (local_symbols
!= NULL
)
1821 /* Muzzle a compiler bug that makes end < start. (which
1822 compilers? Is this ever harmful?). */
1823 if (new->start_addr
> valu
)
1825 complain (&lbrac_rbrac_complaint
);
1826 new->start_addr
= valu
;
1828 /* Make a block for the local symbols within. */
1829 finish_block (0, &local_symbols
, new->old_blocks
,
1830 new->start_addr
, valu
, objfile
);
1835 /* This is the outermost LBRAC...RBRAC pair. There is no
1836 need to do anything; leave the symbols that preceded it
1837 to be attached to the function's own block. We need to
1838 indicate that we just moved outside of the function. */
1839 within_function
= 0;
1842 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1843 /* Now pop locals of block just finished. */
1844 local_symbols
= new->locals
;
1849 /* This kind of symbol indicates the start of an object file. */
1850 /* Relocate for dynamic loading */
1851 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1855 /* This type of symbol indicates the start of data
1856 for one source file.
1857 Finish the symbol table of the previous source file
1858 (if any) and start accumulating a new symbol table. */
1859 /* Relocate for dynamic loading */
1860 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1864 #ifdef SUN_FIXED_LBRAC_BUG
1865 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1868 #ifdef PCC_SOL_BROKEN
1869 /* pcc bug, occasionally puts out SO for SOL. */
1870 if (context_stack_depth
> 0)
1872 start_subfile (name
, NULL
);
1876 if (last_source_file
)
1878 /* Check if previous symbol was also an N_SO (with some
1879 sanity checks). If so, that one was actually the directory
1880 name, and the current one is the real file name.
1882 if (previous_stab_code
== (unsigned char) N_SO
)
1884 patch_subfile_names (current_subfile
, name
);
1885 break; /* Ignore repeated SOs */
1887 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1891 /* Null name means this just marks the end of text for this .o file.
1892 Don't start a new symtab in this case. */
1893 if (*name
== '\000')
1897 start_symtab (name
, NULL
, valu
);
1901 /* This type of symbol indicates the start of data for
1902 a sub-source-file, one whose contents were copied or
1903 included in the compilation of the main source file
1904 (whose name was given in the N_SO symbol.) */
1905 /* Relocate for dynamic loading */
1906 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1907 start_subfile (name
, current_subfile
->dirname
);
1912 add_new_header_file (name
, valu
);
1913 start_subfile (name
, current_subfile
->dirname
);
1917 start_subfile (pop_subfile (), current_subfile
->dirname
);
1921 add_old_header_file (name
, valu
);
1925 /* This type of "symbol" really just records
1926 one line-number -- core-address correspondence.
1927 Enter it in the line list for this symbol table. */
1928 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1929 valu
+= function_start_offset
;
1930 #ifdef SUN_FIXED_LBRAC_BUG
1931 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1933 record_line (current_subfile
, desc
, valu
);
1937 common_block_start (name
, objfile
);
1941 common_block_end (objfile
);
1944 /* The following symbol types need to have the appropriate offset added
1945 to their value; then we process symbol definitions in the name. */
1947 case N_STSYM
: /* Static symbol in data seg */
1948 case N_LCSYM
: /* Static symbol in BSS seg */
1949 case N_ROSYM
: /* Static symbol in Read-only data seg */
1950 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1951 Solaris2's stabs-in-elf makes *most* symbols relative
1952 but leaves a few absolute (at least for Solaris 2.1 and version
1953 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1954 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1955 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1956 This leaves us no choice but to search for the 'S' or 'V'...
1957 (or pass the whole section_offsets stuff down ONE MORE function
1958 call level, which we really don't want to do). */
1962 /* .o files and NLMs have non-zero text seg offsets, but don't need
1963 their static syms offset in this fashion. XXX - This is really a
1964 crock that should be fixed in the solib handling code so that I
1965 don't have to work around it here. */
1967 if (!symfile_relocatable
)
1969 p
= strchr (name
, ':');
1970 if (p
!= 0 && p
[1] == 'S')
1972 /* The linker relocated it. We don't want to add an
1973 elfstab_offset_sections-type offset, but we *do* want
1974 to add whatever solib.c passed to symbol_file_add as
1975 addr (this is known to affect SunOS4, and I suspect ELF
1976 too). Since elfstab_offset_sections currently does not
1977 muck with the text offset (there is no Ttext.text
1978 symbol), we can get addr from the text offset. If
1979 elfstab_offset_sections ever starts dealing with the
1980 text offset, and we still need to do this, we need to
1981 invent a SECT_OFF_ADDR_KLUDGE or something. */
1982 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1983 goto define_a_symbol
;
1986 /* Since it's not the kludge case, re-dispatch to the right handler. */
1988 case N_STSYM
: goto case_N_STSYM
;
1989 case N_LCSYM
: goto case_N_LCSYM
;
1990 case N_ROSYM
: goto case_N_ROSYM
;
1995 case_N_STSYM
: /* Static symbol in data seg */
1996 case N_DSLINE
: /* Source line number, data seg */
1997 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1998 goto define_a_symbol
;
2000 case_N_LCSYM
: /* Static symbol in BSS seg */
2001 case N_BSLINE
: /* Source line number, bss seg */
2002 /* N_BROWS: overlaps with N_BSLINE */
2003 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2004 goto define_a_symbol
;
2006 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2007 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2008 goto define_a_symbol
;
2010 case N_ENTRY
: /* Alternate entry point */
2011 /* Relocate for dynamic loading */
2012 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2013 goto define_a_symbol
;
2015 /* The following symbol types we don't know how to process. Handle
2016 them in a "default" way, but complain to people who care. */
2018 case N_CATCH
: /* Exception handler catcher */
2019 case N_EHDECL
: /* Exception handler name */
2020 case N_PC
: /* Global symbol in Pascal */
2021 case N_M2C
: /* Modula-2 compilation unit */
2022 /* N_MOD2: overlaps with N_EHDECL */
2023 case N_SCOPE
: /* Modula-2 scope information */
2024 case N_ECOML
: /* End common (local name) */
2025 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2030 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2033 /* The following symbol types don't need the address field relocated,
2034 since it is either unused, or is absolute. */
2036 case N_GSYM
: /* Global variable */
2037 case N_NSYMS
: /* Number of symbols (ultrix) */
2038 case N_NOMAP
: /* No map? (ultrix) */
2039 case N_RSYM
: /* Register variable */
2040 case N_DEFD
: /* Modula-2 GNU module dependency */
2041 case N_SSYM
: /* Struct or union element */
2042 case N_LSYM
: /* Local symbol in stack */
2043 case N_PSYM
: /* Parameter variable */
2044 case N_LENG
: /* Length of preceding symbol type */
2048 char *colon_pos
= strchr (name
, ':');
2049 if (colon_pos
== NULL
)
2052 deftype
= colon_pos
[1];
2058 function_stab_type
= type
;
2060 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2061 /* Deal with the SunPRO 3.0 compiler which omits the address
2062 from N_FUN symbols. */
2064 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2066 struct minimal_symbol
*msym
;
2070 p
= strchr (name
, ':');
2075 strncpy (p
, name
, n
);
2078 msym
= lookup_minimal_symbol (p
, last_source_file
,
2081 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2085 #ifdef SUN_FIXED_LBRAC_BUG
2086 /* The Sun acc compiler, under SunOS4, puts out
2087 functions with N_GSYM or N_STSYM. The problem is
2088 that the address of the symbol is no good (for N_GSYM
2089 it doesn't even attept an address; for N_STSYM it
2090 puts out an address but then it gets relocated
2091 relative to the data segment, not the text segment).
2092 Currently we can't fix this up later as we do for
2093 some types of symbol in scan_file_globals.
2094 Fortunately we do have a way of finding the address -
2095 we know that the value in last_pc_address is either
2096 the one we want (if we're dealing with the first
2097 function in an object file), or somewhere in the
2098 previous function. This means that we can use the
2099 minimal symbol table to get the address. */
2101 /* Starting with release 3.0, the Sun acc compiler,
2102 under SunOS4, puts out functions with N_FUN and a value
2103 of zero. This gets relocated to the start of the text
2104 segment of the module, which is no good either.
2105 Under SunOS4 we can deal with this as N_SLINE and N_SO
2106 entries contain valid absolute addresses.
2107 Release 3.0 acc also puts out N_OPT entries, which makes
2108 it possible to discern acc from cc or gcc. */
2110 if (type
== N_GSYM
|| type
== N_STSYM
2112 && n_opt_found
&& !block_address_function_relative
))
2114 struct minimal_symbol
*m
;
2115 int l
= colon_pos
- name
;
2117 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2118 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
2119 /* last_pc_address was in this function */
2120 valu
= SYMBOL_VALUE (m
);
2121 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
2122 /* last_pc_address was in last function */
2123 valu
= SYMBOL_VALUE (m
+1);
2125 /* Not found - use last_pc_address (for finish_block) */
2126 valu
= last_pc_address
;
2129 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2132 if (block_address_function_relative
)
2133 /* For Solaris 2.0 compilers, the block addresses and
2134 N_SLINE's are relative to the start of the
2135 function. On normal systems, and when using gcc on
2136 Solaris 2.0, these addresses are just absolute, or
2137 relative to the N_SO, depending on
2138 BLOCK_ADDRESS_ABSOLUTE. */
2139 function_start_offset
= valu
;
2141 within_function
= 1;
2142 if (context_stack_depth
> 0)
2144 new = pop_context ();
2145 /* Make a block for the local symbols within. */
2146 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2147 new->start_addr
, valu
, objfile
);
2149 /* Stack must be empty now. */
2150 if (context_stack_depth
!= 0)
2151 complain (&lbrac_unmatched_complaint
, symnum
);
2153 new = push_context (0, valu
);
2154 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2158 define_symbol (valu
, name
, desc
, type
, objfile
);
2164 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2165 for a bunch of other flags, too. Someday we may parse their
2166 flags; for now we ignore theirs and hope they'll ignore ours. */
2167 case N_OPT
: /* Solaris 2: Compiler options */
2170 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2172 processing_gcc_compilation
= 2;
2173 #if 1 /* Works, but is experimental. -fnf */
2174 if (AUTO_DEMANGLING
)
2176 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2185 /* The following symbol types can be ignored. */
2186 case N_OBJ
: /* Solaris 2: Object file dir and name */
2187 /* N_UNDF: Solaris 2: file separator mark */
2188 /* N_UNDF: -- we will never encounter it, since we only process one
2189 file's symbols at once. */
2190 case N_ENDM
: /* Solaris 2: End of module */
2191 case N_MAIN
: /* Name of main routine. */
2195 previous_stab_code
= type
;
2198 /* FIXME: The only difference between this and elfstab_build_psymtabs is
2199 the call to install_minimal_symbols for elf. If the differences are
2200 really that small, the code should be shared. */
2202 /* Scan and build partial symbols for an coff symbol file.
2203 The coff file has already been processed to get its minimal symbols.
2205 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2208 OBJFILE is the object file we are reading symbols from.
2209 ADDR is the address relative to which the symbols are (e.g.
2210 the base address of the text segment).
2211 MAINLINE is true if we are reading the main symbol
2212 table (as opposed to a shared lib or dynamically loaded file).
2213 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2215 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2216 .stabstr section exists.
2218 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2219 adjusted for coff details. */
2222 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2223 staboffset
, stabsize
,
2224 stabstroffset
, stabstrsize
)
2225 struct objfile
*objfile
;
2226 struct section_offsets
*section_offsets
;
2228 file_ptr staboffset
;
2229 unsigned int stabsize
;
2230 file_ptr stabstroffset
;
2231 unsigned int stabstrsize
;
2234 bfd
*sym_bfd
= objfile
->obfd
;
2235 char *name
= bfd_get_filename (sym_bfd
);
2236 struct dbx_symfile_info
*info
;
2238 /* There is already a dbx_symfile_info allocated by our caller.
2239 It might even contain some info from the coff symtab to help us. */
2240 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2242 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2243 if (!DBX_TEXT_SECT (objfile
))
2244 error ("Can't find .text section in symbol file");
2246 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2247 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2248 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2249 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2250 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2252 if (stabstrsize
> bfd_get_size (sym_bfd
))
2253 error ("ridiculous string table size: %d bytes", stabstrsize
);
2254 DBX_STRINGTAB (objfile
) = (char *)
2255 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2257 /* Now read in the string table in one big gulp. */
2259 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2261 perror_with_name (name
);
2262 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2263 if (val
!= stabstrsize
)
2264 perror_with_name (name
);
2266 stabsread_new_init ();
2267 buildsym_new_init ();
2268 free_header_files ();
2269 init_header_files ();
2271 processing_acc_compilation
= 1;
2273 /* In a coff file, we've already installed the minimal symbols that came
2274 from the coff (non-stab) symbol table, so always act like an
2275 incremental load here. */
2276 dbx_symfile_read (objfile
, section_offsets
, 0);
2279 /* Scan and build partial symbols for an ELF symbol file.
2280 This ELF file has already been processed to get its minimal symbols,
2281 and any DWARF symbols that were in it.
2283 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2286 OBJFILE is the object file we are reading symbols from.
2287 ADDR is the address relative to which the symbols are (e.g.
2288 the base address of the text segment).
2289 MAINLINE is true if we are reading the main symbol
2290 table (as opposed to a shared lib or dynamically loaded file).
2291 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2293 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2294 .stabstr section exists.
2296 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2297 adjusted for elf details. */
2300 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2301 staboffset
, stabsize
,
2302 stabstroffset
, stabstrsize
)
2303 struct objfile
*objfile
;
2304 struct section_offsets
*section_offsets
;
2306 file_ptr staboffset
;
2307 unsigned int stabsize
;
2308 file_ptr stabstroffset
;
2309 unsigned int stabstrsize
;
2312 bfd
*sym_bfd
= objfile
->obfd
;
2313 char *name
= bfd_get_filename (sym_bfd
);
2314 struct dbx_symfile_info
*info
;
2316 /* There is already a dbx_symfile_info allocated by our caller.
2317 It might even contain some info from the ELF symtab to help us. */
2318 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2320 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2321 if (!DBX_TEXT_SECT (objfile
))
2322 error ("Can't find .text section in symbol file");
2324 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2325 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2326 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2327 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2328 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2330 if (stabstrsize
> bfd_get_size (sym_bfd
))
2331 error ("ridiculous string table size: %d bytes", stabstrsize
);
2332 DBX_STRINGTAB (objfile
) = (char *)
2333 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2335 /* Now read in the string table in one big gulp. */
2337 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2339 perror_with_name (name
);
2340 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2341 if (val
!= stabstrsize
)
2342 perror_with_name (name
);
2344 stabsread_new_init ();
2345 buildsym_new_init ();
2346 free_header_files ();
2347 init_header_files ();
2348 install_minimal_symbols (objfile
);
2350 processing_acc_compilation
= 1;
2352 /* In an elf file, we've already installed the minimal symbols that came
2353 from the elf (non-stab) symbol table, so always act like an
2354 incremental load here. */
2355 dbx_symfile_read (objfile
, section_offsets
, 0);
2358 /* Scan and build partial symbols for a file with special sections for stabs
2359 and stabstrings. The file has already been processed to get its minimal
2360 symbols, and any other symbols that might be necessary to resolve GSYMs.
2362 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2365 OBJFILE is the object file we are reading symbols from.
2366 ADDR is the address relative to which the symbols are (e.g. the base address
2367 of the text segment).
2368 MAINLINE is true if we are reading the main symbol table (as opposed to a
2369 shared lib or dynamically loaded file).
2370 STAB_NAME is the name of the section that contains the stabs.
2371 STABSTR_NAME is the name of the section that contains the stab strings.
2373 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2376 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2377 stabstr_name
, text_name
)
2378 struct objfile
*objfile
;
2379 struct section_offsets
*section_offsets
;
2386 bfd
*sym_bfd
= objfile
->obfd
;
2387 char *name
= bfd_get_filename (sym_bfd
);
2389 asection
*stabstrsect
;
2391 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2392 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2398 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2399 stab_name
, stabstr_name
);
2401 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2402 memset (DBX_SYMFILE_INFO (objfile
), 0, sizeof (struct dbx_symfile_info
));
2404 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, text_name
);
2405 if (!DBX_TEXT_SECT (objfile
))
2406 error ("Can't find %s section in symbol file", text_name
);
2408 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2409 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2410 / DBX_SYMBOL_SIZE (objfile
);
2411 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2412 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2414 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2415 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2416 DBX_STRINGTAB (objfile
) = (char *)
2417 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2419 /* Now read in the string table in one big gulp. */
2421 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2422 stabstrsect
, /* bfd section */
2423 DBX_STRINGTAB (objfile
), /* input buffer */
2424 0, /* offset into section */
2425 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2428 perror_with_name (name
);
2430 stabsread_new_init ();
2431 buildsym_new_init ();
2432 free_header_files ();
2433 init_header_files ();
2434 install_minimal_symbols (objfile
);
2436 /* Now, do an incremental load */
2438 processing_acc_compilation
= 1;
2439 dbx_symfile_read (objfile
, section_offsets
, 0);
2442 /* Parse the user's idea of an offset for dynamic linking, into our idea
2443 of how to represent it for fast symbol reading. */
2445 static struct section_offsets
*
2446 dbx_symfile_offsets (objfile
, addr
)
2447 struct objfile
*objfile
;
2450 struct section_offsets
*section_offsets
;
2453 objfile
->num_sections
= SECT_OFF_MAX
;
2454 section_offsets
= (struct section_offsets
*)
2455 obstack_alloc (&objfile
-> psymbol_obstack
,
2456 sizeof (struct section_offsets
)
2457 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2459 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2460 ANOFFSET (section_offsets
, i
) = addr
;
2462 return section_offsets
;
2465 static struct sym_fns aout_sym_fns
=
2467 bfd_target_aout_flavour
,
2468 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2469 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2470 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2471 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2472 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2473 NULL
/* next: pointer to next struct sym_fns */
2477 _initialize_dbxread ()
2479 add_symtab_fns(&aout_sym_fns
);