1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 */
36 #include "gdb_string.h"
38 #if defined(USG) || defined(__CYGNUSCLIB__)
39 #include <sys/types.h>
47 #include "breakpoint.h"
50 #include "gdbcore.h" /* for bfd stuff */
51 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
55 #include "stabsread.h"
56 #include "gdb-stabs.h"
58 #include "language.h" /* Needed inside partial-stab.h */
59 #include "complaints.h"
61 #include "aout/aout64.h"
62 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
65 /* We put a pointer to this structure in the read_symtab_private field
70 /* Offset within the file symbol table of first local symbol for this
75 /* Length (in bytes) of the section of the symbol table devoted to
76 this file's symbols (actually, the section bracketed may contain
77 more than just this file's symbols). If ldsymlen is 0, the only
78 reason for this thing's existence is the dependency list. Nothing
79 else will happen when it is read in. */
83 /* The size of each symbol in the symbol file (in external form). */
87 /* Further information needed to locate the symbols if they are in
92 int file_string_offset
;
95 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
96 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
97 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
98 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
99 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
100 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
101 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->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 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
149 to the function start address. */
151 static int block_address_function_relative
= 0;
153 /* The lowest text address we have yet encountered. This is needed
154 because in an a.out file, there is no header field which tells us
155 what address the program is actually going to be loaded at, so we
156 need to make guesses based on the symbols (which *are* relocated to
157 reflect the address it will be loaded at). */
158 static CORE_ADDR lowest_text_address
;
160 /* Complaints about the symbols we have encountered. */
162 struct complaint lbrac_complaint
=
163 {"bad block start address patched", 0, 0};
165 struct complaint string_table_offset_complaint
=
166 {"bad string table offset in symbol %d", 0, 0};
168 struct complaint unknown_symtype_complaint
=
169 {"unknown symbol type %s", 0, 0};
171 struct complaint unknown_symchar_complaint
=
172 {"unknown symbol descriptor `%c'", 0, 0};
174 struct complaint lbrac_rbrac_complaint
=
175 {"block start larger than block end", 0, 0};
177 struct complaint lbrac_unmatched_complaint
=
178 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
180 struct complaint lbrac_mismatch_complaint
=
181 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
183 struct complaint repeated_header_complaint
=
184 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
186 struct complaint unclaimed_bincl_complaint
=
187 {"N_BINCL %s not in entries for any file, at symtab pos %d", 0, 0};
189 /* During initial symbol readin, we need to have a structure to keep
190 track of which psymtabs have which bincls in them. This structure
191 is used during readin to setup the list of dependencies within each
192 partial symbol table. */
194 struct header_file_location
196 char *name
; /* Name of header file */
197 int instance
; /* See above */
198 struct partial_symtab
*pst
; /* Partial symtab that has the
199 BINCL/EINCL defs for this file */
202 /* The actual list and controling variables */
203 static struct header_file_location
*bincl_list
, *next_bincl
;
204 static int bincls_allocated
;
206 /* Local function prototypes */
209 process_now
PARAMS ((struct objfile
*));
212 free_header_files
PARAMS ((void));
215 init_header_files
PARAMS ((void));
218 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
221 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
224 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
227 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
228 struct objfile
*objfile
));
231 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
235 free_bincl_list
PARAMS ((struct objfile
*));
237 static struct partial_symtab
*
238 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
241 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
244 init_bincl_list
PARAMS ((int, struct objfile
*));
247 dbx_next_symbol_text
PARAMS ((struct objfile
*));
250 fill_symbuf
PARAMS ((bfd
*));
253 dbx_symfile_init
PARAMS ((struct objfile
*));
256 dbx_new_init
PARAMS ((struct objfile
*));
259 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
262 dbx_symfile_finish
PARAMS ((struct objfile
*));
265 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
268 add_new_header_file
PARAMS ((char *, int));
271 add_old_header_file
PARAMS ((char *, int));
274 add_this_object_header_file
PARAMS ((int));
276 /* Free up old header file tables */
281 if (this_object_header_files
)
283 free ((PTR
)this_object_header_files
);
284 this_object_header_files
= NULL
;
286 n_allocated_this_object_header_files
= 0;
289 /* Allocate new header file tables */
294 n_allocated_this_object_header_files
= 10;
295 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
298 /* Add header file number I for this object file
299 at the next successive FILENUM. */
302 add_this_object_header_file (i
)
305 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
307 n_allocated_this_object_header_files
*= 2;
308 this_object_header_files
309 = (int *) xrealloc ((char *) this_object_header_files
,
310 n_allocated_this_object_header_files
* sizeof (int));
313 this_object_header_files
[n_this_object_header_files
++] = i
;
316 /* Add to this file an "old" header file, one already seen in
317 a previous object file. NAME is the header file's name.
318 INSTANCE is its instance code, to select among multiple
319 symbol tables for the same header file. */
322 add_old_header_file (name
, instance
)
326 register struct header_file
*p
= HEADER_FILES (current_objfile
);
329 for (i
= 0; i
< N_HEADER_FILES (current_objfile
); i
++)
330 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
332 add_this_object_header_file (i
);
335 complain (&repeated_header_complaint
, name
, symnum
);
338 /* Add to this file a "new" header file: definitions for its types follow.
339 NAME is the header file's name.
340 Most often this happens only once for each distinct header file,
341 but not necessarily. If it happens more than once, INSTANCE has
342 a different value each time, and references to the header file
343 use INSTANCE values to select among them.
345 dbx output contains "begin" and "end" markers for each new header file,
346 but at this level we just need to know which files there have been;
347 so we record the file when its "begin" is seen and ignore the "end". */
350 add_new_header_file (name
, instance
)
355 register struct header_file
*hfile
;
357 /* Make sure there is room for one more header file. */
359 i
= N_ALLOCATED_HEADER_FILES (current_objfile
);
361 if (N_HEADER_FILES (current_objfile
) == i
)
365 N_ALLOCATED_HEADER_FILES (current_objfile
) = 10;
366 HEADER_FILES (current_objfile
) = (struct header_file
*)
367 xmalloc (10 * sizeof (struct header_file
));
372 N_ALLOCATED_HEADER_FILES (current_objfile
) = i
;
373 HEADER_FILES (current_objfile
) = (struct header_file
*)
374 xrealloc ((char *) HEADER_FILES (current_objfile
),
375 (i
* sizeof (struct header_file
)));
379 /* Create an entry for this header file. */
381 i
= N_HEADER_FILES (current_objfile
)++;
382 hfile
= HEADER_FILES (current_objfile
) + i
;
383 hfile
->name
= savestring (name
, strlen(name
));
384 hfile
->instance
= instance
;
387 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
388 memset (hfile
->vector
, 0, 10 * sizeof (struct type
*));
390 add_this_object_header_file (i
);
394 static struct type
**
395 explicit_lookup_type (real_filenum
, index
)
396 int real_filenum
, index
;
398 register struct header_file
*f
= &HEADER_FILES (current_objfile
)[real_filenum
];
400 if (index
>= f
->length
)
403 f
->vector
= (struct type
**)
404 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
405 memset (&f
->vector
[f
->length
/ 2],
406 '\0', f
->length
* sizeof (struct type
*) / 2);
408 return &f
->vector
[index
];
413 record_minimal_symbol (name
, address
, type
, objfile
)
417 struct objfile
*objfile
;
419 enum minimal_symbol_type ms_type
;
421 asection
*bfd_section
;
427 section
= SECT_OFF_TEXT
;
428 bfd_section
= DBX_TEXT_SECTION (objfile
);
432 section
= SECT_OFF_DATA
;
433 bfd_section
= DBX_DATA_SECTION (objfile
);
437 section
= SECT_OFF_BSS
;
438 bfd_section
= DBX_BSS_SECTION (objfile
);
448 section
= SECT_OFF_DATA
;
449 bfd_section
= DBX_DATA_SECTION (objfile
);
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
;
457 bfd_section
= DBX_DATA_SECTION (objfile
);
464 ms_type
= mst_file_text
;
465 section
= SECT_OFF_TEXT
;
466 bfd_section
= DBX_TEXT_SECTION (objfile
);
469 ms_type
= mst_file_data
;
471 /* Check for __DYNAMIC, which is used by Sun shared libraries.
472 Record it as global even if it's local, not global, so
473 lookup_minimal_symbol can find it. We don't check symbol_leading_char
474 because for SunOS4 it always is '_'. */
475 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
478 /* Same with virtual function tables, both global and static. */
480 char *tempstring
= name
;
481 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
483 if (VTBL_PREFIX_P ((tempstring
)))
486 section
= SECT_OFF_DATA
;
487 bfd_section
= DBX_DATA_SECTION (objfile
);
490 ms_type
= mst_file_bss
;
491 section
= SECT_OFF_BSS
;
492 bfd_section
= DBX_BSS_SECTION (objfile
);
495 ms_type
= mst_unknown
;
501 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
502 && address
< lowest_text_address
)
503 lowest_text_address
= address
;
505 prim_record_minimal_symbol_and_info
506 (name
, address
, ms_type
, NULL
, section
, bfd_section
, objfile
);
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 sym_bfd
= objfile
->obfd
;
533 /* .o and .nlm files are relocatables with text, data and bss segs based at
534 0. This flag disables special (Solaris stabs-in-elf only) fixups for
535 symbols with a value of 0. */
537 symfile_relocatable
= bfd_get_file_flags (sym_bfd
) & HAS_RELOC
;
539 /* This is true for Solaris (and all other systems which put stabs
540 in sections, hopefully, since it would be silly to do things
541 differently from Solaris), and false for SunOS4 and other a.out
543 block_address_function_relative
=
544 ((0 == strncmp (bfd_get_target (sym_bfd
), "elf", 3))
545 || (0 == strncmp (bfd_get_target (sym_bfd
), "som", 3))
546 || (0 == strncmp (bfd_get_target (sym_bfd
), "coff", 4))
547 || (0 == strncmp (bfd_get_target (sym_bfd
), "pe", 2))
548 || (0 == strncmp (bfd_get_target (sym_bfd
), "nlm", 3)));
550 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
552 perror_with_name (objfile
->name
);
554 /* If we are reinitializing, or if we have never loaded syms yet, init */
556 || objfile
->global_psymbols
.size
== 0
557 || objfile
->static_psymbols
.size
== 0)
558 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
560 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
561 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
563 free_pending_blocks ();
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 DBX_TEXT_ADDR (objfile
),
574 DBX_TEXT_SIZE (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
);
625 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
627 /* Allocate struct to keep track of the symfile */
628 objfile
->sym_stab_info
= (PTR
)
629 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
630 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
632 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
633 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
634 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
636 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
637 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
638 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
640 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
642 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
644 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
646 error ("Can't find .text section in symbol file");
647 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
648 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
650 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
651 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
652 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
654 /* Read the string table and stash it away in the psymbol_obstack. It is
655 only needed as long as we need to expand psymbols into full symbols,
656 so when we blow away the psymbol the string table goes away as well.
657 Note that gdb used to use the results of attempting to malloc the
658 string table, based on the size it read, as a form of sanity check
659 for botched byte swapping, on the theory that a byte swapped string
660 table size would be so totally bogus that the malloc would fail. Now
661 that we put in on the psymbol_obstack, we can't do this since gdb gets
662 a fatal error (out of virtual memory) if the size is bogus. We can
663 however at least check to see if the size is less than the size of
664 the size field itself, or larger than the size of the entire file.
665 Note that all valid string tables have a size greater than zero, since
666 the bytes used to hold the size are included in the count. */
668 if (STRING_TABLE_OFFSET
== 0)
670 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
671 will never be zero, even when there is no string table. This
672 would appear to be a bug in bfd. */
673 DBX_STRINGTAB_SIZE (objfile
) = 0;
674 DBX_STRINGTAB (objfile
) = NULL
;
678 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
680 perror_with_name (name
);
682 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
683 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
686 perror_with_name (name
);
690 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
691 EOF if there is no string table, and attempting to read the size
692 from EOF will read zero bytes. */
693 DBX_STRINGTAB_SIZE (objfile
) = 0;
694 DBX_STRINGTAB (objfile
) = NULL
;
698 /* Read some data that would appear to be the string table size.
699 If there really is a string table, then it is probably the right
700 size. Byteswap if necessary and validate the size. Note that
701 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
702 random data that happened to be at STRING_TABLE_OFFSET, because
703 bfd can't tell us there is no string table, the sanity checks may
704 or may not catch this. */
705 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
707 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
708 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
709 error ("ridiculous string table size (%d bytes).",
710 DBX_STRINGTAB_SIZE (objfile
));
712 DBX_STRINGTAB (objfile
) =
713 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
714 DBX_STRINGTAB_SIZE (objfile
));
715 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
717 /* Now read in the string table in one big gulp. */
719 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
721 perror_with_name (name
);
722 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
724 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
725 perror_with_name (name
);
730 /* Perform any local cleanups required when we are done with a particular
731 objfile. I.E, we are in the process of discarding all symbol information
732 for an objfile, freeing up all memory held for it, and unlinking the
733 objfile struct from the global list of known objfiles. */
736 dbx_symfile_finish (objfile
)
737 struct objfile
*objfile
;
739 if (objfile
->sym_stab_info
!= NULL
)
741 if (HEADER_FILES (objfile
) != NULL
)
743 register int i
= N_HEADER_FILES (objfile
);
744 register struct header_file
*hfiles
= HEADER_FILES (objfile
);
748 free (hfiles
[i
].name
);
749 free (hfiles
[i
].vector
);
753 mfree (objfile
-> md
, objfile
->sym_stab_info
);
755 free_header_files ();
759 /* Buffer for reading the symbol table entries. */
760 static struct external_nlist symbuf
[4096];
761 static int symbuf_idx
;
762 static int symbuf_end
;
764 /* cont_elem is used for continuing information in cfront.
765 It saves information about which types need to be fixed up and
766 completed after all the stabs are read. */
769 /* sym and stabsstring for continuing information in cfront */
772 /* state dependancies (statics that must be preserved) */
776 int (*func
) (struct objfile
*, struct symbol
*, char *);
777 /* other state dependancies include:
778 (assumption is that these will not change since process_now FIXME!!)
785 static struct cont_elem
*cont_list
= 0;
786 static int cont_limit
= 0;
787 static int cont_count
= 0;
790 process_later (sym
, p
, f
)
793 int (*f
) (struct objfile
*, struct symbol
*, char *);
795 if (cont_count
>= cont_limit
- 1)
797 cont_limit
+= 32; /* chunk size */
798 cont_list
= (struct cont_elem
*) realloc (cont_list
,
799 cont_limit
* sizeof (struct cont_elem
));
801 error ("Virtual memory exhausted\n");
803 /* save state so we can process these stabs later */
804 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
805 cont_list
[cont_count
].sym_end
= symbuf_end
;
806 cont_list
[cont_count
].symnum
= symnum
;
807 cont_list
[cont_count
].sym
= sym
;
808 cont_list
[cont_count
].stabs
= p
;
809 cont_list
[cont_count
].func
= f
;
814 process_now (objfile
)
815 struct objfile
* objfile
;
818 /* save original state */
819 int save_symbuf_idx
= symbuf_idx
;
820 int save_symbuf_end
= symbuf_end
;
821 int save_symnum
= symnum
;
825 int (*func
) (struct objfile
*, struct symbol
*, char *);
827 for (i
=0; i
<cont_count
; i
++)
829 /* Set state as if we were parsing stabs strings
831 symbuf_idx
= cont_list
[i
].sym_idx
; /* statics used by gdb */
832 symbuf_end
= cont_list
[i
].sym_end
;
833 symnum
= cont_list
[i
].symnum
;
834 sym
= cont_list
[i
].sym
;
835 stabs
= cont_list
[i
].stabs
;
836 func
= cont_list
[i
].func
;
838 err
= (*func
) (objfile
, sym
, stabs
);
840 error ("Internal error: unable to resolve stab.\n");
842 /* restore original state */
843 symbuf_idx
= save_symbuf_idx
;
844 symbuf_end
= save_symbuf_end
;
845 symnum
= save_symnum
;
846 cont_count
=0; /* reset for next run */
850 /* Name of last function encountered. Used in Solaris to approximate
851 object file boundaries. */
852 static char *last_function_name
;
854 /* The address in memory of the string table of the object file we are
855 reading (which might not be the "main" object file, but might be a
856 shared library or some other dynamically loaded thing). This is
857 set by read_dbx_symtab when building psymtabs, and by
858 read_ofile_symtab when building symtabs, and is used only by
859 next_symbol_text. FIXME: If that is true, we don't need it when
860 building psymtabs, right? */
861 static char *stringtab_global
;
863 /* These variables are used to control fill_symbuf when the stabs
864 symbols are not contiguous (as may be the case when a COFF file is
865 linked using --split-by-reloc). */
866 static struct stab_section_list
*symbuf_sections
;
867 static unsigned int symbuf_left
;
868 static unsigned int symbuf_read
;
870 /* Refill the symbol table input buffer
871 and set the variables that control fetching entries from it.
872 Reports an error if no data available.
873 This function can read past the end of the symbol table
874 (into the string table) but this does no harm. */
877 fill_symbuf (sym_bfd
)
883 if (symbuf_sections
== NULL
)
884 count
= sizeof (symbuf
);
887 if (symbuf_left
<= 0)
889 file_ptr filepos
= symbuf_sections
->section
->filepos
;
890 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
891 perror_with_name (bfd_get_filename (sym_bfd
));
892 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
893 symbol_table_offset
= filepos
- symbuf_read
;
894 symbuf_sections
= symbuf_sections
->next
;
898 if (count
> sizeof (symbuf
))
899 count
= sizeof (symbuf
);
902 nbytes
= bfd_read ((PTR
)symbuf
, count
, 1, sym_bfd
);
904 perror_with_name (bfd_get_filename (sym_bfd
));
905 else if (nbytes
== 0)
906 error ("Premature end of file reading symbol table");
907 symbuf_end
= nbytes
/ symbol_size
;
909 symbuf_left
-= nbytes
;
910 symbuf_read
+= nbytes
;
913 #define SWAP_SYMBOL(symp, abfd) \
915 (symp)->n_strx = bfd_h_get_32(abfd, \
916 (unsigned char *)&(symp)->n_strx); \
917 (symp)->n_desc = bfd_h_get_16 (abfd, \
918 (unsigned char *)&(symp)->n_desc); \
919 (symp)->n_value = bfd_h_get_32 (abfd, \
920 (unsigned char *)&(symp)->n_value); \
923 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
925 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
926 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
927 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
928 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
931 /* Invariant: The symbol pointed to by symbuf_idx is the first one
932 that hasn't been swapped. Swap the symbol at the same time
933 that symbuf_idx is incremented. */
935 /* dbx allows the text of a symbol name to be continued into the
936 next symbol name! When such a continuation is encountered
937 (a \ at the end of the text of a name)
938 call this function to get the continuation. */
941 dbx_next_symbol_text (objfile
)
942 struct objfile
*objfile
;
944 struct internal_nlist nlist
;
946 if (symbuf_idx
== symbuf_end
)
947 fill_symbuf (symfile_bfd
);
950 INTERNALIZE_SYMBOL(nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
951 OBJSTAT (objfile
, n_stabs
++);
955 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
958 /* Initialize the list of bincls to contain none and have some
962 init_bincl_list (number
, objfile
)
964 struct objfile
*objfile
;
966 bincls_allocated
= number
;
967 next_bincl
= bincl_list
= (struct header_file_location
*)
968 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
971 /* Add a bincl to the list. */
974 add_bincl_to_list (pst
, name
, instance
)
975 struct partial_symtab
*pst
;
979 if (next_bincl
>= bincl_list
+ bincls_allocated
)
981 int offset
= next_bincl
- bincl_list
;
982 bincls_allocated
*= 2;
983 bincl_list
= (struct header_file_location
*)
984 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
985 bincls_allocated
* sizeof (struct header_file_location
));
986 next_bincl
= bincl_list
+ offset
;
988 next_bincl
->pst
= pst
;
989 next_bincl
->instance
= instance
;
990 next_bincl
++->name
= name
;
993 /* Given a name, value pair, find the corresponding
994 bincl in the list. Return the partial symtab associated
995 with that header_file_location. */
997 static struct partial_symtab
*
998 find_corresponding_bincl_psymtab (name
, instance
)
1002 struct header_file_location
*bincl
;
1004 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1005 if (bincl
->instance
== instance
1006 && STREQ (name
, bincl
->name
))
1009 complain (&repeated_header_complaint
, name
, symnum
);
1010 return (struct partial_symtab
*) 0;
1013 /* Free the storage allocated for the bincl list. */
1016 free_bincl_list (objfile
)
1017 struct objfile
*objfile
;
1019 mfree (objfile
-> md
, (PTR
)bincl_list
);
1020 bincls_allocated
= 0;
1023 /* Scan a SunOs dynamic symbol table for symbols of interest and
1024 add them to the minimal symbol table. */
1027 read_dbx_dynamic_symtab (section_offsets
, objfile
)
1028 struct section_offsets
*section_offsets
;
1029 struct objfile
*objfile
;
1031 bfd
*abfd
= objfile
->obfd
;
1032 struct cleanup
*back_to
;
1042 CORE_ADDR sym_value
;
1045 /* Check that the symbol file has dynamic symbols that we know about.
1046 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1047 on a sun4 host (and vice versa) and bfd is not configured
1048 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1049 so we ignore the dynamic symbols in this case. */
1050 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
1051 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
1052 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1055 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1056 if (dynsym_size
< 0)
1059 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1060 back_to
= make_cleanup (free
, dynsyms
);
1062 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1063 if (dynsym_count
< 0)
1065 do_cleanups (back_to
);
1069 /* Enter dynamic symbols into the minimal symbol table
1070 if this is a stripped executable. */
1071 if (bfd_get_symcount (abfd
) <= 0)
1074 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1076 asymbol
*sym
= *symptr
;
1080 sec
= bfd_get_section (sym
);
1082 /* BFD symbols are section relative. */
1083 sym_value
= sym
->value
+ sec
->vma
;
1085 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1087 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1090 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1092 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1095 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1097 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1103 if (sym
->flags
& BSF_GLOBAL
)
1106 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1111 /* Symbols from shared libraries have a dynamic relocation entry
1112 that points to the associated slot in the procedure linkage table.
1113 We make a mininal symbol table entry with type mst_solib_trampoline
1114 at the address in the procedure linkage table. */
1115 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1116 if (dynrel_size
< 0)
1118 do_cleanups (back_to
);
1122 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1123 make_cleanup (free
, dynrels
);
1125 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1126 if (dynrel_count
< 0)
1128 do_cleanups (back_to
);
1132 for (counter
= 0, relptr
= dynrels
;
1133 counter
< dynrel_count
;
1134 counter
++, relptr
++)
1136 arelent
*rel
= *relptr
;
1138 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1140 switch (bfd_get_arch (abfd
))
1142 case bfd_arch_sparc
:
1143 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1147 /* `16' is the type BFD produces for a jump table relocation. */
1148 if (rel
->howto
->type
!= 16)
1151 /* Adjust address in the jump table to point to
1152 the start of the bsr instruction. */
1159 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1160 prim_record_minimal_symbol (name
, address
, mst_solib_trampoline
,
1164 do_cleanups (back_to
);
1167 /* Given pointers to an a.out symbol table in core containing dbx
1168 style data, setup partial_symtab's describing each source file for
1169 which debugging information is available.
1170 SYMFILE_NAME is the name of the file we are reading from
1171 and SECTION_OFFSETS is the set of offsets for the various sections
1172 of the file (a set of zeros if the mainline program). */
1175 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1176 struct section_offsets
*section_offsets
;
1177 struct objfile
*objfile
;
1178 CORE_ADDR text_addr
;
1181 register struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1182 struct internal_nlist nlist
;
1184 register char *namestring
;
1186 int past_first_source_file
= 0;
1187 CORE_ADDR last_o_file_start
= 0;
1188 CORE_ADDR last_function_start
= 0;
1189 struct cleanup
*back_to
;
1191 int textlow_not_set
;
1193 /* Current partial symtab */
1194 struct partial_symtab
*pst
;
1196 /* List of current psymtab's include files */
1197 char **psymtab_include_list
;
1198 int includes_allocated
;
1201 /* Index within current psymtab dependency list */
1202 struct partial_symtab
**dependency_list
;
1203 int dependencies_used
, dependencies_allocated
;
1205 /* FIXME. We probably want to change stringtab_global rather than add this
1206 while processing every symbol entry. FIXME. */
1207 file_string_table_offset
= 0;
1208 next_file_string_table_offset
= 0;
1210 stringtab_global
= DBX_STRINGTAB (objfile
);
1212 pst
= (struct partial_symtab
*) 0;
1214 includes_allocated
= 30;
1216 psymtab_include_list
= (char **) alloca (includes_allocated
*
1219 dependencies_allocated
= 30;
1220 dependencies_used
= 0;
1222 (struct partial_symtab
**) alloca (dependencies_allocated
*
1223 sizeof (struct partial_symtab
*));
1225 /* Init bincl list */
1226 init_bincl_list (20, objfile
);
1227 back_to
= make_cleanup (free_bincl_list
, objfile
);
1229 last_source_file
= NULL
;
1231 lowest_text_address
= (CORE_ADDR
)-1;
1233 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1234 abfd
= objfile
->obfd
;
1235 symbuf_end
= symbuf_idx
= 0;
1236 next_symbol_text_func
= dbx_next_symbol_text
;
1237 textlow_not_set
= 1;
1239 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1241 /* Get the symbol for this run and pull out some info */
1242 QUIT
; /* allow this to be interruptable */
1243 if (symbuf_idx
== symbuf_end
)
1245 bufp
= &symbuf
[symbuf_idx
++];
1248 * Special case to speed up readin.
1250 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1253 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1254 OBJSTAT (objfile
, n_stabs
++);
1256 /* Ok. There is a lot of code duplicated in the rest of this
1257 switch statement (for efficiency reasons). Since I don't
1258 like duplicating code, I will do my penance here, and
1259 describe the code which is duplicated:
1261 *) The assignment to namestring.
1262 *) The call to strchr.
1263 *) The addition of a partial symbol the the two partial
1264 symbol lists. This last is a large section of code, so
1265 I've imbedded it in the following macro.
1268 /* Set namestring based on nlist. If the string table index is invalid,
1269 give a fake name, and print a single error message per symbol file read,
1270 rather than abort the symbol reading or flood the user with messages. */
1272 /*FIXME: Too many adds and indirections in here for the inner loop. */
1273 #define SET_NAMESTRING()\
1274 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1275 DBX_STRINGTAB_SIZE (objfile)) { \
1276 complain (&string_table_offset_complaint, symnum); \
1277 namestring = "<bad string table offset>"; \
1279 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1280 DBX_STRINGTAB (objfile)
1282 #define CUR_SYMBOL_TYPE nlist.n_type
1283 #define CUR_SYMBOL_VALUE nlist.n_value
1284 #define CUR_SYMBOL_STRX nlist.n_strx
1285 #define DBXREAD_ONLY
1286 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1287 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1288 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1289 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1291 #include "partial-stab.h"
1294 /* If there's stuff to be cleaned up, clean it up. */
1295 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1296 /*FIXME, does this have a bug at start address 0? */
1297 && last_o_file_start
1298 && objfile
-> ei
.entry_point
< nlist
.n_value
1299 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1301 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1302 objfile
-> ei
.entry_file_highpc
= nlist
.n_value
;
1307 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1308 symnum
* symbol_size
,
1309 (lowest_text_address
== (CORE_ADDR
)-1
1310 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1311 : lowest_text_address
)
1313 dependency_list
, dependencies_used
, textlow_not_set
);
1316 do_cleanups (back_to
);
1319 /* Allocate and partially fill a partial symtab. It will be
1320 completely filled at the end of the symbol list.
1322 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1323 is the address relative to which its symbols are (incremental) or 0
1327 struct partial_symtab
*
1328 start_psymtab (objfile
, section_offsets
,
1329 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1330 struct objfile
*objfile
;
1331 struct section_offsets
*section_offsets
;
1335 struct partial_symbol
**global_syms
;
1336 struct partial_symbol
**static_syms
;
1338 struct partial_symtab
*result
=
1339 start_psymtab_common(objfile
, section_offsets
,
1340 filename
, textlow
, global_syms
, static_syms
);
1342 result
->read_symtab_private
= (char *)
1343 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1344 LDSYMOFF(result
) = ldsymoff
;
1345 result
->read_symtab
= dbx_psymtab_to_symtab
;
1346 SYMBOL_SIZE(result
) = symbol_size
;
1347 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1348 STRING_OFFSET(result
) = string_table_offset
;
1349 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1351 /* If we're handling an ELF file, drag some section-relocation info
1352 for this source file out of the ELF symbol table, to compensate for
1353 Sun brain death. This replaces the section_offsets in this psymtab,
1355 elfstab_offset_sections (objfile
, result
);
1357 /* Deduce the source language from the filename for this psymtab. */
1358 psymtab_language
= deduce_language_from_filename (filename
);
1363 /* Close off the current usage of PST.
1364 Returns PST or NULL if the partial symtab was empty and thrown away.
1366 FIXME: List variables and peculiarities of same. */
1368 struct partial_symtab
*
1369 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1370 capping_text
, dependency_list
, number_dependencies
, textlow_not_set
)
1371 struct partial_symtab
*pst
;
1372 char **include_list
;
1374 int capping_symbol_offset
;
1375 CORE_ADDR capping_text
;
1376 struct partial_symtab
**dependency_list
;
1377 int number_dependencies
;
1378 int textlow_not_set
;
1381 struct objfile
*objfile
= pst
-> objfile
;
1383 if (capping_symbol_offset
!= -1)
1384 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1385 pst
->texthigh
= capping_text
;
1387 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1388 /* Under Solaris, the N_SO symbols always have a value of 0,
1389 instead of the usual address of the .o file. Therefore,
1390 we have to do some tricks to fill in texthigh and textlow.
1391 The first trick is in partial-stab.h: if we see a static
1392 or global function, and the textlow for the current pst
1393 is not set (ie: textlow_not_set), then we use that function's
1394 address for the textlow of the pst. */
1396 /* Now, to fill in texthigh, we remember the last function seen
1397 in the .o file (also in partial-stab.h). Also, there's a hack in
1398 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1399 to here via the misc_info field. Therefore, we can fill in
1400 a reliable texthigh by taking the address plus size of the
1401 last function in the file. */
1403 if (pst
->texthigh
== 0 && last_function_name
)
1407 struct minimal_symbol
*minsym
;
1409 p
= strchr (last_function_name
, ':');
1411 p
= last_function_name
;
1412 n
= p
- last_function_name
;
1414 strncpy (p
, last_function_name
, n
);
1417 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1420 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
)
1421 + (long) MSYMBOL_INFO (minsym
);
1423 last_function_name
= NULL
;
1426 /* this test will be true if the last .o file is only data */
1427 if (textlow_not_set
)
1428 pst
->textlow
= pst
->texthigh
;
1431 struct partial_symtab
*p1
;
1433 /* If we know our own starting text address, then walk through all other
1434 psymtabs for this objfile, and if any didn't know their ending text
1435 address, set it to our starting address. Take care to not set our
1436 own ending address to our starting address, nor to set addresses on
1437 `dependency' files that have both textlow and texthigh zero. */
1439 ALL_OBJFILE_PSYMTABS (objfile
, p1
)
1441 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
)
1443 p1
->texthigh
= pst
->textlow
;
1444 /* if this file has only data, then make textlow match texthigh */
1445 if (p1
->textlow
== 0)
1446 p1
->textlow
= p1
->texthigh
;
1451 /* End of kludge for patching Solaris textlow and texthigh. */
1452 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1454 pst
->n_global_syms
=
1455 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1456 pst
->n_static_syms
=
1457 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1459 pst
->number_of_dependencies
= number_dependencies
;
1460 if (number_dependencies
)
1462 pst
->dependencies
= (struct partial_symtab
**)
1463 obstack_alloc (&objfile
->psymbol_obstack
,
1464 number_dependencies
* sizeof (struct partial_symtab
*));
1465 memcpy (pst
->dependencies
, dependency_list
,
1466 number_dependencies
* sizeof (struct partial_symtab
*));
1469 pst
->dependencies
= 0;
1471 for (i
= 0; i
< num_includes
; i
++)
1473 struct partial_symtab
*subpst
=
1474 allocate_psymtab (include_list
[i
], objfile
);
1476 subpst
->section_offsets
= pst
->section_offsets
;
1477 subpst
->read_symtab_private
=
1478 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1479 sizeof (struct symloc
));
1483 subpst
->texthigh
= 0;
1485 /* We could save slight bits of space by only making one of these,
1486 shared by the entire set of include files. FIXME-someday. */
1487 subpst
->dependencies
= (struct partial_symtab
**)
1488 obstack_alloc (&objfile
->psymbol_obstack
,
1489 sizeof (struct partial_symtab
*));
1490 subpst
->dependencies
[0] = pst
;
1491 subpst
->number_of_dependencies
= 1;
1493 subpst
->globals_offset
=
1494 subpst
->n_global_syms
=
1495 subpst
->statics_offset
=
1496 subpst
->n_static_syms
= 0;
1500 subpst
->read_symtab
= pst
->read_symtab
;
1503 sort_pst_symbols (pst
);
1505 /* If there is already a psymtab or symtab for a file of this name, remove it.
1506 (If there is a symtab, more drastic things also happen.)
1507 This happens in VxWorks. */
1508 free_named_symtabs (pst
->filename
);
1510 if (num_includes
== 0
1511 && number_dependencies
== 0
1512 && pst
->n_global_syms
== 0
1513 && pst
->n_static_syms
== 0)
1515 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1516 it is on the obstack, but we can forget to chain it on the list. */
1517 /* Empty psymtabs happen as a result of header files which don't have
1518 any symbols in them. There can be a lot of them. But this check
1519 is wrong, in that a psymtab with N_SLINE entries but nothing else
1520 is not empty, but we don't realize that. Fixing that without slowing
1521 things down might be tricky. */
1522 struct partial_symtab
*prev_pst
;
1524 /* First, snip it out of the psymtab chain */
1526 if (pst
->objfile
->psymtabs
== pst
)
1527 pst
->objfile
->psymtabs
= pst
->next
;
1529 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1530 if (prev_pst
->next
== pst
)
1531 prev_pst
->next
= pst
->next
;
1533 /* Next, put it on a free list for recycling */
1535 pst
->next
= pst
->objfile
->free_psymtabs
;
1536 pst
->objfile
->free_psymtabs
= pst
;
1538 /* Indicate that psymtab was thrown away. */
1539 pst
= (struct partial_symtab
*)NULL
;
1545 dbx_psymtab_to_symtab_1 (pst
)
1546 struct partial_symtab
*pst
;
1548 struct cleanup
*old_chain
;
1556 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1561 /* Read in all partial symtabs on which this one is dependent */
1562 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1563 if (!pst
->dependencies
[i
]->readin
)
1565 /* Inform about additional files that need to be read in. */
1568 fputs_filtered (" ", gdb_stdout
);
1570 fputs_filtered ("and ", gdb_stdout
);
1572 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1573 wrap_here (""); /* Flush output */
1574 gdb_flush (gdb_stdout
);
1576 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1579 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1581 /* Init stuff necessary for reading in symbols */
1584 old_chain
= make_cleanup (really_free_pendings
, 0);
1585 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1586 symbol_size
= SYMBOL_SIZE (pst
);
1588 /* Read in this file's symbols */
1589 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1590 read_ofile_symtab (pst
);
1591 sort_symtab_syms (pst
->symtab
);
1593 do_cleanups (old_chain
);
1599 /* Read in all of the symbols for a given psymtab for real.
1600 Be verbose about it if the user wants that. */
1603 dbx_psymtab_to_symtab (pst
)
1604 struct partial_symtab
*pst
;
1613 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1618 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1620 /* Print the message now, before reading the string table,
1621 to avoid disconcerting pauses. */
1624 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1625 gdb_flush (gdb_stdout
);
1628 sym_bfd
= pst
->objfile
->obfd
;
1630 next_symbol_text_func
= dbx_next_symbol_text
;
1632 dbx_psymtab_to_symtab_1 (pst
);
1634 /* Match with global symbols. This only needs to be done once,
1635 after all of the symtabs and dependencies have been read in. */
1636 scan_file_globals (pst
->objfile
);
1638 /* Finish up the debug error message. */
1640 printf_filtered ("done.\n");
1644 /* Read in a defined section of a specific object file's symbols. */
1647 read_ofile_symtab (pst
)
1648 struct partial_symtab
*pst
;
1650 register char *namestring
;
1651 register struct external_nlist
*bufp
;
1652 struct internal_nlist nlist
;
1654 unsigned max_symnum
;
1656 struct objfile
*objfile
;
1657 int sym_offset
; /* Offset to start of symbols to read */
1658 int sym_size
; /* Size of symbols to read */
1659 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1660 int text_size
; /* Size of text segment for symbols */
1661 struct section_offsets
*section_offsets
;
1663 objfile
= pst
->objfile
;
1664 sym_offset
= LDSYMOFF(pst
);
1665 sym_size
= LDSYMLEN(pst
);
1666 text_offset
= pst
->textlow
;
1667 text_size
= pst
->texthigh
- pst
->textlow
;
1668 section_offsets
= pst
->section_offsets
;
1670 current_objfile
= objfile
;
1671 subfile_stack
= NULL
;
1673 stringtab_global
= DBX_STRINGTAB (objfile
);
1674 last_source_file
= NULL
;
1676 abfd
= objfile
->obfd
;
1677 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1678 symbuf_end
= symbuf_idx
= 0;
1680 /* It is necessary to actually read one symbol *before* the start
1681 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1682 occurs before the N_SO symbol.
1684 Detecting this in read_dbx_symtab
1685 would slow down initial readin, so we look for it here instead. */
1686 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1688 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1690 bufp
= &symbuf
[symbuf_idx
++];
1691 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1692 OBJSTAT (objfile
, n_stabs
++);
1696 processing_gcc_compilation
= 0;
1697 if (nlist
.n_type
== N_TEXT
)
1699 const char *tempstring
= namestring
;
1701 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1702 processing_gcc_compilation
= 1;
1703 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1704 processing_gcc_compilation
= 2;
1705 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1707 if (STREQN (tempstring
, "__gnu_compiled", 14))
1708 processing_gcc_compilation
= 2;
1711 /* Try to select a C++ demangling based on the compilation unit
1714 if (processing_gcc_compilation
)
1716 if (AUTO_DEMANGLING
)
1718 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1724 /* The N_SO starting this symtab is the first symbol, so we
1725 better not check the symbol before it. I'm not this can
1726 happen, but it doesn't hurt to check for it. */
1727 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1728 processing_gcc_compilation
= 0;
1731 if (symbuf_idx
== symbuf_end
)
1733 bufp
= &symbuf
[symbuf_idx
];
1734 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
1735 error("First symbol in segment of executable not a source symbol");
1737 max_symnum
= sym_size
/ symbol_size
;
1740 symnum
< max_symnum
;
1743 QUIT
; /* Allow this to be interruptable */
1744 if (symbuf_idx
== symbuf_end
)
1746 bufp
= &symbuf
[symbuf_idx
++];
1747 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1748 OBJSTAT (objfile
, n_stabs
++);
1750 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
1754 if (type
& N_STAB
) {
1755 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
1756 namestring
, section_offsets
, objfile
);
1758 /* We skip checking for a new .o or -l file; that should never
1759 happen in this routine. */
1760 else if (type
== N_TEXT
)
1762 /* I don't think this code will ever be executed, because
1763 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1764 the N_SO symbol which starts this source file.
1765 However, there is no reason not to accept
1766 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1768 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1769 processing_gcc_compilation
= 1;
1770 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1771 processing_gcc_compilation
= 2;
1773 if (AUTO_DEMANGLING
)
1775 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1778 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1779 || type
== (unsigned char)N_NBTEXT
1781 /* Global symbol: see if we came across a dbx defintion for
1782 a corresponding symbol. If so, store the value. Remove
1783 syms from the chain when their values are stored, but
1784 search the whole chain, as there may be several syms from
1785 different files with the same name. */
1786 /* This is probably not true. Since the files will be read
1787 in one at a time, each reference to a global symbol will
1788 be satisfied in each file as it appears. So we skip this
1794 current_objfile
= NULL
;
1796 /* In a Solaris elf file, this variable, which comes from the
1797 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1798 which comes from pst->textlow is correct. */
1799 if (last_source_start_addr
== 0)
1800 last_source_start_addr
= text_offset
;
1802 /* In reordered executables last_source_start_addr may not be the
1803 lower bound for this symtab, instead use text_offset which comes
1804 from pst->textlow which is correct. */
1805 if (last_source_start_addr
> text_offset
)
1806 last_source_start_addr
= text_offset
;
1808 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1810 /* Process items which we had to "process_later" due to dependancies
1812 process_now (objfile
);
1818 /* This handles a single symbol from the symbol-file, building symbols
1819 into a GDB symtab. It takes these arguments and an implicit argument.
1821 TYPE is the type field of the ".stab" symbol entry.
1822 DESC is the desc field of the ".stab" entry.
1823 VALU is the value field of the ".stab" entry.
1824 NAME is the symbol name, in our address space.
1825 SECTION_OFFSETS is a set of amounts by which the sections of this object
1826 file were relocated when it was loaded into memory.
1827 All symbols that refer
1828 to memory locations need to be offset by these amounts.
1829 OBJFILE is the object file from which we are reading symbols.
1830 It is used in end_symtab. */
1833 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1837 struct section_offsets
*section_offsets
;
1838 struct objfile
*objfile
;
1840 #ifdef SUN_FIXED_LBRAC_BUG
1841 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1842 to correct the address of N_LBRAC's. If it is not defined, then
1843 we never need to correct the addresses. */
1845 /* This records the last pc address we've seen. We depend on there being
1846 an SLINE or FUN or SO before the first LBRAC, since the variable does
1847 not get reset in between reads of different symbol files. */
1848 static CORE_ADDR last_pc_address
;
1851 register struct context_stack
*new;
1852 /* This remembers the address of the start of a function. It is used
1853 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1854 relative to the current function's start address. On systems
1855 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1856 used to relocate these symbol types rather than SECTION_OFFSETS. */
1857 static CORE_ADDR function_start_offset
;
1859 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1860 file. Used to detect the SunPRO solaris compiler. */
1861 static int n_opt_found
;
1863 /* The stab type used for the definition of the last function.
1864 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1865 static int function_stab_type
= 0;
1867 if (!block_address_function_relative
)
1868 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1869 function start address, so just use the text offset. */
1870 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1872 /* Something is wrong if we see real data before
1873 seeing a source file name. */
1875 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1877 /* Ignore any symbols which appear before an N_SO symbol. Currently
1878 no one puts symbols there, but we should deal gracefully with the
1879 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1880 but this should not be an error (). */
1889 if (*name
== '\000')
1891 /* This N_FUN marks the end of a function. This closes off the
1893 within_function
= 0;
1894 new = pop_context ();
1896 /* Make a block for the local symbols within. */
1897 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1898 new->start_addr
, new->start_addr
+ valu
,
1903 /* Relocate for dynamic loading */
1904 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1905 goto define_a_symbol
;
1908 /* This "symbol" just indicates the start of an inner lexical
1909 context within a function. */
1911 /* Ignore extra outermost context from SunPRO cc and acc. */
1912 if (n_opt_found
&& desc
== 1)
1915 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1916 /* Relocate for dynamic loading (?). */
1917 valu
+= function_start_offset
;
1919 if (block_address_function_relative
)
1920 /* Relocate for Sun ELF acc fn-relative syms. */
1921 valu
+= function_start_offset
;
1923 /* On most machines, the block addresses are relative to the
1924 N_SO, the linker did not relocate them (sigh). */
1925 valu
+= last_source_start_addr
;
1928 #ifdef SUN_FIXED_LBRAC_BUG
1929 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1930 /* Patch current LBRAC pc value to match last handy pc value */
1931 complain (&lbrac_complaint
);
1932 valu
= last_pc_address
;
1935 new = push_context (desc
, valu
);
1939 /* This "symbol" just indicates the end of an inner lexical
1940 context that was started with N_LBRAC. */
1942 /* Ignore extra outermost context from SunPRO cc and acc. */
1943 if (n_opt_found
&& desc
== 1)
1946 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1947 /* Relocate for dynamic loading (?). */
1948 valu
+= function_start_offset
;
1950 if (block_address_function_relative
)
1951 /* Relocate for Sun ELF acc fn-relative syms. */
1952 valu
+= function_start_offset
;
1954 /* On most machines, the block addresses are relative to the
1955 N_SO, the linker did not relocate them (sigh). */
1956 valu
+= last_source_start_addr
;
1959 new = pop_context();
1960 if (desc
!= new->depth
)
1961 complain (&lbrac_mismatch_complaint
, symnum
);
1963 /* Some compilers put the variable decls inside of an
1964 LBRAC/RBRAC block. This macro should be nonzero if this
1965 is true. DESC is N_DESC from the N_RBRAC symbol.
1966 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1967 or the GCC2_COMPILED_SYMBOL. */
1968 #if !defined (VARIABLES_INSIDE_BLOCK)
1969 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1972 /* Can only use new->locals as local symbols here if we're in
1973 gcc or on a machine that puts them before the lbrack. */
1974 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1975 local_symbols
= new->locals
;
1977 if (context_stack_depth
1978 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1980 /* This is not the outermost LBRAC...RBRAC pair in the function,
1981 its local symbols preceded it, and are the ones just recovered
1982 from the context stack. Define the block for them (but don't
1983 bother if the block contains no symbols. Should we complain
1984 on blocks without symbols? I can't think of any useful purpose
1986 if (local_symbols
!= NULL
)
1988 /* Muzzle a compiler bug that makes end < start. (which
1989 compilers? Is this ever harmful?). */
1990 if (new->start_addr
> valu
)
1992 complain (&lbrac_rbrac_complaint
);
1993 new->start_addr
= valu
;
1995 /* Make a block for the local symbols within. */
1996 finish_block (0, &local_symbols
, new->old_blocks
,
1997 new->start_addr
, valu
, objfile
);
2002 /* This is the outermost LBRAC...RBRAC pair. There is no
2003 need to do anything; leave the symbols that preceded it
2004 to be attached to the function's own block. We need to
2005 indicate that we just moved outside of the function. */
2006 within_function
= 0;
2009 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2010 /* Now pop locals of block just finished. */
2011 local_symbols
= new->locals
;
2016 /* This kind of symbol indicates the start of an object file. */
2017 /* Relocate for dynamic loading */
2018 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2022 /* This type of symbol indicates the start of data
2023 for one source file.
2024 Finish the symbol table of the previous source file
2025 (if any) and start accumulating a new symbol table. */
2026 /* Relocate for dynamic loading */
2027 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2031 #ifdef SUN_FIXED_LBRAC_BUG
2032 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2035 #ifdef PCC_SOL_BROKEN
2036 /* pcc bug, occasionally puts out SO for SOL. */
2037 if (context_stack_depth
> 0)
2039 start_subfile (name
, NULL
);
2043 if (last_source_file
)
2045 /* Check if previous symbol was also an N_SO (with some
2046 sanity checks). If so, that one was actually the directory
2047 name, and the current one is the real file name.
2049 if (previous_stab_code
== (unsigned char) N_SO
)
2051 patch_subfile_names (current_subfile
, name
);
2052 break; /* Ignore repeated SOs */
2054 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
2058 /* Null name means this just marks the end of text for this .o file.
2059 Don't start a new symtab in this case. */
2060 if (*name
== '\000')
2064 start_symtab (name
, NULL
, valu
);
2065 record_debugformat ("stabs");
2069 /* This type of symbol indicates the start of data for
2070 a sub-source-file, one whose contents were copied or
2071 included in the compilation of the main source file
2072 (whose name was given in the N_SO symbol.) */
2073 /* Relocate for dynamic loading */
2074 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2075 start_subfile (name
, current_subfile
->dirname
);
2080 add_new_header_file (name
, valu
);
2081 start_subfile (name
, current_subfile
->dirname
);
2085 start_subfile (pop_subfile (), current_subfile
->dirname
);
2089 add_old_header_file (name
, valu
);
2093 /* This type of "symbol" really just records
2094 one line-number -- core-address correspondence.
2095 Enter it in the line list for this symbol table. */
2096 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2097 valu
+= function_start_offset
;
2098 #ifdef SUN_FIXED_LBRAC_BUG
2099 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2101 record_line (current_subfile
, desc
, valu
);
2105 common_block_start (name
, objfile
);
2109 common_block_end (objfile
);
2112 /* The following symbol types need to have the appropriate offset added
2113 to their value; then we process symbol definitions in the name. */
2115 case N_STSYM
: /* Static symbol in data seg */
2116 case N_LCSYM
: /* Static symbol in BSS seg */
2117 case N_ROSYM
: /* Static symbol in Read-only data seg */
2118 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2119 Solaris2's stabs-in-elf makes *most* symbols relative
2120 but leaves a few absolute (at least for Solaris 2.1 and version
2121 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2122 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2123 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2124 This leaves us no choice but to search for the 'S' or 'V'...
2125 (or pass the whole section_offsets stuff down ONE MORE function
2126 call level, which we really don't want to do). */
2130 /* .o files and NLMs have non-zero text seg offsets, but don't need
2131 their static syms offset in this fashion. XXX - This is really a
2132 crock that should be fixed in the solib handling code so that I
2133 don't have to work around it here. */
2135 if (!symfile_relocatable
)
2137 p
= strchr (name
, ':');
2138 if (p
!= 0 && p
[1] == 'S')
2140 /* The linker relocated it. We don't want to add an
2141 elfstab_offset_sections-type offset, but we *do* want
2142 to add whatever solib.c passed to symbol_file_add as
2143 addr (this is known to affect SunOS4, and I suspect ELF
2144 too). Since elfstab_offset_sections currently does not
2145 muck with the text offset (there is no Ttext.text
2146 symbol), we can get addr from the text offset. If
2147 elfstab_offset_sections ever starts dealing with the
2148 text offset, and we still need to do this, we need to
2149 invent a SECT_OFF_ADDR_KLUDGE or something. */
2150 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2151 goto define_a_symbol
;
2154 /* Since it's not the kludge case, re-dispatch to the right handler. */
2156 case N_STSYM
: goto case_N_STSYM
;
2157 case N_LCSYM
: goto case_N_LCSYM
;
2158 case N_ROSYM
: goto case_N_ROSYM
;
2163 case_N_STSYM
: /* Static symbol in data seg */
2164 case N_DSLINE
: /* Source line number, data seg */
2165 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2166 goto define_a_symbol
;
2168 case_N_LCSYM
: /* Static symbol in BSS seg */
2169 case N_BSLINE
: /* Source line number, bss seg */
2170 /* N_BROWS: overlaps with N_BSLINE */
2171 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2172 goto define_a_symbol
;
2174 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2175 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2176 goto define_a_symbol
;
2178 case N_ENTRY
: /* Alternate entry point */
2179 /* Relocate for dynamic loading */
2180 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2181 goto define_a_symbol
;
2183 /* The following symbol types we don't know how to process. Handle
2184 them in a "default" way, but complain to people who care. */
2186 case N_CATCH
: /* Exception handler catcher */
2187 case N_EHDECL
: /* Exception handler name */
2188 case N_PC
: /* Global symbol in Pascal */
2189 case N_M2C
: /* Modula-2 compilation unit */
2190 /* N_MOD2: overlaps with N_EHDECL */
2191 case N_SCOPE
: /* Modula-2 scope information */
2192 case N_ECOML
: /* End common (local name) */
2193 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2198 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2201 /* The following symbol types don't need the address field relocated,
2202 since it is either unused, or is absolute. */
2204 case N_GSYM
: /* Global variable */
2205 case N_NSYMS
: /* Number of symbols (ultrix) */
2206 case N_NOMAP
: /* No map? (ultrix) */
2207 case N_RSYM
: /* Register variable */
2208 case N_DEFD
: /* Modula-2 GNU module dependency */
2209 case N_SSYM
: /* Struct or union element */
2210 case N_LSYM
: /* Local symbol in stack */
2211 case N_PSYM
: /* Parameter variable */
2212 case N_LENG
: /* Length of preceding symbol type */
2216 char *colon_pos
= strchr (name
, ':');
2217 if (colon_pos
== NULL
)
2220 deftype
= colon_pos
[1];
2226 function_stab_type
= type
;
2228 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2229 /* Deal with the SunPRO 3.0 compiler which omits the address
2230 from N_FUN symbols. */
2232 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2234 struct minimal_symbol
*msym
;
2238 p
= strchr (name
, ':');
2243 strncpy (p
, name
, n
);
2246 msym
= lookup_minimal_symbol (p
, last_source_file
,
2249 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2253 #ifdef SUN_FIXED_LBRAC_BUG
2254 /* The Sun acc compiler, under SunOS4, puts out
2255 functions with N_GSYM or N_STSYM. The problem is
2256 that the address of the symbol is no good (for N_GSYM
2257 it doesn't even attept an address; for N_STSYM it
2258 puts out an address but then it gets relocated
2259 relative to the data segment, not the text segment).
2260 Currently we can't fix this up later as we do for
2261 some types of symbol in scan_file_globals.
2262 Fortunately we do have a way of finding the address -
2263 we know that the value in last_pc_address is either
2264 the one we want (if we're dealing with the first
2265 function in an object file), or somewhere in the
2266 previous function. This means that we can use the
2267 minimal symbol table to get the address. */
2269 /* Starting with release 3.0, the Sun acc compiler,
2270 under SunOS4, puts out functions with N_FUN and a value
2271 of zero. This gets relocated to the start of the text
2272 segment of the module, which is no good either.
2273 Under SunOS4 we can deal with this as N_SLINE and N_SO
2274 entries contain valid absolute addresses.
2275 Release 3.0 acc also puts out N_OPT entries, which makes
2276 it possible to discern acc from cc or gcc. */
2278 if (type
== N_GSYM
|| type
== N_STSYM
2280 && n_opt_found
&& !block_address_function_relative
))
2282 struct minimal_symbol
*m
;
2283 int l
= colon_pos
- name
;
2285 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2286 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2287 && SYMBOL_NAME (m
) [l
] == '\0')
2288 /* last_pc_address was in this function */
2289 valu
= SYMBOL_VALUE (m
);
2290 else if (m
&& SYMBOL_NAME (m
+1)
2291 && STREQN (SYMBOL_NAME (m
+1), name
, l
)
2292 && SYMBOL_NAME (m
+1) [l
] == '\0')
2293 /* last_pc_address was in last function */
2294 valu
= SYMBOL_VALUE (m
+1);
2296 /* Not found - use last_pc_address (for finish_block) */
2297 valu
= last_pc_address
;
2300 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2303 if (block_address_function_relative
)
2304 /* For Solaris 2.0 compilers, the block addresses and
2305 N_SLINE's are relative to the start of the
2306 function. On normal systems, and when using gcc on
2307 Solaris 2.0, these addresses are just absolute, or
2308 relative to the N_SO, depending on
2309 BLOCK_ADDRESS_ABSOLUTE. */
2310 function_start_offset
= valu
;
2312 within_function
= 1;
2313 if (context_stack_depth
> 0)
2315 new = pop_context ();
2316 /* Make a block for the local symbols within. */
2317 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2318 new->start_addr
, valu
, objfile
);
2320 /* Stack must be empty now. */
2321 if (context_stack_depth
!= 0)
2322 complain (&lbrac_unmatched_complaint
, symnum
);
2324 new = push_context (0, valu
);
2325 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2329 define_symbol (valu
, name
, desc
, type
, objfile
);
2335 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2336 for a bunch of other flags, too. Someday we may parse their
2337 flags; for now we ignore theirs and hope they'll ignore ours. */
2338 case N_OPT
: /* Solaris 2: Compiler options */
2341 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2343 processing_gcc_compilation
= 2;
2344 #if 1 /* Works, but is experimental. -fnf */
2345 if (AUTO_DEMANGLING
)
2347 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2356 /* The following symbol types can be ignored. */
2357 case N_OBJ
: /* Solaris 2: Object file dir and name */
2358 /* N_UNDF: Solaris 2: file separator mark */
2359 /* N_UNDF: -- we will never encounter it, since we only process one
2360 file's symbols at once. */
2361 case N_ENDM
: /* Solaris 2: End of module */
2362 case N_MAIN
: /* Name of main routine. */
2366 /* Special GNU C extension for referencing names. */
2369 /* Initialize symbol reference names and determine if this is
2370 a definition. If symbol reference is being defined, go
2371 ahead and add it. Otherwise, just return sym. */
2374 extern int symbol_reference_defined (char **);
2375 extern void ref_add (int, struct symbol
*, char *, CORE_ADDR
);
2376 extern struct symbol
* ref_search (int);
2378 /* If defined, store away a pointer to the symbol;
2379 we'll use it later when we resolve references in
2380 "resolve_symbol_reference". */
2382 if (refnum
= symbol_reference_defined (&s
), refnum
)
2383 if (!ref_search (refnum
))
2384 ref_add (refnum
, 0, name
, valu
);
2385 name
= s
; /* Advance past refid. */
2389 previous_stab_code
= type
;
2392 /* FIXME: The only difference between this and elfstab_build_psymtabs
2393 is the call to install_minimal_symbols for elf, and the support for
2394 split sections. If the differences are really that small, the code
2395 should be shared. */
2397 /* Scan and build partial symbols for an coff symbol file.
2398 The coff file has already been processed to get its minimal symbols.
2400 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2403 OBJFILE is the object file we are reading symbols from.
2404 ADDR is the address relative to which the symbols are (e.g.
2405 the base address of the text segment).
2406 MAINLINE is true if we are reading the main symbol
2407 table (as opposed to a shared lib or dynamically loaded file).
2408 TEXTADDR is the address of the text section.
2409 TEXTSIZE is the size of the text section.
2410 STABSECTS is the list of .stab sections in OBJFILE.
2411 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2412 .stabstr section exists.
2414 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2415 adjusted for coff details. */
2418 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2419 textaddr
, textsize
, stabsects
,
2420 stabstroffset
, stabstrsize
)
2421 struct objfile
*objfile
;
2422 struct section_offsets
*section_offsets
;
2425 unsigned int textsize
;
2426 struct stab_section_list
*stabsects
;
2427 file_ptr stabstroffset
;
2428 unsigned int stabstrsize
;
2431 bfd
*sym_bfd
= objfile
->obfd
;
2432 char *name
= bfd_get_filename (sym_bfd
);
2433 struct dbx_symfile_info
*info
;
2434 unsigned int stabsize
;
2436 /* There is already a dbx_symfile_info allocated by our caller.
2437 It might even contain some info from the coff symtab to help us. */
2438 info
= objfile
->sym_stab_info
;
2440 DBX_TEXT_ADDR (objfile
) = textaddr
;
2441 DBX_TEXT_SIZE (objfile
) = textsize
;
2443 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2444 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2445 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2447 if (stabstrsize
> bfd_get_size (sym_bfd
))
2448 error ("ridiculous string table size: %d bytes", stabstrsize
);
2449 DBX_STRINGTAB (objfile
) = (char *)
2450 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2451 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2453 /* Now read in the string table in one big gulp. */
2455 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2457 perror_with_name (name
);
2458 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2459 if (val
!= stabstrsize
)
2460 perror_with_name (name
);
2462 stabsread_new_init ();
2463 buildsym_new_init ();
2464 free_header_files ();
2465 init_header_files ();
2467 processing_acc_compilation
= 1;
2469 /* In a coff file, we've already installed the minimal symbols that came
2470 from the coff (non-stab) symbol table, so always act like an
2471 incremental load here. */
2472 if (stabsects
->next
== NULL
)
2474 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2475 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2476 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2480 struct stab_section_list
*stabsect
;
2482 DBX_SYMCOUNT (objfile
) = 0;
2483 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2485 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2486 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2489 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2491 symbuf_sections
= stabsects
->next
;
2492 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2496 dbx_symfile_read (objfile
, section_offsets
, 0);
2499 /* Scan and build partial symbols for an ELF symbol file.
2500 This ELF file has already been processed to get its minimal symbols,
2501 and any DWARF symbols that were in it.
2503 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2506 OBJFILE is the object file we are reading symbols from.
2507 ADDR is the address relative to which the symbols are (e.g.
2508 the base address of the text segment).
2509 MAINLINE is true if we are reading the main symbol
2510 table (as opposed to a shared lib or dynamically loaded file).
2511 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2513 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2514 .stabstr section exists.
2516 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2517 adjusted for elf details. */
2520 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2521 staboffset
, stabsize
,
2522 stabstroffset
, stabstrsize
)
2523 struct objfile
*objfile
;
2524 struct section_offsets
*section_offsets
;
2526 file_ptr staboffset
;
2527 unsigned int stabsize
;
2528 file_ptr stabstroffset
;
2529 unsigned int stabstrsize
;
2532 bfd
*sym_bfd
= objfile
->obfd
;
2533 char *name
= bfd_get_filename (sym_bfd
);
2534 struct dbx_symfile_info
*info
;
2535 asection
*text_sect
;
2537 /* There is already a dbx_symfile_info allocated by our caller.
2538 It might even contain some info from the ELF symtab to help us. */
2539 info
= objfile
->sym_stab_info
;
2541 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
2543 error ("Can't find .text section in symbol file");
2544 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2545 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2547 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2548 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2549 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2550 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2551 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2553 if (stabstrsize
> bfd_get_size (sym_bfd
))
2554 error ("ridiculous string table size: %d bytes", stabstrsize
);
2555 DBX_STRINGTAB (objfile
) = (char *)
2556 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2557 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2559 /* Now read in the string table in one big gulp. */
2561 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2563 perror_with_name (name
);
2564 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2565 if (val
!= stabstrsize
)
2566 perror_with_name (name
);
2568 stabsread_new_init ();
2569 buildsym_new_init ();
2570 free_header_files ();
2571 init_header_files ();
2572 install_minimal_symbols (objfile
);
2574 processing_acc_compilation
= 1;
2576 /* In an elf file, we've already installed the minimal symbols that came
2577 from the elf (non-stab) symbol table, so always act like an
2578 incremental load here. */
2579 dbx_symfile_read (objfile
, section_offsets
, 0);
2582 /* Scan and build partial symbols for a file with special sections for stabs
2583 and stabstrings. The file has already been processed to get its minimal
2584 symbols, and any other symbols that might be necessary to resolve GSYMs.
2586 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2589 OBJFILE is the object file we are reading symbols from.
2590 ADDR is the address relative to which the symbols are (e.g. the base address
2591 of the text segment).
2592 MAINLINE is true if we are reading the main symbol table (as opposed to a
2593 shared lib or dynamically loaded file).
2594 STAB_NAME is the name of the section that contains the stabs.
2595 STABSTR_NAME is the name of the section that contains the stab strings.
2597 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2600 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2601 stabstr_name
, text_name
)
2602 struct objfile
*objfile
;
2603 struct section_offsets
*section_offsets
;
2610 bfd
*sym_bfd
= objfile
->obfd
;
2611 char *name
= bfd_get_filename (sym_bfd
);
2613 asection
*stabstrsect
;
2614 asection
*text_sect
;
2616 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2617 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2623 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2624 stab_name
, stabstr_name
);
2626 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2627 memset (objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
2629 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2631 error ("Can't find %s section in symbol file", text_name
);
2632 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2633 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2635 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2636 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2637 / DBX_SYMBOL_SIZE (objfile
);
2638 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2639 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2641 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2642 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2643 DBX_STRINGTAB (objfile
) = (char *)
2644 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2645 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2647 /* Now read in the string table in one big gulp. */
2649 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2650 stabstrsect
, /* bfd section */
2651 DBX_STRINGTAB (objfile
), /* input buffer */
2652 0, /* offset into section */
2653 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2656 perror_with_name (name
);
2658 stabsread_new_init ();
2659 buildsym_new_init ();
2660 free_header_files ();
2661 init_header_files ();
2662 install_minimal_symbols (objfile
);
2664 /* Now, do an incremental load */
2666 processing_acc_compilation
= 1;
2667 dbx_symfile_read (objfile
, section_offsets
, 0);
2670 static struct sym_fns aout_sym_fns
=
2672 bfd_target_aout_flavour
,
2673 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2674 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2675 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2676 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2677 default_symfile_offsets
,
2678 /* sym_offsets: parse user's offsets to internal form */
2679 NULL
/* next: pointer to next struct sym_fns */
2683 _initialize_dbxread ()
2685 add_symtab_fns(&aout_sym_fns
);