1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This module provides three functions: dbx_symfile_init,
22 which initializes to read a symbol file; dbx_new_init, which
23 discards existing cached information when all symbols are being
24 discarded; and dbx_symfile_read, which reads a symbol table
27 dbx_symfile_read only does the minimum work necessary for letting the
28 user "name" things symbolically; it does not read the entire symtab.
29 Instead, it reads the external and static symbols and puts them in partial
30 symbol tables. When more extensive information is requested of a
31 file, the corresponding partial symbol table is mutated into a full
32 fledged symbol table by going back and reading the symbols
33 for real. dbx_psymtab_to_symtab() is the function that does this */
38 #if defined(USG) || defined(__CYGNUSCLIB__)
39 #include <sys/types.h>
44 #include <sys/param.h>
51 #include "breakpoint.h"
54 #include "gdbcore.h" /* for bfd stuff */
55 #include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
56 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
60 #include "stabsread.h"
61 #include "gdb-stabs.h"
63 #include "language.h" /* Needed inside partial-stab.h */
64 #include "complaints.h"
66 #include "aout/aout64.h"
67 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
69 #if !defined (SEEK_SET)
74 /* Each partial symbol table entry contains a pointer to private data for the
75 read_symtab() function to use when expanding a partial symbol table entry
76 to a full symbol table entry.
78 For dbxread this structure contains the offset within the file symbol table
79 of first local symbol for this file, and length (in bytes) of the section
80 of the symbol table devoted to this file's symbols (actually, the section
81 bracketed may contain more than just this file's symbols). It also contains
82 further information needed to locate the symbols if they are in an ELF file.
84 If ldsymlen is 0, the only reason for this thing's existence is the
85 dependency list. Nothing else will happen when it is read in. */
87 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
88 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
89 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
90 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
91 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
92 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
93 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
101 int file_string_offset
;
104 /* Macro to determine which symbols to ignore when reading the first symbol
105 of a file. Some machines override this definition. */
106 #ifndef IGNORE_SYMBOL
107 /* This code is used on Ultrix systems. Ignore it */
108 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
111 /* Remember what we deduced to be the source language of this psymtab. */
113 static enum language psymtab_language
= language_unknown
;
115 /* Nonzero means give verbose info on gdb action. From main.c. */
116 extern int info_verbose
;
118 /* The BFD for this file -- implicit parameter to next_symbol_text. */
120 static bfd
*symfile_bfd
;
122 /* The size of each symbol in the symbol file (in external form).
123 This is set by dbx_symfile_read when building psymtabs, and by
124 dbx_psymtab_to_symtab when building symtabs. */
126 static unsigned symbol_size
;
128 /* This is the offset of the symbol table in the executable file */
129 static unsigned symbol_table_offset
;
131 /* This is the offset of the string table in the executable file */
132 static unsigned string_table_offset
;
134 /* For elf+stab executables, the n_strx field is not a simple index
135 into the string table. Instead, each .o file has a base offset
136 in the string table, and the associated symbols contain offsets
137 from this base. The following two variables contain the base
138 offset for the current and next .o files. */
139 static unsigned int file_string_table_offset
;
140 static unsigned int next_file_string_table_offset
;
142 /* .o and NLM files contain unrelocated addresses which are based at 0. When
143 non-zero, this flag disables some of the special cases for Solaris elf+stab
144 text addresses at location 0. */
146 static int symfile_relocatable
= 0;
148 /* This is the lowest text address we have yet encountered. */
149 static CORE_ADDR lowest_text_address
;
151 /* Complaints about the symbols we have encountered. */
153 struct complaint lbrac_complaint
=
154 {"bad block start address patched", 0, 0};
156 struct complaint string_table_offset_complaint
=
157 {"bad string table offset in symbol %d", 0, 0};
159 struct complaint unknown_symtype_complaint
=
160 {"unknown symbol type %s", 0, 0};
162 struct complaint unknown_symchar_complaint
=
163 {"unknown symbol descriptor `%c'", 0, 0};
165 struct complaint lbrac_rbrac_complaint
=
166 {"block start larger than block end", 0, 0};
168 struct complaint lbrac_unmatched_complaint
=
169 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
171 struct complaint lbrac_mismatch_complaint
=
172 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
174 struct complaint repeated_header_complaint
=
175 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
177 struct complaint repeated_header_name_complaint
=
178 {"\"repeated\" header file not previously seen, named %s", 0, 0};
180 /* During initial symbol readin, we need to have a structure to keep
181 track of which psymtabs have which bincls in them. This structure
182 is used during readin to setup the list of dependencies within each
183 partial symbol table. */
185 struct header_file_location
187 char *name
; /* Name of header file */
188 int instance
; /* See above */
189 struct partial_symtab
*pst
; /* Partial symtab that has the
190 BINCL/EINCL defs for this file */
193 /* The actual list and controling variables */
194 static struct header_file_location
*bincl_list
, *next_bincl
;
195 static int bincls_allocated
;
197 /* Local function prototypes */
200 free_header_files
PARAMS ((void));
203 init_header_files
PARAMS ((void));
206 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
209 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
212 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
215 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
216 struct objfile
*objfile
));
219 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
223 free_bincl_list
PARAMS ((struct objfile
*));
225 static struct partial_symtab
*
226 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
229 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
232 init_bincl_list
PARAMS ((int, struct objfile
*));
235 init_psymbol_list
PARAMS ((struct objfile
*));
238 dbx_next_symbol_text
PARAMS ((void));
241 fill_symbuf
PARAMS ((bfd
*));
244 dbx_symfile_init
PARAMS ((struct objfile
*));
247 dbx_new_init
PARAMS ((struct objfile
*));
250 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
253 dbx_symfile_finish
PARAMS ((struct objfile
*));
256 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
259 add_new_header_file
PARAMS ((char *, int));
262 add_old_header_file
PARAMS ((char *, int));
265 add_this_object_header_file
PARAMS ((int));
267 /* Free up old header file tables */
274 if (header_files
!= NULL
)
276 for (i
= 0; i
< n_header_files
; i
++)
278 free (header_files
[i
].name
);
280 free ((PTR
)header_files
);
284 if (this_object_header_files
)
286 free ((PTR
)this_object_header_files
);
287 this_object_header_files
= NULL
;
289 n_allocated_header_files
= 0;
290 n_allocated_this_object_header_files
= 0;
293 /* Allocate new header file tables */
299 n_allocated_header_files
= 10;
300 header_files
= (struct header_file
*)
301 xmalloc (10 * sizeof (struct header_file
));
303 n_allocated_this_object_header_files
= 10;
304 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
307 /* Add header file number I for this object file
308 at the next successive FILENUM. */
311 add_this_object_header_file (i
)
314 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
316 n_allocated_this_object_header_files
*= 2;
317 this_object_header_files
318 = (int *) xrealloc ((char *) this_object_header_files
,
319 n_allocated_this_object_header_files
* sizeof (int));
322 this_object_header_files
[n_this_object_header_files
++] = i
;
325 /* Add to this file an "old" header file, one already seen in
326 a previous object file. NAME is the header file's name.
327 INSTANCE is its instance code, to select among multiple
328 symbol tables for the same header file. */
331 add_old_header_file (name
, instance
)
335 register struct header_file
*p
= header_files
;
338 for (i
= 0; i
< n_header_files
; i
++)
339 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
341 add_this_object_header_file (i
);
344 complain (&repeated_header_complaint
, symnum
);
345 complain (&repeated_header_name_complaint
, name
);
348 /* Add to this file a "new" header file: definitions for its types follow.
349 NAME is the header file's name.
350 Most often this happens only once for each distinct header file,
351 but not necessarily. If it happens more than once, INSTANCE has
352 a different value each time, and references to the header file
353 use INSTANCE values to select among them.
355 dbx output contains "begin" and "end" markers for each new header file,
356 but at this level we just need to know which files there have been;
357 so we record the file when its "begin" is seen and ignore the "end". */
360 add_new_header_file (name
, instance
)
366 /* Make sure there is room for one more header file. */
368 if (n_header_files
== n_allocated_header_files
)
370 n_allocated_header_files
*= 2;
371 header_files
= (struct header_file
*)
372 xrealloc ((char *) header_files
,
373 (n_allocated_header_files
* sizeof (struct header_file
)));
376 /* Create an entry for this header file. */
378 i
= n_header_files
++;
379 header_files
[i
].name
= savestring (name
, strlen(name
));
380 header_files
[i
].instance
= instance
;
381 header_files
[i
].length
= 10;
382 header_files
[i
].vector
383 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
384 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
386 add_this_object_header_file (i
);
390 static struct type
**
391 explicit_lookup_type (real_filenum
, index
)
392 int real_filenum
, index
;
394 register struct header_file
*f
= &header_files
[real_filenum
];
396 if (index
>= f
->length
)
399 f
->vector
= (struct type
**)
400 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
401 memset (&f
->vector
[f
->length
/ 2],
402 '\0', f
->length
* sizeof (struct type
*) / 2);
404 return &f
->vector
[index
];
409 record_minimal_symbol (name
, address
, type
, objfile
)
413 struct objfile
*objfile
;
415 enum minimal_symbol_type ms_type
;
422 section
= SECT_OFF_TEXT
;
426 section
= SECT_OFF_DATA
;
430 section
= SECT_OFF_BSS
;
439 section
= SECT_OFF_DATA
;
442 /* I don't think this type actually exists; since a N_SETV is the result
443 of going over many .o files, it doesn't make sense to have one
445 ms_type
= mst_file_data
;
446 section
= SECT_OFF_DATA
;
453 ms_type
= mst_file_text
;
454 section
= SECT_OFF_TEXT
;
457 ms_type
= mst_file_data
;
459 /* Check for __DYNAMIC, which is used by Sun shared libraries.
460 Record it as global even if it's local, not global, so
461 lookup_minimal_symbol can find it. We don't check symbol_leading_char
462 because for SunOS4 it always is '_'. */
463 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
466 /* Same with virtual function tables, both global and static. */
468 char *tempstring
= name
;
469 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
471 if (VTBL_PREFIX_P ((tempstring
)))
474 section
= SECT_OFF_DATA
;
477 ms_type
= mst_file_bss
;
478 section
= SECT_OFF_BSS
;
481 ms_type
= mst_unknown
;
486 if (ms_type
== mst_file_text
|| ms_type
== mst_text
487 && address
< lowest_text_address
)
488 lowest_text_address
= address
;
490 prim_record_minimal_symbol_and_info
491 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
499 /* Scan and build partial symbols for a symbol file.
500 We have been initialized by a call to dbx_symfile_init, which
501 put all the relevant info into a "struct dbx_symfile_info",
502 hung off the objfile structure.
504 SECTION_OFFSETS contains offsets relative to which the symbols in the
505 various sections are (depending where the sections were actually loaded).
506 MAINLINE is true if we are reading the main symbol
507 table (as opposed to a shared lib or dynamically loaded file). */
510 dbx_symfile_read (objfile
, section_offsets
, mainline
)
511 struct objfile
*objfile
;
512 struct section_offsets
*section_offsets
;
513 int mainline
; /* FIXME comments above */
517 struct cleanup
*back_to
;
519 val
= strlen (objfile
->name
);
521 /* .o and .nlm files are relocatables with text, data and bss segs based at
522 0. This flag disables special (Solaris stabs-in-elf only) fixups for
523 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
524 should be fixed to determine pst->textlow without using this text seg of
527 if (strcmp (&objfile
->name
[val
-2], ".o") == 0
528 || strcmp (&objfile
->name
[val
-4], ".nlm") == 0)
529 symfile_relocatable
= 1;
531 sym_bfd
= objfile
->obfd
;
532 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
534 perror_with_name (objfile
->name
);
536 /* If we are reinitializing, or if we have never loaded syms yet, init */
537 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
538 init_psymbol_list (objfile
);
540 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
541 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
544 back_to
= make_cleanup (really_free_pendings
, 0);
546 init_minimal_symbol_collection ();
547 make_cleanup (discard_minimal_symbols
, 0);
549 /* Now that the symbol table data of the executable file are all in core,
550 process them and define symbols accordingly. */
552 read_dbx_symtab (section_offsets
, objfile
,
553 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
554 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
556 /* Add the dynamic symbols if we are reading the main symbol table. */
559 read_dbx_dynamic_symtab (section_offsets
, objfile
);
561 /* Install any minimal symbols that have been collected as the current
562 minimal symbols for this objfile. */
564 install_minimal_symbols (objfile
);
566 if (!have_partial_symbols ()) {
568 printf_filtered ("(no debugging symbols found)...");
572 do_cleanups (back_to
);
575 /* Initialize anything that needs initializing when a completely new
576 symbol file is specified (not just adding some symbols from another
577 file, e.g. a shared library). */
580 dbx_new_init (ignore
)
581 struct objfile
*ignore
;
583 stabsread_new_init ();
584 buildsym_new_init ();
585 init_header_files ();
589 /* dbx_symfile_init ()
590 is the dbx-specific initialization routine for reading symbols.
591 It is passed a struct objfile which contains, among other things,
592 the BFD for the file whose symbols are being read, and a slot for a pointer
593 to "private data" which we fill with goodies.
595 We read the string table into malloc'd space and stash a pointer to it.
597 Since BFD doesn't know how to read debug symbols in a format-independent
598 way (and may never do so...), we have to do it ourselves. We will never
599 be called unless this is an a.out (or very similar) file.
600 FIXME, there should be a cleaner peephole into the BFD environment here. */
602 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
605 dbx_symfile_init (objfile
)
606 struct objfile
*objfile
;
609 bfd
*sym_bfd
= objfile
->obfd
;
610 char *name
= bfd_get_filename (sym_bfd
);
611 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
613 /* Allocate struct to keep track of the symfile */
614 objfile
->sym_stab_info
= (PTR
)
615 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
617 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
618 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
619 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
621 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
623 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
624 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
625 if (!DBX_TEXT_SECT (objfile
))
626 error ("Can't find .text section in symbol file");
628 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
629 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
630 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
632 /* Read the string table and stash it away in the psymbol_obstack. It is
633 only needed as long as we need to expand psymbols into full symbols,
634 so when we blow away the psymbol the string table goes away as well.
635 Note that gdb used to use the results of attempting to malloc the
636 string table, based on the size it read, as a form of sanity check
637 for botched byte swapping, on the theory that a byte swapped string
638 table size would be so totally bogus that the malloc would fail. Now
639 that we put in on the psymbol_obstack, we can't do this since gdb gets
640 a fatal error (out of virtual memory) if the size is bogus. We can
641 however at least check to see if the size is less than the size of
642 the size field itself, or larger than the size of the entire file.
643 Note that all valid string tables have a size greater than zero, since
644 the bytes used to hold the size are included in the count. */
646 if (STRING_TABLE_OFFSET
== 0)
648 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
649 will never be zero, even when there is no string table. This
650 would appear to be a bug in bfd. */
651 DBX_STRINGTAB_SIZE (objfile
) = 0;
652 DBX_STRINGTAB (objfile
) = NULL
;
656 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
658 perror_with_name (name
);
660 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
661 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
664 perror_with_name (name
);
668 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
669 EOF if there is no string table, and attempting to read the size
670 from EOF will read zero bytes. */
671 DBX_STRINGTAB_SIZE (objfile
) = 0;
672 DBX_STRINGTAB (objfile
) = NULL
;
676 /* Read some data that would appear to be the string table size.
677 If there really is a string table, then it is probably the right
678 size. Byteswap if necessary and validate the size. Note that
679 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
680 random data that happened to be at STRING_TABLE_OFFSET, because
681 bfd can't tell us there is no string table, the sanity checks may
682 or may not catch this. */
683 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
685 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
686 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
687 error ("ridiculous string table size (%d bytes).",
688 DBX_STRINGTAB_SIZE (objfile
));
690 DBX_STRINGTAB (objfile
) =
691 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
692 DBX_STRINGTAB_SIZE (objfile
));
694 /* Now read in the string table in one big gulp. */
696 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
698 perror_with_name (name
);
699 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
701 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
702 perror_with_name (name
);
707 /* Perform any local cleanups required when we are done with a particular
708 objfile. I.E, we are in the process of discarding all symbol information
709 for an objfile, freeing up all memory held for it, and unlinking the
710 objfile struct from the global list of known objfiles. */
713 dbx_symfile_finish (objfile
)
714 struct objfile
*objfile
;
716 if (objfile
->sym_stab_info
!= NULL
)
718 mfree (objfile
-> md
, objfile
->sym_stab_info
);
720 free_header_files ();
724 /* Buffer for reading the symbol table entries. */
725 static struct internal_nlist symbuf
[4096];
726 static int symbuf_idx
;
727 static int symbuf_end
;
729 /* Name of last function encountered. Used in Solaris to approximate
730 object file boundaries. */
731 static char *last_function_name
;
733 /* The address in memory of the string table of the object file we are
734 reading (which might not be the "main" object file, but might be a
735 shared library or some other dynamically loaded thing). This is set
736 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
737 when building symtabs, and is used only by next_symbol_text. */
738 static char *stringtab_global
;
740 /* Refill the symbol table input buffer
741 and set the variables that control fetching entries from it.
742 Reports an error if no data available.
743 This function can read past the end of the symbol table
744 (into the string table) but this does no harm. */
747 fill_symbuf (sym_bfd
)
750 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
752 perror_with_name (bfd_get_filename (sym_bfd
));
753 else if (nbytes
== 0)
754 error ("Premature end of file reading symbol table");
755 symbuf_end
= nbytes
/ symbol_size
;
759 #define SWAP_SYMBOL(symp, abfd) \
761 (symp)->n_strx = bfd_h_get_32(abfd, \
762 (unsigned char *)&(symp)->n_strx); \
763 (symp)->n_desc = bfd_h_get_16 (abfd, \
764 (unsigned char *)&(symp)->n_desc); \
765 (symp)->n_value = bfd_h_get_32 (abfd, \
766 (unsigned char *)&(symp)->n_value); \
769 /* Invariant: The symbol pointed to by symbuf_idx is the first one
770 that hasn't been swapped. Swap the symbol at the same time
771 that symbuf_idx is incremented. */
773 /* dbx allows the text of a symbol name to be continued into the
774 next symbol name! When such a continuation is encountered
775 (a \ at the end of the text of a name)
776 call this function to get the continuation. */
779 dbx_next_symbol_text ()
781 if (symbuf_idx
== symbuf_end
)
782 fill_symbuf (symfile_bfd
);
784 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
785 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
786 + file_string_table_offset
;
789 /* Initializes storage for all of the partial symbols that will be
790 created by read_dbx_symtab and subsidiaries. */
793 init_psymbol_list (objfile
)
794 struct objfile
*objfile
;
796 /* Free any previously allocated psymbol lists. */
797 if (objfile
-> global_psymbols
.list
)
798 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
799 if (objfile
-> static_psymbols
.list
)
800 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
802 /* Current best guess is that there are approximately a twentieth
803 of the total symbols (in a debugging file) are global or static
805 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
806 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
807 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
808 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
809 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
810 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
813 /* Initialize the list of bincls to contain none and have some
817 init_bincl_list (number
, objfile
)
819 struct objfile
*objfile
;
821 bincls_allocated
= number
;
822 next_bincl
= bincl_list
= (struct header_file_location
*)
823 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
826 /* Add a bincl to the list. */
829 add_bincl_to_list (pst
, name
, instance
)
830 struct partial_symtab
*pst
;
834 if (next_bincl
>= bincl_list
+ bincls_allocated
)
836 int offset
= next_bincl
- bincl_list
;
837 bincls_allocated
*= 2;
838 bincl_list
= (struct header_file_location
*)
839 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
840 bincls_allocated
* sizeof (struct header_file_location
));
841 next_bincl
= bincl_list
+ offset
;
843 next_bincl
->pst
= pst
;
844 next_bincl
->instance
= instance
;
845 next_bincl
++->name
= name
;
848 /* Given a name, value pair, find the corresponding
849 bincl in the list. Return the partial symtab associated
850 with that header_file_location. */
852 static struct partial_symtab
*
853 find_corresponding_bincl_psymtab (name
, instance
)
857 struct header_file_location
*bincl
;
859 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
860 if (bincl
->instance
== instance
861 && STREQ (name
, bincl
->name
))
864 return (struct partial_symtab
*) 0;
867 /* Free the storage allocated for the bincl list. */
870 free_bincl_list (objfile
)
871 struct objfile
*objfile
;
873 mfree (objfile
-> md
, (PTR
)bincl_list
);
874 bincls_allocated
= 0;
877 /* Scan a SunOs dynamic symbol table for symbols of interest and
878 add them to the minimal symbol table. */
881 read_dbx_dynamic_symtab (section_offsets
, objfile
)
882 struct section_offsets
*section_offsets
;
883 struct objfile
*objfile
;
885 bfd
*abfd
= objfile
->obfd
;
886 struct cleanup
*back_to
;
898 /* Check that the symbol file has dynamic symbols that we know about.
899 bfd_arch_unknown can happen if we are reading a sun3 symbol file
900 on a sun4 host (and vice versa) and bfd is not configured
901 --with-target=all. This would trigger an assertion in bfd/sunos.c,
902 so we ignore the dynamic symbols in this case. */
903 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
904 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
905 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
908 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
912 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
913 back_to
= make_cleanup (free
, dynsyms
);
915 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
916 if (dynsym_count
< 0)
918 do_cleanups (back_to
);
922 /* Enter dynamic symbols into the minimal symbol table
923 if this is a stripped executable. */
924 if (bfd_get_symcount (abfd
) <= 0)
927 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
929 asymbol
*sym
= *symptr
;
933 sec
= bfd_get_section (sym
);
935 /* BFD symbols are section relative. */
936 sym_value
= sym
->value
+ sec
->vma
;
938 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
940 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
943 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
945 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
948 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
950 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
956 if (sym
->flags
& BSF_GLOBAL
)
959 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
964 /* Symbols from shared libraries have a dynamic relocation entry
965 that points to the associated slot in the procedure linkage table.
966 We make a mininal symbol table entry with type mst_solib_trampoline
967 at the address in the procedure linkage table. */
968 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
971 do_cleanups (back_to
);
975 dynrels
= (arelent
**) xmalloc (dynrel_size
);
976 make_cleanup (free
, dynrels
);
978 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
979 if (dynrel_count
< 0)
981 do_cleanups (back_to
);
985 for (counter
= 0, relptr
= dynrels
;
986 counter
< dynrel_count
;
989 arelent
*rel
= *relptr
;
990 CORE_ADDR address
= rel
->address
;
992 switch (bfd_get_arch (abfd
))
995 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
999 /* `16' is the type BFD produces for a jump table relocation. */
1000 if (rel
->howto
->type
!= 16)
1003 /* Adjust address in the jump table to point to
1004 the start of the bsr instruction. */
1011 prim_record_minimal_symbol (bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1013 mst_solib_trampoline
,
1017 do_cleanups (back_to
);
1020 /* Given pointers to an a.out symbol table in core containing dbx
1021 style data, setup partial_symtab's describing each source file for
1022 which debugging information is available.
1023 SYMFILE_NAME is the name of the file we are reading from
1024 and SECTION_OFFSETS is the set of offsets for the various sections
1025 of the file (a set of zeros if the mainline program). */
1028 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1029 struct section_offsets
*section_offsets
;
1030 struct objfile
*objfile
;
1031 CORE_ADDR text_addr
;
1034 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1035 register char *namestring
;
1037 int past_first_source_file
= 0;
1038 CORE_ADDR last_o_file_start
= 0;
1039 struct cleanup
*back_to
;
1042 /* Current partial symtab */
1043 struct partial_symtab
*pst
;
1045 /* List of current psymtab's include files */
1046 char **psymtab_include_list
;
1047 int includes_allocated
;
1050 /* Index within current psymtab dependency list */
1051 struct partial_symtab
**dependency_list
;
1052 int dependencies_used
, dependencies_allocated
;
1054 /* FIXME. We probably want to change stringtab_global rather than add this
1055 while processing every symbol entry. FIXME. */
1056 file_string_table_offset
= 0;
1057 next_file_string_table_offset
= 0;
1059 stringtab_global
= DBX_STRINGTAB (objfile
);
1061 pst
= (struct partial_symtab
*) 0;
1063 includes_allocated
= 30;
1065 psymtab_include_list
= (char **) alloca (includes_allocated
*
1068 dependencies_allocated
= 30;
1069 dependencies_used
= 0;
1071 (struct partial_symtab
**) alloca (dependencies_allocated
*
1072 sizeof (struct partial_symtab
*));
1074 /* Init bincl list */
1075 init_bincl_list (20, objfile
);
1076 back_to
= make_cleanup (free_bincl_list
, objfile
);
1078 last_source_file
= NULL
;
1080 lowest_text_address
= (CORE_ADDR
)-1;
1082 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1083 abfd
= objfile
->obfd
;
1084 symbuf_end
= symbuf_idx
= 0;
1085 next_symbol_text_func
= dbx_next_symbol_text
;
1087 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1089 /* Get the symbol for this run and pull out some info */
1090 QUIT
; /* allow this to be interruptable */
1091 if (symbuf_idx
== symbuf_end
)
1093 bufp
= &symbuf
[symbuf_idx
++];
1096 * Special case to speed up readin.
1098 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1100 SWAP_SYMBOL (bufp
, abfd
);
1102 /* Ok. There is a lot of code duplicated in the rest of this
1103 switch statement (for efficiency reasons). Since I don't
1104 like duplicating code, I will do my penance here, and
1105 describe the code which is duplicated:
1107 *) The assignment to namestring.
1108 *) The call to strchr.
1109 *) The addition of a partial symbol the the two partial
1110 symbol lists. This last is a large section of code, so
1111 I've imbedded it in the following macro.
1114 /* Set namestring based on bufp. If the string table index is invalid,
1115 give a fake name, and print a single error message per symbol file read,
1116 rather than abort the symbol reading or flood the user with messages. */
1118 /*FIXME: Too many adds and indirections in here for the inner loop. */
1119 #define SET_NAMESTRING()\
1120 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1121 DBX_STRINGTAB_SIZE (objfile)) { \
1122 complain (&string_table_offset_complaint, symnum); \
1123 namestring = "<bad string table offset>"; \
1125 namestring = bufp->n_strx + file_string_table_offset + \
1126 DBX_STRINGTAB (objfile)
1128 #define CUR_SYMBOL_TYPE bufp->n_type
1129 #define CUR_SYMBOL_VALUE bufp->n_value
1130 #define DBXREAD_ONLY
1131 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1132 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1133 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1134 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1136 #include "partial-stab.h"
1139 /* If there's stuff to be cleaned up, clean it up. */
1140 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1141 /*FIXME, does this have a bug at start address 0? */
1142 && last_o_file_start
1143 && objfile
-> ei
.entry_point
< bufp
->n_value
1144 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1146 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1147 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1152 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1153 symnum
* symbol_size
,
1154 (lowest_text_address
== (CORE_ADDR
)-1
1155 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1156 : lowest_text_address
)
1158 dependency_list
, dependencies_used
);
1161 do_cleanups (back_to
);
1164 /* Allocate and partially fill a partial symtab. It will be
1165 completely filled at the end of the symbol list.
1167 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1168 is the address relative to which its symbols are (incremental) or 0
1172 struct partial_symtab
*
1173 start_psymtab (objfile
, section_offsets
,
1174 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1175 struct objfile
*objfile
;
1176 struct section_offsets
*section_offsets
;
1180 struct partial_symbol
*global_syms
;
1181 struct partial_symbol
*static_syms
;
1183 struct partial_symtab
*result
=
1184 start_psymtab_common(objfile
, section_offsets
,
1185 filename
, textlow
, global_syms
, static_syms
);
1187 result
->read_symtab_private
= (char *)
1188 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1189 LDSYMOFF(result
) = ldsymoff
;
1190 result
->read_symtab
= dbx_psymtab_to_symtab
;
1191 SYMBOL_SIZE(result
) = symbol_size
;
1192 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1193 STRING_OFFSET(result
) = string_table_offset
;
1194 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1196 /* If we're handling an ELF file, drag some section-relocation info
1197 for this source file out of the ELF symbol table, to compensate for
1198 Sun brain death. This replaces the section_offsets in this psymtab,
1200 elfstab_offset_sections (objfile
, result
);
1202 /* Deduce the source language from the filename for this psymtab. */
1203 psymtab_language
= deduce_language_from_filename (filename
);
1208 /* Close off the current usage of PST.
1209 Returns PST or NULL if the partial symtab was empty and thrown away.
1211 FIXME: List variables and peculiarities of same. */
1213 struct partial_symtab
*
1214 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1215 capping_text
, dependency_list
, number_dependencies
)
1216 struct partial_symtab
*pst
;
1217 char **include_list
;
1219 int capping_symbol_offset
;
1220 CORE_ADDR capping_text
;
1221 struct partial_symtab
**dependency_list
;
1222 int number_dependencies
;
1225 struct partial_symtab
*p1
;
1226 struct objfile
*objfile
= pst
-> objfile
;
1228 if (capping_symbol_offset
!= -1)
1229 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1230 pst
->texthigh
= capping_text
;
1232 #ifdef N_SO_ADDRESS_MAYBE_MISSING
1233 /* Under Solaris, the N_SO symbols always have a value of 0,
1234 instead of the usual address of the .o file. Therefore,
1235 we have to do some tricks to fill in texthigh and textlow.
1236 The first trick is in partial-stab.h: if we see a static
1237 or global function, and the textlow for the current pst
1238 is still 0, then we use that function's address for
1239 the textlow of the pst.
1241 Now, to fill in texthigh, we remember the last function seen
1242 in the .o file (also in partial-stab.h). Also, there's a hack in
1243 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1244 to here via the misc_info field. Therefore, we can fill in
1245 a reliable texthigh by taking the address plus size of the
1246 last function in the file.
1248 Unfortunately, that does not cover the case where the last function
1249 in the file is static. See the paragraph below for more comments
1252 Finally, if we have a valid textlow for the current file, we run
1253 down the partial_symtab_list filling in previous texthighs that
1254 are still unknown. */
1256 if (pst
->texthigh
== 0 && last_function_name
) {
1259 struct minimal_symbol
*minsym
;
1261 p
= strchr (last_function_name
, ':');
1263 p
= last_function_name
;
1264 n
= p
- last_function_name
;
1266 strncpy (p
, last_function_name
, n
);
1269 minsym
= lookup_minimal_symbol (p
, objfile
);
1272 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1273 (long) MSYMBOL_INFO (minsym
);
1275 /* This file ends with a static function, and it's
1276 difficult to imagine how hard it would be to track down
1277 the elf symbol. Luckily, most of the time no one will notice,
1278 since the next file will likely be compiled with -g, so
1279 the code below will copy the first fuction's start address
1280 back to our texthigh variable. (Also, if this file is the
1281 last one in a dynamically linked program, texthigh already
1282 has the right value.) If the next file isn't compiled
1283 with -g, then the last function in this file winds up owning
1284 all of the text space up to the next -g file, or the end (minus
1285 shared libraries). This only matters for single stepping,
1286 and even then it will still work, except that it will single
1287 step through all of the covered functions, instead of setting
1288 breakpoints around them as it usualy does. This makes it
1289 pretty slow, but at least it doesn't fail.
1291 We can fix this with a fairly big change to bfd, but we need
1292 to coordinate better with Cygnus if we want to do that. FIXME. */
1294 last_function_name
= NULL
;
1297 /* this test will be true if the last .o file is only data */
1298 if (pst
->textlow
== 0)
1299 /* This loses if the text section really starts at address zero
1300 (generally true when we are debugging a .o file, for example).
1301 That is why this whole thing is inside N_SO_ADDRESS_MAYBE_MISSING. */
1302 pst
->textlow
= pst
->texthigh
;
1304 /* If we know our own starting text address, then walk through all other
1305 psymtabs for this objfile, and if any didn't know their ending text
1306 address, set it to our starting address. Take care to not set our
1307 own ending address to our starting address, nor to set addresses on
1308 `dependency' files that have both textlow and texthigh zero. */
1310 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1311 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1312 p1
->texthigh
= pst
->textlow
;
1313 /* if this file has only data, then make textlow match texthigh */
1314 if (p1
->textlow
== 0)
1315 p1
->textlow
= p1
->texthigh
;
1320 /* End of kludge for patching Solaris textlow and texthigh. */
1321 #endif /* N_SO_ADDRESS_MAYBE_MISSING. */
1323 pst
->n_global_syms
=
1324 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1325 pst
->n_static_syms
=
1326 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1328 pst
->number_of_dependencies
= number_dependencies
;
1329 if (number_dependencies
)
1331 pst
->dependencies
= (struct partial_symtab
**)
1332 obstack_alloc (&objfile
->psymbol_obstack
,
1333 number_dependencies
* sizeof (struct partial_symtab
*));
1334 memcpy (pst
->dependencies
, dependency_list
,
1335 number_dependencies
* sizeof (struct partial_symtab
*));
1338 pst
->dependencies
= 0;
1340 for (i
= 0; i
< num_includes
; i
++)
1342 struct partial_symtab
*subpst
=
1343 allocate_psymtab (include_list
[i
], objfile
);
1345 subpst
->section_offsets
= pst
->section_offsets
;
1346 subpst
->read_symtab_private
=
1347 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1348 sizeof (struct symloc
));
1352 subpst
->texthigh
= 0;
1354 /* We could save slight bits of space by only making one of these,
1355 shared by the entire set of include files. FIXME-someday. */
1356 subpst
->dependencies
= (struct partial_symtab
**)
1357 obstack_alloc (&objfile
->psymbol_obstack
,
1358 sizeof (struct partial_symtab
*));
1359 subpst
->dependencies
[0] = pst
;
1360 subpst
->number_of_dependencies
= 1;
1362 subpst
->globals_offset
=
1363 subpst
->n_global_syms
=
1364 subpst
->statics_offset
=
1365 subpst
->n_static_syms
= 0;
1369 subpst
->read_symtab
= pst
->read_symtab
;
1372 sort_pst_symbols (pst
);
1374 /* If there is already a psymtab or symtab for a file of this name, remove it.
1375 (If there is a symtab, more drastic things also happen.)
1376 This happens in VxWorks. */
1377 free_named_symtabs (pst
->filename
);
1379 if (num_includes
== 0
1380 && number_dependencies
== 0
1381 && pst
->n_global_syms
== 0
1382 && pst
->n_static_syms
== 0)
1384 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1385 it is on the obstack, but we can forget to chain it on the list. */
1386 /* Empty psymtabs happen as a result of header files which don't have
1387 any symbols in them. There can be a lot of them. But this check
1388 is wrong, in that a psymtab with N_SLINE entries but nothing else
1389 is not empty, but we don't realize that. Fixing that without slowing
1390 things down might be tricky. */
1391 struct partial_symtab
*prev_pst
;
1393 /* First, snip it out of the psymtab chain */
1395 if (pst
->objfile
->psymtabs
== pst
)
1396 pst
->objfile
->psymtabs
= pst
->next
;
1398 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1399 if (prev_pst
->next
== pst
)
1400 prev_pst
->next
= pst
->next
;
1402 /* Next, put it on a free list for recycling */
1404 pst
->next
= pst
->objfile
->free_psymtabs
;
1405 pst
->objfile
->free_psymtabs
= pst
;
1407 /* Indicate that psymtab was thrown away. */
1408 pst
= (struct partial_symtab
*)NULL
;
1414 dbx_psymtab_to_symtab_1 (pst
)
1415 struct partial_symtab
*pst
;
1417 struct cleanup
*old_chain
;
1425 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1430 /* Read in all partial symtabs on which this one is dependent */
1431 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1432 if (!pst
->dependencies
[i
]->readin
)
1434 /* Inform about additional files that need to be read in. */
1437 fputs_filtered (" ", gdb_stdout
);
1439 fputs_filtered ("and ", gdb_stdout
);
1441 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1442 wrap_here (""); /* Flush output */
1443 gdb_flush (gdb_stdout
);
1445 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1448 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1450 /* Init stuff necessary for reading in symbols */
1453 old_chain
= make_cleanup (really_free_pendings
, 0);
1454 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1455 symbol_size
= SYMBOL_SIZE (pst
);
1457 /* Read in this file's symbols */
1458 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1459 read_ofile_symtab (pst
);
1460 sort_symtab_syms (pst
->symtab
);
1462 do_cleanups (old_chain
);
1468 /* Read in all of the symbols for a given psymtab for real.
1469 Be verbose about it if the user wants that. */
1472 dbx_psymtab_to_symtab (pst
)
1473 struct partial_symtab
*pst
;
1482 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1487 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1489 /* Print the message now, before reading the string table,
1490 to avoid disconcerting pauses. */
1493 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1494 gdb_flush (gdb_stdout
);
1497 sym_bfd
= pst
->objfile
->obfd
;
1499 next_symbol_text_func
= dbx_next_symbol_text
;
1501 dbx_psymtab_to_symtab_1 (pst
);
1503 /* Match with global symbols. This only needs to be done once,
1504 after all of the symtabs and dependencies have been read in. */
1505 scan_file_globals (pst
->objfile
);
1507 /* Finish up the debug error message. */
1509 printf_filtered ("done.\n");
1513 /* Read in a defined section of a specific object file's symbols. */
1516 read_ofile_symtab (pst
)
1517 struct partial_symtab
*pst
;
1519 register char *namestring
;
1520 register struct internal_nlist
*bufp
;
1522 unsigned max_symnum
;
1524 struct objfile
*objfile
;
1525 int sym_offset
; /* Offset to start of symbols to read */
1526 int sym_size
; /* Size of symbols to read */
1527 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1528 int text_size
; /* Size of text segment for symbols */
1529 struct section_offsets
*section_offsets
;
1531 objfile
= pst
->objfile
;
1532 sym_offset
= LDSYMOFF(pst
);
1533 sym_size
= LDSYMLEN(pst
);
1534 text_offset
= pst
->textlow
;
1535 text_size
= pst
->texthigh
- pst
->textlow
;
1536 section_offsets
= pst
->section_offsets
;
1538 current_objfile
= objfile
;
1539 subfile_stack
= NULL
;
1541 stringtab_global
= DBX_STRINGTAB (objfile
);
1542 last_source_file
= NULL
;
1544 abfd
= objfile
->obfd
;
1545 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1546 symbuf_end
= symbuf_idx
= 0;
1548 /* It is necessary to actually read one symbol *before* the start
1549 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1550 occurs before the N_SO symbol.
1552 Detecting this in read_dbx_symtab
1553 would slow down initial readin, so we look for it here instead. */
1554 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1556 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1558 bufp
= &symbuf
[symbuf_idx
++];
1559 SWAP_SYMBOL (bufp
, abfd
);
1563 processing_gcc_compilation
= 0;
1564 if (bufp
->n_type
== N_TEXT
)
1566 const char *tempstring
= namestring
;
1568 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1569 processing_gcc_compilation
= 1;
1570 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1571 processing_gcc_compilation
= 2;
1572 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1574 if (STREQN (tempstring
, "__gnu_compiled", 14))
1575 processing_gcc_compilation
= 2;
1578 /* Try to select a C++ demangling based on the compilation unit
1581 if (processing_gcc_compilation
)
1583 if (AUTO_DEMANGLING
)
1585 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1591 /* The N_SO starting this symtab is the first symbol, so we
1592 better not check the symbol before it. I'm not this can
1593 happen, but it doesn't hurt to check for it. */
1594 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1595 processing_gcc_compilation
= 0;
1598 if (symbuf_idx
== symbuf_end
)
1600 bufp
= &symbuf
[symbuf_idx
];
1601 if (bufp
->n_type
!= (unsigned char)N_SO
)
1602 error("First symbol in segment of executable not a source symbol");
1604 max_symnum
= sym_size
/ symbol_size
;
1607 symnum
< max_symnum
;
1610 QUIT
; /* Allow this to be interruptable */
1611 if (symbuf_idx
== symbuf_end
)
1613 bufp
= &symbuf
[symbuf_idx
++];
1614 SWAP_SYMBOL (bufp
, abfd
);
1616 type
= bufp
->n_type
;
1620 if (type
& N_STAB
) {
1621 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1622 namestring
, section_offsets
, objfile
);
1624 /* We skip checking for a new .o or -l file; that should never
1625 happen in this routine. */
1626 else if (type
== N_TEXT
)
1628 /* I don't think this code will ever be executed, because
1629 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1630 the N_SO symbol which starts this source file.
1631 However, there is no reason not to accept
1632 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1634 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1635 processing_gcc_compilation
= 1;
1636 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1637 processing_gcc_compilation
= 2;
1639 if (AUTO_DEMANGLING
)
1641 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1644 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1645 || type
== (unsigned char)N_NBTEXT
1647 /* Global symbol: see if we came across a dbx defintion for
1648 a corresponding symbol. If so, store the value. Remove
1649 syms from the chain when their values are stored, but
1650 search the whole chain, as there may be several syms from
1651 different files with the same name. */
1652 /* This is probably not true. Since the files will be read
1653 in one at a time, each reference to a global symbol will
1654 be satisfied in each file as it appears. So we skip this
1660 current_objfile
= NULL
;
1662 /* In a Solaris elf file, this variable, which comes from the
1663 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1664 which comes from pst->textlow is correct. */
1665 if (last_source_start_addr
== 0)
1666 last_source_start_addr
= text_offset
;
1668 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1674 /* This handles a single symbol from the symbol-file, building symbols
1675 into a GDB symtab. It takes these arguments and an implicit argument.
1677 TYPE is the type field of the ".stab" symbol entry.
1678 DESC is the desc field of the ".stab" entry.
1679 VALU is the value field of the ".stab" entry.
1680 NAME is the symbol name, in our address space.
1681 SECTION_OFFSETS is a set of amounts by which the sections of this object
1682 file were relocated when it was loaded into memory.
1683 All symbols that refer
1684 to memory locations need to be offset by these amounts.
1685 OBJFILE is the object file from which we are reading symbols.
1686 It is used in end_symtab. */
1689 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1693 struct section_offsets
*section_offsets
;
1694 struct objfile
*objfile
;
1696 #ifdef SUN_FIXED_LBRAC_BUG
1697 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1698 to correct the address of N_LBRAC's. If it is not defined, then
1699 we never need to correct the addresses. */
1701 /* This records the last pc address we've seen. We depend on there being
1702 an SLINE or FUN or SO before the first LBRAC, since the variable does
1703 not get reset in between reads of different symbol files. */
1704 static CORE_ADDR last_pc_address
;
1707 register struct context_stack
*new;
1708 /* This remembers the address of the start of a function. It is used
1709 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1710 relative to the current function's start address. On systems
1711 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1712 used to relocate these symbol types rather than SECTION_OFFSETS. */
1713 static CORE_ADDR function_start_offset
;
1715 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
1716 to the function start address. */
1717 int block_address_function_relative
;
1719 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1720 file. Used to detect the SunPRO solaris compiler. */
1721 static int n_opt_found
;
1723 /* The stab type used for the definition of the last function.
1724 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1725 static int function_stab_type
= 0;
1727 /* This is true for Solaris (and all other systems which put stabs
1728 in sections, hopefully, since it would be silly to do things
1729 differently from Solaris), and false for SunOS4 and other a.out
1731 block_address_function_relative
=
1732 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
1733 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
1734 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4))
1735 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "nlm", 3)));
1737 if (!block_address_function_relative
)
1738 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1739 function start address, so just use the text offset. */
1740 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1742 /* Something is wrong if we see real data before
1743 seeing a source file name. */
1745 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1747 /* Ignore any symbols which appear before an N_SO symbol. Currently
1748 no one puts symbols there, but we should deal gracefully with the
1749 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1750 but this should not be an error (). */
1758 /* Relocate for dynamic loading */
1759 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1760 goto define_a_symbol
;
1763 /* This "symbol" just indicates the start of an inner lexical
1764 context within a function. */
1766 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1767 /* Relocate for dynamic loading (?). */
1768 valu
+= function_start_offset
;
1770 if (block_address_function_relative
)
1771 /* Relocate for Sun ELF acc fn-relative syms. */
1772 valu
+= function_start_offset
;
1774 /* On most machines, the block addresses are relative to the
1775 N_SO, the linker did not relocate them (sigh). */
1776 valu
+= last_source_start_addr
;
1779 #ifdef SUN_FIXED_LBRAC_BUG
1780 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1781 /* Patch current LBRAC pc value to match last handy pc value */
1782 complain (&lbrac_complaint
);
1783 valu
= last_pc_address
;
1786 new = push_context (desc
, valu
);
1790 /* This "symbol" just indicates the end of an inner lexical
1791 context that was started with N_LBRAC. */
1793 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1794 /* Relocate for dynamic loading (?). */
1795 valu
+= function_start_offset
;
1797 if (block_address_function_relative
)
1798 /* Relocate for Sun ELF acc fn-relative syms. */
1799 valu
+= function_start_offset
;
1801 /* On most machines, the block addresses are relative to the
1802 N_SO, the linker did not relocate them (sigh). */
1803 valu
+= last_source_start_addr
;
1806 new = pop_context();
1807 if (desc
!= new->depth
)
1808 complain (&lbrac_mismatch_complaint
, symnum
);
1810 /* Some compilers put the variable decls inside of an
1811 LBRAC/RBRAC block. This macro should be nonzero if this
1812 is true. DESC is N_DESC from the N_RBRAC symbol.
1813 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1814 or the GCC2_COMPILED_SYMBOL. */
1815 #if !defined (VARIABLES_INSIDE_BLOCK)
1816 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1819 /* Can only use new->locals as local symbols here if we're in
1820 gcc or on a machine that puts them before the lbrack. */
1821 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1822 local_symbols
= new->locals
;
1824 if (context_stack_depth
1825 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1827 /* This is not the outermost LBRAC...RBRAC pair in the function,
1828 its local symbols preceded it, and are the ones just recovered
1829 from the context stack. Define the block for them (but don't
1830 bother if the block contains no symbols. Should we complain
1831 on blocks without symbols? I can't think of any useful purpose
1833 if (local_symbols
!= NULL
)
1835 /* Muzzle a compiler bug that makes end < start. (which
1836 compilers? Is this ever harmful?). */
1837 if (new->start_addr
> valu
)
1839 complain (&lbrac_rbrac_complaint
);
1840 new->start_addr
= valu
;
1842 /* Make a block for the local symbols within. */
1843 finish_block (0, &local_symbols
, new->old_blocks
,
1844 new->start_addr
, valu
, objfile
);
1849 /* This is the outermost LBRAC...RBRAC pair. There is no
1850 need to do anything; leave the symbols that preceded it
1851 to be attached to the function's own block. We need to
1852 indicate that we just moved outside of the function. */
1853 within_function
= 0;
1856 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1857 /* Now pop locals of block just finished. */
1858 local_symbols
= new->locals
;
1863 /* This kind of symbol indicates the start of an object file. */
1864 /* Relocate for dynamic loading */
1865 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1869 /* This type of symbol indicates the start of data
1870 for one source file.
1871 Finish the symbol table of the previous source file
1872 (if any) and start accumulating a new symbol table. */
1873 /* Relocate for dynamic loading */
1874 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1878 #ifdef SUN_FIXED_LBRAC_BUG
1879 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1882 #ifdef PCC_SOL_BROKEN
1883 /* pcc bug, occasionally puts out SO for SOL. */
1884 if (context_stack_depth
> 0)
1886 start_subfile (name
, NULL
);
1890 if (last_source_file
)
1892 /* Check if previous symbol was also an N_SO (with some
1893 sanity checks). If so, that one was actually the directory
1894 name, and the current one is the real file name.
1896 if (previous_stab_code
== (unsigned char) N_SO
)
1898 patch_subfile_names (current_subfile
, name
);
1899 break; /* Ignore repeated SOs */
1901 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1905 start_symtab (name
, NULL
, valu
);
1910 /* This type of symbol indicates the start of data for
1911 a sub-source-file, one whose contents were copied or
1912 included in the compilation of the main source file
1913 (whose name was given in the N_SO symbol.) */
1914 /* Relocate for dynamic loading */
1915 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1916 start_subfile (name
, current_subfile
->dirname
);
1921 add_new_header_file (name
, valu
);
1922 start_subfile (name
, current_subfile
->dirname
);
1926 start_subfile (pop_subfile (), current_subfile
->dirname
);
1930 add_old_header_file (name
, valu
);
1934 /* This type of "symbol" really just records
1935 one line-number -- core-address correspondence.
1936 Enter it in the line list for this symbol table. */
1937 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1938 valu
+= function_start_offset
;
1939 #ifdef SUN_FIXED_LBRAC_BUG
1940 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1942 record_line (current_subfile
, desc
, valu
);
1946 common_block_start (name
, objfile
);
1950 common_block_end (objfile
);
1953 /* The following symbol types need to have the appropriate offset added
1954 to their value; then we process symbol definitions in the name. */
1956 case N_STSYM
: /* Static symbol in data seg */
1957 case N_LCSYM
: /* Static symbol in BSS seg */
1958 case N_ROSYM
: /* Static symbol in Read-only data seg */
1959 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1960 Solaris2's stabs-in-elf makes *most* symbols relative
1961 but leaves a few absolute (at least for Solaris 2.1 and version
1962 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1963 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1964 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1965 This leaves us no choice but to search for the 'S' or 'V'...
1966 (or pass the whole section_offsets stuff down ONE MORE function
1967 call level, which we really don't want to do). */
1971 /* .o files and NLMs have non-zero text seg offsets, but don't need
1972 their static syms offset in this fashion. XXX - This is really a
1973 crock that should be fixed in the solib handling code so that I
1974 don't have to work around it here. */
1976 if (!symfile_relocatable
)
1978 p
= strchr (name
, ':');
1979 if (p
!= 0 && p
[1] == 'S')
1981 /* The linker relocated it. We don't want to add an
1982 elfstab_offset_sections-type offset, but we *do* want
1983 to add whatever solib.c passed to symbol_file_add as
1984 addr (this is known to affect SunOS4, and I suspect ELF
1985 too). Since elfstab_offset_sections currently does not
1986 muck with the text offset (there is no Ttext.text
1987 symbol), we can get addr from the text offset. If
1988 elfstab_offset_sections ever starts dealing with the
1989 text offset, and we still need to do this, we need to
1990 invent a SECT_OFF_ADDR_KLUDGE or something. */
1991 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1992 goto define_a_symbol
;
1995 /* Since it's not the kludge case, re-dispatch to the right handler. */
1997 case N_STSYM
: goto case_N_STSYM
;
1998 case N_LCSYM
: goto case_N_LCSYM
;
1999 case N_ROSYM
: goto case_N_ROSYM
;
2004 case_N_STSYM
: /* Static symbol in data seg */
2005 case N_DSLINE
: /* Source line number, data seg */
2006 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2007 goto define_a_symbol
;
2009 case_N_LCSYM
: /* Static symbol in BSS seg */
2010 case N_BSLINE
: /* Source line number, bss seg */
2011 /* N_BROWS: overlaps with N_BSLINE */
2012 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2013 goto define_a_symbol
;
2015 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2016 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2017 goto define_a_symbol
;
2019 case N_ENTRY
: /* Alternate entry point */
2020 /* Relocate for dynamic loading */
2021 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2022 goto define_a_symbol
;
2024 /* The following symbol types we don't know how to process. Handle
2025 them in a "default" way, but complain to people who care. */
2027 case N_CATCH
: /* Exception handler catcher */
2028 case N_EHDECL
: /* Exception handler name */
2029 case N_PC
: /* Global symbol in Pascal */
2030 case N_M2C
: /* Modula-2 compilation unit */
2031 /* N_MOD2: overlaps with N_EHDECL */
2032 case N_SCOPE
: /* Modula-2 scope information */
2033 case N_ECOML
: /* End common (local name) */
2034 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2039 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2042 /* The following symbol types don't need the address field relocated,
2043 since it is either unused, or is absolute. */
2045 case N_GSYM
: /* Global variable */
2046 case N_NSYMS
: /* Number of symbols (ultrix) */
2047 case N_NOMAP
: /* No map? (ultrix) */
2048 case N_RSYM
: /* Register variable */
2049 case N_DEFD
: /* Modula-2 GNU module dependency */
2050 case N_SSYM
: /* Struct or union element */
2051 case N_LSYM
: /* Local symbol in stack */
2052 case N_PSYM
: /* Parameter variable */
2053 case N_LENG
: /* Length of preceding symbol type */
2057 char *colon_pos
= strchr (name
, ':');
2058 if (colon_pos
== NULL
)
2061 deftype
= colon_pos
[1];
2067 function_stab_type
= type
;
2069 #ifdef SUN_FIXED_LBRAC_BUG
2070 /* The Sun acc compiler, under SunOS4, puts out
2071 functions with N_GSYM or N_STSYM. The problem is
2072 that the address of the symbol is no good (for N_GSYM
2073 it doesn't even attept an address; for N_STSYM it
2074 puts out an address but then it gets relocated
2075 relative to the data segment, not the text segment).
2076 Currently we can't fix this up later as we do for
2077 some types of symbol in scan_file_globals.
2078 Fortunately we do have a way of finding the address -
2079 we know that the value in last_pc_address is either
2080 the one we want (if we're dealing with the first
2081 function in an object file), or somewhere in the
2082 previous function. This means that we can use the
2083 minimal symbol table to get the address. */
2085 /* On solaris up to 2.2, the N_FUN stab gets relocated.
2086 On Solaris 2.3, ld no longer relocates stabs (which
2087 is good), and the N_FUN's value is now always zero.
2088 The following code can't deal with this, because
2089 last_pc_address depends on getting the address from a
2090 N_SLINE or some such and in Solaris those are function
2091 relative. Best fix is probably to create a Ttext.text symbol
2092 and handle this like Ddata.data and so on. */
2094 if (type
== N_GSYM
|| type
== N_STSYM
)
2096 struct minimal_symbol
*m
;
2097 int l
= colon_pos
- name
;
2099 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2100 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
2101 /* last_pc_address was in this function */
2102 valu
= SYMBOL_VALUE (m
);
2103 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
2104 /* last_pc_address was in last function */
2105 valu
= SYMBOL_VALUE (m
+1);
2107 /* Not found - use last_pc_address (for finish_block) */
2108 valu
= last_pc_address
;
2111 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2114 if (block_address_function_relative
)
2115 /* For Solaris 2.0 compilers, the block addresses and
2116 N_SLINE's are relative to the start of the
2117 function. On normal systems, and when using gcc on
2118 Solaris 2.0, these addresses are just absolute, or
2119 relative to the N_SO, depending on
2120 BLOCK_ADDRESS_ABSOLUTE. */
2121 function_start_offset
= valu
;
2123 within_function
= 1;
2124 if (context_stack_depth
> 0)
2126 new = pop_context ();
2127 /* Make a block for the local symbols within. */
2128 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2129 new->start_addr
, valu
, objfile
);
2131 /* Stack must be empty now. */
2132 if (context_stack_depth
!= 0)
2133 complain (&lbrac_unmatched_complaint
, symnum
);
2135 new = push_context (0, valu
);
2136 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2140 define_symbol (valu
, name
, desc
, type
, objfile
);
2146 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2147 for a bunch of other flags, too. Someday we may parse their
2148 flags; for now we ignore theirs and hope they'll ignore ours. */
2149 case N_OPT
: /* Solaris 2: Compiler options */
2152 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2154 processing_gcc_compilation
= 2;
2155 #if 1 /* Works, but is experimental. -fnf */
2156 if (AUTO_DEMANGLING
)
2158 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2167 /* The following symbol types can be ignored. */
2168 case N_OBJ
: /* Solaris 2: Object file dir and name */
2169 /* N_UNDF: Solaris 2: file separator mark */
2170 /* N_UNDF: -- we will never encounter it, since we only process one
2171 file's symbols at once. */
2172 case N_ENDM
: /* Solaris 2: End of module */
2173 case N_MAIN
: /* Name of main routine. */
2177 previous_stab_code
= type
;
2180 /* FIXME: The only difference between this and elfstab_build_psymtabs is
2181 the call to install_minimal_symbols for elf. If the differences are
2182 really that small, the code should be shared. */
2184 /* Scan and build partial symbols for an coff symbol file.
2185 The coff file has already been processed to get its minimal symbols.
2187 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2190 OBJFILE is the object file we are reading symbols from.
2191 ADDR is the address relative to which the symbols are (e.g.
2192 the base address of the text segment).
2193 MAINLINE is true if we are reading the main symbol
2194 table (as opposed to a shared lib or dynamically loaded file).
2195 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2197 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2198 .stabstr section exists.
2200 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2201 adjusted for coff details. */
2204 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2205 staboffset
, stabsize
,
2206 stabstroffset
, stabstrsize
)
2207 struct objfile
*objfile
;
2208 struct section_offsets
*section_offsets
;
2210 file_ptr staboffset
;
2211 unsigned int stabsize
;
2212 file_ptr stabstroffset
;
2213 unsigned int stabstrsize
;
2216 bfd
*sym_bfd
= objfile
->obfd
;
2217 char *name
= bfd_get_filename (sym_bfd
);
2218 struct dbx_symfile_info
*info
;
2220 /* There is already a dbx_symfile_info allocated by our caller.
2221 It might even contain some info from the coff symtab to help us. */
2222 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2224 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2225 if (!DBX_TEXT_SECT (objfile
))
2226 error ("Can't find .text section in symbol file");
2228 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2229 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2230 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2231 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2232 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2234 if (stabstrsize
> bfd_get_size (sym_bfd
))
2235 error ("ridiculous string table size: %d bytes", stabstrsize
);
2236 DBX_STRINGTAB (objfile
) = (char *)
2237 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2239 /* Now read in the string table in one big gulp. */
2241 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2243 perror_with_name (name
);
2244 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2245 if (val
!= stabstrsize
)
2246 perror_with_name (name
);
2248 stabsread_new_init ();
2249 buildsym_new_init ();
2250 free_header_files ();
2251 init_header_files ();
2253 processing_acc_compilation
= 1;
2255 /* In a coff file, we've already installed the minimal symbols that came
2256 from the coff (non-stab) symbol table, so always act like an
2257 incremental load here. */
2258 dbx_symfile_read (objfile
, section_offsets
, 0);
2261 /* Scan and build partial symbols for an ELF symbol file.
2262 This ELF file has already been processed to get its minimal symbols,
2263 and any DWARF symbols that were in it.
2265 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2268 OBJFILE is the object file we are reading symbols from.
2269 ADDR is the address relative to which the symbols are (e.g.
2270 the base address of the text segment).
2271 MAINLINE is true if we are reading the main symbol
2272 table (as opposed to a shared lib or dynamically loaded file).
2273 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2275 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2276 .stabstr section exists.
2278 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2279 adjusted for elf details. */
2282 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2283 staboffset
, stabsize
,
2284 stabstroffset
, stabstrsize
)
2285 struct objfile
*objfile
;
2286 struct section_offsets
*section_offsets
;
2288 file_ptr staboffset
;
2289 unsigned int stabsize
;
2290 file_ptr stabstroffset
;
2291 unsigned int stabstrsize
;
2294 bfd
*sym_bfd
= objfile
->obfd
;
2295 char *name
= bfd_get_filename (sym_bfd
);
2296 struct dbx_symfile_info
*info
;
2298 /* There is already a dbx_symfile_info allocated by our caller.
2299 It might even contain some info from the ELF symtab to help us. */
2300 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2302 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2303 if (!DBX_TEXT_SECT (objfile
))
2304 error ("Can't find .text section in symbol file");
2306 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2307 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2308 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2309 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2310 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2312 if (stabstrsize
> bfd_get_size (sym_bfd
))
2313 error ("ridiculous string table size: %d bytes", stabstrsize
);
2314 DBX_STRINGTAB (objfile
) = (char *)
2315 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2317 /* Now read in the string table in one big gulp. */
2319 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2321 perror_with_name (name
);
2322 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2323 if (val
!= stabstrsize
)
2324 perror_with_name (name
);
2326 stabsread_new_init ();
2327 buildsym_new_init ();
2328 free_header_files ();
2329 init_header_files ();
2330 install_minimal_symbols (objfile
);
2332 processing_acc_compilation
= 1;
2334 /* In an elf file, we've already installed the minimal symbols that came
2335 from the elf (non-stab) symbol table, so always act like an
2336 incremental load here. */
2337 dbx_symfile_read (objfile
, section_offsets
, 0);
2340 /* Scan and build partial symbols for a file with special sections for stabs
2341 and stabstrings. The file has already been processed to get its minimal
2342 symbols, and any other symbols that might be necessary to resolve GSYMs.
2344 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2347 OBJFILE is the object file we are reading symbols from.
2348 ADDR is the address relative to which the symbols are (e.g. the base address
2349 of the text segment).
2350 MAINLINE is true if we are reading the main symbol table (as opposed to a
2351 shared lib or dynamically loaded file).
2352 STAB_NAME is the name of the section that contains the stabs.
2353 STABSTR_NAME is the name of the section that contains the stab strings.
2355 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2358 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2360 struct objfile
*objfile
;
2361 struct section_offsets
*section_offsets
;
2367 bfd
*sym_bfd
= objfile
->obfd
;
2368 char *name
= bfd_get_filename (sym_bfd
);
2370 asection
*stabstrsect
;
2372 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2373 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2379 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2380 stab_name
, stabstr_name
);
2382 DBX_SYMFILE_INFO (objfile
) = (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2383 memset (DBX_SYMFILE_INFO (objfile
), 0, sizeof (struct dbx_symfile_info
));
2385 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2386 if (!DBX_TEXT_SECT (objfile
))
2387 error ("Can't find .text section in symbol file");
2389 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2390 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2391 / DBX_SYMBOL_SIZE (objfile
);
2392 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2393 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2395 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2396 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2397 DBX_STRINGTAB (objfile
) = (char *)
2398 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2400 /* Now read in the string table in one big gulp. */
2402 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2403 stabstrsect
, /* bfd section */
2404 DBX_STRINGTAB (objfile
), /* input buffer */
2405 0, /* offset into section */
2406 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2409 perror_with_name (name
);
2411 stabsread_new_init ();
2412 buildsym_new_init ();
2413 free_header_files ();
2414 init_header_files ();
2415 install_minimal_symbols (objfile
);
2417 /* Now, do an incremental load */
2419 processing_acc_compilation
= 1;
2420 dbx_symfile_read (objfile
, section_offsets
, 0);
2423 /* Scan and build partial symbols for a PA symbol file.
2424 This PA file has already been processed to get its minimal symbols.
2426 OBJFILE is the object file we are reading symbols from.
2427 ADDR is the address relative to which the symbols are (e.g.
2428 the base address of the text segment).
2429 MAINLINE is true if we are reading the main symbol
2430 table (as opposed to a shared lib or dynamically loaded file).
2435 pastab_build_psymtabs (objfile
, section_offsets
, mainline
)
2436 struct objfile
*objfile
;
2437 struct section_offsets
*section_offsets
;
2440 free_header_files ();
2441 init_header_files ();
2443 /* This is needed to debug objects assembled with gas2. */
2444 processing_acc_compilation
= 1;
2446 /* In a PA file, we've already installed the minimal symbols that came
2447 from the PA (non-stab) symbol table, so always act like an
2448 incremental load here. */
2450 dbx_symfile_read (objfile
, section_offsets
, mainline
);
2453 /* Parse the user's idea of an offset for dynamic linking, into our idea
2454 of how to represent it for fast symbol reading. */
2456 static struct section_offsets
*
2457 dbx_symfile_offsets (objfile
, addr
)
2458 struct objfile
*objfile
;
2461 struct section_offsets
*section_offsets
;
2464 objfile
->num_sections
= SECT_OFF_MAX
;
2465 section_offsets
= (struct section_offsets
*)
2466 obstack_alloc (&objfile
-> psymbol_obstack
,
2467 sizeof (struct section_offsets
)
2468 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2470 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2471 ANOFFSET (section_offsets
, i
) = addr
;
2473 return section_offsets
;
2476 static struct sym_fns aout_sym_fns
=
2478 bfd_target_aout_flavour
,
2479 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2480 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2481 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2482 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2483 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2484 NULL
/* next: pointer to next struct sym_fns */
2488 _initialize_dbxread ()
2490 add_symtab_fns(&aout_sym_fns
);