1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This module provides three functions: dbx_symfile_init,
22 which initializes to read a symbol file; dbx_new_init, which
23 discards existing cached information when all symbols are being
24 discarded; and dbx_symfile_read, which reads a symbol table
27 dbx_symfile_read only does the minimum work necessary for letting the
28 user "name" things symbolically; it does not read the entire symtab.
29 Instead, it reads the external and static symbols and puts them in partial
30 symbol tables. When more extensive information is requested of a
31 file, the corresponding partial symbol table is mutated into a full
32 fledged symbol table by going back and reading the symbols
33 for real. dbx_psymtab_to_symtab() is the function that does this */
36 #include "gdb_string.h"
38 #if defined(USG) || defined(__CYGNUSCLIB__)
39 #include <sys/types.h>
44 #include <sys/param.h>
51 #include "breakpoint.h"
54 #include "gdbcore.h" /* for bfd stuff */
55 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
59 #include "stabsread.h"
60 #include "gdb-stabs.h"
62 #include "language.h" /* Needed inside partial-stab.h */
63 #include "complaints.h"
65 #include "aout/aout64.h"
66 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
68 /* defined in stabsread.c; used for completing cfront stabs strings */
70 resolve_cfront_continuation
PARAMS((struct objfile
* objfile
,
71 struct symbol
* sym
, char * p
));
74 /* We put a pointer to this structure in the read_symtab_private field
79 /* Offset within the file symbol table of first local symbol for this
84 /* Length (in bytes) of the section of the symbol table devoted to
85 this file's symbols (actually, the section bracketed may contain
86 more than just this file's symbols). If ldsymlen is 0, the only
87 reason for this thing's existence is the dependency list. Nothing
88 else will happen when it is read in. */
92 /* The size of each symbol in the symbol file (in external form). */
96 /* Further information needed to locate the symbols if they are in
101 int file_string_offset
;
104 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
105 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
106 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
107 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
108 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
109 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
110 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
113 /* Macro to determine which symbols to ignore when reading the first symbol
114 of a file. Some machines override this definition. */
115 #ifndef IGNORE_SYMBOL
116 /* This code is used on Ultrix systems. Ignore it */
117 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
120 /* Remember what we deduced to be the source language of this psymtab. */
122 static enum language psymtab_language
= language_unknown
;
124 /* Nonzero means give verbose info on gdb action. From main.c. */
125 extern int info_verbose
;
127 /* The BFD for this file -- implicit parameter to next_symbol_text. */
129 static bfd
*symfile_bfd
;
131 /* The size of each symbol in the symbol file (in external form).
132 This is set by dbx_symfile_read when building psymtabs, and by
133 dbx_psymtab_to_symtab when building symtabs. */
135 static unsigned symbol_size
;
137 /* This is the offset of the symbol table in the executable file */
138 static unsigned symbol_table_offset
;
140 /* This is the offset of the string table in the executable file */
141 static unsigned string_table_offset
;
143 /* For elf+stab executables, the n_strx field is not a simple index
144 into the string table. Instead, each .o file has a base offset
145 in the string table, and the associated symbols contain offsets
146 from this base. The following two variables contain the base
147 offset for the current and next .o files. */
148 static unsigned int file_string_table_offset
;
149 static unsigned int next_file_string_table_offset
;
151 /* .o and NLM files contain unrelocated addresses which are based at 0. When
152 non-zero, this flag disables some of the special cases for Solaris elf+stab
153 text addresses at location 0. */
155 static int symfile_relocatable
= 0;
157 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
158 to the function start address. */
160 static int block_address_function_relative
= 0;
162 /* The lowest text address we have yet encountered. This is needed
163 because in an a.out file, there is no header field which tells us
164 what address the program is actually going to be loaded at, so we
165 need to make guesses based on the symbols (which *are* relocated to
166 reflect the address it will be loaded at). */
167 static CORE_ADDR lowest_text_address
;
169 /* Complaints about the symbols we have encountered. */
171 struct complaint lbrac_complaint
=
172 {"bad block start address patched", 0, 0};
174 struct complaint string_table_offset_complaint
=
175 {"bad string table offset in symbol %d", 0, 0};
177 struct complaint unknown_symtype_complaint
=
178 {"unknown symbol type %s", 0, 0};
180 struct complaint unknown_symchar_complaint
=
181 {"unknown symbol descriptor `%c'", 0, 0};
183 struct complaint lbrac_rbrac_complaint
=
184 {"block start larger than block end", 0, 0};
186 struct complaint lbrac_unmatched_complaint
=
187 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
189 struct complaint lbrac_mismatch_complaint
=
190 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
192 struct complaint repeated_header_complaint
=
193 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
195 /* During initial symbol readin, we need to have a structure to keep
196 track of which psymtabs have which bincls in them. This structure
197 is used during readin to setup the list of dependencies within each
198 partial symbol table. */
200 struct header_file_location
202 char *name
; /* Name of header file */
203 int instance
; /* See above */
204 struct partial_symtab
*pst
; /* Partial symtab that has the
205 BINCL/EINCL defs for this file */
208 /* The actual list and controling variables */
209 static struct header_file_location
*bincl_list
, *next_bincl
;
210 static int bincls_allocated
;
212 /* Local function prototypes */
215 free_header_files
PARAMS ((void));
218 init_header_files
PARAMS ((void));
221 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
224 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
227 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
230 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
231 struct objfile
*objfile
));
234 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
238 free_bincl_list
PARAMS ((struct objfile
*));
240 static struct partial_symtab
*
241 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
244 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
247 init_bincl_list
PARAMS ((int, struct objfile
*));
250 dbx_next_symbol_text
PARAMS ((struct objfile
*));
253 fill_symbuf
PARAMS ((bfd
*));
256 dbx_symfile_init
PARAMS ((struct objfile
*));
259 dbx_new_init
PARAMS ((struct objfile
*));
262 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
265 dbx_symfile_finish
PARAMS ((struct objfile
*));
268 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
271 add_new_header_file
PARAMS ((char *, int));
274 add_old_header_file
PARAMS ((char *, int));
277 add_this_object_header_file
PARAMS ((int));
279 /* Free up old header file tables */
286 if (header_files
!= NULL
)
288 for (i
= 0; i
< n_header_files
; i
++)
290 free (header_files
[i
].name
);
292 free ((PTR
)header_files
);
296 if (this_object_header_files
)
298 free ((PTR
)this_object_header_files
);
299 this_object_header_files
= NULL
;
301 n_allocated_header_files
= 0;
302 n_allocated_this_object_header_files
= 0;
305 /* Allocate new header file tables */
311 n_allocated_header_files
= 10;
312 header_files
= (struct header_file
*)
313 xmalloc (10 * sizeof (struct header_file
));
315 n_allocated_this_object_header_files
= 10;
316 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
319 /* Add header file number I for this object file
320 at the next successive FILENUM. */
323 add_this_object_header_file (i
)
326 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
328 n_allocated_this_object_header_files
*= 2;
329 this_object_header_files
330 = (int *) xrealloc ((char *) this_object_header_files
,
331 n_allocated_this_object_header_files
* sizeof (int));
334 this_object_header_files
[n_this_object_header_files
++] = i
;
337 /* Add to this file an "old" header file, one already seen in
338 a previous object file. NAME is the header file's name.
339 INSTANCE is its instance code, to select among multiple
340 symbol tables for the same header file. */
343 add_old_header_file (name
, instance
)
347 register struct header_file
*p
= header_files
;
350 for (i
= 0; i
< n_header_files
; i
++)
351 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
353 add_this_object_header_file (i
);
356 complain (&repeated_header_complaint
, name
, symnum
);
359 /* Add to this file a "new" header file: definitions for its types follow.
360 NAME is the header file's name.
361 Most often this happens only once for each distinct header file,
362 but not necessarily. If it happens more than once, INSTANCE has
363 a different value each time, and references to the header file
364 use INSTANCE values to select among them.
366 dbx output contains "begin" and "end" markers for each new header file,
367 but at this level we just need to know which files there have been;
368 so we record the file when its "begin" is seen and ignore the "end". */
371 add_new_header_file (name
, instance
)
377 /* Make sure there is room for one more header file. */
379 if (n_header_files
== n_allocated_header_files
)
381 n_allocated_header_files
*= 2;
382 header_files
= (struct header_file
*)
383 xrealloc ((char *) header_files
,
384 (n_allocated_header_files
* sizeof (struct header_file
)));
387 /* Create an entry for this header file. */
389 i
= n_header_files
++;
390 header_files
[i
].name
= savestring (name
, strlen(name
));
391 header_files
[i
].instance
= instance
;
392 header_files
[i
].length
= 10;
393 header_files
[i
].vector
394 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
395 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
397 add_this_object_header_file (i
);
401 static struct type
**
402 explicit_lookup_type (real_filenum
, index
)
403 int real_filenum
, index
;
405 register struct header_file
*f
= &header_files
[real_filenum
];
407 if (index
>= f
->length
)
410 f
->vector
= (struct type
**)
411 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
412 memset (&f
->vector
[f
->length
/ 2],
413 '\0', f
->length
* sizeof (struct type
*) / 2);
415 return &f
->vector
[index
];
420 record_minimal_symbol (name
, address
, type
, objfile
)
424 struct objfile
*objfile
;
426 enum minimal_symbol_type ms_type
;
433 section
= SECT_OFF_TEXT
;
437 section
= SECT_OFF_DATA
;
441 section
= SECT_OFF_BSS
;
450 section
= SECT_OFF_DATA
;
453 /* I don't think this type actually exists; since a N_SETV is the result
454 of going over many .o files, it doesn't make sense to have one
456 ms_type
= mst_file_data
;
457 section
= SECT_OFF_DATA
;
464 ms_type
= mst_file_text
;
465 section
= SECT_OFF_TEXT
;
468 ms_type
= mst_file_data
;
470 /* Check for __DYNAMIC, which is used by Sun shared libraries.
471 Record it as global even if it's local, not global, so
472 lookup_minimal_symbol can find it. We don't check symbol_leading_char
473 because for SunOS4 it always is '_'. */
474 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
477 /* Same with virtual function tables, both global and static. */
479 char *tempstring
= name
;
480 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
482 if (VTBL_PREFIX_P ((tempstring
)))
485 section
= SECT_OFF_DATA
;
488 ms_type
= mst_file_bss
;
489 section
= SECT_OFF_BSS
;
492 ms_type
= mst_unknown
;
497 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
498 && address
< lowest_text_address
)
499 lowest_text_address
= address
;
501 prim_record_minimal_symbol_and_info
502 (name
, address
, ms_type
, NULL
, section
, objfile
);
505 /* Scan and build partial symbols for a symbol file.
506 We have been initialized by a call to dbx_symfile_init, which
507 put all the relevant info into a "struct dbx_symfile_info",
508 hung off the objfile structure.
510 SECTION_OFFSETS contains offsets relative to which the symbols in the
511 various sections are (depending where the sections were actually loaded).
512 MAINLINE is true if we are reading the main symbol
513 table (as opposed to a shared lib or dynamically loaded file). */
516 dbx_symfile_read (objfile
, section_offsets
, mainline
)
517 struct objfile
*objfile
;
518 struct section_offsets
*section_offsets
;
519 int mainline
; /* FIXME comments above */
523 struct cleanup
*back_to
;
525 val
= strlen (objfile
->name
);
527 /* .o and .nlm files are relocatables with text, data and bss segs based at
528 0. This flag disables special (Solaris stabs-in-elf only) fixups for
529 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
530 should be fixed to determine pst->textlow without using this text seg of
533 if (strcmp (&objfile
->name
[val
-2], ".o") == 0
534 || strcmp (&objfile
->name
[val
-4], ".nlm") == 0)
535 symfile_relocatable
= 1;
537 /* This is true for Solaris (and all other systems which put stabs
538 in sections, hopefully, since it would be silly to do things
539 differently from Solaris), and false for SunOS4 and other a.out
541 block_address_function_relative
=
542 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
543 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
544 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4))
545 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "pe", 2))
546 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "nlm", 3)));
548 sym_bfd
= objfile
->obfd
;
549 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
551 perror_with_name (objfile
->name
);
553 /* If we are reinitializing, or if we have never loaded syms yet, init */
555 || objfile
->global_psymbols
.size
== 0
556 || objfile
->static_psymbols
.size
== 0)
557 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
559 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
560 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
563 back_to
= make_cleanup (really_free_pendings
, 0);
565 init_minimal_symbol_collection ();
566 make_cleanup (discard_minimal_symbols
, 0);
568 /* Now that the symbol table data of the executable file are all in core,
569 process them and define symbols accordingly. */
571 read_dbx_symtab (section_offsets
, objfile
,
572 DBX_TEXT_ADDR (objfile
),
573 DBX_TEXT_SIZE (objfile
));
575 /* Add the dynamic symbols. */
577 read_dbx_dynamic_symtab (section_offsets
, objfile
);
579 /* Install any minimal symbols that have been collected as the current
580 minimal symbols for this objfile. */
582 install_minimal_symbols (objfile
);
584 do_cleanups (back_to
);
587 /* Initialize anything that needs initializing when a completely new
588 symbol file is specified (not just adding some symbols from another
589 file, e.g. a shared library). */
592 dbx_new_init (ignore
)
593 struct objfile
*ignore
;
595 stabsread_new_init ();
596 buildsym_new_init ();
597 init_header_files ();
601 /* dbx_symfile_init ()
602 is the dbx-specific initialization routine for reading symbols.
603 It is passed a struct objfile which contains, among other things,
604 the BFD for the file whose symbols are being read, and a slot for a pointer
605 to "private data" which we fill with goodies.
607 We read the string table into malloc'd space and stash a pointer to it.
609 Since BFD doesn't know how to read debug symbols in a format-independent
610 way (and may never do so...), we have to do it ourselves. We will never
611 be called unless this is an a.out (or very similar) file.
612 FIXME, there should be a cleaner peephole into the BFD environment here. */
614 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
617 dbx_symfile_init (objfile
)
618 struct objfile
*objfile
;
621 bfd
*sym_bfd
= objfile
->obfd
;
622 char *name
= bfd_get_filename (sym_bfd
);
624 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
626 /* Allocate struct to keep track of the symfile */
627 objfile
->sym_stab_info
= (PTR
)
628 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
630 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
631 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
632 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
634 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
636 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
638 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
640 error ("Can't find .text section in symbol file");
641 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
642 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
644 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
645 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
646 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
648 /* Read the string table and stash it away in the psymbol_obstack. It is
649 only needed as long as we need to expand psymbols into full symbols,
650 so when we blow away the psymbol the string table goes away as well.
651 Note that gdb used to use the results of attempting to malloc the
652 string table, based on the size it read, as a form of sanity check
653 for botched byte swapping, on the theory that a byte swapped string
654 table size would be so totally bogus that the malloc would fail. Now
655 that we put in on the psymbol_obstack, we can't do this since gdb gets
656 a fatal error (out of virtual memory) if the size is bogus. We can
657 however at least check to see if the size is less than the size of
658 the size field itself, or larger than the size of the entire file.
659 Note that all valid string tables have a size greater than zero, since
660 the bytes used to hold the size are included in the count. */
662 if (STRING_TABLE_OFFSET
== 0)
664 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
665 will never be zero, even when there is no string table. This
666 would appear to be a bug in bfd. */
667 DBX_STRINGTAB_SIZE (objfile
) = 0;
668 DBX_STRINGTAB (objfile
) = NULL
;
672 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
674 perror_with_name (name
);
676 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
677 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
680 perror_with_name (name
);
684 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
685 EOF if there is no string table, and attempting to read the size
686 from EOF will read zero bytes. */
687 DBX_STRINGTAB_SIZE (objfile
) = 0;
688 DBX_STRINGTAB (objfile
) = NULL
;
692 /* Read some data that would appear to be the string table size.
693 If there really is a string table, then it is probably the right
694 size. Byteswap if necessary and validate the size. Note that
695 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
696 random data that happened to be at STRING_TABLE_OFFSET, because
697 bfd can't tell us there is no string table, the sanity checks may
698 or may not catch this. */
699 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
701 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
702 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
703 error ("ridiculous string table size (%d bytes).",
704 DBX_STRINGTAB_SIZE (objfile
));
706 DBX_STRINGTAB (objfile
) =
707 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
708 DBX_STRINGTAB_SIZE (objfile
));
709 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
711 /* Now read in the string table in one big gulp. */
713 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
715 perror_with_name (name
);
716 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
718 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
719 perror_with_name (name
);
724 /* Perform any local cleanups required when we are done with a particular
725 objfile. I.E, we are in the process of discarding all symbol information
726 for an objfile, freeing up all memory held for it, and unlinking the
727 objfile struct from the global list of known objfiles. */
730 dbx_symfile_finish (objfile
)
731 struct objfile
*objfile
;
733 if (objfile
->sym_stab_info
!= NULL
)
735 mfree (objfile
-> md
, objfile
->sym_stab_info
);
737 free_header_files ();
741 /* Buffer for reading the symbol table entries. */
742 static struct internal_nlist symbuf
[4096];
743 static int symbuf_idx
;
744 static int symbuf_end
;
746 /* cont_elem is used for continuing information in cfront.
747 It saves information about which types need to be fixed up and
748 completed after all the stabs are read. */
751 /* sym and stabsstring for continuing information in cfront */
754 /* state dependancies (statics that must be preserved) */
758 /* other state dependancies include:
759 (assumption is that these will not change since process_now FIXME!!)
765 static struct cont_elem cont_list
[100];
766 static int cont_count
= 0;
773 /* save state so we can process these stabs later */
774 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
775 cont_list
[cont_count
].sym_end
= symbuf_end
;
776 cont_list
[cont_count
].symnum
= symnum
;
777 cont_list
[cont_count
].sym
= sym
;
778 cont_list
[cont_count
].stabs
= p
;
784 struct objfile
* objfile
;
787 /* save original state */
788 int save_symbuf_idx
= symbuf_idx
;
789 int save_symbuf_end
= symbuf_end
;
790 int save_symnum
= symnum
;
791 for (i
=0; i
<cont_count
; i
++)
793 /* set state as if we were parsing stabs strings
795 symbuf_idx
= cont_list
[i
].sym_idx
; /* statics used by gdb */
796 symbuf_end
= cont_list
[i
].sym_end
;
797 symnum
= cont_list
[i
].symnum
;
798 resolve_cfront_continuation(objfile
,cont_list
[i
].sym
,cont_list
[i
].stabs
);
800 /* restore original state */
801 symbuf_idx
= save_symbuf_idx
;
802 symbuf_end
= save_symbuf_end
;
803 symnum
= save_symnum
;
804 cont_count
=0; /* reset for next run */
808 /* Name of last function encountered. Used in Solaris to approximate
809 object file boundaries. */
810 static char *last_function_name
;
812 /* The address in memory of the string table of the object file we are
813 reading (which might not be the "main" object file, but might be a
814 shared library or some other dynamically loaded thing). This is
815 set by read_dbx_symtab when building psymtabs, and by
816 read_ofile_symtab when building symtabs, and is used only by
817 next_symbol_text. FIXME: If that is true, we don't need it when
818 building psymtabs, right? */
819 static char *stringtab_global
;
821 /* These variables are used to control fill_symbuf when the stabs
822 symbols are not contiguous (as may be the case when a COFF file is
823 linked using --split-by-reloc). */
824 static struct stab_section_list
*symbuf_sections
;
825 static unsigned int symbuf_left
;
826 static unsigned int symbuf_read
;
828 /* Refill the symbol table input buffer
829 and set the variables that control fetching entries from it.
830 Reports an error if no data available.
831 This function can read past the end of the symbol table
832 (into the string table) but this does no harm. */
835 fill_symbuf (sym_bfd
)
841 if (symbuf_sections
== NULL
)
842 count
= sizeof (symbuf
);
845 if (symbuf_left
<= 0)
847 file_ptr filepos
= symbuf_sections
->section
->filepos
;
848 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
849 perror_with_name (bfd_get_filename (sym_bfd
));
850 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
851 symbol_table_offset
= filepos
- symbuf_read
;
852 symbuf_sections
= symbuf_sections
->next
;
856 if (count
> sizeof (symbuf
))
857 count
= sizeof (symbuf
);
860 nbytes
= bfd_read ((PTR
)symbuf
, count
, 1, sym_bfd
);
862 perror_with_name (bfd_get_filename (sym_bfd
));
863 else if (nbytes
== 0)
864 error ("Premature end of file reading symbol table");
865 symbuf_end
= nbytes
/ symbol_size
;
867 symbuf_left
-= nbytes
;
868 symbuf_read
+= nbytes
;
871 #define SWAP_SYMBOL(symp, abfd) \
873 (symp)->n_strx = bfd_h_get_32(abfd, \
874 (unsigned char *)&(symp)->n_strx); \
875 (symp)->n_desc = bfd_h_get_16 (abfd, \
876 (unsigned char *)&(symp)->n_desc); \
877 (symp)->n_value = bfd_h_get_32 (abfd, \
878 (unsigned char *)&(symp)->n_value); \
881 /* Invariant: The symbol pointed to by symbuf_idx is the first one
882 that hasn't been swapped. Swap the symbol at the same time
883 that symbuf_idx is incremented. */
885 /* dbx allows the text of a symbol name to be continued into the
886 next symbol name! When such a continuation is encountered
887 (a \ at the end of the text of a name)
888 call this function to get the continuation. */
891 dbx_next_symbol_text (objfile
)
892 struct objfile
*objfile
;
894 if (symbuf_idx
== symbuf_end
)
895 fill_symbuf (symfile_bfd
);
897 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
898 OBJSTAT (objfile
, n_stabs
++);
899 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
900 + file_string_table_offset
;
903 /* Initialize the list of bincls to contain none and have some
907 init_bincl_list (number
, objfile
)
909 struct objfile
*objfile
;
911 bincls_allocated
= number
;
912 next_bincl
= bincl_list
= (struct header_file_location
*)
913 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
916 /* Add a bincl to the list. */
919 add_bincl_to_list (pst
, name
, instance
)
920 struct partial_symtab
*pst
;
924 if (next_bincl
>= bincl_list
+ bincls_allocated
)
926 int offset
= next_bincl
- bincl_list
;
927 bincls_allocated
*= 2;
928 bincl_list
= (struct header_file_location
*)
929 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
930 bincls_allocated
* sizeof (struct header_file_location
));
931 next_bincl
= bincl_list
+ offset
;
933 next_bincl
->pst
= pst
;
934 next_bincl
->instance
= instance
;
935 next_bincl
++->name
= name
;
938 /* Given a name, value pair, find the corresponding
939 bincl in the list. Return the partial symtab associated
940 with that header_file_location. */
942 static struct partial_symtab
*
943 find_corresponding_bincl_psymtab (name
, instance
)
947 struct header_file_location
*bincl
;
949 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
950 if (bincl
->instance
== instance
951 && STREQ (name
, bincl
->name
))
954 complain (&repeated_header_complaint
, name
, symnum
);
955 return (struct partial_symtab
*) 0;
958 /* Free the storage allocated for the bincl list. */
961 free_bincl_list (objfile
)
962 struct objfile
*objfile
;
964 mfree (objfile
-> md
, (PTR
)bincl_list
);
965 bincls_allocated
= 0;
968 /* Scan a SunOs dynamic symbol table for symbols of interest and
969 add them to the minimal symbol table. */
972 read_dbx_dynamic_symtab (section_offsets
, objfile
)
973 struct section_offsets
*section_offsets
;
974 struct objfile
*objfile
;
976 bfd
*abfd
= objfile
->obfd
;
977 struct cleanup
*back_to
;
990 /* Check that the symbol file has dynamic symbols that we know about.
991 bfd_arch_unknown can happen if we are reading a sun3 symbol file
992 on a sun4 host (and vice versa) and bfd is not configured
993 --with-target=all. This would trigger an assertion in bfd/sunos.c,
994 so we ignore the dynamic symbols in this case. */
995 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
996 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
997 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1000 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1001 if (dynsym_size
< 0)
1004 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1005 back_to
= make_cleanup (free
, dynsyms
);
1007 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1008 if (dynsym_count
< 0)
1010 do_cleanups (back_to
);
1014 /* Enter dynamic symbols into the minimal symbol table
1015 if this is a stripped executable. */
1016 if (bfd_get_symcount (abfd
) <= 0)
1019 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1021 asymbol
*sym
= *symptr
;
1025 sec
= bfd_get_section (sym
);
1027 /* BFD symbols are section relative. */
1028 sym_value
= sym
->value
+ sec
->vma
;
1030 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1032 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1035 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1037 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1040 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1042 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1048 if (sym
->flags
& BSF_GLOBAL
)
1051 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1056 /* Symbols from shared libraries have a dynamic relocation entry
1057 that points to the associated slot in the procedure linkage table.
1058 We make a mininal symbol table entry with type mst_solib_trampoline
1059 at the address in the procedure linkage table. */
1060 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1061 if (dynrel_size
< 0)
1063 do_cleanups (back_to
);
1067 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1068 make_cleanup (free
, dynrels
);
1070 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1071 if (dynrel_count
< 0)
1073 do_cleanups (back_to
);
1077 for (counter
= 0, relptr
= dynrels
;
1078 counter
< dynrel_count
;
1079 counter
++, relptr
++)
1081 arelent
*rel
= *relptr
;
1083 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1085 switch (bfd_get_arch (abfd
))
1087 case bfd_arch_sparc
:
1088 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1092 /* `16' is the type BFD produces for a jump table relocation. */
1093 if (rel
->howto
->type
!= 16)
1096 /* Adjust address in the jump table to point to
1097 the start of the bsr instruction. */
1104 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1105 prim_record_minimal_symbol (name
, address
, mst_solib_trampoline
,
1109 do_cleanups (back_to
);
1112 /* Given pointers to an a.out symbol table in core containing dbx
1113 style data, setup partial_symtab's describing each source file for
1114 which debugging information is available.
1115 SYMFILE_NAME is the name of the file we are reading from
1116 and SECTION_OFFSETS is the set of offsets for the various sections
1117 of the file (a set of zeros if the mainline program). */
1120 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1121 struct section_offsets
*section_offsets
;
1122 struct objfile
*objfile
;
1123 CORE_ADDR text_addr
;
1126 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1127 register char *namestring
;
1129 int past_first_source_file
= 0;
1130 CORE_ADDR last_o_file_start
= 0;
1131 CORE_ADDR last_function_start
= 0;
1132 struct cleanup
*back_to
;
1135 /* Current partial symtab */
1136 struct partial_symtab
*pst
;
1138 /* List of current psymtab's include files */
1139 char **psymtab_include_list
;
1140 int includes_allocated
;
1143 /* Index within current psymtab dependency list */
1144 struct partial_symtab
**dependency_list
;
1145 int dependencies_used
, dependencies_allocated
;
1147 /* FIXME. We probably want to change stringtab_global rather than add this
1148 while processing every symbol entry. FIXME. */
1149 file_string_table_offset
= 0;
1150 next_file_string_table_offset
= 0;
1152 stringtab_global
= DBX_STRINGTAB (objfile
);
1154 pst
= (struct partial_symtab
*) 0;
1156 includes_allocated
= 30;
1158 psymtab_include_list
= (char **) alloca (includes_allocated
*
1161 dependencies_allocated
= 30;
1162 dependencies_used
= 0;
1164 (struct partial_symtab
**) alloca (dependencies_allocated
*
1165 sizeof (struct partial_symtab
*));
1167 /* Init bincl list */
1168 init_bincl_list (20, objfile
);
1169 back_to
= make_cleanup (free_bincl_list
, objfile
);
1171 last_source_file
= NULL
;
1173 lowest_text_address
= (CORE_ADDR
)-1;
1175 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1176 abfd
= objfile
->obfd
;
1177 symbuf_end
= symbuf_idx
= 0;
1178 next_symbol_text_func
= dbx_next_symbol_text
;
1180 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1182 /* Get the symbol for this run and pull out some info */
1183 QUIT
; /* allow this to be interruptable */
1184 if (symbuf_idx
== symbuf_end
)
1186 bufp
= &symbuf
[symbuf_idx
++];
1189 * Special case to speed up readin.
1191 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1193 SWAP_SYMBOL (bufp
, abfd
);
1194 OBJSTAT (objfile
, n_stabs
++);
1196 /* Ok. There is a lot of code duplicated in the rest of this
1197 switch statement (for efficiency reasons). Since I don't
1198 like duplicating code, I will do my penance here, and
1199 describe the code which is duplicated:
1201 *) The assignment to namestring.
1202 *) The call to strchr.
1203 *) The addition of a partial symbol the the two partial
1204 symbol lists. This last is a large section of code, so
1205 I've imbedded it in the following macro.
1208 /* Set namestring based on bufp. If the string table index is invalid,
1209 give a fake name, and print a single error message per symbol file read,
1210 rather than abort the symbol reading or flood the user with messages. */
1212 /*FIXME: Too many adds and indirections in here for the inner loop. */
1213 #define SET_NAMESTRING()\
1214 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1215 DBX_STRINGTAB_SIZE (objfile)) { \
1216 complain (&string_table_offset_complaint, symnum); \
1217 namestring = "<bad string table offset>"; \
1219 namestring = bufp->n_strx + file_string_table_offset + \
1220 DBX_STRINGTAB (objfile)
1222 #define CUR_SYMBOL_TYPE bufp->n_type
1223 #define CUR_SYMBOL_VALUE bufp->n_value
1224 #define DBXREAD_ONLY
1225 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1226 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1227 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1228 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1230 #include "partial-stab.h"
1233 /* If there's stuff to be cleaned up, clean it up. */
1234 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1235 /*FIXME, does this have a bug at start address 0? */
1236 && last_o_file_start
1237 && objfile
-> ei
.entry_point
< bufp
->n_value
1238 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1240 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1241 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1246 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1247 symnum
* symbol_size
,
1248 (lowest_text_address
== (CORE_ADDR
)-1
1249 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1250 : lowest_text_address
)
1252 dependency_list
, dependencies_used
);
1255 do_cleanups (back_to
);
1258 /* Allocate and partially fill a partial symtab. It will be
1259 completely filled at the end of the symbol list.
1261 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1262 is the address relative to which its symbols are (incremental) or 0
1266 struct partial_symtab
*
1267 start_psymtab (objfile
, section_offsets
,
1268 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1269 struct objfile
*objfile
;
1270 struct section_offsets
*section_offsets
;
1274 struct partial_symbol
**global_syms
;
1275 struct partial_symbol
**static_syms
;
1277 struct partial_symtab
*result
=
1278 start_psymtab_common(objfile
, section_offsets
,
1279 filename
, textlow
, global_syms
, static_syms
);
1281 result
->read_symtab_private
= (char *)
1282 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1283 LDSYMOFF(result
) = ldsymoff
;
1284 result
->read_symtab
= dbx_psymtab_to_symtab
;
1285 SYMBOL_SIZE(result
) = symbol_size
;
1286 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1287 STRING_OFFSET(result
) = string_table_offset
;
1288 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1290 /* If we're handling an ELF file, drag some section-relocation info
1291 for this source file out of the ELF symbol table, to compensate for
1292 Sun brain death. This replaces the section_offsets in this psymtab,
1294 elfstab_offset_sections (objfile
, result
);
1296 /* Deduce the source language from the filename for this psymtab. */
1297 psymtab_language
= deduce_language_from_filename (filename
);
1302 /* Close off the current usage of PST.
1303 Returns PST or NULL if the partial symtab was empty and thrown away.
1305 FIXME: List variables and peculiarities of same. */
1307 struct partial_symtab
*
1308 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1309 capping_text
, dependency_list
, number_dependencies
)
1310 struct partial_symtab
*pst
;
1311 char **include_list
;
1313 int capping_symbol_offset
;
1314 CORE_ADDR capping_text
;
1315 struct partial_symtab
**dependency_list
;
1316 int number_dependencies
;
1319 struct objfile
*objfile
= pst
-> objfile
;
1321 if (capping_symbol_offset
!= -1)
1322 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1323 pst
->texthigh
= capping_text
;
1325 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1326 /* Under Solaris, the N_SO symbols always have a value of 0,
1327 instead of the usual address of the .o file. Therefore,
1328 we have to do some tricks to fill in texthigh and textlow.
1329 The first trick is in partial-stab.h: if we see a static
1330 or global function, and the textlow for the current pst
1331 is still 0, then we use that function's address for
1332 the textlow of the pst. */
1334 /* Now, to fill in texthigh, we remember the last function seen
1335 in the .o file (also in partial-stab.h). Also, there's a hack in
1336 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1337 to here via the misc_info field. Therefore, we can fill in
1338 a reliable texthigh by taking the address plus size of the
1339 last function in the file. */
1341 if (pst
->texthigh
== 0 && last_function_name
) {
1344 struct minimal_symbol
*minsym
;
1346 p
= strchr (last_function_name
, ':');
1348 p
= last_function_name
;
1349 n
= p
- last_function_name
;
1351 strncpy (p
, last_function_name
, n
);
1354 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1357 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1358 (long) MSYMBOL_INFO (minsym
);
1360 last_function_name
= NULL
;
1363 /* this test will be true if the last .o file is only data */
1364 if (pst
->textlow
== 0)
1365 /* This loses if the text section really starts at address zero
1366 (generally true when we are debugging a .o file, for example).
1367 That is why this whole thing is inside SOFUN_ADDRESS_MAYBE_MISSING. */
1368 pst
->textlow
= pst
->texthigh
;
1370 /* If we know our own starting text address, then walk through all other
1371 psymtabs for this objfile, and if any didn't know their ending text
1372 address, set it to our starting address. Take care to not set our
1373 own ending address to our starting address, nor to set addresses on
1374 `dependency' files that have both textlow and texthigh zero. */
1376 struct partial_symtab
*p1
;
1378 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1379 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1380 p1
->texthigh
= pst
->textlow
;
1381 /* if this file has only data, then make textlow match texthigh */
1382 if (p1
->textlow
== 0)
1383 p1
->textlow
= p1
->texthigh
;
1388 /* End of kludge for patching Solaris textlow and texthigh. */
1389 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1391 pst
->n_global_syms
=
1392 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1393 pst
->n_static_syms
=
1394 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1396 pst
->number_of_dependencies
= number_dependencies
;
1397 if (number_dependencies
)
1399 pst
->dependencies
= (struct partial_symtab
**)
1400 obstack_alloc (&objfile
->psymbol_obstack
,
1401 number_dependencies
* sizeof (struct partial_symtab
*));
1402 memcpy (pst
->dependencies
, dependency_list
,
1403 number_dependencies
* sizeof (struct partial_symtab
*));
1406 pst
->dependencies
= 0;
1408 for (i
= 0; i
< num_includes
; i
++)
1410 struct partial_symtab
*subpst
=
1411 allocate_psymtab (include_list
[i
], objfile
);
1413 subpst
->section_offsets
= pst
->section_offsets
;
1414 subpst
->read_symtab_private
=
1415 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1416 sizeof (struct symloc
));
1420 subpst
->texthigh
= 0;
1422 /* We could save slight bits of space by only making one of these,
1423 shared by the entire set of include files. FIXME-someday. */
1424 subpst
->dependencies
= (struct partial_symtab
**)
1425 obstack_alloc (&objfile
->psymbol_obstack
,
1426 sizeof (struct partial_symtab
*));
1427 subpst
->dependencies
[0] = pst
;
1428 subpst
->number_of_dependencies
= 1;
1430 subpst
->globals_offset
=
1431 subpst
->n_global_syms
=
1432 subpst
->statics_offset
=
1433 subpst
->n_static_syms
= 0;
1437 subpst
->read_symtab
= pst
->read_symtab
;
1440 sort_pst_symbols (pst
);
1442 /* If there is already a psymtab or symtab for a file of this name, remove it.
1443 (If there is a symtab, more drastic things also happen.)
1444 This happens in VxWorks. */
1445 free_named_symtabs (pst
->filename
);
1447 if (num_includes
== 0
1448 && number_dependencies
== 0
1449 && pst
->n_global_syms
== 0
1450 && pst
->n_static_syms
== 0)
1452 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1453 it is on the obstack, but we can forget to chain it on the list. */
1454 /* Empty psymtabs happen as a result of header files which don't have
1455 any symbols in them. There can be a lot of them. But this check
1456 is wrong, in that a psymtab with N_SLINE entries but nothing else
1457 is not empty, but we don't realize that. Fixing that without slowing
1458 things down might be tricky. */
1459 struct partial_symtab
*prev_pst
;
1461 /* First, snip it out of the psymtab chain */
1463 if (pst
->objfile
->psymtabs
== pst
)
1464 pst
->objfile
->psymtabs
= pst
->next
;
1466 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1467 if (prev_pst
->next
== pst
)
1468 prev_pst
->next
= pst
->next
;
1470 /* Next, put it on a free list for recycling */
1472 pst
->next
= pst
->objfile
->free_psymtabs
;
1473 pst
->objfile
->free_psymtabs
= pst
;
1475 /* Indicate that psymtab was thrown away. */
1476 pst
= (struct partial_symtab
*)NULL
;
1482 dbx_psymtab_to_symtab_1 (pst
)
1483 struct partial_symtab
*pst
;
1485 struct cleanup
*old_chain
;
1493 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1498 /* Read in all partial symtabs on which this one is dependent */
1499 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1500 if (!pst
->dependencies
[i
]->readin
)
1502 /* Inform about additional files that need to be read in. */
1505 fputs_filtered (" ", gdb_stdout
);
1507 fputs_filtered ("and ", gdb_stdout
);
1509 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1510 wrap_here (""); /* Flush output */
1511 gdb_flush (gdb_stdout
);
1513 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1516 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1518 /* Init stuff necessary for reading in symbols */
1521 old_chain
= make_cleanup (really_free_pendings
, 0);
1522 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1523 symbol_size
= SYMBOL_SIZE (pst
);
1525 /* Read in this file's symbols */
1526 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1527 read_ofile_symtab (pst
);
1528 sort_symtab_syms (pst
->symtab
);
1530 do_cleanups (old_chain
);
1536 /* Read in all of the symbols for a given psymtab for real.
1537 Be verbose about it if the user wants that. */
1540 dbx_psymtab_to_symtab (pst
)
1541 struct partial_symtab
*pst
;
1550 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1555 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1557 /* Print the message now, before reading the string table,
1558 to avoid disconcerting pauses. */
1561 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1562 gdb_flush (gdb_stdout
);
1565 sym_bfd
= pst
->objfile
->obfd
;
1567 next_symbol_text_func
= dbx_next_symbol_text
;
1569 dbx_psymtab_to_symtab_1 (pst
);
1571 /* Match with global symbols. This only needs to be done once,
1572 after all of the symtabs and dependencies have been read in. */
1573 scan_file_globals (pst
->objfile
);
1575 /* Finish up the debug error message. */
1577 printf_filtered ("done.\n");
1581 /* Read in a defined section of a specific object file's symbols. */
1584 read_ofile_symtab (pst
)
1585 struct partial_symtab
*pst
;
1587 register char *namestring
;
1588 register struct internal_nlist
*bufp
;
1590 unsigned max_symnum
;
1592 struct objfile
*objfile
;
1593 int sym_offset
; /* Offset to start of symbols to read */
1594 int sym_size
; /* Size of symbols to read */
1595 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1596 int text_size
; /* Size of text segment for symbols */
1597 struct section_offsets
*section_offsets
;
1599 objfile
= pst
->objfile
;
1600 sym_offset
= LDSYMOFF(pst
);
1601 sym_size
= LDSYMLEN(pst
);
1602 text_offset
= pst
->textlow
;
1603 text_size
= pst
->texthigh
- pst
->textlow
;
1604 section_offsets
= pst
->section_offsets
;
1606 current_objfile
= objfile
;
1607 subfile_stack
= NULL
;
1609 stringtab_global
= DBX_STRINGTAB (objfile
);
1610 last_source_file
= NULL
;
1612 abfd
= objfile
->obfd
;
1613 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1614 symbuf_end
= symbuf_idx
= 0;
1616 /* It is necessary to actually read one symbol *before* the start
1617 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1618 occurs before the N_SO symbol.
1620 Detecting this in read_dbx_symtab
1621 would slow down initial readin, so we look for it here instead. */
1622 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1624 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1626 bufp
= &symbuf
[symbuf_idx
++];
1627 SWAP_SYMBOL (bufp
, abfd
);
1628 OBJSTAT (objfile
, n_stabs
++);
1632 processing_gcc_compilation
= 0;
1633 if (bufp
->n_type
== N_TEXT
)
1635 const char *tempstring
= namestring
;
1637 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1638 processing_gcc_compilation
= 1;
1639 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1640 processing_gcc_compilation
= 2;
1641 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1643 if (STREQN (tempstring
, "__gnu_compiled", 14))
1644 processing_gcc_compilation
= 2;
1647 /* Try to select a C++ demangling based on the compilation unit
1650 if (processing_gcc_compilation
)
1652 if (AUTO_DEMANGLING
)
1654 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1660 /* The N_SO starting this symtab is the first symbol, so we
1661 better not check the symbol before it. I'm not this can
1662 happen, but it doesn't hurt to check for it. */
1663 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1664 processing_gcc_compilation
= 0;
1667 if (symbuf_idx
== symbuf_end
)
1669 bufp
= &symbuf
[symbuf_idx
];
1670 if (bufp
->n_type
!= (unsigned char)N_SO
)
1671 error("First symbol in segment of executable not a source symbol");
1673 max_symnum
= sym_size
/ symbol_size
;
1676 symnum
< max_symnum
;
1679 QUIT
; /* Allow this to be interruptable */
1680 if (symbuf_idx
== symbuf_end
)
1682 bufp
= &symbuf
[symbuf_idx
++];
1683 SWAP_SYMBOL (bufp
, abfd
);
1684 OBJSTAT (objfile
, n_stabs
++);
1686 type
= bufp
->n_type
;
1690 if (type
& N_STAB
) {
1691 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1692 namestring
, section_offsets
, objfile
);
1694 /* We skip checking for a new .o or -l file; that should never
1695 happen in this routine. */
1696 else if (type
== N_TEXT
)
1698 /* I don't think this code will ever be executed, because
1699 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1700 the N_SO symbol which starts this source file.
1701 However, there is no reason not to accept
1702 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1704 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1705 processing_gcc_compilation
= 1;
1706 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1707 processing_gcc_compilation
= 2;
1709 if (AUTO_DEMANGLING
)
1711 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1714 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1715 || type
== (unsigned char)N_NBTEXT
1717 /* Global symbol: see if we came across a dbx defintion for
1718 a corresponding symbol. If so, store the value. Remove
1719 syms from the chain when their values are stored, but
1720 search the whole chain, as there may be several syms from
1721 different files with the same name. */
1722 /* This is probably not true. Since the files will be read
1723 in one at a time, each reference to a global symbol will
1724 be satisfied in each file as it appears. So we skip this
1730 current_objfile
= NULL
;
1732 /* In a Solaris elf file, this variable, which comes from the
1733 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1734 which comes from pst->textlow is correct. */
1735 if (last_source_start_addr
== 0)
1736 last_source_start_addr
= text_offset
;
1738 /* In reordered executables last_source_start_addr may not be the
1739 lower bound for this symtab, instead use text_offset which comes
1740 from pst->textlow which is correct. */
1741 if (last_source_start_addr
> text_offset
)
1742 last_source_start_addr
= text_offset
;
1744 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1746 if (ARM_DEMANGLING
) /* process incomplete C++ types now */
1747 process_now(objfile
);
1753 /* This handles a single symbol from the symbol-file, building symbols
1754 into a GDB symtab. It takes these arguments and an implicit argument.
1756 TYPE is the type field of the ".stab" symbol entry.
1757 DESC is the desc field of the ".stab" entry.
1758 VALU is the value field of the ".stab" entry.
1759 NAME is the symbol name, in our address space.
1760 SECTION_OFFSETS is a set of amounts by which the sections of this object
1761 file were relocated when it was loaded into memory.
1762 All symbols that refer
1763 to memory locations need to be offset by these amounts.
1764 OBJFILE is the object file from which we are reading symbols.
1765 It is used in end_symtab. */
1768 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1772 struct section_offsets
*section_offsets
;
1773 struct objfile
*objfile
;
1775 #ifdef SUN_FIXED_LBRAC_BUG
1776 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1777 to correct the address of N_LBRAC's. If it is not defined, then
1778 we never need to correct the addresses. */
1780 /* This records the last pc address we've seen. We depend on there being
1781 an SLINE or FUN or SO before the first LBRAC, since the variable does
1782 not get reset in between reads of different symbol files. */
1783 static CORE_ADDR last_pc_address
;
1786 register struct context_stack
*new;
1787 /* This remembers the address of the start of a function. It is used
1788 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1789 relative to the current function's start address. On systems
1790 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1791 used to relocate these symbol types rather than SECTION_OFFSETS. */
1792 static CORE_ADDR function_start_offset
;
1794 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1795 file. Used to detect the SunPRO solaris compiler. */
1796 static int n_opt_found
;
1798 /* The stab type used for the definition of the last function.
1799 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1800 static int function_stab_type
= 0;
1802 if (!block_address_function_relative
)
1803 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1804 function start address, so just use the text offset. */
1805 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1807 /* Something is wrong if we see real data before
1808 seeing a source file name. */
1810 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1812 /* Ignore any symbols which appear before an N_SO symbol. Currently
1813 no one puts symbols there, but we should deal gracefully with the
1814 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1815 but this should not be an error (). */
1824 if (! strcmp (name
, ""))
1826 /* This N_FUN marks the end of a function. This closes off the
1828 within_function
= 0;
1829 new = pop_context ();
1831 /* Make a block for the local symbols within. */
1832 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1833 function_start_offset
, function_start_offset
+ valu
,
1838 /* Relocate for dynamic loading */
1839 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1840 goto define_a_symbol
;
1843 /* This "symbol" just indicates the start of an inner lexical
1844 context within a function. */
1846 /* Ignore extra outermost context from SunPRO cc and acc. */
1847 if (n_opt_found
&& desc
== 1)
1850 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1851 /* Relocate for dynamic loading (?). */
1852 valu
+= function_start_offset
;
1854 if (block_address_function_relative
)
1855 /* Relocate for Sun ELF acc fn-relative syms. */
1856 valu
+= function_start_offset
;
1858 /* On most machines, the block addresses are relative to the
1859 N_SO, the linker did not relocate them (sigh). */
1860 valu
+= last_source_start_addr
;
1863 #ifdef SUN_FIXED_LBRAC_BUG
1864 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1865 /* Patch current LBRAC pc value to match last handy pc value */
1866 complain (&lbrac_complaint
);
1867 valu
= last_pc_address
;
1870 new = push_context (desc
, valu
);
1874 /* This "symbol" just indicates the end of an inner lexical
1875 context that was started with N_LBRAC. */
1877 /* Ignore extra outermost context from SunPRO cc and acc. */
1878 if (n_opt_found
&& desc
== 1)
1881 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1882 /* Relocate for dynamic loading (?). */
1883 valu
+= function_start_offset
;
1885 if (block_address_function_relative
)
1886 /* Relocate for Sun ELF acc fn-relative syms. */
1887 valu
+= function_start_offset
;
1889 /* On most machines, the block addresses are relative to the
1890 N_SO, the linker did not relocate them (sigh). */
1891 valu
+= last_source_start_addr
;
1894 new = pop_context();
1895 if (desc
!= new->depth
)
1896 complain (&lbrac_mismatch_complaint
, symnum
);
1898 /* Some compilers put the variable decls inside of an
1899 LBRAC/RBRAC block. This macro should be nonzero if this
1900 is true. DESC is N_DESC from the N_RBRAC symbol.
1901 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1902 or the GCC2_COMPILED_SYMBOL. */
1903 #if !defined (VARIABLES_INSIDE_BLOCK)
1904 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1907 /* Can only use new->locals as local symbols here if we're in
1908 gcc or on a machine that puts them before the lbrack. */
1909 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1910 local_symbols
= new->locals
;
1912 if (context_stack_depth
1913 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1915 /* This is not the outermost LBRAC...RBRAC pair in the function,
1916 its local symbols preceded it, and are the ones just recovered
1917 from the context stack. Define the block for them (but don't
1918 bother if the block contains no symbols. Should we complain
1919 on blocks without symbols? I can't think of any useful purpose
1921 if (local_symbols
!= NULL
)
1923 /* Muzzle a compiler bug that makes end < start. (which
1924 compilers? Is this ever harmful?). */
1925 if (new->start_addr
> valu
)
1927 complain (&lbrac_rbrac_complaint
);
1928 new->start_addr
= valu
;
1930 /* Make a block for the local symbols within. */
1931 finish_block (0, &local_symbols
, new->old_blocks
,
1932 new->start_addr
, valu
, objfile
);
1937 /* This is the outermost LBRAC...RBRAC pair. There is no
1938 need to do anything; leave the symbols that preceded it
1939 to be attached to the function's own block. We need to
1940 indicate that we just moved outside of the function. */
1941 within_function
= 0;
1944 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1945 /* Now pop locals of block just finished. */
1946 local_symbols
= new->locals
;
1951 /* This kind of symbol indicates the start of an object file. */
1952 /* Relocate for dynamic loading */
1953 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1957 /* This type of symbol indicates the start of data
1958 for one source file.
1959 Finish the symbol table of the previous source file
1960 (if any) and start accumulating a new symbol table. */
1961 /* Relocate for dynamic loading */
1962 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1966 #ifdef SUN_FIXED_LBRAC_BUG
1967 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1970 #ifdef PCC_SOL_BROKEN
1971 /* pcc bug, occasionally puts out SO for SOL. */
1972 if (context_stack_depth
> 0)
1974 start_subfile (name
, NULL
);
1978 if (last_source_file
)
1980 /* Check if previous symbol was also an N_SO (with some
1981 sanity checks). If so, that one was actually the directory
1982 name, and the current one is the real file name.
1984 if (previous_stab_code
== (unsigned char) N_SO
)
1986 patch_subfile_names (current_subfile
, name
);
1987 break; /* Ignore repeated SOs */
1989 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
1993 /* Null name means this just marks the end of text for this .o file.
1994 Don't start a new symtab in this case. */
1995 if (*name
== '\000')
1999 start_symtab (name
, NULL
, valu
);
2003 /* This type of symbol indicates the start of data for
2004 a sub-source-file, one whose contents were copied or
2005 included in the compilation of the main source file
2006 (whose name was given in the N_SO symbol.) */
2007 /* Relocate for dynamic loading */
2008 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2009 start_subfile (name
, current_subfile
->dirname
);
2014 add_new_header_file (name
, valu
);
2015 start_subfile (name
, current_subfile
->dirname
);
2019 start_subfile (pop_subfile (), current_subfile
->dirname
);
2023 add_old_header_file (name
, valu
);
2027 /* This type of "symbol" really just records
2028 one line-number -- core-address correspondence.
2029 Enter it in the line list for this symbol table. */
2030 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2031 valu
+= function_start_offset
;
2032 #ifdef SUN_FIXED_LBRAC_BUG
2033 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2035 record_line (current_subfile
, desc
, valu
);
2039 common_block_start (name
, objfile
);
2043 common_block_end (objfile
);
2046 /* The following symbol types need to have the appropriate offset added
2047 to their value; then we process symbol definitions in the name. */
2049 case N_STSYM
: /* Static symbol in data seg */
2050 case N_LCSYM
: /* Static symbol in BSS seg */
2051 case N_ROSYM
: /* Static symbol in Read-only data seg */
2052 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2053 Solaris2's stabs-in-elf makes *most* symbols relative
2054 but leaves a few absolute (at least for Solaris 2.1 and version
2055 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2056 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2057 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2058 This leaves us no choice but to search for the 'S' or 'V'...
2059 (or pass the whole section_offsets stuff down ONE MORE function
2060 call level, which we really don't want to do). */
2064 /* .o files and NLMs have non-zero text seg offsets, but don't need
2065 their static syms offset in this fashion. XXX - This is really a
2066 crock that should be fixed in the solib handling code so that I
2067 don't have to work around it here. */
2069 if (!symfile_relocatable
)
2071 p
= strchr (name
, ':');
2072 if (p
!= 0 && p
[1] == 'S')
2074 /* The linker relocated it. We don't want to add an
2075 elfstab_offset_sections-type offset, but we *do* want
2076 to add whatever solib.c passed to symbol_file_add as
2077 addr (this is known to affect SunOS4, and I suspect ELF
2078 too). Since elfstab_offset_sections currently does not
2079 muck with the text offset (there is no Ttext.text
2080 symbol), we can get addr from the text offset. If
2081 elfstab_offset_sections ever starts dealing with the
2082 text offset, and we still need to do this, we need to
2083 invent a SECT_OFF_ADDR_KLUDGE or something. */
2084 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2085 goto define_a_symbol
;
2088 /* Since it's not the kludge case, re-dispatch to the right handler. */
2090 case N_STSYM
: goto case_N_STSYM
;
2091 case N_LCSYM
: goto case_N_LCSYM
;
2092 case N_ROSYM
: goto case_N_ROSYM
;
2097 case_N_STSYM
: /* Static symbol in data seg */
2098 case N_DSLINE
: /* Source line number, data seg */
2099 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2100 goto define_a_symbol
;
2102 case_N_LCSYM
: /* Static symbol in BSS seg */
2103 case N_BSLINE
: /* Source line number, bss seg */
2104 /* N_BROWS: overlaps with N_BSLINE */
2105 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2106 goto define_a_symbol
;
2108 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2109 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2110 goto define_a_symbol
;
2112 case N_ENTRY
: /* Alternate entry point */
2113 /* Relocate for dynamic loading */
2114 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2115 goto define_a_symbol
;
2117 /* The following symbol types we don't know how to process. Handle
2118 them in a "default" way, but complain to people who care. */
2120 case N_CATCH
: /* Exception handler catcher */
2121 case N_EHDECL
: /* Exception handler name */
2122 case N_PC
: /* Global symbol in Pascal */
2123 case N_M2C
: /* Modula-2 compilation unit */
2124 /* N_MOD2: overlaps with N_EHDECL */
2125 case N_SCOPE
: /* Modula-2 scope information */
2126 case N_ECOML
: /* End common (local name) */
2127 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2132 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2135 /* The following symbol types don't need the address field relocated,
2136 since it is either unused, or is absolute. */
2138 case N_GSYM
: /* Global variable */
2139 case N_NSYMS
: /* Number of symbols (ultrix) */
2140 case N_NOMAP
: /* No map? (ultrix) */
2141 case N_RSYM
: /* Register variable */
2142 case N_DEFD
: /* Modula-2 GNU module dependency */
2143 case N_SSYM
: /* Struct or union element */
2144 case N_LSYM
: /* Local symbol in stack */
2145 case N_PSYM
: /* Parameter variable */
2146 case N_LENG
: /* Length of preceding symbol type */
2150 char *colon_pos
= strchr (name
, ':');
2151 if (colon_pos
== NULL
)
2154 deftype
= colon_pos
[1];
2160 function_stab_type
= type
;
2162 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2163 /* Deal with the SunPRO 3.0 compiler which omits the address
2164 from N_FUN symbols. */
2166 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2168 struct minimal_symbol
*msym
;
2172 p
= strchr (name
, ':');
2177 strncpy (p
, name
, n
);
2180 msym
= lookup_minimal_symbol (p
, last_source_file
,
2183 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2187 #ifdef SUN_FIXED_LBRAC_BUG
2188 /* The Sun acc compiler, under SunOS4, puts out
2189 functions with N_GSYM or N_STSYM. The problem is
2190 that the address of the symbol is no good (for N_GSYM
2191 it doesn't even attept an address; for N_STSYM it
2192 puts out an address but then it gets relocated
2193 relative to the data segment, not the text segment).
2194 Currently we can't fix this up later as we do for
2195 some types of symbol in scan_file_globals.
2196 Fortunately we do have a way of finding the address -
2197 we know that the value in last_pc_address is either
2198 the one we want (if we're dealing with the first
2199 function in an object file), or somewhere in the
2200 previous function. This means that we can use the
2201 minimal symbol table to get the address. */
2203 /* Starting with release 3.0, the Sun acc compiler,
2204 under SunOS4, puts out functions with N_FUN and a value
2205 of zero. This gets relocated to the start of the text
2206 segment of the module, which is no good either.
2207 Under SunOS4 we can deal with this as N_SLINE and N_SO
2208 entries contain valid absolute addresses.
2209 Release 3.0 acc also puts out N_OPT entries, which makes
2210 it possible to discern acc from cc or gcc. */
2212 if (type
== N_GSYM
|| type
== N_STSYM
2214 && n_opt_found
&& !block_address_function_relative
))
2216 struct minimal_symbol
*m
;
2217 int l
= colon_pos
- name
;
2219 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2220 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2221 && SYMBOL_NAME (m
) [l
] == '\0')
2222 /* last_pc_address was in this function */
2223 valu
= SYMBOL_VALUE (m
);
2224 else if (m
&& SYMBOL_NAME (m
+1)
2225 && STREQN (SYMBOL_NAME (m
+1), name
, l
)
2226 && SYMBOL_NAME (m
+1) [l
] == '\0')
2227 /* last_pc_address was in last function */
2228 valu
= SYMBOL_VALUE (m
+1);
2230 /* Not found - use last_pc_address (for finish_block) */
2231 valu
= last_pc_address
;
2234 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2237 if (block_address_function_relative
)
2238 /* For Solaris 2.0 compilers, the block addresses and
2239 N_SLINE's are relative to the start of the
2240 function. On normal systems, and when using gcc on
2241 Solaris 2.0, these addresses are just absolute, or
2242 relative to the N_SO, depending on
2243 BLOCK_ADDRESS_ABSOLUTE. */
2244 function_start_offset
= valu
;
2246 within_function
= 1;
2247 if (context_stack_depth
> 0)
2249 new = pop_context ();
2250 /* Make a block for the local symbols within. */
2251 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2252 new->start_addr
, valu
, objfile
);
2254 /* Stack must be empty now. */
2255 if (context_stack_depth
!= 0)
2256 complain (&lbrac_unmatched_complaint
, symnum
);
2258 new = push_context (0, valu
);
2259 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2263 define_symbol (valu
, name
, desc
, type
, objfile
);
2269 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2270 for a bunch of other flags, too. Someday we may parse their
2271 flags; for now we ignore theirs and hope they'll ignore ours. */
2272 case N_OPT
: /* Solaris 2: Compiler options */
2275 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2277 processing_gcc_compilation
= 2;
2278 #if 1 /* Works, but is experimental. -fnf */
2279 if (AUTO_DEMANGLING
)
2281 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2290 /* The following symbol types can be ignored. */
2291 case N_OBJ
: /* Solaris 2: Object file dir and name */
2292 /* N_UNDF: Solaris 2: file separator mark */
2293 /* N_UNDF: -- we will never encounter it, since we only process one
2294 file's symbols at once. */
2295 case N_ENDM
: /* Solaris 2: End of module */
2296 case N_MAIN
: /* Name of main routine. */
2300 previous_stab_code
= type
;
2303 /* FIXME: The only difference between this and elfstab_build_psymtabs
2304 is the call to install_minimal_symbols for elf, and the support for
2305 split sections. If the differences are really that small, the code
2306 should be shared. */
2308 /* Scan and build partial symbols for an coff symbol file.
2309 The coff file has already been processed to get its minimal symbols.
2311 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2314 OBJFILE is the object file we are reading symbols from.
2315 ADDR is the address relative to which the symbols are (e.g.
2316 the base address of the text segment).
2317 MAINLINE is true if we are reading the main symbol
2318 table (as opposed to a shared lib or dynamically loaded file).
2319 TEXTADDR is the address of the text section.
2320 TEXTSIZE is the size of the text section.
2321 STABSECTS is the list of .stab sections in OBJFILE.
2322 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2323 .stabstr section exists.
2325 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2326 adjusted for coff details. */
2329 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2330 textaddr
, textsize
, stabsects
,
2331 stabstroffset
, stabstrsize
)
2332 struct objfile
*objfile
;
2333 struct section_offsets
*section_offsets
;
2336 unsigned int textsize
;
2337 struct stab_section_list
*stabsects
;
2338 file_ptr stabstroffset
;
2339 unsigned int stabstrsize
;
2342 bfd
*sym_bfd
= objfile
->obfd
;
2343 char *name
= bfd_get_filename (sym_bfd
);
2344 struct dbx_symfile_info
*info
;
2345 unsigned int stabsize
;
2347 /* There is already a dbx_symfile_info allocated by our caller.
2348 It might even contain some info from the coff symtab to help us. */
2349 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2351 DBX_TEXT_ADDR (objfile
) = textaddr
;
2352 DBX_TEXT_SIZE (objfile
) = textsize
;
2354 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2355 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2356 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2358 if (stabstrsize
> bfd_get_size (sym_bfd
))
2359 error ("ridiculous string table size: %d bytes", stabstrsize
);
2360 DBX_STRINGTAB (objfile
) = (char *)
2361 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2362 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2364 /* Now read in the string table in one big gulp. */
2366 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2368 perror_with_name (name
);
2369 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2370 if (val
!= stabstrsize
)
2371 perror_with_name (name
);
2373 stabsread_new_init ();
2374 buildsym_new_init ();
2375 free_header_files ();
2376 init_header_files ();
2378 processing_acc_compilation
= 1;
2380 /* In a coff file, we've already installed the minimal symbols that came
2381 from the coff (non-stab) symbol table, so always act like an
2382 incremental load here. */
2383 if (stabsects
->next
== NULL
)
2385 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2386 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2387 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2391 struct stab_section_list
*stabsect
;
2393 DBX_SYMCOUNT (objfile
) = 0;
2394 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2396 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2397 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2400 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2402 symbuf_sections
= stabsects
->next
;
2403 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2407 dbx_symfile_read (objfile
, section_offsets
, 0);
2410 /* Scan and build partial symbols for an ELF symbol file.
2411 This ELF file has already been processed to get its minimal symbols,
2412 and any DWARF symbols that were in it.
2414 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2417 OBJFILE is the object file we are reading symbols from.
2418 ADDR is the address relative to which the symbols are (e.g.
2419 the base address of the text segment).
2420 MAINLINE is true if we are reading the main symbol
2421 table (as opposed to a shared lib or dynamically loaded file).
2422 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2424 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2425 .stabstr section exists.
2427 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2428 adjusted for elf details. */
2431 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2432 staboffset
, stabsize
,
2433 stabstroffset
, stabstrsize
)
2434 struct objfile
*objfile
;
2435 struct section_offsets
*section_offsets
;
2437 file_ptr staboffset
;
2438 unsigned int stabsize
;
2439 file_ptr stabstroffset
;
2440 unsigned int stabstrsize
;
2443 bfd
*sym_bfd
= objfile
->obfd
;
2444 char *name
= bfd_get_filename (sym_bfd
);
2445 struct dbx_symfile_info
*info
;
2446 asection
*text_sect
;
2448 /* There is already a dbx_symfile_info allocated by our caller.
2449 It might even contain some info from the ELF symtab to help us. */
2450 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2452 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
2454 error ("Can't find .text section in symbol file");
2455 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2456 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2458 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2459 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2460 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2461 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2462 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2464 if (stabstrsize
> bfd_get_size (sym_bfd
))
2465 error ("ridiculous string table size: %d bytes", stabstrsize
);
2466 DBX_STRINGTAB (objfile
) = (char *)
2467 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2468 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2470 /* Now read in the string table in one big gulp. */
2472 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2474 perror_with_name (name
);
2475 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2476 if (val
!= stabstrsize
)
2477 perror_with_name (name
);
2479 stabsread_new_init ();
2480 buildsym_new_init ();
2481 free_header_files ();
2482 init_header_files ();
2483 install_minimal_symbols (objfile
);
2485 processing_acc_compilation
= 1;
2487 /* In an elf file, we've already installed the minimal symbols that came
2488 from the elf (non-stab) symbol table, so always act like an
2489 incremental load here. */
2490 dbx_symfile_read (objfile
, section_offsets
, 0);
2493 /* Scan and build partial symbols for a file with special sections for stabs
2494 and stabstrings. The file has already been processed to get its minimal
2495 symbols, and any other symbols that might be necessary to resolve GSYMs.
2497 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2500 OBJFILE is the object file we are reading symbols from.
2501 ADDR is the address relative to which the symbols are (e.g. the base address
2502 of the text segment).
2503 MAINLINE is true if we are reading the main symbol table (as opposed to a
2504 shared lib or dynamically loaded file).
2505 STAB_NAME is the name of the section that contains the stabs.
2506 STABSTR_NAME is the name of the section that contains the stab strings.
2508 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2511 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2512 stabstr_name
, text_name
)
2513 struct objfile
*objfile
;
2514 struct section_offsets
*section_offsets
;
2521 bfd
*sym_bfd
= objfile
->obfd
;
2522 char *name
= bfd_get_filename (sym_bfd
);
2524 asection
*stabstrsect
;
2525 asection
*text_sect
;
2527 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2528 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2534 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2535 stab_name
, stabstr_name
);
2537 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2538 memset (DBX_SYMFILE_INFO (objfile
), 0, sizeof (struct dbx_symfile_info
));
2540 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2542 error ("Can't find %s section in symbol file", text_name
);
2543 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2544 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2546 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2547 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2548 / DBX_SYMBOL_SIZE (objfile
);
2549 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2550 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2552 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2553 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2554 DBX_STRINGTAB (objfile
) = (char *)
2555 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2556 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2558 /* Now read in the string table in one big gulp. */
2560 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2561 stabstrsect
, /* bfd section */
2562 DBX_STRINGTAB (objfile
), /* input buffer */
2563 0, /* offset into section */
2564 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2567 perror_with_name (name
);
2569 stabsread_new_init ();
2570 buildsym_new_init ();
2571 free_header_files ();
2572 init_header_files ();
2573 install_minimal_symbols (objfile
);
2575 /* Now, do an incremental load */
2577 processing_acc_compilation
= 1;
2578 dbx_symfile_read (objfile
, section_offsets
, 0);
2581 static struct sym_fns aout_sym_fns
=
2583 bfd_target_aout_flavour
,
2584 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2585 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2586 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2587 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2588 default_symfile_offsets
,
2589 /* sym_offsets: parse user's offsets to internal form */
2590 NULL
/* next: pointer to next struct sym_fns */
2594 _initialize_dbxread ()
2596 add_symtab_fns(&aout_sym_fns
);