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 /* find_text_range --- find start and end of loadable code sections
202 The find_text_range function finds the shortest address range that
203 encloses all sections containing executable code, and stores it in
204 objfile's text_addr and text_size members.
206 dbx_symfile_read will use this to finish off the partial symbol
207 table, in some cases. */
210 find_text_range (bfd
*sym_bfd
, struct objfile
*objfile
)
214 CORE_ADDR start
, end
;
216 for (sec
= sym_bfd
->sections
; sec
; sec
= sec
->next
)
217 if (bfd_get_section_flags (sym_bfd
, sec
) & SEC_CODE
)
219 CORE_ADDR sec_start
= bfd_section_vma (sym_bfd
, sec
);
220 CORE_ADDR sec_end
= sec_start
+ bfd_section_size (sym_bfd
, sec
);
224 if (sec_start
< start
) start
= sec_start
;
225 if (sec_end
> end
) end
= sec_end
;
237 error ("Can't find any code sections in symbol file");
239 DBX_TEXT_ADDR (objfile
) = start
;
240 DBX_TEXT_SIZE (objfile
) = end
- start
;
245 /* During initial symbol readin, we need to have a structure to keep
246 track of which psymtabs have which bincls in them. This structure
247 is used during readin to setup the list of dependencies within each
248 partial symbol table. */
250 struct header_file_location
252 char *name
; /* Name of header file */
253 int instance
; /* See above */
254 struct partial_symtab
*pst
; /* Partial symtab that has the
255 BINCL/EINCL defs for this file */
258 /* The actual list and controling variables */
259 static struct header_file_location
*bincl_list
, *next_bincl
;
260 static int bincls_allocated
;
262 /* Local function prototypes */
264 extern void _initialize_dbxread
PARAMS ((void));
267 process_now
PARAMS ((struct objfile
*));
270 free_header_files
PARAMS ((void));
273 init_header_files
PARAMS ((void));
276 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
279 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
282 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
285 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
286 struct objfile
*objfile
));
289 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
293 free_bincl_list
PARAMS ((struct objfile
*));
295 static struct partial_symtab
*
296 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
299 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
302 init_bincl_list
PARAMS ((int, struct objfile
*));
305 dbx_next_symbol_text
PARAMS ((struct objfile
*));
308 fill_symbuf
PARAMS ((bfd
*));
311 dbx_symfile_init
PARAMS ((struct objfile
*));
314 dbx_new_init
PARAMS ((struct objfile
*));
317 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
320 dbx_symfile_finish
PARAMS ((struct objfile
*));
323 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
326 add_new_header_file
PARAMS ((char *, int));
329 add_old_header_file
PARAMS ((char *, int));
332 add_this_object_header_file
PARAMS ((int));
334 /* Free up old header file tables */
339 if (this_object_header_files
)
341 free ((PTR
)this_object_header_files
);
342 this_object_header_files
= NULL
;
344 n_allocated_this_object_header_files
= 0;
347 /* Allocate new header file tables */
352 n_allocated_this_object_header_files
= 10;
353 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
356 /* Add header file number I for this object file
357 at the next successive FILENUM. */
360 add_this_object_header_file (i
)
363 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
365 n_allocated_this_object_header_files
*= 2;
366 this_object_header_files
367 = (int *) xrealloc ((char *) this_object_header_files
,
368 n_allocated_this_object_header_files
* sizeof (int));
371 this_object_header_files
[n_this_object_header_files
++] = i
;
374 /* Add to this file an "old" header file, one already seen in
375 a previous object file. NAME is the header file's name.
376 INSTANCE is its instance code, to select among multiple
377 symbol tables for the same header file. */
380 add_old_header_file (name
, instance
)
384 register struct header_file
*p
= HEADER_FILES (current_objfile
);
387 for (i
= 0; i
< N_HEADER_FILES (current_objfile
); i
++)
388 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
390 add_this_object_header_file (i
);
393 complain (&repeated_header_complaint
, name
, symnum
);
396 /* Add to this file a "new" header file: definitions for its types follow.
397 NAME is the header file's name.
398 Most often this happens only once for each distinct header file,
399 but not necessarily. If it happens more than once, INSTANCE has
400 a different value each time, and references to the header file
401 use INSTANCE values to select among them.
403 dbx output contains "begin" and "end" markers for each new header file,
404 but at this level we just need to know which files there have been;
405 so we record the file when its "begin" is seen and ignore the "end". */
408 add_new_header_file (name
, instance
)
413 register struct header_file
*hfile
;
415 /* Make sure there is room for one more header file. */
417 i
= N_ALLOCATED_HEADER_FILES (current_objfile
);
419 if (N_HEADER_FILES (current_objfile
) == i
)
423 N_ALLOCATED_HEADER_FILES (current_objfile
) = 10;
424 HEADER_FILES (current_objfile
) = (struct header_file
*)
425 xmalloc (10 * sizeof (struct header_file
));
430 N_ALLOCATED_HEADER_FILES (current_objfile
) = i
;
431 HEADER_FILES (current_objfile
) = (struct header_file
*)
432 xrealloc ((char *) HEADER_FILES (current_objfile
),
433 (i
* sizeof (struct header_file
)));
437 /* Create an entry for this header file. */
439 i
= N_HEADER_FILES (current_objfile
)++;
440 hfile
= HEADER_FILES (current_objfile
) + i
;
441 hfile
->name
= savestring (name
, strlen(name
));
442 hfile
->instance
= instance
;
445 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
446 memset (hfile
->vector
, 0, 10 * sizeof (struct type
*));
448 add_this_object_header_file (i
);
452 static struct type
**
453 explicit_lookup_type (real_filenum
, index
)
454 int real_filenum
, index
;
456 register struct header_file
*f
= &HEADER_FILES (current_objfile
)[real_filenum
];
458 if (index
>= f
->length
)
461 f
->vector
= (struct type
**)
462 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
463 memset (&f
->vector
[f
->length
/ 2],
464 '\0', f
->length
* sizeof (struct type
*) / 2);
466 return &f
->vector
[index
];
471 record_minimal_symbol (name
, address
, type
, objfile
)
475 struct objfile
*objfile
;
477 enum minimal_symbol_type ms_type
;
479 asection
*bfd_section
;
485 section
= SECT_OFF_TEXT
;
486 bfd_section
= DBX_TEXT_SECTION (objfile
);
490 section
= SECT_OFF_DATA
;
491 bfd_section
= DBX_DATA_SECTION (objfile
);
495 section
= SECT_OFF_BSS
;
496 bfd_section
= DBX_BSS_SECTION (objfile
);
506 section
= SECT_OFF_DATA
;
507 bfd_section
= DBX_DATA_SECTION (objfile
);
510 /* I don't think this type actually exists; since a N_SETV is the result
511 of going over many .o files, it doesn't make sense to have one
513 ms_type
= mst_file_data
;
514 section
= SECT_OFF_DATA
;
515 bfd_section
= DBX_DATA_SECTION (objfile
);
522 ms_type
= mst_file_text
;
523 section
= SECT_OFF_TEXT
;
524 bfd_section
= DBX_TEXT_SECTION (objfile
);
527 ms_type
= mst_file_data
;
529 /* Check for __DYNAMIC, which is used by Sun shared libraries.
530 Record it as global even if it's local, not global, so
531 lookup_minimal_symbol can find it. We don't check symbol_leading_char
532 because for SunOS4 it always is '_'. */
533 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
536 /* Same with virtual function tables, both global and static. */
538 char *tempstring
= name
;
539 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
541 if (VTBL_PREFIX_P ((tempstring
)))
544 section
= SECT_OFF_DATA
;
545 bfd_section
= DBX_DATA_SECTION (objfile
);
548 ms_type
= mst_file_bss
;
549 section
= SECT_OFF_BSS
;
550 bfd_section
= DBX_BSS_SECTION (objfile
);
553 ms_type
= mst_unknown
;
559 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
560 && address
< lowest_text_address
)
561 lowest_text_address
= address
;
563 prim_record_minimal_symbol_and_info
564 (name
, address
, ms_type
, NULL
, section
, bfd_section
, objfile
);
567 /* Scan and build partial symbols for a symbol file.
568 We have been initialized by a call to dbx_symfile_init, which
569 put all the relevant info into a "struct dbx_symfile_info",
570 hung off the objfile structure.
572 SECTION_OFFSETS contains offsets relative to which the symbols in the
573 various sections are (depending where the sections were actually loaded).
574 MAINLINE is true if we are reading the main symbol
575 table (as opposed to a shared lib or dynamically loaded file). */
578 dbx_symfile_read (objfile
, section_offsets
, mainline
)
579 struct objfile
*objfile
;
580 struct section_offsets
*section_offsets
;
581 int mainline
; /* FIXME comments above */
585 struct cleanup
*back_to
;
587 val
= strlen (objfile
->name
);
589 sym_bfd
= objfile
->obfd
;
591 /* .o and .nlm files are relocatables with text, data and bss segs based at
592 0. This flag disables special (Solaris stabs-in-elf only) fixups for
593 symbols with a value of 0. */
595 symfile_relocatable
= bfd_get_file_flags (sym_bfd
) & HAS_RELOC
;
597 /* This is true for Solaris (and all other systems which put stabs
598 in sections, hopefully, since it would be silly to do things
599 differently from Solaris), and false for SunOS4 and other a.out
601 block_address_function_relative
=
602 ((0 == strncmp (bfd_get_target (sym_bfd
), "elf", 3))
603 || (0 == strncmp (bfd_get_target (sym_bfd
), "som", 3))
604 || (0 == strncmp (bfd_get_target (sym_bfd
), "coff", 4))
605 || (0 == strncmp (bfd_get_target (sym_bfd
), "pe", 2))
606 || (0 == strncmp (bfd_get_target (sym_bfd
), "nlm", 3)));
608 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
610 perror_with_name (objfile
->name
);
612 /* If we are reinitializing, or if we have never loaded syms yet, init */
614 || objfile
->global_psymbols
.size
== 0
615 || objfile
->static_psymbols
.size
== 0)
616 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
618 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
619 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
621 free_pending_blocks ();
622 back_to
= make_cleanup ((make_cleanup_func
) really_free_pendings
, 0);
624 init_minimal_symbol_collection ();
625 make_cleanup ((make_cleanup_func
) discard_minimal_symbols
, 0);
627 /* Now that the symbol table data of the executable file are all in core,
628 process them and define symbols accordingly. */
630 read_dbx_symtab (section_offsets
, objfile
,
631 DBX_TEXT_ADDR (objfile
),
632 DBX_TEXT_SIZE (objfile
));
634 /* Add the dynamic symbols. */
636 read_dbx_dynamic_symtab (section_offsets
, objfile
);
638 /* Install any minimal symbols that have been collected as the current
639 minimal symbols for this objfile. */
641 install_minimal_symbols (objfile
);
643 do_cleanups (back_to
);
646 /* Initialize anything that needs initializing when a completely new
647 symbol file is specified (not just adding some symbols from another
648 file, e.g. a shared library). */
651 dbx_new_init (ignore
)
652 struct objfile
*ignore
;
654 stabsread_new_init ();
655 buildsym_new_init ();
656 init_header_files ();
660 /* dbx_symfile_init ()
661 is the dbx-specific initialization routine for reading symbols.
662 It is passed a struct objfile which contains, among other things,
663 the BFD for the file whose symbols are being read, and a slot for a pointer
664 to "private data" which we fill with goodies.
666 We read the string table into malloc'd space and stash a pointer to it.
668 Since BFD doesn't know how to read debug symbols in a format-independent
669 way (and may never do so...), we have to do it ourselves. We will never
670 be called unless this is an a.out (or very similar) file.
671 FIXME, there should be a cleaner peephole into the BFD environment here. */
673 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
676 dbx_symfile_init (objfile
)
677 struct objfile
*objfile
;
680 bfd
*sym_bfd
= objfile
->obfd
;
681 char *name
= bfd_get_filename (sym_bfd
);
683 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
685 /* Allocate struct to keep track of the symfile */
686 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
687 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
688 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
690 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
691 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
692 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
694 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
695 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
696 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
698 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
700 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
702 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
704 error ("Can't find .text section in symbol file");
705 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
706 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
708 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
709 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
710 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
712 /* Read the string table and stash it away in the psymbol_obstack. It is
713 only needed as long as we need to expand psymbols into full symbols,
714 so when we blow away the psymbol the string table goes away as well.
715 Note that gdb used to use the results of attempting to malloc the
716 string table, based on the size it read, as a form of sanity check
717 for botched byte swapping, on the theory that a byte swapped string
718 table size would be so totally bogus that the malloc would fail. Now
719 that we put in on the psymbol_obstack, we can't do this since gdb gets
720 a fatal error (out of virtual memory) if the size is bogus. We can
721 however at least check to see if the size is less than the size of
722 the size field itself, or larger than the size of the entire file.
723 Note that all valid string tables have a size greater than zero, since
724 the bytes used to hold the size are included in the count. */
726 if (STRING_TABLE_OFFSET
== 0)
728 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
729 will never be zero, even when there is no string table. This
730 would appear to be a bug in bfd. */
731 DBX_STRINGTAB_SIZE (objfile
) = 0;
732 DBX_STRINGTAB (objfile
) = NULL
;
736 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
738 perror_with_name (name
);
740 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
741 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
744 perror_with_name (name
);
748 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
749 EOF if there is no string table, and attempting to read the size
750 from EOF will read zero bytes. */
751 DBX_STRINGTAB_SIZE (objfile
) = 0;
752 DBX_STRINGTAB (objfile
) = NULL
;
756 /* Read some data that would appear to be the string table size.
757 If there really is a string table, then it is probably the right
758 size. Byteswap if necessary and validate the size. Note that
759 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
760 random data that happened to be at STRING_TABLE_OFFSET, because
761 bfd can't tell us there is no string table, the sanity checks may
762 or may not catch this. */
763 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
765 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
766 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
767 error ("ridiculous string table size (%d bytes).",
768 DBX_STRINGTAB_SIZE (objfile
));
770 DBX_STRINGTAB (objfile
) =
771 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
772 DBX_STRINGTAB_SIZE (objfile
));
773 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
775 /* Now read in the string table in one big gulp. */
777 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
779 perror_with_name (name
);
780 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
782 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
783 perror_with_name (name
);
788 /* Perform any local cleanups required when we are done with a particular
789 objfile. I.E, we are in the process of discarding all symbol information
790 for an objfile, freeing up all memory held for it, and unlinking the
791 objfile struct from the global list of known objfiles. */
794 dbx_symfile_finish (objfile
)
795 struct objfile
*objfile
;
797 if (objfile
->sym_stab_info
!= NULL
)
799 if (HEADER_FILES (objfile
) != NULL
)
801 register int i
= N_HEADER_FILES (objfile
);
802 register struct header_file
*hfiles
= HEADER_FILES (objfile
);
806 free (hfiles
[i
].name
);
807 free (hfiles
[i
].vector
);
811 mfree (objfile
-> md
, objfile
->sym_stab_info
);
813 free_header_files ();
817 /* Buffer for reading the symbol table entries. */
818 static struct external_nlist symbuf
[4096];
819 static int symbuf_idx
;
820 static int symbuf_end
;
822 /* cont_elem is used for continuing information in cfront.
823 It saves information about which types need to be fixed up and
824 completed after all the stabs are read. */
827 /* sym and stabsstring for continuing information in cfront */
830 /* state dependancies (statics that must be preserved) */
834 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
835 /* other state dependancies include:
836 (assumption is that these will not change since process_now FIXME!!)
843 static struct cont_elem
*cont_list
= 0;
844 static int cont_limit
= 0;
845 static int cont_count
= 0;
847 /* Arrange for function F to be called with arguments SYM and P later
848 in the stabs reading process. */
850 process_later (sym
, p
, f
)
853 int (*f
) PARAMS ((struct objfile
*, struct symbol
*, char *));
856 /* Allocate more space for the deferred list. */
857 if (cont_count
>= cont_limit
- 1)
859 cont_limit
+= 32; /* chunk size */
862 = (struct cont_elem
*) xrealloc (cont_list
,
864 * sizeof (struct cont_elem
)));
866 error ("Virtual memory exhausted\n");
869 /* Save state variables so we can process these stabs later. */
870 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
871 cont_list
[cont_count
].sym_end
= symbuf_end
;
872 cont_list
[cont_count
].symnum
= symnum
;
873 cont_list
[cont_count
].sym
= sym
;
874 cont_list
[cont_count
].stabs
= p
;
875 cont_list
[cont_count
].func
= f
;
879 /* Call deferred funtions in CONT_LIST. */
882 process_now (objfile
)
883 struct objfile
*objfile
;
892 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
894 /* Save the state of our caller, we'll want to restore it before
896 save_symbuf_idx
= symbuf_idx
;
897 save_symbuf_end
= symbuf_end
;
898 save_symnum
= symnum
;
900 /* Iterate over all the deferred stabs. */
901 for (i
= 0; i
< cont_count
; i
++)
903 /* Restore the state for this deferred stab. */
904 symbuf_idx
= cont_list
[i
].sym_idx
;
905 symbuf_end
= cont_list
[i
].sym_end
;
906 symnum
= cont_list
[i
].symnum
;
907 sym
= cont_list
[i
].sym
;
908 stabs
= cont_list
[i
].stabs
;
909 func
= cont_list
[i
].func
;
911 /* Call the function to handle this deferrd stab. */
912 err
= (*func
) (objfile
, sym
, stabs
);
914 error ("Internal error: unable to resolve stab.\n");
917 /* Restore our caller's state. */
918 symbuf_idx
= save_symbuf_idx
;
919 symbuf_end
= save_symbuf_end
;
920 symnum
= save_symnum
;
925 /* Name of last function encountered. Used in Solaris to approximate
926 object file boundaries. */
927 static char *last_function_name
;
929 /* The address in memory of the string table of the object file we are
930 reading (which might not be the "main" object file, but might be a
931 shared library or some other dynamically loaded thing). This is
932 set by read_dbx_symtab when building psymtabs, and by
933 read_ofile_symtab when building symtabs, and is used only by
934 next_symbol_text. FIXME: If that is true, we don't need it when
935 building psymtabs, right? */
936 static char *stringtab_global
;
938 /* These variables are used to control fill_symbuf when the stabs
939 symbols are not contiguous (as may be the case when a COFF file is
940 linked using --split-by-reloc). */
941 static struct stab_section_list
*symbuf_sections
;
942 static unsigned int symbuf_left
;
943 static unsigned int symbuf_read
;
945 /* Refill the symbol table input buffer
946 and set the variables that control fetching entries from it.
947 Reports an error if no data available.
948 This function can read past the end of the symbol table
949 (into the string table) but this does no harm. */
952 fill_symbuf (sym_bfd
)
958 if (symbuf_sections
== NULL
)
959 count
= sizeof (symbuf
);
962 if (symbuf_left
<= 0)
964 file_ptr filepos
= symbuf_sections
->section
->filepos
;
965 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
966 perror_with_name (bfd_get_filename (sym_bfd
));
967 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
968 symbol_table_offset
= filepos
- symbuf_read
;
969 symbuf_sections
= symbuf_sections
->next
;
973 if (count
> sizeof (symbuf
))
974 count
= sizeof (symbuf
);
977 nbytes
= bfd_read ((PTR
)symbuf
, count
, 1, sym_bfd
);
979 perror_with_name (bfd_get_filename (sym_bfd
));
980 else if (nbytes
== 0)
981 error ("Premature end of file reading symbol table");
982 symbuf_end
= nbytes
/ symbol_size
;
984 symbuf_left
-= nbytes
;
985 symbuf_read
+= nbytes
;
988 #define SWAP_SYMBOL(symp, abfd) \
990 (symp)->n_strx = bfd_h_get_32(abfd, \
991 (unsigned char *)&(symp)->n_strx); \
992 (symp)->n_desc = bfd_h_get_16 (abfd, \
993 (unsigned char *)&(symp)->n_desc); \
994 (symp)->n_value = bfd_h_get_32 (abfd, \
995 (unsigned char *)&(symp)->n_value); \
998 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
1000 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
1001 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
1002 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
1003 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
1006 /* Invariant: The symbol pointed to by symbuf_idx is the first one
1007 that hasn't been swapped. Swap the symbol at the same time
1008 that symbuf_idx is incremented. */
1010 /* dbx allows the text of a symbol name to be continued into the
1011 next symbol name! When such a continuation is encountered
1012 (a \ at the end of the text of a name)
1013 call this function to get the continuation. */
1016 dbx_next_symbol_text (objfile
)
1017 struct objfile
*objfile
;
1019 struct internal_nlist nlist
;
1021 if (symbuf_idx
== symbuf_end
)
1022 fill_symbuf (symfile_bfd
);
1025 INTERNALIZE_SYMBOL(nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
1026 OBJSTAT (objfile
, n_stabs
++);
1030 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
1033 /* Initialize the list of bincls to contain none and have some
1037 init_bincl_list (number
, objfile
)
1039 struct objfile
*objfile
;
1041 bincls_allocated
= number
;
1042 next_bincl
= bincl_list
= (struct header_file_location
*)
1043 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
1046 /* Add a bincl to the list. */
1049 add_bincl_to_list (pst
, name
, instance
)
1050 struct partial_symtab
*pst
;
1054 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1056 int offset
= next_bincl
- bincl_list
;
1057 bincls_allocated
*= 2;
1058 bincl_list
= (struct header_file_location
*)
1059 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
1060 bincls_allocated
* sizeof (struct header_file_location
));
1061 next_bincl
= bincl_list
+ offset
;
1063 next_bincl
->pst
= pst
;
1064 next_bincl
->instance
= instance
;
1065 next_bincl
++->name
= name
;
1068 /* Given a name, value pair, find the corresponding
1069 bincl in the list. Return the partial symtab associated
1070 with that header_file_location. */
1072 static struct partial_symtab
*
1073 find_corresponding_bincl_psymtab (name
, instance
)
1077 struct header_file_location
*bincl
;
1079 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1080 if (bincl
->instance
== instance
1081 && STREQ (name
, bincl
->name
))
1084 complain (&repeated_header_complaint
, name
, symnum
);
1085 return (struct partial_symtab
*) 0;
1088 /* Free the storage allocated for the bincl list. */
1091 free_bincl_list (objfile
)
1092 struct objfile
*objfile
;
1094 mfree (objfile
-> md
, (PTR
)bincl_list
);
1095 bincls_allocated
= 0;
1098 /* Scan a SunOs dynamic symbol table for symbols of interest and
1099 add them to the minimal symbol table. */
1102 read_dbx_dynamic_symtab (section_offsets
, objfile
)
1103 struct section_offsets
*section_offsets
;
1104 struct objfile
*objfile
;
1106 bfd
*abfd
= objfile
->obfd
;
1107 struct cleanup
*back_to
;
1117 CORE_ADDR sym_value
;
1120 /* Check that the symbol file has dynamic symbols that we know about.
1121 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1122 on a sun4 host (and vice versa) and bfd is not configured
1123 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1124 so we ignore the dynamic symbols in this case. */
1125 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
1126 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
1127 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1130 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1131 if (dynsym_size
< 0)
1134 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1135 back_to
= make_cleanup (free
, dynsyms
);
1137 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1138 if (dynsym_count
< 0)
1140 do_cleanups (back_to
);
1144 /* Enter dynamic symbols into the minimal symbol table
1145 if this is a stripped executable. */
1146 if (bfd_get_symcount (abfd
) <= 0)
1149 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1151 asymbol
*sym
= *symptr
;
1155 sec
= bfd_get_section (sym
);
1157 /* BFD symbols are section relative. */
1158 sym_value
= sym
->value
+ sec
->vma
;
1160 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1162 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1165 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1167 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1170 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1172 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1178 if (sym
->flags
& BSF_GLOBAL
)
1181 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1186 /* Symbols from shared libraries have a dynamic relocation entry
1187 that points to the associated slot in the procedure linkage table.
1188 We make a mininal symbol table entry with type mst_solib_trampoline
1189 at the address in the procedure linkage table. */
1190 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1191 if (dynrel_size
< 0)
1193 do_cleanups (back_to
);
1197 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1198 make_cleanup (free
, dynrels
);
1200 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1201 if (dynrel_count
< 0)
1203 do_cleanups (back_to
);
1207 for (counter
= 0, relptr
= dynrels
;
1208 counter
< dynrel_count
;
1209 counter
++, relptr
++)
1211 arelent
*rel
= *relptr
;
1213 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1215 switch (bfd_get_arch (abfd
))
1217 case bfd_arch_sparc
:
1218 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1222 /* `16' is the type BFD produces for a jump table relocation. */
1223 if (rel
->howto
->type
!= 16)
1226 /* Adjust address in the jump table to point to
1227 the start of the bsr instruction. */
1234 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1235 prim_record_minimal_symbol (name
, address
, mst_solib_trampoline
,
1239 do_cleanups (back_to
);
1242 /* Given pointers to an a.out symbol table in core containing dbx
1243 style data, setup partial_symtab's describing each source file for
1244 which debugging information is available.
1245 SYMFILE_NAME is the name of the file we are reading from
1246 and SECTION_OFFSETS is the set of offsets for the various sections
1247 of the file (a set of zeros if the mainline program). */
1250 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1251 struct section_offsets
*section_offsets
;
1252 struct objfile
*objfile
;
1253 CORE_ADDR text_addr
;
1256 register struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1257 struct internal_nlist nlist
;
1259 register char *namestring
;
1261 int past_first_source_file
= 0;
1262 CORE_ADDR last_o_file_start
= 0;
1263 CORE_ADDR last_function_start
= 0;
1264 struct cleanup
*back_to
;
1266 int textlow_not_set
;
1268 /* Current partial symtab */
1269 struct partial_symtab
*pst
;
1271 /* List of current psymtab's include files */
1272 char **psymtab_include_list
;
1273 int includes_allocated
;
1276 /* Index within current psymtab dependency list */
1277 struct partial_symtab
**dependency_list
;
1278 int dependencies_used
, dependencies_allocated
;
1280 /* FIXME. We probably want to change stringtab_global rather than add this
1281 while processing every symbol entry. FIXME. */
1282 file_string_table_offset
= 0;
1283 next_file_string_table_offset
= 0;
1285 stringtab_global
= DBX_STRINGTAB (objfile
);
1287 pst
= (struct partial_symtab
*) 0;
1289 includes_allocated
= 30;
1291 psymtab_include_list
= (char **) alloca (includes_allocated
*
1294 dependencies_allocated
= 30;
1295 dependencies_used
= 0;
1297 (struct partial_symtab
**) alloca (dependencies_allocated
*
1298 sizeof (struct partial_symtab
*));
1300 /* Init bincl list */
1301 init_bincl_list (20, objfile
);
1302 back_to
= make_cleanup ((make_cleanup_func
) free_bincl_list
, objfile
);
1304 last_source_file
= NULL
;
1306 lowest_text_address
= (CORE_ADDR
)-1;
1308 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1309 abfd
= objfile
->obfd
;
1310 symbuf_end
= symbuf_idx
= 0;
1311 next_symbol_text_func
= dbx_next_symbol_text
;
1312 textlow_not_set
= 1;
1313 has_line_numbers
= 0;
1315 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1317 /* Get the symbol for this run and pull out some info */
1318 QUIT
; /* allow this to be interruptable */
1319 if (symbuf_idx
== symbuf_end
)
1321 bufp
= &symbuf
[symbuf_idx
++];
1324 * Special case to speed up readin.
1326 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1328 has_line_numbers
= 1;
1332 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1333 OBJSTAT (objfile
, n_stabs
++);
1335 /* Ok. There is a lot of code duplicated in the rest of this
1336 switch statement (for efficiency reasons). Since I don't
1337 like duplicating code, I will do my penance here, and
1338 describe the code which is duplicated:
1340 *) The assignment to namestring.
1341 *) The call to strchr.
1342 *) The addition of a partial symbol the the two partial
1343 symbol lists. This last is a large section of code, so
1344 I've imbedded it in the following macro.
1347 /* Set namestring based on nlist. If the string table index is invalid,
1348 give a fake name, and print a single error message per symbol file read,
1349 rather than abort the symbol reading or flood the user with messages. */
1351 /*FIXME: Too many adds and indirections in here for the inner loop. */
1352 #define SET_NAMESTRING()\
1353 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1354 DBX_STRINGTAB_SIZE (objfile)) { \
1355 complain (&string_table_offset_complaint, symnum); \
1356 namestring = "<bad string table offset>"; \
1358 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1359 DBX_STRINGTAB (objfile)
1361 #define CUR_SYMBOL_TYPE nlist.n_type
1362 #define CUR_SYMBOL_VALUE nlist.n_value
1363 #define CUR_SYMBOL_STRX nlist.n_strx
1364 #define DBXREAD_ONLY
1365 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1366 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1367 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1368 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1370 #include "partial-stab.h"
1373 /* If there's stuff to be cleaned up, clean it up. */
1374 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1375 /*FIXME, does this have a bug at start address 0? */
1376 && last_o_file_start
1377 && objfile
-> ei
.entry_point
< nlist
.n_value
1378 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1380 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1381 objfile
-> ei
.entry_file_highpc
= nlist
.n_value
;
1386 /* Don't set pst->texthigh lower than it already is. */
1387 CORE_ADDR text_end
=
1388 (lowest_text_address
== (CORE_ADDR
)-1
1389 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1390 : lowest_text_address
)
1393 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1394 symnum
* symbol_size
,
1395 text_end
> pst
->texthigh
? text_end
: pst
->texthigh
,
1396 dependency_list
, dependencies_used
, textlow_not_set
);
1399 do_cleanups (back_to
);
1402 /* Allocate and partially fill a partial symtab. It will be
1403 completely filled at the end of the symbol list.
1405 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1406 is the address relative to which its symbols are (incremental) or 0
1410 struct partial_symtab
*
1411 start_psymtab (objfile
, section_offsets
,
1412 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1413 struct objfile
*objfile
;
1414 struct section_offsets
*section_offsets
;
1418 struct partial_symbol
**global_syms
;
1419 struct partial_symbol
**static_syms
;
1421 struct partial_symtab
*result
=
1422 start_psymtab_common(objfile
, section_offsets
,
1423 filename
, textlow
, global_syms
, static_syms
);
1425 result
->read_symtab_private
= (char *)
1426 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1427 LDSYMOFF(result
) = ldsymoff
;
1428 result
->read_symtab
= dbx_psymtab_to_symtab
;
1429 SYMBOL_SIZE(result
) = symbol_size
;
1430 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1431 STRING_OFFSET(result
) = string_table_offset
;
1432 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1434 /* If we're handling an ELF file, drag some section-relocation info
1435 for this source file out of the ELF symbol table, to compensate for
1436 Sun brain death. This replaces the section_offsets in this psymtab,
1438 elfstab_offset_sections (objfile
, result
);
1440 /* Deduce the source language from the filename for this psymtab. */
1441 psymtab_language
= deduce_language_from_filename (filename
);
1446 /* Close off the current usage of PST.
1447 Returns PST or NULL if the partial symtab was empty and thrown away.
1449 FIXME: List variables and peculiarities of same. */
1451 struct partial_symtab
*
1452 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1453 capping_text
, dependency_list
, number_dependencies
, textlow_not_set
)
1454 struct partial_symtab
*pst
;
1455 char **include_list
;
1457 int capping_symbol_offset
;
1458 CORE_ADDR capping_text
;
1459 struct partial_symtab
**dependency_list
;
1460 int number_dependencies
;
1461 int textlow_not_set
;
1464 struct objfile
*objfile
= pst
-> objfile
;
1466 if (capping_symbol_offset
!= -1)
1467 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1468 pst
->texthigh
= capping_text
;
1470 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1471 /* Under Solaris, the N_SO symbols always have a value of 0,
1472 instead of the usual address of the .o file. Therefore,
1473 we have to do some tricks to fill in texthigh and textlow.
1474 The first trick is in partial-stab.h: if we see a static
1475 or global function, and the textlow for the current pst
1476 is not set (ie: textlow_not_set), then we use that function's
1477 address for the textlow of the pst. */
1479 /* Now, to fill in texthigh, we remember the last function seen
1480 in the .o file (also in partial-stab.h). Also, there's a hack in
1481 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1482 to here via the misc_info field. Therefore, we can fill in
1483 a reliable texthigh by taking the address plus size of the
1484 last function in the file. */
1486 if (pst
->texthigh
== 0 && last_function_name
)
1490 struct minimal_symbol
*minsym
;
1492 p
= strchr (last_function_name
, ':');
1494 p
= last_function_name
;
1495 n
= p
- last_function_name
;
1497 strncpy (p
, last_function_name
, n
);
1500 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1503 /* Sun Fortran appends an underscore to the minimal symbol name,
1504 try again with an appended underscore if the minimal symbol
1508 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1512 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) + MSYMBOL_SIZE (minsym
);
1514 last_function_name
= NULL
;
1517 /* this test will be true if the last .o file is only data */
1518 if (textlow_not_set
)
1519 pst
->textlow
= pst
->texthigh
;
1522 struct partial_symtab
*p1
;
1524 /* If we know our own starting text address, then walk through all other
1525 psymtabs for this objfile, and if any didn't know their ending text
1526 address, set it to our starting address. Take care to not set our
1527 own ending address to our starting address, nor to set addresses on
1528 `dependency' files that have both textlow and texthigh zero. */
1530 ALL_OBJFILE_PSYMTABS (objfile
, p1
)
1532 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
)
1534 p1
->texthigh
= pst
->textlow
;
1535 /* if this file has only data, then make textlow match texthigh */
1536 if (p1
->textlow
== 0)
1537 p1
->textlow
= p1
->texthigh
;
1542 /* End of kludge for patching Solaris textlow and texthigh. */
1543 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1545 pst
->n_global_syms
=
1546 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1547 pst
->n_static_syms
=
1548 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1550 pst
->number_of_dependencies
= number_dependencies
;
1551 if (number_dependencies
)
1553 pst
->dependencies
= (struct partial_symtab
**)
1554 obstack_alloc (&objfile
->psymbol_obstack
,
1555 number_dependencies
* sizeof (struct partial_symtab
*));
1556 memcpy (pst
->dependencies
, dependency_list
,
1557 number_dependencies
* sizeof (struct partial_symtab
*));
1560 pst
->dependencies
= 0;
1562 for (i
= 0; i
< num_includes
; i
++)
1564 struct partial_symtab
*subpst
=
1565 allocate_psymtab (include_list
[i
], objfile
);
1567 subpst
->section_offsets
= pst
->section_offsets
;
1568 subpst
->read_symtab_private
=
1569 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1570 sizeof (struct symloc
));
1574 subpst
->texthigh
= 0;
1576 /* We could save slight bits of space by only making one of these,
1577 shared by the entire set of include files. FIXME-someday. */
1578 subpst
->dependencies
= (struct partial_symtab
**)
1579 obstack_alloc (&objfile
->psymbol_obstack
,
1580 sizeof (struct partial_symtab
*));
1581 subpst
->dependencies
[0] = pst
;
1582 subpst
->number_of_dependencies
= 1;
1584 subpst
->globals_offset
=
1585 subpst
->n_global_syms
=
1586 subpst
->statics_offset
=
1587 subpst
->n_static_syms
= 0;
1591 subpst
->read_symtab
= pst
->read_symtab
;
1594 sort_pst_symbols (pst
);
1596 /* If there is already a psymtab or symtab for a file of this name, remove it.
1597 (If there is a symtab, more drastic things also happen.)
1598 This happens in VxWorks. */
1599 free_named_symtabs (pst
->filename
);
1601 if (num_includes
== 0
1602 && number_dependencies
== 0
1603 && pst
->n_global_syms
== 0
1604 && pst
->n_static_syms
== 0
1605 && has_line_numbers
== 0)
1607 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1608 it is on the obstack, but we can forget to chain it on the list. */
1609 /* Empty psymtabs happen as a result of header files which don't have
1610 any symbols in them. There can be a lot of them. But this check
1611 is wrong, in that a psymtab with N_SLINE entries but nothing else
1612 is not empty, but we don't realize that. Fixing that without slowing
1613 things down might be tricky. */
1615 discard_psymtab (pst
);
1617 /* Indicate that psymtab was thrown away. */
1618 pst
= (struct partial_symtab
*)NULL
;
1624 dbx_psymtab_to_symtab_1 (pst
)
1625 struct partial_symtab
*pst
;
1627 struct cleanup
*old_chain
;
1635 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1640 /* Read in all partial symtabs on which this one is dependent */
1641 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1642 if (!pst
->dependencies
[i
]->readin
)
1644 /* Inform about additional files that need to be read in. */
1647 fputs_filtered (" ", gdb_stdout
);
1649 fputs_filtered ("and ", gdb_stdout
);
1651 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1652 wrap_here (""); /* Flush output */
1653 gdb_flush (gdb_stdout
);
1655 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1658 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1660 /* Init stuff necessary for reading in symbols */
1663 old_chain
= make_cleanup ((make_cleanup_func
) really_free_pendings
, 0);
1664 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1665 symbol_size
= SYMBOL_SIZE (pst
);
1667 /* Read in this file's symbols */
1668 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1669 read_ofile_symtab (pst
);
1670 sort_symtab_syms (pst
->symtab
);
1672 do_cleanups (old_chain
);
1678 /* Read in all of the symbols for a given psymtab for real.
1679 Be verbose about it if the user wants that. */
1682 dbx_psymtab_to_symtab (pst
)
1683 struct partial_symtab
*pst
;
1692 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1697 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1699 /* Print the message now, before reading the string table,
1700 to avoid disconcerting pauses. */
1703 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1704 gdb_flush (gdb_stdout
);
1707 sym_bfd
= pst
->objfile
->obfd
;
1709 next_symbol_text_func
= dbx_next_symbol_text
;
1711 dbx_psymtab_to_symtab_1 (pst
);
1713 /* Match with global symbols. This only needs to be done once,
1714 after all of the symtabs and dependencies have been read in. */
1715 scan_file_globals (pst
->objfile
);
1717 /* Finish up the debug error message. */
1719 printf_filtered ("done.\n");
1723 /* Read in a defined section of a specific object file's symbols. */
1726 read_ofile_symtab (pst
)
1727 struct partial_symtab
*pst
;
1729 register char *namestring
;
1730 register struct external_nlist
*bufp
;
1731 struct internal_nlist nlist
;
1733 unsigned max_symnum
;
1735 struct objfile
*objfile
;
1736 int sym_offset
; /* Offset to start of symbols to read */
1737 int sym_size
; /* Size of symbols to read */
1738 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1739 int text_size
; /* Size of text segment for symbols */
1740 struct section_offsets
*section_offsets
;
1742 objfile
= pst
->objfile
;
1743 sym_offset
= LDSYMOFF(pst
);
1744 sym_size
= LDSYMLEN(pst
);
1745 text_offset
= pst
->textlow
;
1746 text_size
= pst
->texthigh
- pst
->textlow
;
1747 section_offsets
= pst
->section_offsets
;
1749 current_objfile
= objfile
;
1750 subfile_stack
= NULL
;
1752 stringtab_global
= DBX_STRINGTAB (objfile
);
1753 last_source_file
= NULL
;
1755 abfd
= objfile
->obfd
;
1756 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1757 symbuf_end
= symbuf_idx
= 0;
1759 /* It is necessary to actually read one symbol *before* the start
1760 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1761 occurs before the N_SO symbol.
1763 Detecting this in read_dbx_symtab
1764 would slow down initial readin, so we look for it here instead. */
1765 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1767 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1769 bufp
= &symbuf
[symbuf_idx
++];
1770 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1771 OBJSTAT (objfile
, n_stabs
++);
1775 processing_gcc_compilation
= 0;
1776 if (nlist
.n_type
== N_TEXT
)
1778 const char *tempstring
= namestring
;
1780 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1781 processing_gcc_compilation
= 1;
1782 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1783 processing_gcc_compilation
= 2;
1784 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1786 if (STREQN (tempstring
, "__gnu_compiled", 14))
1787 processing_gcc_compilation
= 2;
1790 /* Try to select a C++ demangling based on the compilation unit
1793 if (processing_gcc_compilation
)
1795 if (AUTO_DEMANGLING
)
1797 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1803 /* The N_SO starting this symtab is the first symbol, so we
1804 better not check the symbol before it. I'm not this can
1805 happen, but it doesn't hurt to check for it. */
1806 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1807 processing_gcc_compilation
= 0;
1810 if (symbuf_idx
== symbuf_end
)
1812 bufp
= &symbuf
[symbuf_idx
];
1813 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
1814 error("First symbol in segment of executable not a source symbol");
1816 max_symnum
= sym_size
/ symbol_size
;
1819 symnum
< max_symnum
;
1822 QUIT
; /* Allow this to be interruptable */
1823 if (symbuf_idx
== symbuf_end
)
1825 bufp
= &symbuf
[symbuf_idx
++];
1826 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1827 OBJSTAT (objfile
, n_stabs
++);
1829 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
1833 if (type
& N_STAB
) {
1834 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
1835 namestring
, section_offsets
, objfile
);
1837 /* We skip checking for a new .o or -l file; that should never
1838 happen in this routine. */
1839 else if (type
== N_TEXT
)
1841 /* I don't think this code will ever be executed, because
1842 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1843 the N_SO symbol which starts this source file.
1844 However, there is no reason not to accept
1845 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1847 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1848 processing_gcc_compilation
= 1;
1849 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1850 processing_gcc_compilation
= 2;
1852 if (AUTO_DEMANGLING
)
1854 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1857 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1858 || type
== (unsigned char)N_NBTEXT
1860 /* Global symbol: see if we came across a dbx defintion for
1861 a corresponding symbol. If so, store the value. Remove
1862 syms from the chain when their values are stored, but
1863 search the whole chain, as there may be several syms from
1864 different files with the same name. */
1865 /* This is probably not true. Since the files will be read
1866 in one at a time, each reference to a global symbol will
1867 be satisfied in each file as it appears. So we skip this
1873 current_objfile
= NULL
;
1875 /* In a Solaris elf file, this variable, which comes from the
1876 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1877 which comes from pst->textlow is correct. */
1878 if (last_source_start_addr
== 0)
1879 last_source_start_addr
= text_offset
;
1881 /* In reordered executables last_source_start_addr may not be the
1882 lower bound for this symtab, instead use text_offset which comes
1883 from pst->textlow which is correct. */
1884 if (last_source_start_addr
> text_offset
)
1885 last_source_start_addr
= text_offset
;
1887 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1889 /* Process items which we had to "process_later" due to dependancies
1891 process_now (objfile
);
1897 /* This handles a single symbol from the symbol-file, building symbols
1898 into a GDB symtab. It takes these arguments and an implicit argument.
1900 TYPE is the type field of the ".stab" symbol entry.
1901 DESC is the desc field of the ".stab" entry.
1902 VALU is the value field of the ".stab" entry.
1903 NAME is the symbol name, in our address space.
1904 SECTION_OFFSETS is a set of amounts by which the sections of this object
1905 file were relocated when it was loaded into memory.
1906 All symbols that refer
1907 to memory locations need to be offset by these amounts.
1908 OBJFILE is the object file from which we are reading symbols.
1909 It is used in end_symtab. */
1912 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1916 struct section_offsets
*section_offsets
;
1917 struct objfile
*objfile
;
1919 #ifdef SUN_FIXED_LBRAC_BUG
1920 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1921 to correct the address of N_LBRAC's. If it is not defined, then
1922 we never need to correct the addresses. */
1924 /* This records the last pc address we've seen. We depend on there being
1925 an SLINE or FUN or SO before the first LBRAC, since the variable does
1926 not get reset in between reads of different symbol files. */
1927 static CORE_ADDR last_pc_address
;
1930 register struct context_stack
*new;
1931 /* This remembers the address of the start of a function. It is used
1932 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1933 relative to the current function's start address. On systems
1934 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1935 used to relocate these symbol types rather than SECTION_OFFSETS. */
1936 static CORE_ADDR function_start_offset
;
1938 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1939 file. Used to detect the SunPRO solaris compiler. */
1940 static int n_opt_found
;
1942 /* The stab type used for the definition of the last function.
1943 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1944 static int function_stab_type
= 0;
1946 if (!block_address_function_relative
)
1947 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1948 function start address, so just use the text offset. */
1949 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1951 /* Something is wrong if we see real data before
1952 seeing a source file name. */
1954 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1956 /* Ignore any symbols which appear before an N_SO symbol.
1957 Currently no one puts symbols there, but we should deal
1958 gracefully with the case. A complain()t might be in order,
1959 but this should not be an error (). */
1968 if (*name
== '\000')
1970 /* This N_FUN marks the end of a function. This closes off the
1972 within_function
= 0;
1973 new = pop_context ();
1975 /* Make a block for the local symbols within. */
1976 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1977 new->start_addr
, new->start_addr
+ valu
,
1980 /* May be switching to an assembler file which may not be using
1981 block relative stabs, so reset the offset. */
1982 if (block_address_function_relative
)
1983 function_start_offset
= 0;
1988 /* Relocate for dynamic loading */
1989 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1990 #ifdef SMASH_TEXT_ADDRESS
1991 SMASH_TEXT_ADDRESS (valu
);
1993 goto define_a_symbol
;
1996 /* This "symbol" just indicates the start of an inner lexical
1997 context within a function. */
1999 /* Ignore extra outermost context from SunPRO cc and acc. */
2000 if (n_opt_found
&& desc
== 1)
2003 if (block_address_function_relative
)
2004 /* Relocate for Sun ELF acc fn-relative syms. */
2005 valu
+= function_start_offset
;
2007 /* On most machines, the block addresses are relative to the
2008 N_SO, the linker did not relocate them (sigh). */
2009 valu
+= last_source_start_addr
;
2011 #ifdef SUN_FIXED_LBRAC_BUG
2012 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
2013 /* Patch current LBRAC pc value to match last handy pc value */
2014 complain (&lbrac_complaint
);
2015 valu
= last_pc_address
;
2018 new = push_context (desc
, valu
);
2022 /* This "symbol" just indicates the end of an inner lexical
2023 context that was started with N_LBRAC. */
2025 /* Ignore extra outermost context from SunPRO cc and acc. */
2026 if (n_opt_found
&& desc
== 1)
2029 if (block_address_function_relative
)
2030 /* Relocate for Sun ELF acc fn-relative syms. */
2031 valu
+= function_start_offset
;
2033 /* On most machines, the block addresses are relative to the
2034 N_SO, the linker did not relocate them (sigh). */
2035 valu
+= last_source_start_addr
;
2037 new = pop_context();
2038 if (desc
!= new->depth
)
2039 complain (&lbrac_mismatch_complaint
, symnum
);
2041 /* Some compilers put the variable decls inside of an
2042 LBRAC/RBRAC block. This macro should be nonzero if this
2043 is true. DESC is N_DESC from the N_RBRAC symbol.
2044 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
2045 or the GCC2_COMPILED_SYMBOL. */
2046 #if !defined (VARIABLES_INSIDE_BLOCK)
2047 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2050 /* Can only use new->locals as local symbols here if we're in
2051 gcc or on a machine that puts them before the lbrack. */
2052 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2053 local_symbols
= new->locals
;
2055 if (context_stack_depth
2056 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2058 /* This is not the outermost LBRAC...RBRAC pair in the function,
2059 its local symbols preceded it, and are the ones just recovered
2060 from the context stack. Define the block for them (but don't
2061 bother if the block contains no symbols. Should we complain
2062 on blocks without symbols? I can't think of any useful purpose
2064 if (local_symbols
!= NULL
)
2066 /* Muzzle a compiler bug that makes end < start. (which
2067 compilers? Is this ever harmful?). */
2068 if (new->start_addr
> valu
)
2070 complain (&lbrac_rbrac_complaint
);
2071 new->start_addr
= valu
;
2073 /* Make a block for the local symbols within. */
2074 finish_block (0, &local_symbols
, new->old_blocks
,
2075 new->start_addr
, valu
, objfile
);
2080 /* This is the outermost LBRAC...RBRAC pair. There is no
2081 need to do anything; leave the symbols that preceded it
2082 to be attached to the function's own block. We need to
2083 indicate that we just moved outside of the function. */
2084 within_function
= 0;
2087 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
2088 /* Now pop locals of block just finished. */
2089 local_symbols
= new->locals
;
2094 /* This kind of symbol indicates the start of an object file. */
2095 /* Relocate for dynamic loading */
2096 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2100 /* This type of symbol indicates the start of data
2101 for one source file.
2102 Finish the symbol table of the previous source file
2103 (if any) and start accumulating a new symbol table. */
2104 /* Relocate for dynamic loading */
2105 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2109 #ifdef SUN_FIXED_LBRAC_BUG
2110 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2113 #ifdef PCC_SOL_BROKEN
2114 /* pcc bug, occasionally puts out SO for SOL. */
2115 if (context_stack_depth
> 0)
2117 start_subfile (name
, NULL
);
2121 if (last_source_file
)
2123 /* Check if previous symbol was also an N_SO (with some
2124 sanity checks). If so, that one was actually the directory
2125 name, and the current one is the real file name.
2127 if (previous_stab_code
== (unsigned char) N_SO
)
2129 patch_subfile_names (current_subfile
, name
);
2130 break; /* Ignore repeated SOs */
2132 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
2136 /* Null name means this just marks the end of text for this .o file.
2137 Don't start a new symtab in this case. */
2138 if (*name
== '\000')
2141 if (block_address_function_relative
)
2142 function_start_offset
= 0;
2145 start_symtab (name
, NULL
, valu
);
2146 record_debugformat ("stabs");
2150 /* This type of symbol indicates the start of data for
2151 a sub-source-file, one whose contents were copied or
2152 included in the compilation of the main source file
2153 (whose name was given in the N_SO symbol.) */
2154 /* Relocate for dynamic loading */
2155 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2156 start_subfile (name
, current_subfile
->dirname
);
2161 add_new_header_file (name
, valu
);
2162 start_subfile (name
, current_subfile
->dirname
);
2166 start_subfile (pop_subfile (), current_subfile
->dirname
);
2170 add_old_header_file (name
, valu
);
2174 /* This type of "symbol" really just records
2175 one line-number -- core-address correspondence.
2176 Enter it in the line list for this symbol table. */
2178 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2179 valu
+= function_start_offset
;
2181 #ifdef SUN_FIXED_LBRAC_BUG
2182 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2184 record_line (current_subfile
, desc
, valu
);
2188 common_block_start (name
, objfile
);
2192 common_block_end (objfile
);
2195 /* The following symbol types need to have the appropriate offset added
2196 to their value; then we process symbol definitions in the name. */
2198 case N_STSYM
: /* Static symbol in data seg */
2199 case N_LCSYM
: /* Static symbol in BSS seg */
2200 case N_ROSYM
: /* Static symbol in Read-only data seg */
2201 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2202 Solaris2's stabs-in-elf makes *most* symbols relative
2203 but leaves a few absolute (at least for Solaris 2.1 and version
2204 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2205 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2206 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2207 This leaves us no choice but to search for the 'S' or 'V'...
2208 (or pass the whole section_offsets stuff down ONE MORE function
2209 call level, which we really don't want to do). */
2213 /* .o files and NLMs have non-zero text seg offsets, but don't need
2214 their static syms offset in this fashion. XXX - This is really a
2215 crock that should be fixed in the solib handling code so that I
2216 don't have to work around it here. */
2218 if (!symfile_relocatable
)
2220 p
= strchr (name
, ':');
2221 if (p
!= 0 && p
[1] == 'S')
2223 /* The linker relocated it. We don't want to add an
2224 elfstab_offset_sections-type offset, but we *do* want
2225 to add whatever solib.c passed to symbol_file_add as
2226 addr (this is known to affect SunOS4, and I suspect ELF
2227 too). Since elfstab_offset_sections currently does not
2228 muck with the text offset (there is no Ttext.text
2229 symbol), we can get addr from the text offset. If
2230 elfstab_offset_sections ever starts dealing with the
2231 text offset, and we still need to do this, we need to
2232 invent a SECT_OFF_ADDR_KLUDGE or something. */
2233 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2234 goto define_a_symbol
;
2237 /* Since it's not the kludge case, re-dispatch to the right handler. */
2239 case N_STSYM
: goto case_N_STSYM
;
2240 case N_LCSYM
: goto case_N_LCSYM
;
2241 case N_ROSYM
: goto case_N_ROSYM
;
2246 case_N_STSYM
: /* Static symbol in data seg */
2247 case N_DSLINE
: /* Source line number, data seg */
2248 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2249 goto define_a_symbol
;
2251 case_N_LCSYM
: /* Static symbol in BSS seg */
2252 case N_BSLINE
: /* Source line number, bss seg */
2253 /* N_BROWS: overlaps with N_BSLINE */
2254 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2255 goto define_a_symbol
;
2257 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2258 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2259 goto define_a_symbol
;
2261 case N_ENTRY
: /* Alternate entry point */
2262 /* Relocate for dynamic loading */
2263 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2264 goto define_a_symbol
;
2266 /* The following symbol types we don't know how to process. Handle
2267 them in a "default" way, but complain to people who care. */
2269 case N_CATCH
: /* Exception handler catcher */
2270 case N_EHDECL
: /* Exception handler name */
2271 case N_PC
: /* Global symbol in Pascal */
2272 case N_M2C
: /* Modula-2 compilation unit */
2273 /* N_MOD2: overlaps with N_EHDECL */
2274 case N_SCOPE
: /* Modula-2 scope information */
2275 case N_ECOML
: /* End common (local name) */
2276 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2281 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2284 /* The following symbol types don't need the address field relocated,
2285 since it is either unused, or is absolute. */
2287 case N_GSYM
: /* Global variable */
2288 case N_NSYMS
: /* Number of symbols (ultrix) */
2289 case N_NOMAP
: /* No map? (ultrix) */
2290 case N_RSYM
: /* Register variable */
2291 case N_DEFD
: /* Modula-2 GNU module dependency */
2292 case N_SSYM
: /* Struct or union element */
2293 case N_LSYM
: /* Local symbol in stack */
2294 case N_PSYM
: /* Parameter variable */
2295 case N_LENG
: /* Length of preceding symbol type */
2299 char *colon_pos
= strchr (name
, ':');
2300 if (colon_pos
== NULL
)
2303 deftype
= colon_pos
[1];
2309 function_stab_type
= type
;
2311 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2312 /* Deal with the SunPRO 3.0 compiler which omits the address
2313 from N_FUN symbols. */
2315 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2317 struct minimal_symbol
*msym
;
2321 p
= strchr (name
, ':');
2326 strncpy (p
, name
, n
);
2329 msym
= lookup_minimal_symbol (p
, last_source_file
,
2333 /* Sun Fortran appends an underscore to the minimal
2334 symbol name, try again with an appended underscore
2335 if the minimal symbol was not found. */
2338 msym
= lookup_minimal_symbol (p
, last_source_file
,
2342 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2346 #ifdef SUN_FIXED_LBRAC_BUG
2347 /* The Sun acc compiler, under SunOS4, puts out
2348 functions with N_GSYM or N_STSYM. The problem is
2349 that the address of the symbol is no good (for N_GSYM
2350 it doesn't even attept an address; for N_STSYM it
2351 puts out an address but then it gets relocated
2352 relative to the data segment, not the text segment).
2353 Currently we can't fix this up later as we do for
2354 some types of symbol in scan_file_globals.
2355 Fortunately we do have a way of finding the address -
2356 we know that the value in last_pc_address is either
2357 the one we want (if we're dealing with the first
2358 function in an object file), or somewhere in the
2359 previous function. This means that we can use the
2360 minimal symbol table to get the address. */
2362 /* Starting with release 3.0, the Sun acc compiler,
2363 under SunOS4, puts out functions with N_FUN and a value
2364 of zero. This gets relocated to the start of the text
2365 segment of the module, which is no good either.
2366 Under SunOS4 we can deal with this as N_SLINE and N_SO
2367 entries contain valid absolute addresses.
2368 Release 3.0 acc also puts out N_OPT entries, which makes
2369 it possible to discern acc from cc or gcc. */
2371 if (type
== N_GSYM
|| type
== N_STSYM
2373 && n_opt_found
&& !block_address_function_relative
))
2375 struct minimal_symbol
*m
;
2376 int l
= colon_pos
- name
;
2378 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2379 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2380 && SYMBOL_NAME (m
) [l
] == '\0')
2381 /* last_pc_address was in this function */
2382 valu
= SYMBOL_VALUE (m
);
2383 else if (m
&& SYMBOL_NAME (m
+1)
2384 && STREQN (SYMBOL_NAME (m
+1), name
, l
)
2385 && SYMBOL_NAME (m
+1) [l
] == '\0')
2386 /* last_pc_address was in last function */
2387 valu
= SYMBOL_VALUE (m
+1);
2389 /* Not found - use last_pc_address (for finish_block) */
2390 valu
= last_pc_address
;
2393 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2396 if (block_address_function_relative
)
2397 /* For Solaris 2.0 compilers, the block addresses and
2398 N_SLINE's are relative to the start of the
2399 function. On normal systems, and when using gcc on
2400 Solaris 2.0, these addresses are just absolute, or
2401 relative to the N_SO, depending on
2402 BLOCK_ADDRESS_ABSOLUTE. */
2403 function_start_offset
= valu
;
2405 within_function
= 1;
2406 if (context_stack_depth
> 0)
2408 new = pop_context ();
2409 /* Make a block for the local symbols within. */
2410 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2411 new->start_addr
, valu
, objfile
);
2413 /* Stack must be empty now. */
2414 if (context_stack_depth
!= 0)
2415 complain (&lbrac_unmatched_complaint
, symnum
);
2417 new = push_context (0, valu
);
2418 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2422 define_symbol (valu
, name
, desc
, type
, objfile
);
2428 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2429 for a bunch of other flags, too. Someday we may parse their
2430 flags; for now we ignore theirs and hope they'll ignore ours. */
2431 case N_OPT
: /* Solaris 2: Compiler options */
2434 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2436 processing_gcc_compilation
= 2;
2437 #if 1 /* Works, but is experimental. -fnf */
2438 if (AUTO_DEMANGLING
)
2440 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2449 /* The following symbol types can be ignored. */
2450 case N_OBJ
: /* Solaris 2: Object file dir and name */
2451 /* N_UNDF: Solaris 2: file separator mark */
2452 /* N_UNDF: -- we will never encounter it, since we only process one
2453 file's symbols at once. */
2454 case N_ENDM
: /* Solaris 2: End of module */
2455 case N_MAIN
: /* Name of main routine. */
2456 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
2460 /* '#' is a GNU C extension to allow one symbol to refer to another
2463 Generally this is used so that an alias can refer to its main
2467 /* Initialize symbol reference names and determine if this is
2468 a definition. If symbol reference is being defined, go
2469 ahead and add it. Otherwise, just return sym. */
2474 /* If this stab defines a new reference ID that is not on the
2475 reference list, then put it on the reference list.
2477 We go ahead and advance NAME past the reference, even though
2478 it is not strictly necessary at this time. */
2479 refnum
= symbol_reference_defined (&s
);
2481 if (!ref_search (refnum
))
2482 ref_add (refnum
, 0, name
, valu
);
2487 previous_stab_code
= type
;
2490 /* FIXME: The only difference between this and elfstab_build_psymtabs
2491 is the call to install_minimal_symbols for elf, and the support for
2492 split sections. If the differences are really that small, the code
2493 should be shared. */
2495 /* Scan and build partial symbols for an coff symbol file.
2496 The coff file has already been processed to get its minimal symbols.
2498 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2501 OBJFILE is the object file we are reading symbols from.
2502 ADDR is the address relative to which the symbols are (e.g.
2503 the base address of the text segment).
2504 MAINLINE is true if we are reading the main symbol
2505 table (as opposed to a shared lib or dynamically loaded file).
2506 TEXTADDR is the address of the text section.
2507 TEXTSIZE is the size of the text section.
2508 STABSECTS is the list of .stab sections in OBJFILE.
2509 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2510 .stabstr section exists.
2512 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2513 adjusted for coff details. */
2516 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2517 textaddr
, textsize
, stabsects
,
2518 stabstroffset
, stabstrsize
)
2519 struct objfile
*objfile
;
2520 struct section_offsets
*section_offsets
;
2523 unsigned int textsize
;
2524 struct stab_section_list
*stabsects
;
2525 file_ptr stabstroffset
;
2526 unsigned int stabstrsize
;
2529 bfd
*sym_bfd
= objfile
->obfd
;
2530 char *name
= bfd_get_filename (sym_bfd
);
2531 struct dbx_symfile_info
*info
;
2532 unsigned int stabsize
;
2534 /* There is already a dbx_symfile_info allocated by our caller.
2535 It might even contain some info from the coff symtab to help us. */
2536 info
= objfile
->sym_stab_info
;
2538 DBX_TEXT_ADDR (objfile
) = textaddr
;
2539 DBX_TEXT_SIZE (objfile
) = textsize
;
2541 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2542 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2543 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2545 if (stabstrsize
> bfd_get_size (sym_bfd
))
2546 error ("ridiculous string table size: %d bytes", stabstrsize
);
2547 DBX_STRINGTAB (objfile
) = (char *)
2548 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2549 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2551 /* Now read in the string table in one big gulp. */
2553 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2555 perror_with_name (name
);
2556 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2557 if (val
!= stabstrsize
)
2558 perror_with_name (name
);
2560 stabsread_new_init ();
2561 buildsym_new_init ();
2562 free_header_files ();
2563 init_header_files ();
2565 processing_acc_compilation
= 1;
2567 /* In a coff file, we've already installed the minimal symbols that came
2568 from the coff (non-stab) symbol table, so always act like an
2569 incremental load here. */
2570 if (stabsects
->next
== NULL
)
2572 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2573 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2574 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2578 struct stab_section_list
*stabsect
;
2580 DBX_SYMCOUNT (objfile
) = 0;
2581 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2583 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2584 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2587 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2589 symbuf_sections
= stabsects
->next
;
2590 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2594 dbx_symfile_read (objfile
, section_offsets
, 0);
2597 /* Scan and build partial symbols for an ELF symbol file.
2598 This ELF file has already been processed to get its minimal symbols,
2599 and any DWARF symbols that were in it.
2601 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2604 OBJFILE is the object file we are reading symbols from.
2605 ADDR is the address relative to which the symbols are (e.g.
2606 the base address of the text segment).
2607 MAINLINE is true if we are reading the main symbol
2608 table (as opposed to a shared lib or dynamically loaded file).
2609 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2611 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2612 .stabstr section exists.
2614 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2615 adjusted for elf details. */
2618 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2619 staboffset
, stabsize
,
2620 stabstroffset
, stabstrsize
)
2621 struct objfile
*objfile
;
2622 struct section_offsets
*section_offsets
;
2624 file_ptr staboffset
;
2625 unsigned int stabsize
;
2626 file_ptr stabstroffset
;
2627 unsigned int stabstrsize
;
2630 bfd
*sym_bfd
= objfile
->obfd
;
2631 char *name
= bfd_get_filename (sym_bfd
);
2632 struct dbx_symfile_info
*info
;
2633 asection
*text_sect
;
2635 /* There is already a dbx_symfile_info allocated by our caller.
2636 It might even contain some info from the ELF symtab to help us. */
2637 info
= objfile
->sym_stab_info
;
2639 /* Find the first and last text address. dbx_symfile_read seems to
2641 find_text_range (sym_bfd
, objfile
);
2643 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2644 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2645 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2646 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2647 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2649 if (stabstrsize
> bfd_get_size (sym_bfd
))
2650 error ("ridiculous string table size: %d bytes", stabstrsize
);
2651 DBX_STRINGTAB (objfile
) = (char *)
2652 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2653 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2655 /* Now read in the string table in one big gulp. */
2657 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2659 perror_with_name (name
);
2660 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2661 if (val
!= stabstrsize
)
2662 perror_with_name (name
);
2664 stabsread_new_init ();
2665 buildsym_new_init ();
2666 free_header_files ();
2667 init_header_files ();
2668 install_minimal_symbols (objfile
);
2670 processing_acc_compilation
= 1;
2672 /* In an elf file, we've already installed the minimal symbols that came
2673 from the elf (non-stab) symbol table, so always act like an
2674 incremental load here. */
2675 dbx_symfile_read (objfile
, section_offsets
, 0);
2678 /* Scan and build partial symbols for a file with special sections for stabs
2679 and stabstrings. The file has already been processed to get its minimal
2680 symbols, and any other symbols that might be necessary to resolve GSYMs.
2682 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2685 OBJFILE is the object file we are reading symbols from.
2686 ADDR is the address relative to which the symbols are (e.g. the base address
2687 of the text segment).
2688 MAINLINE is true if we are reading the main symbol table (as opposed to a
2689 shared lib or dynamically loaded file).
2690 STAB_NAME is the name of the section that contains the stabs.
2691 STABSTR_NAME is the name of the section that contains the stab strings.
2693 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2696 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2697 stabstr_name
, text_name
)
2698 struct objfile
*objfile
;
2699 struct section_offsets
*section_offsets
;
2706 bfd
*sym_bfd
= objfile
->obfd
;
2707 char *name
= bfd_get_filename (sym_bfd
);
2709 asection
*stabstrsect
;
2710 asection
*text_sect
;
2712 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2713 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2719 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2720 stab_name
, stabstr_name
);
2722 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
2723 xmalloc (sizeof (struct dbx_symfile_info
));
2724 memset (objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
2726 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2728 error ("Can't find %s section in symbol file", text_name
);
2729 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2730 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2732 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2733 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2734 / DBX_SYMBOL_SIZE (objfile
);
2735 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2736 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2738 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2739 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2740 DBX_STRINGTAB (objfile
) = (char *)
2741 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2742 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2744 /* Now read in the string table in one big gulp. */
2746 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2747 stabstrsect
, /* bfd section */
2748 DBX_STRINGTAB (objfile
), /* input buffer */
2749 0, /* offset into section */
2750 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2753 perror_with_name (name
);
2755 stabsread_new_init ();
2756 buildsym_new_init ();
2757 free_header_files ();
2758 init_header_files ();
2759 install_minimal_symbols (objfile
);
2761 /* Now, do an incremental load */
2763 processing_acc_compilation
= 1;
2764 dbx_symfile_read (objfile
, section_offsets
, 0);
2767 static struct sym_fns aout_sym_fns
=
2769 bfd_target_aout_flavour
,
2770 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2771 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2772 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2773 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2774 default_symfile_offsets
,
2775 /* sym_offsets: parse user's offsets to internal form */
2776 NULL
/* next: pointer to next struct sym_fns */
2780 _initialize_dbxread ()
2782 add_symtab_fns(&aout_sym_fns
);