1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
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 /* This macro returns the size field of a minimal symbol, which is normally
66 stored in the "info" field. The macro can be overridden for specific
67 targets (e.g. MIPS16) that use the info field for other purposes. */
69 #define MSYMBOL_SIZE(msym) ((long) MSYMBOL_INFO (msym))
73 /* We put a pointer to this structure in the read_symtab_private field
78 /* Offset within the file symbol table of first local symbol for this
83 /* Length (in bytes) of the section of the symbol table devoted to
84 this file's symbols (actually, the section bracketed may contain
85 more than just this file's symbols). If ldsymlen is 0, the only
86 reason for this thing's existence is the dependency list. Nothing
87 else will happen when it is read in. */
91 /* The size of each symbol in the symbol file (in external form). */
95 /* Further information needed to locate the symbols if they are in
100 int file_string_offset
;
103 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
104 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
105 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
106 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
107 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
108 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
109 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
112 /* Remember what we deduced to be the source language of this psymtab. */
114 static enum language psymtab_language
= language_unknown
;
116 /* Nonzero means give verbose info on gdb action. From main.c. */
118 extern int info_verbose
;
120 /* The BFD for this file -- implicit parameter to next_symbol_text. */
122 static bfd
*symfile_bfd
;
124 /* The size of each symbol in the symbol file (in external form).
125 This is set by dbx_symfile_read when building psymtabs, and by
126 dbx_psymtab_to_symtab when building symtabs. */
128 static unsigned symbol_size
;
130 /* This is the offset of the symbol table in the executable file. */
132 static unsigned symbol_table_offset
;
134 /* This is the offset of the string table in the executable file. */
136 static unsigned string_table_offset
;
138 /* For elf+stab executables, the n_strx field is not a simple index
139 into the string table. Instead, each .o file has a base offset in
140 the string table, and the associated symbols contain offsets from
141 this base. The following two variables contain the base offset for
142 the current and next .o files. */
144 static unsigned int file_string_table_offset
;
145 static unsigned int next_file_string_table_offset
;
147 /* .o and NLM files contain unrelocated addresses which are based at
148 0. When non-zero, this flag disables some of the special cases for
149 Solaris elf+stab text addresses at location 0. */
151 static int symfile_relocatable
= 0;
153 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are
154 relative to the function start address. */
156 static int block_address_function_relative
= 0;
158 /* The lowest text address we have yet encountered. This is needed
159 because in an a.out file, there is no header field which tells us
160 what address the program is actually going to be loaded at, so we
161 need to make guesses based on the symbols (which *are* relocated to
162 reflect the address it will be loaded at). */
164 static CORE_ADDR lowest_text_address
;
166 /* Non-zero if there is any line number info in the objfile. Prevents
167 end_psymtab from discarding an otherwise empty psymtab. */
169 static int has_line_numbers
;
171 /* Complaints about the symbols we have encountered. */
173 struct complaint lbrac_complaint
=
174 {"bad block start address patched", 0, 0};
176 struct complaint string_table_offset_complaint
=
177 {"bad string table offset in symbol %d", 0, 0};
179 struct complaint unknown_symtype_complaint
=
180 {"unknown symbol type %s", 0, 0};
182 struct complaint unknown_symchar_complaint
=
183 {"unknown symbol descriptor `%c'", 0, 0};
185 struct complaint lbrac_rbrac_complaint
=
186 {"block start larger than block end", 0, 0};
188 struct complaint lbrac_unmatched_complaint
=
189 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
191 struct complaint lbrac_mismatch_complaint
=
192 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
194 struct complaint repeated_header_complaint
=
195 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
197 struct complaint unclaimed_bincl_complaint
=
198 {"N_BINCL %s not in entries for any file, at symtab pos %d", 0, 0};
200 /* During initial symbol readin, we need to have a structure to keep
201 track of which psymtabs have which bincls in them. This structure
202 is used during readin to setup the list of dependencies within each
203 partial symbol table. */
205 struct header_file_location
207 char *name
; /* Name of header file */
208 int instance
; /* See above */
209 struct partial_symtab
*pst
; /* Partial symtab that has the
210 BINCL/EINCL defs for this file */
213 /* The actual list and controling variables */
214 static struct header_file_location
*bincl_list
, *next_bincl
;
215 static int bincls_allocated
;
217 /* Local function prototypes */
220 process_now
PARAMS ((struct objfile
*));
223 free_header_files
PARAMS ((void));
226 init_header_files
PARAMS ((void));
229 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
232 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
235 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
238 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
239 struct objfile
*objfile
));
242 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
246 free_bincl_list
PARAMS ((struct objfile
*));
248 static struct partial_symtab
*
249 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
252 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
255 init_bincl_list
PARAMS ((int, struct objfile
*));
258 dbx_next_symbol_text
PARAMS ((struct objfile
*));
261 fill_symbuf
PARAMS ((bfd
*));
264 dbx_symfile_init
PARAMS ((struct objfile
*));
267 dbx_new_init
PARAMS ((struct objfile
*));
270 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
273 dbx_symfile_finish
PARAMS ((struct objfile
*));
276 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
279 add_new_header_file
PARAMS ((char *, int));
282 add_old_header_file
PARAMS ((char *, int));
285 add_this_object_header_file
PARAMS ((int));
287 /* Free up old header file tables */
292 if (this_object_header_files
)
294 free ((PTR
)this_object_header_files
);
295 this_object_header_files
= NULL
;
297 n_allocated_this_object_header_files
= 0;
300 /* Allocate new header file tables */
305 n_allocated_this_object_header_files
= 10;
306 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
309 /* Add header file number I for this object file
310 at the next successive FILENUM. */
313 add_this_object_header_file (i
)
316 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
318 n_allocated_this_object_header_files
*= 2;
319 this_object_header_files
320 = (int *) xrealloc ((char *) this_object_header_files
,
321 n_allocated_this_object_header_files
* sizeof (int));
324 this_object_header_files
[n_this_object_header_files
++] = i
;
327 /* Add to this file an "old" header file, one already seen in
328 a previous object file. NAME is the header file's name.
329 INSTANCE is its instance code, to select among multiple
330 symbol tables for the same header file. */
333 add_old_header_file (name
, instance
)
337 register struct header_file
*p
= HEADER_FILES (current_objfile
);
340 for (i
= 0; i
< N_HEADER_FILES (current_objfile
); i
++)
341 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
343 add_this_object_header_file (i
);
346 complain (&repeated_header_complaint
, name
, symnum
);
349 /* Add to this file a "new" header file: definitions for its types follow.
350 NAME is the header file's name.
351 Most often this happens only once for each distinct header file,
352 but not necessarily. If it happens more than once, INSTANCE has
353 a different value each time, and references to the header file
354 use INSTANCE values to select among them.
356 dbx output contains "begin" and "end" markers for each new header file,
357 but at this level we just need to know which files there have been;
358 so we record the file when its "begin" is seen and ignore the "end". */
361 add_new_header_file (name
, instance
)
366 register struct header_file
*hfile
;
368 /* Make sure there is room for one more header file. */
370 i
= N_ALLOCATED_HEADER_FILES (current_objfile
);
372 if (N_HEADER_FILES (current_objfile
) == i
)
376 N_ALLOCATED_HEADER_FILES (current_objfile
) = 10;
377 HEADER_FILES (current_objfile
) = (struct header_file
*)
378 xmalloc (10 * sizeof (struct header_file
));
383 N_ALLOCATED_HEADER_FILES (current_objfile
) = i
;
384 HEADER_FILES (current_objfile
) = (struct header_file
*)
385 xrealloc ((char *) HEADER_FILES (current_objfile
),
386 (i
* sizeof (struct header_file
)));
390 /* Create an entry for this header file. */
392 i
= N_HEADER_FILES (current_objfile
)++;
393 hfile
= HEADER_FILES (current_objfile
) + i
;
394 hfile
->name
= savestring (name
, strlen(name
));
395 hfile
->instance
= instance
;
398 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
399 memset (hfile
->vector
, 0, 10 * sizeof (struct type
*));
401 add_this_object_header_file (i
);
405 static struct type
**
406 explicit_lookup_type (real_filenum
, index
)
407 int real_filenum
, index
;
409 register struct header_file
*f
= &HEADER_FILES (current_objfile
)[real_filenum
];
411 if (index
>= f
->length
)
414 f
->vector
= (struct type
**)
415 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
416 memset (&f
->vector
[f
->length
/ 2],
417 '\0', f
->length
* sizeof (struct type
*) / 2);
419 return &f
->vector
[index
];
424 record_minimal_symbol (name
, address
, type
, objfile
)
428 struct objfile
*objfile
;
430 enum minimal_symbol_type ms_type
;
432 asection
*bfd_section
;
438 section
= SECT_OFF_TEXT
;
439 bfd_section
= DBX_TEXT_SECTION (objfile
);
443 section
= SECT_OFF_DATA
;
444 bfd_section
= DBX_DATA_SECTION (objfile
);
448 section
= SECT_OFF_BSS
;
449 bfd_section
= DBX_BSS_SECTION (objfile
);
459 section
= SECT_OFF_DATA
;
460 bfd_section
= DBX_DATA_SECTION (objfile
);
463 /* I don't think this type actually exists; since a N_SETV is the result
464 of going over many .o files, it doesn't make sense to have one
466 ms_type
= mst_file_data
;
467 section
= SECT_OFF_DATA
;
468 bfd_section
= DBX_DATA_SECTION (objfile
);
475 ms_type
= mst_file_text
;
476 section
= SECT_OFF_TEXT
;
477 bfd_section
= DBX_TEXT_SECTION (objfile
);
480 ms_type
= mst_file_data
;
482 /* Check for __DYNAMIC, which is used by Sun shared libraries.
483 Record it as global even if it's local, not global, so
484 lookup_minimal_symbol can find it. We don't check symbol_leading_char
485 because for SunOS4 it always is '_'. */
486 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
489 /* Same with virtual function tables, both global and static. */
491 char *tempstring
= name
;
492 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
494 if (VTBL_PREFIX_P ((tempstring
)))
497 section
= SECT_OFF_DATA
;
498 bfd_section
= DBX_DATA_SECTION (objfile
);
501 ms_type
= mst_file_bss
;
502 section
= SECT_OFF_BSS
;
503 bfd_section
= DBX_BSS_SECTION (objfile
);
506 ms_type
= mst_unknown
;
512 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
513 && address
< lowest_text_address
)
514 lowest_text_address
= address
;
516 prim_record_minimal_symbol_and_info
517 (name
, address
, ms_type
, NULL
, section
, bfd_section
, objfile
);
520 /* Scan and build partial symbols for a symbol file.
521 We have been initialized by a call to dbx_symfile_init, which
522 put all the relevant info into a "struct dbx_symfile_info",
523 hung off the objfile structure.
525 SECTION_OFFSETS contains offsets relative to which the symbols in the
526 various sections are (depending where the sections were actually loaded).
527 MAINLINE is true if we are reading the main symbol
528 table (as opposed to a shared lib or dynamically loaded file). */
531 dbx_symfile_read (objfile
, section_offsets
, mainline
)
532 struct objfile
*objfile
;
533 struct section_offsets
*section_offsets
;
534 int mainline
; /* FIXME comments above */
538 struct cleanup
*back_to
;
540 val
= strlen (objfile
->name
);
542 sym_bfd
= objfile
->obfd
;
544 /* .o and .nlm files are relocatables with text, data and bss segs based at
545 0. This flag disables special (Solaris stabs-in-elf only) fixups for
546 symbols with a value of 0. */
548 symfile_relocatable
= bfd_get_file_flags (sym_bfd
) & HAS_RELOC
;
550 /* This is true for Solaris (and all other systems which put stabs
551 in sections, hopefully, since it would be silly to do things
552 differently from Solaris), and false for SunOS4 and other a.out
554 block_address_function_relative
=
555 ((0 == strncmp (bfd_get_target (sym_bfd
), "elf", 3))
556 || (0 == strncmp (bfd_get_target (sym_bfd
), "som", 3))
557 || (0 == strncmp (bfd_get_target (sym_bfd
), "coff", 4))
558 || (0 == strncmp (bfd_get_target (sym_bfd
), "pe", 2))
559 || (0 == strncmp (bfd_get_target (sym_bfd
), "nlm", 3)));
561 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
563 perror_with_name (objfile
->name
);
565 /* If we are reinitializing, or if we have never loaded syms yet, init */
567 || objfile
->global_psymbols
.size
== 0
568 || objfile
->static_psymbols
.size
== 0)
569 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
571 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
572 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
574 free_pending_blocks ();
575 back_to
= make_cleanup ((make_cleanup_func
) really_free_pendings
, 0);
577 init_minimal_symbol_collection ();
578 make_cleanup ((make_cleanup_func
) discard_minimal_symbols
, 0);
580 /* Now that the symbol table data of the executable file are all in core,
581 process them and define symbols accordingly. */
583 read_dbx_symtab (section_offsets
, objfile
,
584 DBX_TEXT_ADDR (objfile
),
585 DBX_TEXT_SIZE (objfile
));
587 /* Add the dynamic symbols. */
589 read_dbx_dynamic_symtab (section_offsets
, objfile
);
591 /* Install any minimal symbols that have been collected as the current
592 minimal symbols for this objfile. */
594 install_minimal_symbols (objfile
);
596 do_cleanups (back_to
);
599 /* Initialize anything that needs initializing when a completely new
600 symbol file is specified (not just adding some symbols from another
601 file, e.g. a shared library). */
604 dbx_new_init (ignore
)
605 struct objfile
*ignore
;
607 stabsread_new_init ();
608 buildsym_new_init ();
609 init_header_files ();
613 /* dbx_symfile_init ()
614 is the dbx-specific initialization routine for reading symbols.
615 It is passed a struct objfile which contains, among other things,
616 the BFD for the file whose symbols are being read, and a slot for a pointer
617 to "private data" which we fill with goodies.
619 We read the string table into malloc'd space and stash a pointer to it.
621 Since BFD doesn't know how to read debug symbols in a format-independent
622 way (and may never do so...), we have to do it ourselves. We will never
623 be called unless this is an a.out (or very similar) file.
624 FIXME, there should be a cleaner peephole into the BFD environment here. */
626 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
629 dbx_symfile_init (objfile
)
630 struct objfile
*objfile
;
633 bfd
*sym_bfd
= objfile
->obfd
;
634 char *name
= bfd_get_filename (sym_bfd
);
636 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
638 /* Allocate struct to keep track of the symfile */
639 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
640 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
641 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
643 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
644 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
645 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
647 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
648 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
649 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
651 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
653 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
655 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
657 error ("Can't find .text section in symbol file");
658 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
659 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
661 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
662 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
663 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
665 /* Read the string table and stash it away in the psymbol_obstack. It is
666 only needed as long as we need to expand psymbols into full symbols,
667 so when we blow away the psymbol the string table goes away as well.
668 Note that gdb used to use the results of attempting to malloc the
669 string table, based on the size it read, as a form of sanity check
670 for botched byte swapping, on the theory that a byte swapped string
671 table size would be so totally bogus that the malloc would fail. Now
672 that we put in on the psymbol_obstack, we can't do this since gdb gets
673 a fatal error (out of virtual memory) if the size is bogus. We can
674 however at least check to see if the size is less than the size of
675 the size field itself, or larger than the size of the entire file.
676 Note that all valid string tables have a size greater than zero, since
677 the bytes used to hold the size are included in the count. */
679 if (STRING_TABLE_OFFSET
== 0)
681 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
682 will never be zero, even when there is no string table. This
683 would appear to be a bug in bfd. */
684 DBX_STRINGTAB_SIZE (objfile
) = 0;
685 DBX_STRINGTAB (objfile
) = NULL
;
689 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
691 perror_with_name (name
);
693 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
694 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
697 perror_with_name (name
);
701 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
702 EOF if there is no string table, and attempting to read the size
703 from EOF will read zero bytes. */
704 DBX_STRINGTAB_SIZE (objfile
) = 0;
705 DBX_STRINGTAB (objfile
) = NULL
;
709 /* Read some data that would appear to be the string table size.
710 If there really is a string table, then it is probably the right
711 size. Byteswap if necessary and validate the size. Note that
712 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
713 random data that happened to be at STRING_TABLE_OFFSET, because
714 bfd can't tell us there is no string table, the sanity checks may
715 or may not catch this. */
716 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
718 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
719 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
720 error ("ridiculous string table size (%d bytes).",
721 DBX_STRINGTAB_SIZE (objfile
));
723 DBX_STRINGTAB (objfile
) =
724 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
725 DBX_STRINGTAB_SIZE (objfile
));
726 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
728 /* Now read in the string table in one big gulp. */
730 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
732 perror_with_name (name
);
733 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
735 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
736 perror_with_name (name
);
741 /* Perform any local cleanups required when we are done with a particular
742 objfile. I.E, we are in the process of discarding all symbol information
743 for an objfile, freeing up all memory held for it, and unlinking the
744 objfile struct from the global list of known objfiles. */
747 dbx_symfile_finish (objfile
)
748 struct objfile
*objfile
;
750 if (objfile
->sym_stab_info
!= NULL
)
752 if (HEADER_FILES (objfile
) != NULL
)
754 register int i
= N_HEADER_FILES (objfile
);
755 register struct header_file
*hfiles
= HEADER_FILES (objfile
);
759 free (hfiles
[i
].name
);
760 free (hfiles
[i
].vector
);
764 mfree (objfile
-> md
, objfile
->sym_stab_info
);
766 free_header_files ();
770 /* Buffer for reading the symbol table entries. */
771 static struct external_nlist symbuf
[4096];
772 static int symbuf_idx
;
773 static int symbuf_end
;
775 /* cont_elem is used for continuing information in cfront.
776 It saves information about which types need to be fixed up and
777 completed after all the stabs are read. */
780 /* sym and stabsstring for continuing information in cfront */
783 /* state dependancies (statics that must be preserved) */
787 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
788 /* other state dependancies include:
789 (assumption is that these will not change since process_now FIXME!!)
796 static struct cont_elem
*cont_list
= 0;
797 static int cont_limit
= 0;
798 static int cont_count
= 0;
800 /* Arrange for function F to be called with arguments SYM and P later
801 in the stabs reading process. */
803 process_later (sym
, p
, f
)
806 int (*f
) PARAMS ((struct objfile
*, struct symbol
*, char *));
809 /* Allocate more space for the deferred list. */
810 if (cont_count
>= cont_limit
- 1)
812 cont_limit
+= 32; /* chunk size */
815 = (struct cont_elem
*) xrealloc (cont_list
,
817 * sizeof (struct cont_elem
)));
819 error ("Virtual memory exhausted\n");
822 /* Save state variables so we can process these stabs later. */
823 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
824 cont_list
[cont_count
].sym_end
= symbuf_end
;
825 cont_list
[cont_count
].symnum
= symnum
;
826 cont_list
[cont_count
].sym
= sym
;
827 cont_list
[cont_count
].stabs
= p
;
828 cont_list
[cont_count
].func
= f
;
832 /* Call deferred funtions in CONT_LIST. */
835 process_now (objfile
)
836 struct objfile
*objfile
;
845 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
847 /* Save the state of our caller, we'll want to restore it before
849 save_symbuf_idx
= symbuf_idx
;
850 save_symbuf_end
= symbuf_end
;
851 save_symnum
= symnum
;
853 /* Iterate over all the deferred stabs. */
854 for (i
= 0; i
< cont_count
; i
++)
856 /* Restore the state for this deferred stab. */
857 symbuf_idx
= cont_list
[i
].sym_idx
;
858 symbuf_end
= cont_list
[i
].sym_end
;
859 symnum
= cont_list
[i
].symnum
;
860 sym
= cont_list
[i
].sym
;
861 stabs
= cont_list
[i
].stabs
;
862 func
= cont_list
[i
].func
;
864 /* Call the function to handle this deferrd stab. */
865 err
= (*func
) (objfile
, sym
, stabs
);
867 error ("Internal error: unable to resolve stab.\n");
870 /* Restore our caller's state. */
871 symbuf_idx
= save_symbuf_idx
;
872 symbuf_end
= save_symbuf_end
;
873 symnum
= save_symnum
;
878 /* Name of last function encountered. Used in Solaris to approximate
879 object file boundaries. */
880 static char *last_function_name
;
882 /* The address in memory of the string table of the object file we are
883 reading (which might not be the "main" object file, but might be a
884 shared library or some other dynamically loaded thing). This is
885 set by read_dbx_symtab when building psymtabs, and by
886 read_ofile_symtab when building symtabs, and is used only by
887 next_symbol_text. FIXME: If that is true, we don't need it when
888 building psymtabs, right? */
889 static char *stringtab_global
;
891 /* These variables are used to control fill_symbuf when the stabs
892 symbols are not contiguous (as may be the case when a COFF file is
893 linked using --split-by-reloc). */
894 static struct stab_section_list
*symbuf_sections
;
895 static unsigned int symbuf_left
;
896 static unsigned int symbuf_read
;
898 /* Refill the symbol table input buffer
899 and set the variables that control fetching entries from it.
900 Reports an error if no data available.
901 This function can read past the end of the symbol table
902 (into the string table) but this does no harm. */
905 fill_symbuf (sym_bfd
)
911 if (symbuf_sections
== NULL
)
912 count
= sizeof (symbuf
);
915 if (symbuf_left
<= 0)
917 file_ptr filepos
= symbuf_sections
->section
->filepos
;
918 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
919 perror_with_name (bfd_get_filename (sym_bfd
));
920 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
921 symbol_table_offset
= filepos
- symbuf_read
;
922 symbuf_sections
= symbuf_sections
->next
;
926 if (count
> sizeof (symbuf
))
927 count
= sizeof (symbuf
);
930 nbytes
= bfd_read ((PTR
)symbuf
, count
, 1, sym_bfd
);
932 perror_with_name (bfd_get_filename (sym_bfd
));
933 else if (nbytes
== 0)
934 error ("Premature end of file reading symbol table");
935 symbuf_end
= nbytes
/ symbol_size
;
937 symbuf_left
-= nbytes
;
938 symbuf_read
+= nbytes
;
941 #define SWAP_SYMBOL(symp, abfd) \
943 (symp)->n_strx = bfd_h_get_32(abfd, \
944 (unsigned char *)&(symp)->n_strx); \
945 (symp)->n_desc = bfd_h_get_16 (abfd, \
946 (unsigned char *)&(symp)->n_desc); \
947 (symp)->n_value = bfd_h_get_32 (abfd, \
948 (unsigned char *)&(symp)->n_value); \
951 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
953 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
954 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
955 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
956 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
959 /* Invariant: The symbol pointed to by symbuf_idx is the first one
960 that hasn't been swapped. Swap the symbol at the same time
961 that symbuf_idx is incremented. */
963 /* dbx allows the text of a symbol name to be continued into the
964 next symbol name! When such a continuation is encountered
965 (a \ at the end of the text of a name)
966 call this function to get the continuation. */
969 dbx_next_symbol_text (objfile
)
970 struct objfile
*objfile
;
972 struct internal_nlist nlist
;
974 if (symbuf_idx
== symbuf_end
)
975 fill_symbuf (symfile_bfd
);
978 INTERNALIZE_SYMBOL(nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
979 OBJSTAT (objfile
, n_stabs
++);
983 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
986 /* Initialize the list of bincls to contain none and have some
990 init_bincl_list (number
, objfile
)
992 struct objfile
*objfile
;
994 bincls_allocated
= number
;
995 next_bincl
= bincl_list
= (struct header_file_location
*)
996 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
999 /* Add a bincl to the list. */
1002 add_bincl_to_list (pst
, name
, instance
)
1003 struct partial_symtab
*pst
;
1007 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1009 int offset
= next_bincl
- bincl_list
;
1010 bincls_allocated
*= 2;
1011 bincl_list
= (struct header_file_location
*)
1012 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
1013 bincls_allocated
* sizeof (struct header_file_location
));
1014 next_bincl
= bincl_list
+ offset
;
1016 next_bincl
->pst
= pst
;
1017 next_bincl
->instance
= instance
;
1018 next_bincl
++->name
= name
;
1021 /* Given a name, value pair, find the corresponding
1022 bincl in the list. Return the partial symtab associated
1023 with that header_file_location. */
1025 static struct partial_symtab
*
1026 find_corresponding_bincl_psymtab (name
, instance
)
1030 struct header_file_location
*bincl
;
1032 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1033 if (bincl
->instance
== instance
1034 && STREQ (name
, bincl
->name
))
1037 complain (&repeated_header_complaint
, name
, symnum
);
1038 return (struct partial_symtab
*) 0;
1041 /* Free the storage allocated for the bincl list. */
1044 free_bincl_list (objfile
)
1045 struct objfile
*objfile
;
1047 mfree (objfile
-> md
, (PTR
)bincl_list
);
1048 bincls_allocated
= 0;
1051 /* Scan a SunOs dynamic symbol table for symbols of interest and
1052 add them to the minimal symbol table. */
1055 read_dbx_dynamic_symtab (section_offsets
, objfile
)
1056 struct section_offsets
*section_offsets
;
1057 struct objfile
*objfile
;
1059 bfd
*abfd
= objfile
->obfd
;
1060 struct cleanup
*back_to
;
1070 CORE_ADDR sym_value
;
1073 /* Check that the symbol file has dynamic symbols that we know about.
1074 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1075 on a sun4 host (and vice versa) and bfd is not configured
1076 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1077 so we ignore the dynamic symbols in this case. */
1078 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
1079 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
1080 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1083 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1084 if (dynsym_size
< 0)
1087 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1088 back_to
= make_cleanup (free
, dynsyms
);
1090 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1091 if (dynsym_count
< 0)
1093 do_cleanups (back_to
);
1097 /* Enter dynamic symbols into the minimal symbol table
1098 if this is a stripped executable. */
1099 if (bfd_get_symcount (abfd
) <= 0)
1102 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1104 asymbol
*sym
= *symptr
;
1108 sec
= bfd_get_section (sym
);
1110 /* BFD symbols are section relative. */
1111 sym_value
= sym
->value
+ sec
->vma
;
1113 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1115 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1118 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1120 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1123 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1125 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1131 if (sym
->flags
& BSF_GLOBAL
)
1134 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1139 /* Symbols from shared libraries have a dynamic relocation entry
1140 that points to the associated slot in the procedure linkage table.
1141 We make a mininal symbol table entry with type mst_solib_trampoline
1142 at the address in the procedure linkage table. */
1143 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1144 if (dynrel_size
< 0)
1146 do_cleanups (back_to
);
1150 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1151 make_cleanup (free
, dynrels
);
1153 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1154 if (dynrel_count
< 0)
1156 do_cleanups (back_to
);
1160 for (counter
= 0, relptr
= dynrels
;
1161 counter
< dynrel_count
;
1162 counter
++, relptr
++)
1164 arelent
*rel
= *relptr
;
1166 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1168 switch (bfd_get_arch (abfd
))
1170 case bfd_arch_sparc
:
1171 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1175 /* `16' is the type BFD produces for a jump table relocation. */
1176 if (rel
->howto
->type
!= 16)
1179 /* Adjust address in the jump table to point to
1180 the start of the bsr instruction. */
1187 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1188 prim_record_minimal_symbol (name
, address
, mst_solib_trampoline
,
1192 do_cleanups (back_to
);
1195 /* Given pointers to an a.out symbol table in core containing dbx
1196 style data, setup partial_symtab's describing each source file for
1197 which debugging information is available.
1198 SYMFILE_NAME is the name of the file we are reading from
1199 and SECTION_OFFSETS is the set of offsets for the various sections
1200 of the file (a set of zeros if the mainline program). */
1203 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1204 struct section_offsets
*section_offsets
;
1205 struct objfile
*objfile
;
1206 CORE_ADDR text_addr
;
1209 register struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1210 struct internal_nlist nlist
;
1212 register char *namestring
;
1214 int past_first_source_file
= 0;
1215 CORE_ADDR last_o_file_start
= 0;
1216 CORE_ADDR last_function_start
= 0;
1217 struct cleanup
*back_to
;
1219 int textlow_not_set
;
1221 /* Current partial symtab */
1222 struct partial_symtab
*pst
;
1224 /* List of current psymtab's include files */
1225 char **psymtab_include_list
;
1226 int includes_allocated
;
1229 /* Index within current psymtab dependency list */
1230 struct partial_symtab
**dependency_list
;
1231 int dependencies_used
, dependencies_allocated
;
1233 /* FIXME. We probably want to change stringtab_global rather than add this
1234 while processing every symbol entry. FIXME. */
1235 file_string_table_offset
= 0;
1236 next_file_string_table_offset
= 0;
1238 stringtab_global
= DBX_STRINGTAB (objfile
);
1240 pst
= (struct partial_symtab
*) 0;
1242 includes_allocated
= 30;
1244 psymtab_include_list
= (char **) alloca (includes_allocated
*
1247 dependencies_allocated
= 30;
1248 dependencies_used
= 0;
1250 (struct partial_symtab
**) alloca (dependencies_allocated
*
1251 sizeof (struct partial_symtab
*));
1253 /* Init bincl list */
1254 init_bincl_list (20, objfile
);
1255 back_to
= make_cleanup ((make_cleanup_func
) free_bincl_list
, objfile
);
1257 last_source_file
= NULL
;
1259 lowest_text_address
= (CORE_ADDR
)-1;
1261 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1262 abfd
= objfile
->obfd
;
1263 symbuf_end
= symbuf_idx
= 0;
1264 next_symbol_text_func
= dbx_next_symbol_text
;
1265 textlow_not_set
= 1;
1266 has_line_numbers
= 0;
1268 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1270 /* Get the symbol for this run and pull out some info */
1271 QUIT
; /* allow this to be interruptable */
1272 if (symbuf_idx
== symbuf_end
)
1274 bufp
= &symbuf
[symbuf_idx
++];
1277 * Special case to speed up readin.
1279 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1281 has_line_numbers
= 1;
1285 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1286 OBJSTAT (objfile
, n_stabs
++);
1288 /* Ok. There is a lot of code duplicated in the rest of this
1289 switch statement (for efficiency reasons). Since I don't
1290 like duplicating code, I will do my penance here, and
1291 describe the code which is duplicated:
1293 *) The assignment to namestring.
1294 *) The call to strchr.
1295 *) The addition of a partial symbol the the two partial
1296 symbol lists. This last is a large section of code, so
1297 I've imbedded it in the following macro.
1300 /* Set namestring based on nlist. If the string table index is invalid,
1301 give a fake name, and print a single error message per symbol file read,
1302 rather than abort the symbol reading or flood the user with messages. */
1304 /*FIXME: Too many adds and indirections in here for the inner loop. */
1305 #define SET_NAMESTRING()\
1306 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1307 DBX_STRINGTAB_SIZE (objfile)) { \
1308 complain (&string_table_offset_complaint, symnum); \
1309 namestring = "<bad string table offset>"; \
1311 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1312 DBX_STRINGTAB (objfile)
1314 #define CUR_SYMBOL_TYPE nlist.n_type
1315 #define CUR_SYMBOL_VALUE nlist.n_value
1316 #define CUR_SYMBOL_STRX nlist.n_strx
1317 #define DBXREAD_ONLY
1318 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1319 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1320 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1321 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1323 #include "partial-stab.h"
1326 /* If there's stuff to be cleaned up, clean it up. */
1327 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1328 /*FIXME, does this have a bug at start address 0? */
1329 && last_o_file_start
1330 && objfile
-> ei
.entry_point
< nlist
.n_value
1331 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1333 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1334 objfile
-> ei
.entry_file_highpc
= nlist
.n_value
;
1339 /* Don't set pst->texthigh lower than it already is. */
1340 CORE_ADDR text_end
=
1341 (lowest_text_address
== (CORE_ADDR
)-1
1342 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1343 : lowest_text_address
)
1346 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1347 symnum
* symbol_size
,
1348 text_end
> pst
->texthigh
? text_end
: pst
->texthigh
,
1349 dependency_list
, dependencies_used
, textlow_not_set
);
1352 do_cleanups (back_to
);
1355 /* Allocate and partially fill a partial symtab. It will be
1356 completely filled at the end of the symbol list.
1358 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1359 is the address relative to which its symbols are (incremental) or 0
1363 struct partial_symtab
*
1364 start_psymtab (objfile
, section_offsets
,
1365 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1366 struct objfile
*objfile
;
1367 struct section_offsets
*section_offsets
;
1371 struct partial_symbol
**global_syms
;
1372 struct partial_symbol
**static_syms
;
1374 struct partial_symtab
*result
=
1375 start_psymtab_common(objfile
, section_offsets
,
1376 filename
, textlow
, global_syms
, static_syms
);
1378 result
->read_symtab_private
= (char *)
1379 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1380 LDSYMOFF(result
) = ldsymoff
;
1381 result
->read_symtab
= dbx_psymtab_to_symtab
;
1382 SYMBOL_SIZE(result
) = symbol_size
;
1383 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1384 STRING_OFFSET(result
) = string_table_offset
;
1385 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1387 /* If we're handling an ELF file, drag some section-relocation info
1388 for this source file out of the ELF symbol table, to compensate for
1389 Sun brain death. This replaces the section_offsets in this psymtab,
1391 elfstab_offset_sections (objfile
, result
);
1393 /* Deduce the source language from the filename for this psymtab. */
1394 psymtab_language
= deduce_language_from_filename (filename
);
1399 /* Close off the current usage of PST.
1400 Returns PST or NULL if the partial symtab was empty and thrown away.
1402 FIXME: List variables and peculiarities of same. */
1404 struct partial_symtab
*
1405 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1406 capping_text
, dependency_list
, number_dependencies
, textlow_not_set
)
1407 struct partial_symtab
*pst
;
1408 char **include_list
;
1410 int capping_symbol_offset
;
1411 CORE_ADDR capping_text
;
1412 struct partial_symtab
**dependency_list
;
1413 int number_dependencies
;
1414 int textlow_not_set
;
1417 struct objfile
*objfile
= pst
-> objfile
;
1419 if (capping_symbol_offset
!= -1)
1420 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1421 pst
->texthigh
= capping_text
;
1423 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1424 /* Under Solaris, the N_SO symbols always have a value of 0,
1425 instead of the usual address of the .o file. Therefore,
1426 we have to do some tricks to fill in texthigh and textlow.
1427 The first trick is in partial-stab.h: if we see a static
1428 or global function, and the textlow for the current pst
1429 is not set (ie: textlow_not_set), then we use that function's
1430 address for the textlow of the pst. */
1432 /* Now, to fill in texthigh, we remember the last function seen
1433 in the .o file (also in partial-stab.h). Also, there's a hack in
1434 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1435 to here via the misc_info field. Therefore, we can fill in
1436 a reliable texthigh by taking the address plus size of the
1437 last function in the file. */
1439 if (pst
->texthigh
== 0 && last_function_name
)
1443 struct minimal_symbol
*minsym
;
1445 p
= strchr (last_function_name
, ':');
1447 p
= last_function_name
;
1448 n
= p
- last_function_name
;
1450 strncpy (p
, last_function_name
, n
);
1453 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1456 /* Sun Fortran appends an underscore to the minimal symbol name,
1457 try again with an appended underscore if the minimal symbol
1461 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1465 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) + MSYMBOL_SIZE (minsym
);
1467 last_function_name
= NULL
;
1470 /* this test will be true if the last .o file is only data */
1471 if (textlow_not_set
)
1472 pst
->textlow
= pst
->texthigh
;
1475 struct partial_symtab
*p1
;
1477 /* If we know our own starting text address, then walk through all other
1478 psymtabs for this objfile, and if any didn't know their ending text
1479 address, set it to our starting address. Take care to not set our
1480 own ending address to our starting address, nor to set addresses on
1481 `dependency' files that have both textlow and texthigh zero. */
1483 ALL_OBJFILE_PSYMTABS (objfile
, p1
)
1485 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
)
1487 p1
->texthigh
= pst
->textlow
;
1488 /* if this file has only data, then make textlow match texthigh */
1489 if (p1
->textlow
== 0)
1490 p1
->textlow
= p1
->texthigh
;
1495 /* End of kludge for patching Solaris textlow and texthigh. */
1496 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1498 pst
->n_global_syms
=
1499 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1500 pst
->n_static_syms
=
1501 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1503 pst
->number_of_dependencies
= number_dependencies
;
1504 if (number_dependencies
)
1506 pst
->dependencies
= (struct partial_symtab
**)
1507 obstack_alloc (&objfile
->psymbol_obstack
,
1508 number_dependencies
* sizeof (struct partial_symtab
*));
1509 memcpy (pst
->dependencies
, dependency_list
,
1510 number_dependencies
* sizeof (struct partial_symtab
*));
1513 pst
->dependencies
= 0;
1515 for (i
= 0; i
< num_includes
; i
++)
1517 struct partial_symtab
*subpst
=
1518 allocate_psymtab (include_list
[i
], objfile
);
1520 subpst
->section_offsets
= pst
->section_offsets
;
1521 subpst
->read_symtab_private
=
1522 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1523 sizeof (struct symloc
));
1527 subpst
->texthigh
= 0;
1529 /* We could save slight bits of space by only making one of these,
1530 shared by the entire set of include files. FIXME-someday. */
1531 subpst
->dependencies
= (struct partial_symtab
**)
1532 obstack_alloc (&objfile
->psymbol_obstack
,
1533 sizeof (struct partial_symtab
*));
1534 subpst
->dependencies
[0] = pst
;
1535 subpst
->number_of_dependencies
= 1;
1537 subpst
->globals_offset
=
1538 subpst
->n_global_syms
=
1539 subpst
->statics_offset
=
1540 subpst
->n_static_syms
= 0;
1544 subpst
->read_symtab
= pst
->read_symtab
;
1547 sort_pst_symbols (pst
);
1549 /* If there is already a psymtab or symtab for a file of this name, remove it.
1550 (If there is a symtab, more drastic things also happen.)
1551 This happens in VxWorks. */
1552 free_named_symtabs (pst
->filename
);
1554 if (num_includes
== 0
1555 && number_dependencies
== 0
1556 && pst
->n_global_syms
== 0
1557 && pst
->n_static_syms
== 0
1558 && has_line_numbers
== 0)
1560 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1561 it is on the obstack, but we can forget to chain it on the list. */
1562 /* Empty psymtabs happen as a result of header files which don't have
1563 any symbols in them. There can be a lot of them. But this check
1564 is wrong, in that a psymtab with N_SLINE entries but nothing else
1565 is not empty, but we don't realize that. Fixing that without slowing
1566 things down might be tricky. */
1568 discard_psymtab (pst
);
1570 /* Indicate that psymtab was thrown away. */
1571 pst
= (struct partial_symtab
*)NULL
;
1577 dbx_psymtab_to_symtab_1 (pst
)
1578 struct partial_symtab
*pst
;
1580 struct cleanup
*old_chain
;
1588 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1593 /* Read in all partial symtabs on which this one is dependent */
1594 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1595 if (!pst
->dependencies
[i
]->readin
)
1597 /* Inform about additional files that need to be read in. */
1600 fputs_filtered (" ", gdb_stdout
);
1602 fputs_filtered ("and ", gdb_stdout
);
1604 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1605 wrap_here (""); /* Flush output */
1606 gdb_flush (gdb_stdout
);
1608 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1611 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1613 /* Init stuff necessary for reading in symbols */
1616 old_chain
= make_cleanup ((make_cleanup_func
) really_free_pendings
, 0);
1617 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1618 symbol_size
= SYMBOL_SIZE (pst
);
1620 /* Read in this file's symbols */
1621 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1622 read_ofile_symtab (pst
);
1623 sort_symtab_syms (pst
->symtab
);
1625 do_cleanups (old_chain
);
1631 /* Read in all of the symbols for a given psymtab for real.
1632 Be verbose about it if the user wants that. */
1635 dbx_psymtab_to_symtab (pst
)
1636 struct partial_symtab
*pst
;
1645 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1650 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1652 /* Print the message now, before reading the string table,
1653 to avoid disconcerting pauses. */
1656 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1657 gdb_flush (gdb_stdout
);
1660 sym_bfd
= pst
->objfile
->obfd
;
1662 next_symbol_text_func
= dbx_next_symbol_text
;
1664 dbx_psymtab_to_symtab_1 (pst
);
1666 /* Match with global symbols. This only needs to be done once,
1667 after all of the symtabs and dependencies have been read in. */
1668 scan_file_globals (pst
->objfile
);
1670 /* Finish up the debug error message. */
1672 printf_filtered ("done.\n");
1676 /* Read in a defined section of a specific object file's symbols. */
1679 read_ofile_symtab (pst
)
1680 struct partial_symtab
*pst
;
1682 register char *namestring
;
1683 register struct external_nlist
*bufp
;
1684 struct internal_nlist nlist
;
1686 unsigned max_symnum
;
1688 struct objfile
*objfile
;
1689 int sym_offset
; /* Offset to start of symbols to read */
1690 int sym_size
; /* Size of symbols to read */
1691 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1692 int text_size
; /* Size of text segment for symbols */
1693 struct section_offsets
*section_offsets
;
1695 objfile
= pst
->objfile
;
1696 sym_offset
= LDSYMOFF(pst
);
1697 sym_size
= LDSYMLEN(pst
);
1698 text_offset
= pst
->textlow
;
1699 text_size
= pst
->texthigh
- pst
->textlow
;
1700 section_offsets
= pst
->section_offsets
;
1702 current_objfile
= objfile
;
1703 subfile_stack
= NULL
;
1705 stringtab_global
= DBX_STRINGTAB (objfile
);
1706 last_source_file
= NULL
;
1708 abfd
= objfile
->obfd
;
1709 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1710 symbuf_end
= symbuf_idx
= 0;
1712 /* It is necessary to actually read one symbol *before* the start
1713 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1714 occurs before the N_SO symbol.
1716 Detecting this in read_dbx_symtab
1717 would slow down initial readin, so we look for it here instead. */
1718 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1720 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1722 bufp
= &symbuf
[symbuf_idx
++];
1723 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1724 OBJSTAT (objfile
, n_stabs
++);
1728 processing_gcc_compilation
= 0;
1729 if (nlist
.n_type
== N_TEXT
)
1731 const char *tempstring
= namestring
;
1733 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1734 processing_gcc_compilation
= 1;
1735 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1736 processing_gcc_compilation
= 2;
1737 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1739 if (STREQN (tempstring
, "__gnu_compiled", 14))
1740 processing_gcc_compilation
= 2;
1743 /* Try to select a C++ demangling based on the compilation unit
1746 if (processing_gcc_compilation
)
1748 if (AUTO_DEMANGLING
)
1750 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1756 /* The N_SO starting this symtab is the first symbol, so we
1757 better not check the symbol before it. I'm not this can
1758 happen, but it doesn't hurt to check for it. */
1759 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1760 processing_gcc_compilation
= 0;
1763 if (symbuf_idx
== symbuf_end
)
1765 bufp
= &symbuf
[symbuf_idx
];
1766 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
1767 error("First symbol in segment of executable not a source symbol");
1769 max_symnum
= sym_size
/ symbol_size
;
1772 symnum
< max_symnum
;
1775 QUIT
; /* Allow this to be interruptable */
1776 if (symbuf_idx
== symbuf_end
)
1778 bufp
= &symbuf
[symbuf_idx
++];
1779 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1780 OBJSTAT (objfile
, n_stabs
++);
1782 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
1786 if (type
& N_STAB
) {
1787 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
1788 namestring
, section_offsets
, objfile
);
1790 /* We skip checking for a new .o or -l file; that should never
1791 happen in this routine. */
1792 else if (type
== N_TEXT
)
1794 /* I don't think this code will ever be executed, because
1795 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1796 the N_SO symbol which starts this source file.
1797 However, there is no reason not to accept
1798 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1800 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1801 processing_gcc_compilation
= 1;
1802 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1803 processing_gcc_compilation
= 2;
1805 if (AUTO_DEMANGLING
)
1807 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1810 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1811 || type
== (unsigned char)N_NBTEXT
1813 /* Global symbol: see if we came across a dbx defintion for
1814 a corresponding symbol. If so, store the value. Remove
1815 syms from the chain when their values are stored, but
1816 search the whole chain, as there may be several syms from
1817 different files with the same name. */
1818 /* This is probably not true. Since the files will be read
1819 in one at a time, each reference to a global symbol will
1820 be satisfied in each file as it appears. So we skip this
1826 current_objfile
= NULL
;
1828 /* In a Solaris elf file, this variable, which comes from the
1829 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1830 which comes from pst->textlow is correct. */
1831 if (last_source_start_addr
== 0)
1832 last_source_start_addr
= text_offset
;
1834 /* In reordered executables last_source_start_addr may not be the
1835 lower bound for this symtab, instead use text_offset which comes
1836 from pst->textlow which is correct. */
1837 if (last_source_start_addr
> text_offset
)
1838 last_source_start_addr
= text_offset
;
1840 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1842 /* Process items which we had to "process_later" due to dependancies
1844 process_now (objfile
);
1850 /* This handles a single symbol from the symbol-file, building symbols
1851 into a GDB symtab. It takes these arguments and an implicit argument.
1853 TYPE is the type field of the ".stab" symbol entry.
1854 DESC is the desc field of the ".stab" entry.
1855 VALU is the value field of the ".stab" entry.
1856 NAME is the symbol name, in our address space.
1857 SECTION_OFFSETS is a set of amounts by which the sections of this object
1858 file were relocated when it was loaded into memory.
1859 All symbols that refer
1860 to memory locations need to be offset by these amounts.
1861 OBJFILE is the object file from which we are reading symbols.
1862 It is used in end_symtab. */
1865 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1869 struct section_offsets
*section_offsets
;
1870 struct objfile
*objfile
;
1872 #ifdef SUN_FIXED_LBRAC_BUG
1873 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1874 to correct the address of N_LBRAC's. If it is not defined, then
1875 we never need to correct the addresses. */
1877 /* This records the last pc address we've seen. We depend on there being
1878 an SLINE or FUN or SO before the first LBRAC, since the variable does
1879 not get reset in between reads of different symbol files. */
1880 static CORE_ADDR last_pc_address
;
1883 register struct context_stack
*new;
1884 /* This remembers the address of the start of a function. It is used
1885 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1886 relative to the current function's start address. On systems
1887 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1888 used to relocate these symbol types rather than SECTION_OFFSETS. */
1889 static CORE_ADDR function_start_offset
;
1891 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1892 file. Used to detect the SunPRO solaris compiler. */
1893 static int n_opt_found
;
1895 /* The stab type used for the definition of the last function.
1896 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1897 static int function_stab_type
= 0;
1899 if (!block_address_function_relative
)
1900 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1901 function start address, so just use the text offset. */
1902 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1904 /* Something is wrong if we see real data before
1905 seeing a source file name. */
1907 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1909 /* Ignore any symbols which appear before an N_SO symbol.
1910 Currently no one puts symbols there, but we should deal
1911 gracefully with the case. A complain()t might be in order,
1912 but this should not be an error (). */
1921 if (*name
== '\000')
1923 /* This N_FUN marks the end of a function. This closes off the
1925 within_function
= 0;
1926 new = pop_context ();
1928 /* Make a block for the local symbols within. */
1929 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1930 new->start_addr
, new->start_addr
+ valu
,
1933 /* May be switching to an assembler file which may not be using
1934 block relative stabs, so reset the offset. */
1935 if (block_address_function_relative
)
1936 function_start_offset
= 0;
1941 /* Relocate for dynamic loading */
1942 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1943 #ifdef SMASH_TEXT_ADDRESS
1944 SMASH_TEXT_ADDRESS (valu
);
1946 goto define_a_symbol
;
1949 /* This "symbol" just indicates the start of an inner lexical
1950 context within a function. */
1952 /* Ignore extra outermost context from SunPRO cc and acc. */
1953 if (n_opt_found
&& desc
== 1)
1956 if (block_address_function_relative
)
1957 /* Relocate for Sun ELF acc fn-relative syms. */
1958 valu
+= function_start_offset
;
1960 /* On most machines, the block addresses are relative to the
1961 N_SO, the linker did not relocate them (sigh). */
1962 valu
+= last_source_start_addr
;
1964 #ifdef SUN_FIXED_LBRAC_BUG
1965 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1966 /* Patch current LBRAC pc value to match last handy pc value */
1967 complain (&lbrac_complaint
);
1968 valu
= last_pc_address
;
1971 new = push_context (desc
, valu
);
1975 /* This "symbol" just indicates the end of an inner lexical
1976 context that was started with N_LBRAC. */
1978 /* Ignore extra outermost context from SunPRO cc and acc. */
1979 if (n_opt_found
&& desc
== 1)
1982 if (block_address_function_relative
)
1983 /* Relocate for Sun ELF acc fn-relative syms. */
1984 valu
+= function_start_offset
;
1986 /* On most machines, the block addresses are relative to the
1987 N_SO, the linker did not relocate them (sigh). */
1988 valu
+= last_source_start_addr
;
1990 new = pop_context();
1991 if (desc
!= new->depth
)
1992 complain (&lbrac_mismatch_complaint
, symnum
);
1994 /* Some compilers put the variable decls inside of an
1995 LBRAC/RBRAC block. This macro should be nonzero if this
1996 is true. DESC is N_DESC from the N_RBRAC symbol.
1997 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1998 or the GCC2_COMPILED_SYMBOL. */
1999 #if !defined (VARIABLES_INSIDE_BLOCK)
2000 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2003 /* Can only use new->locals as local symbols here if we're in
2004 gcc or on a machine that puts them before the lbrack. */
2005 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2006 local_symbols
= new->locals
;
2008 if (context_stack_depth
2009 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2011 /* This is not the outermost LBRAC...RBRAC pair in the function,
2012 its local symbols preceded it, and are the ones just recovered
2013 from the context stack. Define the block for them (but don't
2014 bother if the block contains no symbols. Should we complain
2015 on blocks without symbols? I can't think of any useful purpose
2017 if (local_symbols
!= NULL
)
2019 /* Muzzle a compiler bug that makes end < start. (which
2020 compilers? Is this ever harmful?). */
2021 if (new->start_addr
> valu
)
2023 complain (&lbrac_rbrac_complaint
);
2024 new->start_addr
= valu
;
2026 /* Make a block for the local symbols within. */
2027 finish_block (0, &local_symbols
, new->old_blocks
,
2028 new->start_addr
, valu
, objfile
);
2033 /* This is the outermost LBRAC...RBRAC pair. There is no
2034 need to do anything; leave the symbols that preceded it
2035 to be attached to the function's own block. We need to
2036 indicate that we just moved outside of the function. */
2037 within_function
= 0;
2040 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2041 /* Now pop locals of block just finished. */
2042 local_symbols
= new->locals
;
2047 /* This kind of symbol indicates the start of an object file. */
2048 /* Relocate for dynamic loading */
2049 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2053 /* This type of symbol indicates the start of data
2054 for one source file.
2055 Finish the symbol table of the previous source file
2056 (if any) and start accumulating a new symbol table. */
2057 /* Relocate for dynamic loading */
2058 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2062 #ifdef SUN_FIXED_LBRAC_BUG
2063 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2066 #ifdef PCC_SOL_BROKEN
2067 /* pcc bug, occasionally puts out SO for SOL. */
2068 if (context_stack_depth
> 0)
2070 start_subfile (name
, NULL
);
2074 if (last_source_file
)
2076 /* Check if previous symbol was also an N_SO (with some
2077 sanity checks). If so, that one was actually the directory
2078 name, and the current one is the real file name.
2080 if (previous_stab_code
== (unsigned char) N_SO
)
2082 patch_subfile_names (current_subfile
, name
);
2083 break; /* Ignore repeated SOs */
2085 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
2089 /* Null name means this just marks the end of text for this .o file.
2090 Don't start a new symtab in this case. */
2091 if (*name
== '\000')
2094 if (block_address_function_relative
)
2095 function_start_offset
= 0;
2098 start_symtab (name
, NULL
, valu
);
2099 record_debugformat ("stabs");
2103 /* This type of symbol indicates the start of data for
2104 a sub-source-file, one whose contents were copied or
2105 included in the compilation of the main source file
2106 (whose name was given in the N_SO symbol.) */
2107 /* Relocate for dynamic loading */
2108 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2109 start_subfile (name
, current_subfile
->dirname
);
2114 add_new_header_file (name
, valu
);
2115 start_subfile (name
, current_subfile
->dirname
);
2119 start_subfile (pop_subfile (), current_subfile
->dirname
);
2123 add_old_header_file (name
, valu
);
2127 /* This type of "symbol" really just records
2128 one line-number -- core-address correspondence.
2129 Enter it in the line list for this symbol table. */
2131 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2132 valu
+= function_start_offset
;
2134 #ifdef SUN_FIXED_LBRAC_BUG
2135 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2137 record_line (current_subfile
, desc
, valu
);
2141 common_block_start (name
, objfile
);
2145 common_block_end (objfile
);
2148 /* The following symbol types need to have the appropriate offset added
2149 to their value; then we process symbol definitions in the name. */
2151 case N_STSYM
: /* Static symbol in data seg */
2152 case N_LCSYM
: /* Static symbol in BSS seg */
2153 case N_ROSYM
: /* Static symbol in Read-only data seg */
2154 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2155 Solaris2's stabs-in-elf makes *most* symbols relative
2156 but leaves a few absolute (at least for Solaris 2.1 and version
2157 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2158 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2159 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2160 This leaves us no choice but to search for the 'S' or 'V'...
2161 (or pass the whole section_offsets stuff down ONE MORE function
2162 call level, which we really don't want to do). */
2166 /* .o files and NLMs have non-zero text seg offsets, but don't need
2167 their static syms offset in this fashion. XXX - This is really a
2168 crock that should be fixed in the solib handling code so that I
2169 don't have to work around it here. */
2171 if (!symfile_relocatable
)
2173 p
= strchr (name
, ':');
2174 if (p
!= 0 && p
[1] == 'S')
2176 /* The linker relocated it. We don't want to add an
2177 elfstab_offset_sections-type offset, but we *do* want
2178 to add whatever solib.c passed to symbol_file_add as
2179 addr (this is known to affect SunOS4, and I suspect ELF
2180 too). Since elfstab_offset_sections currently does not
2181 muck with the text offset (there is no Ttext.text
2182 symbol), we can get addr from the text offset. If
2183 elfstab_offset_sections ever starts dealing with the
2184 text offset, and we still need to do this, we need to
2185 invent a SECT_OFF_ADDR_KLUDGE or something. */
2186 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2187 goto define_a_symbol
;
2190 /* Since it's not the kludge case, re-dispatch to the right handler. */
2192 case N_STSYM
: goto case_N_STSYM
;
2193 case N_LCSYM
: goto case_N_LCSYM
;
2194 case N_ROSYM
: goto case_N_ROSYM
;
2199 case_N_STSYM
: /* Static symbol in data seg */
2200 case N_DSLINE
: /* Source line number, data seg */
2201 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2202 goto define_a_symbol
;
2204 case_N_LCSYM
: /* Static symbol in BSS seg */
2205 case N_BSLINE
: /* Source line number, bss seg */
2206 /* N_BROWS: overlaps with N_BSLINE */
2207 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2208 goto define_a_symbol
;
2210 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2211 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2212 goto define_a_symbol
;
2214 case N_ENTRY
: /* Alternate entry point */
2215 /* Relocate for dynamic loading */
2216 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2217 goto define_a_symbol
;
2219 /* The following symbol types we don't know how to process. Handle
2220 them in a "default" way, but complain to people who care. */
2222 case N_CATCH
: /* Exception handler catcher */
2223 case N_EHDECL
: /* Exception handler name */
2224 case N_PC
: /* Global symbol in Pascal */
2225 case N_M2C
: /* Modula-2 compilation unit */
2226 /* N_MOD2: overlaps with N_EHDECL */
2227 case N_SCOPE
: /* Modula-2 scope information */
2228 case N_ECOML
: /* End common (local name) */
2229 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2234 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2237 /* The following symbol types don't need the address field relocated,
2238 since it is either unused, or is absolute. */
2240 case N_GSYM
: /* Global variable */
2241 case N_NSYMS
: /* Number of symbols (ultrix) */
2242 case N_NOMAP
: /* No map? (ultrix) */
2243 case N_RSYM
: /* Register variable */
2244 case N_DEFD
: /* Modula-2 GNU module dependency */
2245 case N_SSYM
: /* Struct or union element */
2246 case N_LSYM
: /* Local symbol in stack */
2247 case N_PSYM
: /* Parameter variable */
2248 case N_LENG
: /* Length of preceding symbol type */
2252 char *colon_pos
= strchr (name
, ':');
2253 if (colon_pos
== NULL
)
2256 deftype
= colon_pos
[1];
2262 function_stab_type
= type
;
2264 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2265 /* Deal with the SunPRO 3.0 compiler which omits the address
2266 from N_FUN symbols. */
2268 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2270 struct minimal_symbol
*msym
;
2274 p
= strchr (name
, ':');
2279 strncpy (p
, name
, n
);
2282 msym
= lookup_minimal_symbol (p
, last_source_file
,
2286 /* Sun Fortran appends an underscore to the minimal
2287 symbol name, try again with an appended underscore
2288 if the minimal symbol was not found. */
2291 msym
= lookup_minimal_symbol (p
, last_source_file
,
2295 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2299 #ifdef SUN_FIXED_LBRAC_BUG
2300 /* The Sun acc compiler, under SunOS4, puts out
2301 functions with N_GSYM or N_STSYM. The problem is
2302 that the address of the symbol is no good (for N_GSYM
2303 it doesn't even attept an address; for N_STSYM it
2304 puts out an address but then it gets relocated
2305 relative to the data segment, not the text segment).
2306 Currently we can't fix this up later as we do for
2307 some types of symbol in scan_file_globals.
2308 Fortunately we do have a way of finding the address -
2309 we know that the value in last_pc_address is either
2310 the one we want (if we're dealing with the first
2311 function in an object file), or somewhere in the
2312 previous function. This means that we can use the
2313 minimal symbol table to get the address. */
2315 /* Starting with release 3.0, the Sun acc compiler,
2316 under SunOS4, puts out functions with N_FUN and a value
2317 of zero. This gets relocated to the start of the text
2318 segment of the module, which is no good either.
2319 Under SunOS4 we can deal with this as N_SLINE and N_SO
2320 entries contain valid absolute addresses.
2321 Release 3.0 acc also puts out N_OPT entries, which makes
2322 it possible to discern acc from cc or gcc. */
2324 if (type
== N_GSYM
|| type
== N_STSYM
2326 && n_opt_found
&& !block_address_function_relative
))
2328 struct minimal_symbol
*m
;
2329 int l
= colon_pos
- name
;
2331 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2332 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2333 && SYMBOL_NAME (m
) [l
] == '\0')
2334 /* last_pc_address was in this function */
2335 valu
= SYMBOL_VALUE (m
);
2336 else if (m
&& SYMBOL_NAME (m
+1)
2337 && STREQN (SYMBOL_NAME (m
+1), name
, l
)
2338 && SYMBOL_NAME (m
+1) [l
] == '\0')
2339 /* last_pc_address was in last function */
2340 valu
= SYMBOL_VALUE (m
+1);
2342 /* Not found - use last_pc_address (for finish_block) */
2343 valu
= last_pc_address
;
2346 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2349 if (block_address_function_relative
)
2350 /* For Solaris 2.0 compilers, the block addresses and
2351 N_SLINE's are relative to the start of the
2352 function. On normal systems, and when using gcc on
2353 Solaris 2.0, these addresses are just absolute, or
2354 relative to the N_SO, depending on
2355 BLOCK_ADDRESS_ABSOLUTE. */
2356 function_start_offset
= valu
;
2358 within_function
= 1;
2359 if (context_stack_depth
> 0)
2361 new = pop_context ();
2362 /* Make a block for the local symbols within. */
2363 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2364 new->start_addr
, valu
, objfile
);
2366 /* Stack must be empty now. */
2367 if (context_stack_depth
!= 0)
2368 complain (&lbrac_unmatched_complaint
, symnum
);
2370 new = push_context (0, valu
);
2371 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2375 define_symbol (valu
, name
, desc
, type
, objfile
);
2381 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2382 for a bunch of other flags, too. Someday we may parse their
2383 flags; for now we ignore theirs and hope they'll ignore ours. */
2384 case N_OPT
: /* Solaris 2: Compiler options */
2387 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2389 processing_gcc_compilation
= 2;
2390 #if 1 /* Works, but is experimental. -fnf */
2391 if (AUTO_DEMANGLING
)
2393 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2402 /* The following symbol types can be ignored. */
2403 case N_OBJ
: /* Solaris 2: Object file dir and name */
2404 /* N_UNDF: Solaris 2: file separator mark */
2405 /* N_UNDF: -- we will never encounter it, since we only process one
2406 file's symbols at once. */
2407 case N_ENDM
: /* Solaris 2: End of module */
2408 case N_MAIN
: /* Name of main routine. */
2409 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
2413 /* '#' is a GNU C extension to allow one symbol to refer to another
2416 Generally this is used so that an alias can refer to its main
2420 /* Initialize symbol reference names and determine if this is
2421 a definition. If symbol reference is being defined, go
2422 ahead and add it. Otherwise, just return sym. */
2427 /* If this stab defines a new reference ID that is not on the
2428 reference list, then put it on the reference list.
2430 We go ahead and advance NAME past the reference, even though
2431 it is not strictly necessary at this time. */
2432 refnum
= symbol_reference_defined (&s
);
2434 if (!ref_search (refnum
))
2435 ref_add (refnum
, 0, name
, valu
);
2440 previous_stab_code
= type
;
2443 /* FIXME: The only difference between this and elfstab_build_psymtabs
2444 is the call to install_minimal_symbols for elf, and the support for
2445 split sections. If the differences are really that small, the code
2446 should be shared. */
2448 /* Scan and build partial symbols for an coff symbol file.
2449 The coff file has already been processed to get its minimal symbols.
2451 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2454 OBJFILE is the object file we are reading symbols from.
2455 ADDR is the address relative to which the symbols are (e.g.
2456 the base address of the text segment).
2457 MAINLINE is true if we are reading the main symbol
2458 table (as opposed to a shared lib or dynamically loaded file).
2459 TEXTADDR is the address of the text section.
2460 TEXTSIZE is the size of the text section.
2461 STABSECTS is the list of .stab sections in OBJFILE.
2462 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2463 .stabstr section exists.
2465 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2466 adjusted for coff details. */
2469 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2470 textaddr
, textsize
, stabsects
,
2471 stabstroffset
, stabstrsize
)
2472 struct objfile
*objfile
;
2473 struct section_offsets
*section_offsets
;
2476 unsigned int textsize
;
2477 struct stab_section_list
*stabsects
;
2478 file_ptr stabstroffset
;
2479 unsigned int stabstrsize
;
2482 bfd
*sym_bfd
= objfile
->obfd
;
2483 char *name
= bfd_get_filename (sym_bfd
);
2484 struct dbx_symfile_info
*info
;
2485 unsigned int stabsize
;
2487 /* There is already a dbx_symfile_info allocated by our caller.
2488 It might even contain some info from the coff symtab to help us. */
2489 info
= objfile
->sym_stab_info
;
2491 DBX_TEXT_ADDR (objfile
) = textaddr
;
2492 DBX_TEXT_SIZE (objfile
) = textsize
;
2494 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2495 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2496 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2498 if (stabstrsize
> bfd_get_size (sym_bfd
))
2499 error ("ridiculous string table size: %d bytes", stabstrsize
);
2500 DBX_STRINGTAB (objfile
) = (char *)
2501 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2502 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2504 /* Now read in the string table in one big gulp. */
2506 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2508 perror_with_name (name
);
2509 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2510 if (val
!= stabstrsize
)
2511 perror_with_name (name
);
2513 stabsread_new_init ();
2514 buildsym_new_init ();
2515 free_header_files ();
2516 init_header_files ();
2518 processing_acc_compilation
= 1;
2520 /* In a coff file, we've already installed the minimal symbols that came
2521 from the coff (non-stab) symbol table, so always act like an
2522 incremental load here. */
2523 if (stabsects
->next
== NULL
)
2525 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2526 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2527 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2531 struct stab_section_list
*stabsect
;
2533 DBX_SYMCOUNT (objfile
) = 0;
2534 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2536 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2537 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2540 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2542 symbuf_sections
= stabsects
->next
;
2543 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2547 dbx_symfile_read (objfile
, section_offsets
, 0);
2550 /* Scan and build partial symbols for an ELF symbol file.
2551 This ELF file has already been processed to get its minimal symbols,
2552 and any DWARF symbols that were in it.
2554 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2557 OBJFILE is the object file we are reading symbols from.
2558 ADDR is the address relative to which the symbols are (e.g.
2559 the base address of the text segment).
2560 MAINLINE is true if we are reading the main symbol
2561 table (as opposed to a shared lib or dynamically loaded file).
2562 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2564 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2565 .stabstr section exists.
2567 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2568 adjusted for elf details. */
2571 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2572 staboffset
, stabsize
,
2573 stabstroffset
, stabstrsize
)
2574 struct objfile
*objfile
;
2575 struct section_offsets
*section_offsets
;
2577 file_ptr staboffset
;
2578 unsigned int stabsize
;
2579 file_ptr stabstroffset
;
2580 unsigned int stabstrsize
;
2583 bfd
*sym_bfd
= objfile
->obfd
;
2584 char *name
= bfd_get_filename (sym_bfd
);
2585 struct dbx_symfile_info
*info
;
2586 asection
*text_sect
;
2588 /* There is already a dbx_symfile_info allocated by our caller.
2589 It might even contain some info from the ELF symtab to help us. */
2590 info
= objfile
->sym_stab_info
;
2592 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
2594 error ("Can't find .text section in symbol file");
2595 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2596 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2598 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2599 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2600 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2601 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2602 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2604 if (stabstrsize
> bfd_get_size (sym_bfd
))
2605 error ("ridiculous string table size: %d bytes", stabstrsize
);
2606 DBX_STRINGTAB (objfile
) = (char *)
2607 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2608 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2610 /* Now read in the string table in one big gulp. */
2612 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2614 perror_with_name (name
);
2615 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2616 if (val
!= stabstrsize
)
2617 perror_with_name (name
);
2619 stabsread_new_init ();
2620 buildsym_new_init ();
2621 free_header_files ();
2622 init_header_files ();
2623 install_minimal_symbols (objfile
);
2625 processing_acc_compilation
= 1;
2627 /* In an elf file, we've already installed the minimal symbols that came
2628 from the elf (non-stab) symbol table, so always act like an
2629 incremental load here. */
2630 dbx_symfile_read (objfile
, section_offsets
, 0);
2633 /* Scan and build partial symbols for a file with special sections for stabs
2634 and stabstrings. The file has already been processed to get its minimal
2635 symbols, and any other symbols that might be necessary to resolve GSYMs.
2637 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2640 OBJFILE is the object file we are reading symbols from.
2641 ADDR is the address relative to which the symbols are (e.g. the base address
2642 of the text segment).
2643 MAINLINE is true if we are reading the main symbol table (as opposed to a
2644 shared lib or dynamically loaded file).
2645 STAB_NAME is the name of the section that contains the stabs.
2646 STABSTR_NAME is the name of the section that contains the stab strings.
2648 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2651 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2652 stabstr_name
, text_name
)
2653 struct objfile
*objfile
;
2654 struct section_offsets
*section_offsets
;
2661 bfd
*sym_bfd
= objfile
->obfd
;
2662 char *name
= bfd_get_filename (sym_bfd
);
2664 asection
*stabstrsect
;
2665 asection
*text_sect
;
2667 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2668 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2674 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2675 stab_name
, stabstr_name
);
2677 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
2678 xmalloc (sizeof (struct dbx_symfile_info
));
2679 memset (objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
2681 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2683 error ("Can't find %s section in symbol file", text_name
);
2684 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2685 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2687 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2688 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2689 / DBX_SYMBOL_SIZE (objfile
);
2690 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2691 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2693 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2694 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2695 DBX_STRINGTAB (objfile
) = (char *)
2696 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2697 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2699 /* Now read in the string table in one big gulp. */
2701 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2702 stabstrsect
, /* bfd section */
2703 DBX_STRINGTAB (objfile
), /* input buffer */
2704 0, /* offset into section */
2705 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2708 perror_with_name (name
);
2710 stabsread_new_init ();
2711 buildsym_new_init ();
2712 free_header_files ();
2713 init_header_files ();
2714 install_minimal_symbols (objfile
);
2716 /* Now, do an incremental load */
2718 processing_acc_compilation
= 1;
2719 dbx_symfile_read (objfile
, section_offsets
, 0);
2722 static struct sym_fns aout_sym_fns
=
2724 bfd_target_aout_flavour
,
2725 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2726 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2727 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2728 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2729 default_symfile_offsets
,
2730 /* sym_offsets: parse user's offsets to internal form */
2731 NULL
/* next: pointer to next struct sym_fns */
2735 _initialize_dbxread ()
2737 add_symtab_fns(&aout_sym_fns
);