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 */
69 extern void resolve_cont
PARAMS((struct objfile
* objfile
, struct symbol
* sym
, char * p
));
72 /* We put a pointer to this structure in the read_symtab_private field
77 /* Offset within the file symbol table of first local symbol for this
82 /* Length (in bytes) of the section of the symbol table devoted to
83 this file's symbols (actually, the section bracketed may contain
84 more than just this file's symbols). If ldsymlen is 0, the only
85 reason for this thing's existence is the dependency list. Nothing
86 else will happen when it is read in. */
90 /* The size of each symbol in the symbol file (in external form). */
94 /* Further information needed to locate the symbols if they are in
99 int file_string_offset
;
102 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
103 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
104 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
105 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
106 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
107 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
108 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
111 /* Macro to determine which symbols to ignore when reading the first symbol
112 of a file. Some machines override this definition. */
113 #ifndef IGNORE_SYMBOL
114 /* This code is used on Ultrix systems. Ignore it */
115 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
118 /* Remember what we deduced to be the source language of this psymtab. */
120 static enum language psymtab_language
= language_unknown
;
122 /* Nonzero means give verbose info on gdb action. From main.c. */
123 extern int info_verbose
;
125 /* The BFD for this file -- implicit parameter to next_symbol_text. */
127 static bfd
*symfile_bfd
;
129 /* The size of each symbol in the symbol file (in external form).
130 This is set by dbx_symfile_read when building psymtabs, and by
131 dbx_psymtab_to_symtab when building symtabs. */
133 static unsigned symbol_size
;
135 /* This is the offset of the symbol table in the executable file */
136 static unsigned symbol_table_offset
;
138 /* This is the offset of the string table in the executable file */
139 static unsigned string_table_offset
;
141 /* For elf+stab executables, the n_strx field is not a simple index
142 into the string table. Instead, each .o file has a base offset
143 in the string table, and the associated symbols contain offsets
144 from this base. The following two variables contain the base
145 offset for the current and next .o files. */
146 static unsigned int file_string_table_offset
;
147 static unsigned int next_file_string_table_offset
;
149 /* .o and NLM files contain unrelocated addresses which are based at 0. When
150 non-zero, this flag disables some of the special cases for Solaris elf+stab
151 text addresses at location 0. */
153 static int symfile_relocatable
= 0;
155 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
156 to the function start address. */
158 static int block_address_function_relative
= 0;
160 /* The lowest text address we have yet encountered. This is needed
161 because in an a.out file, there is no header field which tells us
162 what address the program is actually going to be loaded at, so we
163 need to make guesses based on the symbols (which *are* relocated to
164 reflect the address it will be loaded at). */
165 static CORE_ADDR lowest_text_address
;
167 /* Complaints about the symbols we have encountered. */
169 struct complaint lbrac_complaint
=
170 {"bad block start address patched", 0, 0};
172 struct complaint string_table_offset_complaint
=
173 {"bad string table offset in symbol %d", 0, 0};
175 struct complaint unknown_symtype_complaint
=
176 {"unknown symbol type %s", 0, 0};
178 struct complaint unknown_symchar_complaint
=
179 {"unknown symbol descriptor `%c'", 0, 0};
181 struct complaint lbrac_rbrac_complaint
=
182 {"block start larger than block end", 0, 0};
184 struct complaint lbrac_unmatched_complaint
=
185 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
187 struct complaint lbrac_mismatch_complaint
=
188 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
190 struct complaint repeated_header_complaint
=
191 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
193 /* During initial symbol readin, we need to have a structure to keep
194 track of which psymtabs have which bincls in them. This structure
195 is used during readin to setup the list of dependencies within each
196 partial symbol table. */
198 struct header_file_location
200 char *name
; /* Name of header file */
201 int instance
; /* See above */
202 struct partial_symtab
*pst
; /* Partial symtab that has the
203 BINCL/EINCL defs for this file */
206 /* The actual list and controling variables */
207 static struct header_file_location
*bincl_list
, *next_bincl
;
208 static int bincls_allocated
;
210 /* Local function prototypes */
213 free_header_files
PARAMS ((void));
216 init_header_files
PARAMS ((void));
219 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
222 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
225 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
228 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
229 struct objfile
*objfile
));
232 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
236 free_bincl_list
PARAMS ((struct objfile
*));
238 static struct partial_symtab
*
239 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
242 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
245 init_bincl_list
PARAMS ((int, struct objfile
*));
248 dbx_next_symbol_text
PARAMS ((struct objfile
*));
251 fill_symbuf
PARAMS ((bfd
*));
254 dbx_symfile_init
PARAMS ((struct objfile
*));
257 dbx_new_init
PARAMS ((struct objfile
*));
260 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
263 dbx_symfile_finish
PARAMS ((struct objfile
*));
266 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
269 add_new_header_file
PARAMS ((char *, int));
272 add_old_header_file
PARAMS ((char *, int));
275 add_this_object_header_file
PARAMS ((int));
277 /* Free up old header file tables */
284 if (header_files
!= NULL
)
286 for (i
= 0; i
< n_header_files
; i
++)
288 free (header_files
[i
].name
);
290 free ((PTR
)header_files
);
294 if (this_object_header_files
)
296 free ((PTR
)this_object_header_files
);
297 this_object_header_files
= NULL
;
299 n_allocated_header_files
= 0;
300 n_allocated_this_object_header_files
= 0;
303 /* Allocate new header file tables */
309 n_allocated_header_files
= 10;
310 header_files
= (struct header_file
*)
311 xmalloc (10 * sizeof (struct header_file
));
313 n_allocated_this_object_header_files
= 10;
314 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
317 /* Add header file number I for this object file
318 at the next successive FILENUM. */
321 add_this_object_header_file (i
)
324 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
326 n_allocated_this_object_header_files
*= 2;
327 this_object_header_files
328 = (int *) xrealloc ((char *) this_object_header_files
,
329 n_allocated_this_object_header_files
* sizeof (int));
332 this_object_header_files
[n_this_object_header_files
++] = i
;
335 /* Add to this file an "old" header file, one already seen in
336 a previous object file. NAME is the header file's name.
337 INSTANCE is its instance code, to select among multiple
338 symbol tables for the same header file. */
341 add_old_header_file (name
, instance
)
345 register struct header_file
*p
= header_files
;
348 for (i
= 0; i
< n_header_files
; i
++)
349 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
351 add_this_object_header_file (i
);
354 complain (&repeated_header_complaint
, name
, symnum
);
357 /* Add to this file a "new" header file: definitions for its types follow.
358 NAME is the header file's name.
359 Most often this happens only once for each distinct header file,
360 but not necessarily. If it happens more than once, INSTANCE has
361 a different value each time, and references to the header file
362 use INSTANCE values to select among them.
364 dbx output contains "begin" and "end" markers for each new header file,
365 but at this level we just need to know which files there have been;
366 so we record the file when its "begin" is seen and ignore the "end". */
369 add_new_header_file (name
, instance
)
375 /* Make sure there is room for one more header file. */
377 if (n_header_files
== n_allocated_header_files
)
379 n_allocated_header_files
*= 2;
380 header_files
= (struct header_file
*)
381 xrealloc ((char *) header_files
,
382 (n_allocated_header_files
* sizeof (struct header_file
)));
385 /* Create an entry for this header file. */
387 i
= n_header_files
++;
388 header_files
[i
].name
= savestring (name
, strlen(name
));
389 header_files
[i
].instance
= instance
;
390 header_files
[i
].length
= 10;
391 header_files
[i
].vector
392 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
393 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
395 add_this_object_header_file (i
);
399 static struct type
**
400 explicit_lookup_type (real_filenum
, index
)
401 int real_filenum
, index
;
403 register struct header_file
*f
= &header_files
[real_filenum
];
405 if (index
>= f
->length
)
408 f
->vector
= (struct type
**)
409 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
410 memset (&f
->vector
[f
->length
/ 2],
411 '\0', f
->length
* sizeof (struct type
*) / 2);
413 return &f
->vector
[index
];
418 record_minimal_symbol (name
, address
, type
, objfile
)
422 struct objfile
*objfile
;
424 enum minimal_symbol_type ms_type
;
431 section
= SECT_OFF_TEXT
;
435 section
= SECT_OFF_DATA
;
439 section
= SECT_OFF_BSS
;
448 section
= SECT_OFF_DATA
;
451 /* I don't think this type actually exists; since a N_SETV is the result
452 of going over many .o files, it doesn't make sense to have one
454 ms_type
= mst_file_data
;
455 section
= SECT_OFF_DATA
;
462 ms_type
= mst_file_text
;
463 section
= SECT_OFF_TEXT
;
466 ms_type
= mst_file_data
;
468 /* Check for __DYNAMIC, which is used by Sun shared libraries.
469 Record it as global even if it's local, not global, so
470 lookup_minimal_symbol can find it. We don't check symbol_leading_char
471 because for SunOS4 it always is '_'. */
472 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
475 /* Same with virtual function tables, both global and static. */
477 char *tempstring
= name
;
478 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
480 if (VTBL_PREFIX_P ((tempstring
)))
483 section
= SECT_OFF_DATA
;
486 ms_type
= mst_file_bss
;
487 section
= SECT_OFF_BSS
;
490 ms_type
= mst_unknown
;
495 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
496 && address
< lowest_text_address
)
497 lowest_text_address
= address
;
499 prim_record_minimal_symbol_and_info
500 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
508 /* Scan and build partial symbols for a symbol file.
509 We have been initialized by a call to dbx_symfile_init, which
510 put all the relevant info into a "struct dbx_symfile_info",
511 hung off the objfile structure.
513 SECTION_OFFSETS contains offsets relative to which the symbols in the
514 various sections are (depending where the sections were actually loaded).
515 MAINLINE is true if we are reading the main symbol
516 table (as opposed to a shared lib or dynamically loaded file). */
519 dbx_symfile_read (objfile
, section_offsets
, mainline
)
520 struct objfile
*objfile
;
521 struct section_offsets
*section_offsets
;
522 int mainline
; /* FIXME comments above */
526 struct cleanup
*back_to
;
528 val
= strlen (objfile
->name
);
530 /* .o and .nlm files are relocatables with text, data and bss segs based at
531 0. This flag disables special (Solaris stabs-in-elf only) fixups for
532 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
533 should be fixed to determine pst->textlow without using this text seg of
536 if (strcmp (&objfile
->name
[val
-2], ".o") == 0
537 || strcmp (&objfile
->name
[val
-4], ".nlm") == 0)
538 symfile_relocatable
= 1;
540 /* This is true for Solaris (and all other systems which put stabs
541 in sections, hopefully, since it would be silly to do things
542 differently from Solaris), and false for SunOS4 and other a.out
544 block_address_function_relative
=
545 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
546 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
547 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4))
548 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "pe", 2))
549 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "nlm", 3)));
551 sym_bfd
= objfile
->obfd
;
552 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
554 perror_with_name (objfile
->name
);
556 /* If we are reinitializing, or if we have never loaded syms yet, init */
558 || objfile
->global_psymbols
.size
== 0
559 || objfile
->static_psymbols
.size
== 0)
560 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
562 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
563 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
566 back_to
= make_cleanup (really_free_pendings
, 0);
568 init_minimal_symbol_collection ();
569 make_cleanup (discard_minimal_symbols
, 0);
571 /* Now that the symbol table data of the executable file are all in core,
572 process them and define symbols accordingly. */
574 read_dbx_symtab (section_offsets
, objfile
,
575 DBX_TEXT_ADDR (objfile
),
576 DBX_TEXT_SIZE (objfile
));
578 /* Add the dynamic symbols. */
580 read_dbx_dynamic_symtab (section_offsets
, objfile
);
582 /* Install any minimal symbols that have been collected as the current
583 minimal symbols for this objfile. */
585 install_minimal_symbols (objfile
);
587 do_cleanups (back_to
);
590 /* Initialize anything that needs initializing when a completely new
591 symbol file is specified (not just adding some symbols from another
592 file, e.g. a shared library). */
595 dbx_new_init (ignore
)
596 struct objfile
*ignore
;
598 stabsread_new_init ();
599 buildsym_new_init ();
600 init_header_files ();
604 /* dbx_symfile_init ()
605 is the dbx-specific initialization routine for reading symbols.
606 It is passed a struct objfile which contains, among other things,
607 the BFD for the file whose symbols are being read, and a slot for a pointer
608 to "private data" which we fill with goodies.
610 We read the string table into malloc'd space and stash a pointer to it.
612 Since BFD doesn't know how to read debug symbols in a format-independent
613 way (and may never do so...), we have to do it ourselves. We will never
614 be called unless this is an a.out (or very similar) file.
615 FIXME, there should be a cleaner peephole into the BFD environment here. */
617 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
620 dbx_symfile_init (objfile
)
621 struct objfile
*objfile
;
624 bfd
*sym_bfd
= objfile
->obfd
;
625 char *name
= bfd_get_filename (sym_bfd
);
627 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
629 /* Allocate struct to keep track of the symfile */
630 objfile
->sym_stab_info
= (PTR
)
631 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
633 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
634 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
635 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
637 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
639 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
641 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
643 error ("Can't find .text section in symbol file");
644 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
645 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
647 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
648 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
649 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
651 /* Read the string table and stash it away in the psymbol_obstack. It is
652 only needed as long as we need to expand psymbols into full symbols,
653 so when we blow away the psymbol the string table goes away as well.
654 Note that gdb used to use the results of attempting to malloc the
655 string table, based on the size it read, as a form of sanity check
656 for botched byte swapping, on the theory that a byte swapped string
657 table size would be so totally bogus that the malloc would fail. Now
658 that we put in on the psymbol_obstack, we can't do this since gdb gets
659 a fatal error (out of virtual memory) if the size is bogus. We can
660 however at least check to see if the size is less than the size of
661 the size field itself, or larger than the size of the entire file.
662 Note that all valid string tables have a size greater than zero, since
663 the bytes used to hold the size are included in the count. */
665 if (STRING_TABLE_OFFSET
== 0)
667 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
668 will never be zero, even when there is no string table. This
669 would appear to be a bug in bfd. */
670 DBX_STRINGTAB_SIZE (objfile
) = 0;
671 DBX_STRINGTAB (objfile
) = NULL
;
675 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
677 perror_with_name (name
);
679 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
680 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
683 perror_with_name (name
);
687 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
688 EOF if there is no string table, and attempting to read the size
689 from EOF will read zero bytes. */
690 DBX_STRINGTAB_SIZE (objfile
) = 0;
691 DBX_STRINGTAB (objfile
) = NULL
;
695 /* Read some data that would appear to be the string table size.
696 If there really is a string table, then it is probably the right
697 size. Byteswap if necessary and validate the size. Note that
698 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
699 random data that happened to be at STRING_TABLE_OFFSET, because
700 bfd can't tell us there is no string table, the sanity checks may
701 or may not catch this. */
702 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
704 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
705 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
706 error ("ridiculous string table size (%d bytes).",
707 DBX_STRINGTAB_SIZE (objfile
));
709 DBX_STRINGTAB (objfile
) =
710 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
711 DBX_STRINGTAB_SIZE (objfile
));
712 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
714 /* Now read in the string table in one big gulp. */
716 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
718 perror_with_name (name
);
719 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
721 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
722 perror_with_name (name
);
727 /* Perform any local cleanups required when we are done with a particular
728 objfile. I.E, we are in the process of discarding all symbol information
729 for an objfile, freeing up all memory held for it, and unlinking the
730 objfile struct from the global list of known objfiles. */
733 dbx_symfile_finish (objfile
)
734 struct objfile
*objfile
;
736 if (objfile
->sym_stab_info
!= NULL
)
738 mfree (objfile
-> md
, objfile
->sym_stab_info
);
740 free_header_files ();
744 /* Buffer for reading the symbol table entries. */
745 static struct internal_nlist symbuf
[4096];
746 static int symbuf_idx
;
747 static int symbuf_end
;
749 /* cont_elem is used for continuing information in cfront.
750 It saves information about which types need to be fixed up and
751 completed after all the stabs are read. */
754 /* sym and stabsstring for continuing information in cfront */
757 /* state dependancies (statics that must be preserved) */
761 /* other state dependancies include:
762 (assumption is that these will not change since process_now FIXME!!)
768 static struct cont_elem cont_list
[100];
769 static int cont_count
= 0;
776 /* save state so we can process these stabs later */
777 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
778 cont_list
[cont_count
].sym_end
= symbuf_end
;
779 cont_list
[cont_count
].symnum
= symnum
;
780 cont_list
[cont_count
].sym
= sym
;
781 cont_list
[cont_count
].stabs
= p
;
787 struct objfile
* objfile
;
790 /* save original state */
791 int save_symbuf_idx
= symbuf_idx
;
792 int save_symbuf_end
= symbuf_end
;
793 int save_symnum
= symnum
;
794 for (i
=0; i
<cont_count
; i
++)
796 /* set state as if we were parsing stabs strings
798 symbuf_idx
= cont_list
[i
].sym_idx
; /* statics used by gdb */
799 symbuf_end
= cont_list
[i
].sym_end
;
800 symnum
= cont_list
[i
].symnum
;
801 resolve_cont(objfile
,cont_list
[i
].sym
,cont_list
[i
].stabs
);
803 /* restore original state */
804 symbuf_idx
= save_symbuf_idx
;
805 symbuf_end
= save_symbuf_end
;
806 symnum
= save_symnum
;
807 cont_count
=0; /* reset for next run */
811 /* Name of last function encountered. Used in Solaris to approximate
812 object file boundaries. */
813 static char *last_function_name
;
815 /* The address in memory of the string table of the object file we are
816 reading (which might not be the "main" object file, but might be a
817 shared library or some other dynamically loaded thing). This is
818 set by read_dbx_symtab when building psymtabs, and by
819 read_ofile_symtab when building symtabs, and is used only by
820 next_symbol_text. FIXME: If that is true, we don't need it when
821 building psymtabs, right? */
822 static char *stringtab_global
;
824 /* These variables are used to control fill_symbuf when the stabs
825 symbols are not contiguous (as may be the case when a COFF file is
826 linked using --split-by-reloc). */
827 static struct stab_section_list
*symbuf_sections
;
828 static unsigned int symbuf_left
;
829 static unsigned int symbuf_read
;
831 /* Refill the symbol table input buffer
832 and set the variables that control fetching entries from it.
833 Reports an error if no data available.
834 This function can read past the end of the symbol table
835 (into the string table) but this does no harm. */
838 fill_symbuf (sym_bfd
)
844 if (symbuf_sections
== NULL
)
845 count
= sizeof (symbuf
);
848 if (symbuf_left
<= 0)
850 file_ptr filepos
= symbuf_sections
->section
->filepos
;
851 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
852 perror_with_name (bfd_get_filename (sym_bfd
));
853 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
854 symbol_table_offset
= filepos
- symbuf_read
;
855 symbuf_sections
= symbuf_sections
->next
;
859 if (count
> sizeof (symbuf
))
860 count
= sizeof (symbuf
);
863 nbytes
= bfd_read ((PTR
)symbuf
, count
, 1, sym_bfd
);
865 perror_with_name (bfd_get_filename (sym_bfd
));
866 else if (nbytes
== 0)
867 error ("Premature end of file reading symbol table");
868 symbuf_end
= nbytes
/ symbol_size
;
870 symbuf_left
-= nbytes
;
871 symbuf_read
+= nbytes
;
874 #define SWAP_SYMBOL(symp, abfd) \
876 (symp)->n_strx = bfd_h_get_32(abfd, \
877 (unsigned char *)&(symp)->n_strx); \
878 (symp)->n_desc = bfd_h_get_16 (abfd, \
879 (unsigned char *)&(symp)->n_desc); \
880 (symp)->n_value = bfd_h_get_32 (abfd, \
881 (unsigned char *)&(symp)->n_value); \
884 /* Invariant: The symbol pointed to by symbuf_idx is the first one
885 that hasn't been swapped. Swap the symbol at the same time
886 that symbuf_idx is incremented. */
888 /* dbx allows the text of a symbol name to be continued into the
889 next symbol name! When such a continuation is encountered
890 (a \ at the end of the text of a name)
891 call this function to get the continuation. */
894 dbx_next_symbol_text (objfile
)
895 struct objfile
*objfile
;
897 if (symbuf_idx
== symbuf_end
)
898 fill_symbuf (symfile_bfd
);
900 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
901 OBJSTAT (objfile
, n_stabs
++);
902 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
903 + file_string_table_offset
;
906 /* Initialize the list of bincls to contain none and have some
910 init_bincl_list (number
, objfile
)
912 struct objfile
*objfile
;
914 bincls_allocated
= number
;
915 next_bincl
= bincl_list
= (struct header_file_location
*)
916 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
919 /* Add a bincl to the list. */
922 add_bincl_to_list (pst
, name
, instance
)
923 struct partial_symtab
*pst
;
927 if (next_bincl
>= bincl_list
+ bincls_allocated
)
929 int offset
= next_bincl
- bincl_list
;
930 bincls_allocated
*= 2;
931 bincl_list
= (struct header_file_location
*)
932 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
933 bincls_allocated
* sizeof (struct header_file_location
));
934 next_bincl
= bincl_list
+ offset
;
936 next_bincl
->pst
= pst
;
937 next_bincl
->instance
= instance
;
938 next_bincl
++->name
= name
;
941 /* Given a name, value pair, find the corresponding
942 bincl in the list. Return the partial symtab associated
943 with that header_file_location. */
945 static struct partial_symtab
*
946 find_corresponding_bincl_psymtab (name
, instance
)
950 struct header_file_location
*bincl
;
952 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
953 if (bincl
->instance
== instance
954 && STREQ (name
, bincl
->name
))
957 complain (&repeated_header_complaint
, name
, symnum
);
958 return (struct partial_symtab
*) 0;
961 /* Free the storage allocated for the bincl list. */
964 free_bincl_list (objfile
)
965 struct objfile
*objfile
;
967 mfree (objfile
-> md
, (PTR
)bincl_list
);
968 bincls_allocated
= 0;
971 /* Scan a SunOs dynamic symbol table for symbols of interest and
972 add them to the minimal symbol table. */
975 read_dbx_dynamic_symtab (section_offsets
, objfile
)
976 struct section_offsets
*section_offsets
;
977 struct objfile
*objfile
;
979 bfd
*abfd
= objfile
->obfd
;
980 struct cleanup
*back_to
;
993 /* Check that the symbol file has dynamic symbols that we know about.
994 bfd_arch_unknown can happen if we are reading a sun3 symbol file
995 on a sun4 host (and vice versa) and bfd is not configured
996 --with-target=all. This would trigger an assertion in bfd/sunos.c,
997 so we ignore the dynamic symbols in this case. */
998 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
999 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
1000 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1003 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1004 if (dynsym_size
< 0)
1007 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1008 back_to
= make_cleanup (free
, dynsyms
);
1010 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1011 if (dynsym_count
< 0)
1013 do_cleanups (back_to
);
1017 /* Enter dynamic symbols into the minimal symbol table
1018 if this is a stripped executable. */
1019 if (bfd_get_symcount (abfd
) <= 0)
1022 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1024 asymbol
*sym
= *symptr
;
1028 sec
= bfd_get_section (sym
);
1030 /* BFD symbols are section relative. */
1031 sym_value
= sym
->value
+ sec
->vma
;
1033 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1035 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1038 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1040 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1043 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1045 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1051 if (sym
->flags
& BSF_GLOBAL
)
1054 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1059 /* Symbols from shared libraries have a dynamic relocation entry
1060 that points to the associated slot in the procedure linkage table.
1061 We make a mininal symbol table entry with type mst_solib_trampoline
1062 at the address in the procedure linkage table. */
1063 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1064 if (dynrel_size
< 0)
1066 do_cleanups (back_to
);
1070 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1071 make_cleanup (free
, dynrels
);
1073 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1074 if (dynrel_count
< 0)
1076 do_cleanups (back_to
);
1080 for (counter
= 0, relptr
= dynrels
;
1081 counter
< dynrel_count
;
1082 counter
++, relptr
++)
1084 arelent
*rel
= *relptr
;
1086 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1088 switch (bfd_get_arch (abfd
))
1090 case bfd_arch_sparc
:
1091 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1095 /* `16' is the type BFD produces for a jump table relocation. */
1096 if (rel
->howto
->type
!= 16)
1099 /* Adjust address in the jump table to point to
1100 the start of the bsr instruction. */
1107 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1108 prim_record_minimal_symbol
1109 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
1111 mst_solib_trampoline
,
1115 do_cleanups (back_to
);
1118 /* Given pointers to an a.out symbol table in core containing dbx
1119 style data, setup partial_symtab's describing each source file for
1120 which debugging information is available.
1121 SYMFILE_NAME is the name of the file we are reading from
1122 and SECTION_OFFSETS is the set of offsets for the various sections
1123 of the file (a set of zeros if the mainline program). */
1126 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1127 struct section_offsets
*section_offsets
;
1128 struct objfile
*objfile
;
1129 CORE_ADDR text_addr
;
1132 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1133 register char *namestring
;
1135 int past_first_source_file
= 0;
1136 CORE_ADDR last_o_file_start
= 0;
1137 CORE_ADDR last_function_start
= 0;
1138 struct cleanup
*back_to
;
1141 /* Current partial symtab */
1142 struct partial_symtab
*pst
;
1144 /* List of current psymtab's include files */
1145 char **psymtab_include_list
;
1146 int includes_allocated
;
1149 /* Index within current psymtab dependency list */
1150 struct partial_symtab
**dependency_list
;
1151 int dependencies_used
, dependencies_allocated
;
1153 /* FIXME. We probably want to change stringtab_global rather than add this
1154 while processing every symbol entry. FIXME. */
1155 file_string_table_offset
= 0;
1156 next_file_string_table_offset
= 0;
1158 stringtab_global
= DBX_STRINGTAB (objfile
);
1160 pst
= (struct partial_symtab
*) 0;
1162 includes_allocated
= 30;
1164 psymtab_include_list
= (char **) alloca (includes_allocated
*
1167 dependencies_allocated
= 30;
1168 dependencies_used
= 0;
1170 (struct partial_symtab
**) alloca (dependencies_allocated
*
1171 sizeof (struct partial_symtab
*));
1173 /* Init bincl list */
1174 init_bincl_list (20, objfile
);
1175 back_to
= make_cleanup (free_bincl_list
, objfile
);
1177 last_source_file
= NULL
;
1179 lowest_text_address
= (CORE_ADDR
)-1;
1181 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1182 abfd
= objfile
->obfd
;
1183 symbuf_end
= symbuf_idx
= 0;
1184 next_symbol_text_func
= dbx_next_symbol_text
;
1186 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1188 /* Get the symbol for this run and pull out some info */
1189 QUIT
; /* allow this to be interruptable */
1190 if (symbuf_idx
== symbuf_end
)
1192 bufp
= &symbuf
[symbuf_idx
++];
1195 * Special case to speed up readin.
1197 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1199 SWAP_SYMBOL (bufp
, abfd
);
1200 OBJSTAT (objfile
, n_stabs
++);
1202 /* Ok. There is a lot of code duplicated in the rest of this
1203 switch statement (for efficiency reasons). Since I don't
1204 like duplicating code, I will do my penance here, and
1205 describe the code which is duplicated:
1207 *) The assignment to namestring.
1208 *) The call to strchr.
1209 *) The addition of a partial symbol the the two partial
1210 symbol lists. This last is a large section of code, so
1211 I've imbedded it in the following macro.
1214 /* Set namestring based on bufp. If the string table index is invalid,
1215 give a fake name, and print a single error message per symbol file read,
1216 rather than abort the symbol reading or flood the user with messages. */
1218 /*FIXME: Too many adds and indirections in here for the inner loop. */
1219 #define SET_NAMESTRING()\
1220 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1221 DBX_STRINGTAB_SIZE (objfile)) { \
1222 complain (&string_table_offset_complaint, symnum); \
1223 namestring = "<bad string table offset>"; \
1225 namestring = bufp->n_strx + file_string_table_offset + \
1226 DBX_STRINGTAB (objfile)
1228 #define CUR_SYMBOL_TYPE bufp->n_type
1229 #define CUR_SYMBOL_VALUE bufp->n_value
1230 #define DBXREAD_ONLY
1231 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1232 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1233 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1234 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1236 #include "partial-stab.h"
1239 /* If there's stuff to be cleaned up, clean it up. */
1240 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1241 /*FIXME, does this have a bug at start address 0? */
1242 && last_o_file_start
1243 && objfile
-> ei
.entry_point
< bufp
->n_value
1244 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1246 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1247 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1252 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1253 symnum
* symbol_size
,
1254 (lowest_text_address
== (CORE_ADDR
)-1
1255 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1256 : lowest_text_address
)
1258 dependency_list
, dependencies_used
);
1261 do_cleanups (back_to
);
1264 /* Allocate and partially fill a partial symtab. It will be
1265 completely filled at the end of the symbol list.
1267 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1268 is the address relative to which its symbols are (incremental) or 0
1272 struct partial_symtab
*
1273 start_psymtab (objfile
, section_offsets
,
1274 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1275 struct objfile
*objfile
;
1276 struct section_offsets
*section_offsets
;
1280 struct partial_symbol
**global_syms
;
1281 struct partial_symbol
**static_syms
;
1283 struct partial_symtab
*result
=
1284 start_psymtab_common(objfile
, section_offsets
,
1285 filename
, textlow
, global_syms
, static_syms
);
1287 result
->read_symtab_private
= (char *)
1288 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1289 LDSYMOFF(result
) = ldsymoff
;
1290 result
->read_symtab
= dbx_psymtab_to_symtab
;
1291 SYMBOL_SIZE(result
) = symbol_size
;
1292 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1293 STRING_OFFSET(result
) = string_table_offset
;
1294 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1296 /* If we're handling an ELF file, drag some section-relocation info
1297 for this source file out of the ELF symbol table, to compensate for
1298 Sun brain death. This replaces the section_offsets in this psymtab,
1300 elfstab_offset_sections (objfile
, result
);
1302 /* Deduce the source language from the filename for this psymtab. */
1303 psymtab_language
= deduce_language_from_filename (filename
);
1308 /* Close off the current usage of PST.
1309 Returns PST or NULL if the partial symtab was empty and thrown away.
1311 FIXME: List variables and peculiarities of same. */
1313 struct partial_symtab
*
1314 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1315 capping_text
, dependency_list
, number_dependencies
)
1316 struct partial_symtab
*pst
;
1317 char **include_list
;
1319 int capping_symbol_offset
;
1320 CORE_ADDR capping_text
;
1321 struct partial_symtab
**dependency_list
;
1322 int number_dependencies
;
1325 struct objfile
*objfile
= pst
-> objfile
;
1327 if (capping_symbol_offset
!= -1)
1328 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1329 pst
->texthigh
= capping_text
;
1331 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1332 /* Under Solaris, the N_SO symbols always have a value of 0,
1333 instead of the usual address of the .o file. Therefore,
1334 we have to do some tricks to fill in texthigh and textlow.
1335 The first trick is in partial-stab.h: if we see a static
1336 or global function, and the textlow for the current pst
1337 is still 0, then we use that function's address for
1338 the textlow of the pst. */
1340 /* Now, to fill in texthigh, we remember the last function seen
1341 in the .o file (also in partial-stab.h). Also, there's a hack in
1342 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1343 to here via the misc_info field. Therefore, we can fill in
1344 a reliable texthigh by taking the address plus size of the
1345 last function in the file. */
1347 if (pst
->texthigh
== 0 && last_function_name
) {
1350 struct minimal_symbol
*minsym
;
1352 p
= strchr (last_function_name
, ':');
1354 p
= last_function_name
;
1355 n
= p
- last_function_name
;
1357 strncpy (p
, last_function_name
, n
);
1360 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1363 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1364 (long) MSYMBOL_INFO (minsym
);
1366 last_function_name
= NULL
;
1369 /* this test will be true if the last .o file is only data */
1370 if (pst
->textlow
== 0)
1371 /* This loses if the text section really starts at address zero
1372 (generally true when we are debugging a .o file, for example).
1373 That is why this whole thing is inside SOFUN_ADDRESS_MAYBE_MISSING. */
1374 pst
->textlow
= pst
->texthigh
;
1376 /* If we know our own starting text address, then walk through all other
1377 psymtabs for this objfile, and if any didn't know their ending text
1378 address, set it to our starting address. Take care to not set our
1379 own ending address to our starting address, nor to set addresses on
1380 `dependency' files that have both textlow and texthigh zero. */
1382 struct partial_symtab
*p1
;
1384 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1385 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1386 p1
->texthigh
= pst
->textlow
;
1387 /* if this file has only data, then make textlow match texthigh */
1388 if (p1
->textlow
== 0)
1389 p1
->textlow
= p1
->texthigh
;
1394 /* End of kludge for patching Solaris textlow and texthigh. */
1395 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1397 pst
->n_global_syms
=
1398 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1399 pst
->n_static_syms
=
1400 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1402 pst
->number_of_dependencies
= number_dependencies
;
1403 if (number_dependencies
)
1405 pst
->dependencies
= (struct partial_symtab
**)
1406 obstack_alloc (&objfile
->psymbol_obstack
,
1407 number_dependencies
* sizeof (struct partial_symtab
*));
1408 memcpy (pst
->dependencies
, dependency_list
,
1409 number_dependencies
* sizeof (struct partial_symtab
*));
1412 pst
->dependencies
= 0;
1414 for (i
= 0; i
< num_includes
; i
++)
1416 struct partial_symtab
*subpst
=
1417 allocate_psymtab (include_list
[i
], objfile
);
1419 subpst
->section_offsets
= pst
->section_offsets
;
1420 subpst
->read_symtab_private
=
1421 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1422 sizeof (struct symloc
));
1426 subpst
->texthigh
= 0;
1428 /* We could save slight bits of space by only making one of these,
1429 shared by the entire set of include files. FIXME-someday. */
1430 subpst
->dependencies
= (struct partial_symtab
**)
1431 obstack_alloc (&objfile
->psymbol_obstack
,
1432 sizeof (struct partial_symtab
*));
1433 subpst
->dependencies
[0] = pst
;
1434 subpst
->number_of_dependencies
= 1;
1436 subpst
->globals_offset
=
1437 subpst
->n_global_syms
=
1438 subpst
->statics_offset
=
1439 subpst
->n_static_syms
= 0;
1443 subpst
->read_symtab
= pst
->read_symtab
;
1446 sort_pst_symbols (pst
);
1448 /* If there is already a psymtab or symtab for a file of this name, remove it.
1449 (If there is a symtab, more drastic things also happen.)
1450 This happens in VxWorks. */
1451 free_named_symtabs (pst
->filename
);
1453 if (num_includes
== 0
1454 && number_dependencies
== 0
1455 && pst
->n_global_syms
== 0
1456 && pst
->n_static_syms
== 0)
1458 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1459 it is on the obstack, but we can forget to chain it on the list. */
1460 /* Empty psymtabs happen as a result of header files which don't have
1461 any symbols in them. There can be a lot of them. But this check
1462 is wrong, in that a psymtab with N_SLINE entries but nothing else
1463 is not empty, but we don't realize that. Fixing that without slowing
1464 things down might be tricky. */
1465 struct partial_symtab
*prev_pst
;
1467 /* First, snip it out of the psymtab chain */
1469 if (pst
->objfile
->psymtabs
== pst
)
1470 pst
->objfile
->psymtabs
= pst
->next
;
1472 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1473 if (prev_pst
->next
== pst
)
1474 prev_pst
->next
= pst
->next
;
1476 /* Next, put it on a free list for recycling */
1478 pst
->next
= pst
->objfile
->free_psymtabs
;
1479 pst
->objfile
->free_psymtabs
= pst
;
1481 /* Indicate that psymtab was thrown away. */
1482 pst
= (struct partial_symtab
*)NULL
;
1488 dbx_psymtab_to_symtab_1 (pst
)
1489 struct partial_symtab
*pst
;
1491 struct cleanup
*old_chain
;
1499 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1504 /* Read in all partial symtabs on which this one is dependent */
1505 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1506 if (!pst
->dependencies
[i
]->readin
)
1508 /* Inform about additional files that need to be read in. */
1511 fputs_filtered (" ", gdb_stdout
);
1513 fputs_filtered ("and ", gdb_stdout
);
1515 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1516 wrap_here (""); /* Flush output */
1517 gdb_flush (gdb_stdout
);
1519 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1522 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1524 /* Init stuff necessary for reading in symbols */
1527 old_chain
= make_cleanup (really_free_pendings
, 0);
1528 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1529 symbol_size
= SYMBOL_SIZE (pst
);
1531 /* Read in this file's symbols */
1532 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1533 read_ofile_symtab (pst
);
1534 sort_symtab_syms (pst
->symtab
);
1536 do_cleanups (old_chain
);
1542 /* Read in all of the symbols for a given psymtab for real.
1543 Be verbose about it if the user wants that. */
1546 dbx_psymtab_to_symtab (pst
)
1547 struct partial_symtab
*pst
;
1556 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1561 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1563 /* Print the message now, before reading the string table,
1564 to avoid disconcerting pauses. */
1567 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1568 gdb_flush (gdb_stdout
);
1571 sym_bfd
= pst
->objfile
->obfd
;
1573 next_symbol_text_func
= dbx_next_symbol_text
;
1575 dbx_psymtab_to_symtab_1 (pst
);
1577 /* Match with global symbols. This only needs to be done once,
1578 after all of the symtabs and dependencies have been read in. */
1579 scan_file_globals (pst
->objfile
);
1581 /* Finish up the debug error message. */
1583 printf_filtered ("done.\n");
1587 /* Read in a defined section of a specific object file's symbols. */
1590 read_ofile_symtab (pst
)
1591 struct partial_symtab
*pst
;
1593 register char *namestring
;
1594 register struct internal_nlist
*bufp
;
1596 unsigned max_symnum
;
1598 struct objfile
*objfile
;
1599 int sym_offset
; /* Offset to start of symbols to read */
1600 int sym_size
; /* Size of symbols to read */
1601 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1602 int text_size
; /* Size of text segment for symbols */
1603 struct section_offsets
*section_offsets
;
1605 objfile
= pst
->objfile
;
1606 sym_offset
= LDSYMOFF(pst
);
1607 sym_size
= LDSYMLEN(pst
);
1608 text_offset
= pst
->textlow
;
1609 text_size
= pst
->texthigh
- pst
->textlow
;
1610 section_offsets
= pst
->section_offsets
;
1612 current_objfile
= objfile
;
1613 subfile_stack
= NULL
;
1615 stringtab_global
= DBX_STRINGTAB (objfile
);
1616 last_source_file
= NULL
;
1618 abfd
= objfile
->obfd
;
1619 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1620 symbuf_end
= symbuf_idx
= 0;
1622 /* It is necessary to actually read one symbol *before* the start
1623 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1624 occurs before the N_SO symbol.
1626 Detecting this in read_dbx_symtab
1627 would slow down initial readin, so we look for it here instead. */
1628 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1630 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1632 bufp
= &symbuf
[symbuf_idx
++];
1633 SWAP_SYMBOL (bufp
, abfd
);
1634 OBJSTAT (objfile
, n_stabs
++);
1638 processing_gcc_compilation
= 0;
1639 if (bufp
->n_type
== N_TEXT
)
1641 const char *tempstring
= namestring
;
1643 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1644 processing_gcc_compilation
= 1;
1645 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1646 processing_gcc_compilation
= 2;
1647 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1649 if (STREQN (tempstring
, "__gnu_compiled", 14))
1650 processing_gcc_compilation
= 2;
1653 /* Try to select a C++ demangling based on the compilation unit
1656 if (processing_gcc_compilation
)
1658 if (AUTO_DEMANGLING
)
1660 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1666 /* The N_SO starting this symtab is the first symbol, so we
1667 better not check the symbol before it. I'm not this can
1668 happen, but it doesn't hurt to check for it. */
1669 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1670 processing_gcc_compilation
= 0;
1673 if (symbuf_idx
== symbuf_end
)
1675 bufp
= &symbuf
[symbuf_idx
];
1676 if (bufp
->n_type
!= (unsigned char)N_SO
)
1677 error("First symbol in segment of executable not a source symbol");
1679 max_symnum
= sym_size
/ symbol_size
;
1682 symnum
< max_symnum
;
1685 QUIT
; /* Allow this to be interruptable */
1686 if (symbuf_idx
== symbuf_end
)
1688 bufp
= &symbuf
[symbuf_idx
++];
1689 SWAP_SYMBOL (bufp
, abfd
);
1690 OBJSTAT (objfile
, n_stabs
++);
1692 type
= bufp
->n_type
;
1696 if (type
& N_STAB
) {
1697 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1698 namestring
, section_offsets
, objfile
);
1700 /* We skip checking for a new .o or -l file; that should never
1701 happen in this routine. */
1702 else if (type
== N_TEXT
)
1704 /* I don't think this code will ever be executed, because
1705 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1706 the N_SO symbol which starts this source file.
1707 However, there is no reason not to accept
1708 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1710 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1711 processing_gcc_compilation
= 1;
1712 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1713 processing_gcc_compilation
= 2;
1715 if (AUTO_DEMANGLING
)
1717 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1720 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1721 || type
== (unsigned char)N_NBTEXT
1723 /* Global symbol: see if we came across a dbx defintion for
1724 a corresponding symbol. If so, store the value. Remove
1725 syms from the chain when their values are stored, but
1726 search the whole chain, as there may be several syms from
1727 different files with the same name. */
1728 /* This is probably not true. Since the files will be read
1729 in one at a time, each reference to a global symbol will
1730 be satisfied in each file as it appears. So we skip this
1736 current_objfile
= NULL
;
1738 /* In a Solaris elf file, this variable, which comes from the
1739 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1740 which comes from pst->textlow is correct. */
1741 if (last_source_start_addr
== 0)
1742 last_source_start_addr
= text_offset
;
1744 /* In reordered executables last_source_start_addr may not be the
1745 lower bound for this symtab, instead use text_offset which comes
1746 from pst->textlow which is correct. */
1747 if (last_source_start_addr
> text_offset
)
1748 last_source_start_addr
= text_offset
;
1750 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1752 if (ARM_DEMANGLING
) /* process incomplete C++ types now */
1753 process_now(objfile
);
1759 /* This handles a single symbol from the symbol-file, building symbols
1760 into a GDB symtab. It takes these arguments and an implicit argument.
1762 TYPE is the type field of the ".stab" symbol entry.
1763 DESC is the desc field of the ".stab" entry.
1764 VALU is the value field of the ".stab" entry.
1765 NAME is the symbol name, in our address space.
1766 SECTION_OFFSETS is a set of amounts by which the sections of this object
1767 file were relocated when it was loaded into memory.
1768 All symbols that refer
1769 to memory locations need to be offset by these amounts.
1770 OBJFILE is the object file from which we are reading symbols.
1771 It is used in end_symtab. */
1774 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1778 struct section_offsets
*section_offsets
;
1779 struct objfile
*objfile
;
1781 #ifdef SUN_FIXED_LBRAC_BUG
1782 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1783 to correct the address of N_LBRAC's. If it is not defined, then
1784 we never need to correct the addresses. */
1786 /* This records the last pc address we've seen. We depend on there being
1787 an SLINE or FUN or SO before the first LBRAC, since the variable does
1788 not get reset in between reads of different symbol files. */
1789 static CORE_ADDR last_pc_address
;
1792 register struct context_stack
*new;
1793 /* This remembers the address of the start of a function. It is used
1794 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1795 relative to the current function's start address. On systems
1796 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1797 used to relocate these symbol types rather than SECTION_OFFSETS. */
1798 static CORE_ADDR function_start_offset
;
1800 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1801 file. Used to detect the SunPRO solaris compiler. */
1802 static int n_opt_found
;
1804 /* The stab type used for the definition of the last function.
1805 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1806 static int function_stab_type
= 0;
1808 if (!block_address_function_relative
)
1809 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1810 function start address, so just use the text offset. */
1811 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1813 /* Something is wrong if we see real data before
1814 seeing a source file name. */
1816 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1818 /* Ignore any symbols which appear before an N_SO symbol. Currently
1819 no one puts symbols there, but we should deal gracefully with the
1820 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1821 but this should not be an error (). */
1830 if (! strcmp (name
, ""))
1832 /* This N_FUN marks the end of a function. This closes off the
1834 within_function
= 0;
1835 new = pop_context ();
1837 /* Make a block for the local symbols within. */
1838 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1839 function_start_offset
, function_start_offset
+ valu
,
1844 /* Relocate for dynamic loading */
1845 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1846 goto define_a_symbol
;
1849 /* This "symbol" just indicates the start of an inner lexical
1850 context within a function. */
1852 /* Ignore extra outermost context from SunPRO cc and acc. */
1853 if (n_opt_found
&& desc
== 1)
1856 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1857 /* Relocate for dynamic loading (?). */
1858 valu
+= function_start_offset
;
1860 if (block_address_function_relative
)
1861 /* Relocate for Sun ELF acc fn-relative syms. */
1862 valu
+= function_start_offset
;
1864 /* On most machines, the block addresses are relative to the
1865 N_SO, the linker did not relocate them (sigh). */
1866 valu
+= last_source_start_addr
;
1869 #ifdef SUN_FIXED_LBRAC_BUG
1870 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1871 /* Patch current LBRAC pc value to match last handy pc value */
1872 complain (&lbrac_complaint
);
1873 valu
= last_pc_address
;
1876 new = push_context (desc
, valu
);
1880 /* This "symbol" just indicates the end of an inner lexical
1881 context that was started with N_LBRAC. */
1883 /* Ignore extra outermost context from SunPRO cc and acc. */
1884 if (n_opt_found
&& desc
== 1)
1887 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1888 /* Relocate for dynamic loading (?). */
1889 valu
+= function_start_offset
;
1891 if (block_address_function_relative
)
1892 /* Relocate for Sun ELF acc fn-relative syms. */
1893 valu
+= function_start_offset
;
1895 /* On most machines, the block addresses are relative to the
1896 N_SO, the linker did not relocate them (sigh). */
1897 valu
+= last_source_start_addr
;
1900 new = pop_context();
1901 if (desc
!= new->depth
)
1902 complain (&lbrac_mismatch_complaint
, symnum
);
1904 /* Some compilers put the variable decls inside of an
1905 LBRAC/RBRAC block. This macro should be nonzero if this
1906 is true. DESC is N_DESC from the N_RBRAC symbol.
1907 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1908 or the GCC2_COMPILED_SYMBOL. */
1909 #if !defined (VARIABLES_INSIDE_BLOCK)
1910 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1913 /* Can only use new->locals as local symbols here if we're in
1914 gcc or on a machine that puts them before the lbrack. */
1915 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1916 local_symbols
= new->locals
;
1918 if (context_stack_depth
1919 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1921 /* This is not the outermost LBRAC...RBRAC pair in the function,
1922 its local symbols preceded it, and are the ones just recovered
1923 from the context stack. Define the block for them (but don't
1924 bother if the block contains no symbols. Should we complain
1925 on blocks without symbols? I can't think of any useful purpose
1927 if (local_symbols
!= NULL
)
1929 /* Muzzle a compiler bug that makes end < start. (which
1930 compilers? Is this ever harmful?). */
1931 if (new->start_addr
> valu
)
1933 complain (&lbrac_rbrac_complaint
);
1934 new->start_addr
= valu
;
1936 /* Make a block for the local symbols within. */
1937 finish_block (0, &local_symbols
, new->old_blocks
,
1938 new->start_addr
, valu
, objfile
);
1943 /* This is the outermost LBRAC...RBRAC pair. There is no
1944 need to do anything; leave the symbols that preceded it
1945 to be attached to the function's own block. We need to
1946 indicate that we just moved outside of the function. */
1947 within_function
= 0;
1950 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1951 /* Now pop locals of block just finished. */
1952 local_symbols
= new->locals
;
1957 /* This kind of symbol indicates the start of an object file. */
1958 /* Relocate for dynamic loading */
1959 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1963 /* This type of symbol indicates the start of data
1964 for one source file.
1965 Finish the symbol table of the previous source file
1966 (if any) and start accumulating a new symbol table. */
1967 /* Relocate for dynamic loading */
1968 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1972 #ifdef SUN_FIXED_LBRAC_BUG
1973 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1976 #ifdef PCC_SOL_BROKEN
1977 /* pcc bug, occasionally puts out SO for SOL. */
1978 if (context_stack_depth
> 0)
1980 start_subfile (name
, NULL
);
1984 if (last_source_file
)
1986 /* Check if previous symbol was also an N_SO (with some
1987 sanity checks). If so, that one was actually the directory
1988 name, and the current one is the real file name.
1990 if (previous_stab_code
== (unsigned char) N_SO
)
1992 patch_subfile_names (current_subfile
, name
);
1993 break; /* Ignore repeated SOs */
1995 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
1999 /* Null name means this just marks the end of text for this .o file.
2000 Don't start a new symtab in this case. */
2001 if (*name
== '\000')
2005 start_symtab (name
, NULL
, valu
);
2009 /* This type of symbol indicates the start of data for
2010 a sub-source-file, one whose contents were copied or
2011 included in the compilation of the main source file
2012 (whose name was given in the N_SO symbol.) */
2013 /* Relocate for dynamic loading */
2014 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2015 start_subfile (name
, current_subfile
->dirname
);
2020 add_new_header_file (name
, valu
);
2021 start_subfile (name
, current_subfile
->dirname
);
2025 start_subfile (pop_subfile (), current_subfile
->dirname
);
2029 add_old_header_file (name
, valu
);
2033 /* This type of "symbol" really just records
2034 one line-number -- core-address correspondence.
2035 Enter it in the line list for this symbol table. */
2036 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2037 valu
+= function_start_offset
;
2038 #ifdef SUN_FIXED_LBRAC_BUG
2039 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2041 record_line (current_subfile
, desc
, valu
);
2045 common_block_start (name
, objfile
);
2049 common_block_end (objfile
);
2052 /* The following symbol types need to have the appropriate offset added
2053 to their value; then we process symbol definitions in the name. */
2055 case N_STSYM
: /* Static symbol in data seg */
2056 case N_LCSYM
: /* Static symbol in BSS seg */
2057 case N_ROSYM
: /* Static symbol in Read-only data seg */
2058 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2059 Solaris2's stabs-in-elf makes *most* symbols relative
2060 but leaves a few absolute (at least for Solaris 2.1 and version
2061 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2062 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2063 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2064 This leaves us no choice but to search for the 'S' or 'V'...
2065 (or pass the whole section_offsets stuff down ONE MORE function
2066 call level, which we really don't want to do). */
2070 /* .o files and NLMs have non-zero text seg offsets, but don't need
2071 their static syms offset in this fashion. XXX - This is really a
2072 crock that should be fixed in the solib handling code so that I
2073 don't have to work around it here. */
2075 if (!symfile_relocatable
)
2077 p
= strchr (name
, ':');
2078 if (p
!= 0 && p
[1] == 'S')
2080 /* The linker relocated it. We don't want to add an
2081 elfstab_offset_sections-type offset, but we *do* want
2082 to add whatever solib.c passed to symbol_file_add as
2083 addr (this is known to affect SunOS4, and I suspect ELF
2084 too). Since elfstab_offset_sections currently does not
2085 muck with the text offset (there is no Ttext.text
2086 symbol), we can get addr from the text offset. If
2087 elfstab_offset_sections ever starts dealing with the
2088 text offset, and we still need to do this, we need to
2089 invent a SECT_OFF_ADDR_KLUDGE or something. */
2090 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2091 goto define_a_symbol
;
2094 /* Since it's not the kludge case, re-dispatch to the right handler. */
2096 case N_STSYM
: goto case_N_STSYM
;
2097 case N_LCSYM
: goto case_N_LCSYM
;
2098 case N_ROSYM
: goto case_N_ROSYM
;
2103 case_N_STSYM
: /* Static symbol in data seg */
2104 case N_DSLINE
: /* Source line number, data seg */
2105 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2106 goto define_a_symbol
;
2108 case_N_LCSYM
: /* Static symbol in BSS seg */
2109 case N_BSLINE
: /* Source line number, bss seg */
2110 /* N_BROWS: overlaps with N_BSLINE */
2111 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2112 goto define_a_symbol
;
2114 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2115 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2116 goto define_a_symbol
;
2118 case N_ENTRY
: /* Alternate entry point */
2119 /* Relocate for dynamic loading */
2120 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2121 goto define_a_symbol
;
2123 /* The following symbol types we don't know how to process. Handle
2124 them in a "default" way, but complain to people who care. */
2126 case N_CATCH
: /* Exception handler catcher */
2127 case N_EHDECL
: /* Exception handler name */
2128 case N_PC
: /* Global symbol in Pascal */
2129 case N_M2C
: /* Modula-2 compilation unit */
2130 /* N_MOD2: overlaps with N_EHDECL */
2131 case N_SCOPE
: /* Modula-2 scope information */
2132 case N_ECOML
: /* End common (local name) */
2133 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2138 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2141 /* The following symbol types don't need the address field relocated,
2142 since it is either unused, or is absolute. */
2144 case N_GSYM
: /* Global variable */
2145 case N_NSYMS
: /* Number of symbols (ultrix) */
2146 case N_NOMAP
: /* No map? (ultrix) */
2147 case N_RSYM
: /* Register variable */
2148 case N_DEFD
: /* Modula-2 GNU module dependency */
2149 case N_SSYM
: /* Struct or union element */
2150 case N_LSYM
: /* Local symbol in stack */
2151 case N_PSYM
: /* Parameter variable */
2152 case N_LENG
: /* Length of preceding symbol type */
2156 char *colon_pos
= strchr (name
, ':');
2157 if (colon_pos
== NULL
)
2160 deftype
= colon_pos
[1];
2166 function_stab_type
= type
;
2168 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2169 /* Deal with the SunPRO 3.0 compiler which omits the address
2170 from N_FUN symbols. */
2172 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2174 struct minimal_symbol
*msym
;
2178 p
= strchr (name
, ':');
2183 strncpy (p
, name
, n
);
2186 msym
= lookup_minimal_symbol (p
, last_source_file
,
2189 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2193 #ifdef SUN_FIXED_LBRAC_BUG
2194 /* The Sun acc compiler, under SunOS4, puts out
2195 functions with N_GSYM or N_STSYM. The problem is
2196 that the address of the symbol is no good (for N_GSYM
2197 it doesn't even attept an address; for N_STSYM it
2198 puts out an address but then it gets relocated
2199 relative to the data segment, not the text segment).
2200 Currently we can't fix this up later as we do for
2201 some types of symbol in scan_file_globals.
2202 Fortunately we do have a way of finding the address -
2203 we know that the value in last_pc_address is either
2204 the one we want (if we're dealing with the first
2205 function in an object file), or somewhere in the
2206 previous function. This means that we can use the
2207 minimal symbol table to get the address. */
2209 /* Starting with release 3.0, the Sun acc compiler,
2210 under SunOS4, puts out functions with N_FUN and a value
2211 of zero. This gets relocated to the start of the text
2212 segment of the module, which is no good either.
2213 Under SunOS4 we can deal with this as N_SLINE and N_SO
2214 entries contain valid absolute addresses.
2215 Release 3.0 acc also puts out N_OPT entries, which makes
2216 it possible to discern acc from cc or gcc. */
2218 if (type
== N_GSYM
|| type
== N_STSYM
2220 && n_opt_found
&& !block_address_function_relative
))
2222 struct minimal_symbol
*m
;
2223 int l
= colon_pos
- name
;
2225 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2226 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2227 && SYMBOL_NAME (m
) [l
] == '\0')
2228 /* last_pc_address was in this function */
2229 valu
= SYMBOL_VALUE (m
);
2230 else if (m
&& SYMBOL_NAME (m
+1)
2231 && STREQN (SYMBOL_NAME (m
+1), name
, l
)
2232 && SYMBOL_NAME (m
+1) [l
] == '\0')
2233 /* last_pc_address was in last function */
2234 valu
= SYMBOL_VALUE (m
+1);
2236 /* Not found - use last_pc_address (for finish_block) */
2237 valu
= last_pc_address
;
2240 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2243 if (block_address_function_relative
)
2244 /* For Solaris 2.0 compilers, the block addresses and
2245 N_SLINE's are relative to the start of the
2246 function. On normal systems, and when using gcc on
2247 Solaris 2.0, these addresses are just absolute, or
2248 relative to the N_SO, depending on
2249 BLOCK_ADDRESS_ABSOLUTE. */
2250 function_start_offset
= valu
;
2252 within_function
= 1;
2253 if (context_stack_depth
> 0)
2255 new = pop_context ();
2256 /* Make a block for the local symbols within. */
2257 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2258 new->start_addr
, valu
, objfile
);
2260 /* Stack must be empty now. */
2261 if (context_stack_depth
!= 0)
2262 complain (&lbrac_unmatched_complaint
, symnum
);
2264 new = push_context (0, valu
);
2265 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2269 define_symbol (valu
, name
, desc
, type
, objfile
);
2275 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2276 for a bunch of other flags, too. Someday we may parse their
2277 flags; for now we ignore theirs and hope they'll ignore ours. */
2278 case N_OPT
: /* Solaris 2: Compiler options */
2281 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2283 processing_gcc_compilation
= 2;
2284 #if 1 /* Works, but is experimental. -fnf */
2285 if (AUTO_DEMANGLING
)
2287 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2296 /* The following symbol types can be ignored. */
2297 case N_OBJ
: /* Solaris 2: Object file dir and name */
2298 /* N_UNDF: Solaris 2: file separator mark */
2299 /* N_UNDF: -- we will never encounter it, since we only process one
2300 file's symbols at once. */
2301 case N_ENDM
: /* Solaris 2: End of module */
2302 case N_MAIN
: /* Name of main routine. */
2306 previous_stab_code
= type
;
2309 /* FIXME: The only difference between this and elfstab_build_psymtabs
2310 is the call to install_minimal_symbols for elf, and the support for
2311 split sections. If the differences are really that small, the code
2312 should be shared. */
2314 /* Scan and build partial symbols for an coff symbol file.
2315 The coff file has already been processed to get its minimal symbols.
2317 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2320 OBJFILE is the object file we are reading symbols from.
2321 ADDR is the address relative to which the symbols are (e.g.
2322 the base address of the text segment).
2323 MAINLINE is true if we are reading the main symbol
2324 table (as opposed to a shared lib or dynamically loaded file).
2325 TEXTADDR is the address of the text section.
2326 TEXTSIZE is the size of the text section.
2327 STABSECTS is the list of .stab sections in OBJFILE.
2328 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2329 .stabstr section exists.
2331 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2332 adjusted for coff details. */
2335 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2336 textaddr
, textsize
, stabsects
,
2337 stabstroffset
, stabstrsize
)
2338 struct objfile
*objfile
;
2339 struct section_offsets
*section_offsets
;
2342 unsigned int textsize
;
2343 struct stab_section_list
*stabsects
;
2344 file_ptr stabstroffset
;
2345 unsigned int stabstrsize
;
2348 bfd
*sym_bfd
= objfile
->obfd
;
2349 char *name
= bfd_get_filename (sym_bfd
);
2350 struct dbx_symfile_info
*info
;
2351 unsigned int stabsize
;
2353 /* There is already a dbx_symfile_info allocated by our caller.
2354 It might even contain some info from the coff symtab to help us. */
2355 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2357 DBX_TEXT_ADDR (objfile
) = textaddr
;
2358 DBX_TEXT_SIZE (objfile
) = textsize
;
2360 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2361 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2362 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2364 if (stabstrsize
> bfd_get_size (sym_bfd
))
2365 error ("ridiculous string table size: %d bytes", stabstrsize
);
2366 DBX_STRINGTAB (objfile
) = (char *)
2367 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2368 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2370 /* Now read in the string table in one big gulp. */
2372 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2374 perror_with_name (name
);
2375 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2376 if (val
!= stabstrsize
)
2377 perror_with_name (name
);
2379 stabsread_new_init ();
2380 buildsym_new_init ();
2381 free_header_files ();
2382 init_header_files ();
2384 processing_acc_compilation
= 1;
2386 /* In a coff file, we've already installed the minimal symbols that came
2387 from the coff (non-stab) symbol table, so always act like an
2388 incremental load here. */
2389 if (stabsects
->next
== NULL
)
2391 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2392 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2393 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2397 struct stab_section_list
*stabsect
;
2399 DBX_SYMCOUNT (objfile
) = 0;
2400 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2402 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2403 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2406 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2408 symbuf_sections
= stabsects
->next
;
2409 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2413 dbx_symfile_read (objfile
, section_offsets
, 0);
2416 /* Scan and build partial symbols for an ELF symbol file.
2417 This ELF file has already been processed to get its minimal symbols,
2418 and any DWARF symbols that were in it.
2420 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2423 OBJFILE is the object file we are reading symbols from.
2424 ADDR is the address relative to which the symbols are (e.g.
2425 the base address of the text segment).
2426 MAINLINE is true if we are reading the main symbol
2427 table (as opposed to a shared lib or dynamically loaded file).
2428 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2430 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2431 .stabstr section exists.
2433 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2434 adjusted for elf details. */
2437 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2438 staboffset
, stabsize
,
2439 stabstroffset
, stabstrsize
)
2440 struct objfile
*objfile
;
2441 struct section_offsets
*section_offsets
;
2443 file_ptr staboffset
;
2444 unsigned int stabsize
;
2445 file_ptr stabstroffset
;
2446 unsigned int stabstrsize
;
2449 bfd
*sym_bfd
= objfile
->obfd
;
2450 char *name
= bfd_get_filename (sym_bfd
);
2451 struct dbx_symfile_info
*info
;
2452 asection
*text_sect
;
2454 /* There is already a dbx_symfile_info allocated by our caller.
2455 It might even contain some info from the ELF symtab to help us. */
2456 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2458 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
2460 error ("Can't find .text section in symbol file");
2461 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2462 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2464 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2465 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2466 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2467 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2468 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2470 if (stabstrsize
> bfd_get_size (sym_bfd
))
2471 error ("ridiculous string table size: %d bytes", stabstrsize
);
2472 DBX_STRINGTAB (objfile
) = (char *)
2473 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2474 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+1);
2476 /* Now read in the string table in one big gulp. */
2478 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2480 perror_with_name (name
);
2481 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2482 if (val
!= stabstrsize
)
2483 perror_with_name (name
);
2485 stabsread_new_init ();
2486 buildsym_new_init ();
2487 free_header_files ();
2488 init_header_files ();
2489 install_minimal_symbols (objfile
);
2491 processing_acc_compilation
= 1;
2493 /* In an elf file, we've already installed the minimal symbols that came
2494 from the elf (non-stab) symbol table, so always act like an
2495 incremental load here. */
2496 dbx_symfile_read (objfile
, section_offsets
, 0);
2499 /* Scan and build partial symbols for a file with special sections for stabs
2500 and stabstrings. The file has already been processed to get its minimal
2501 symbols, and any other symbols that might be necessary to resolve GSYMs.
2503 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2506 OBJFILE is the object file we are reading symbols from.
2507 ADDR is the address relative to which the symbols are (e.g. the base address
2508 of the text segment).
2509 MAINLINE is true if we are reading the main symbol table (as opposed to a
2510 shared lib or dynamically loaded file).
2511 STAB_NAME is the name of the section that contains the stabs.
2512 STABSTR_NAME is the name of the section that contains the stab strings.
2514 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2517 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2518 stabstr_name
, text_name
)
2519 struct objfile
*objfile
;
2520 struct section_offsets
*section_offsets
;
2527 bfd
*sym_bfd
= objfile
->obfd
;
2528 char *name
= bfd_get_filename (sym_bfd
);
2530 asection
*stabstrsect
;
2531 asection
*text_sect
;
2533 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2534 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2540 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2541 stab_name
, stabstr_name
);
2543 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2544 memset (DBX_SYMFILE_INFO (objfile
), 0, sizeof (struct dbx_symfile_info
));
2546 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2548 error ("Can't find %s section in symbol file", text_name
);
2549 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2550 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2552 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2553 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2554 / DBX_SYMBOL_SIZE (objfile
);
2555 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2556 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2558 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2559 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2560 DBX_STRINGTAB (objfile
) = (char *)
2561 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2562 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2564 /* Now read in the string table in one big gulp. */
2566 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2567 stabstrsect
, /* bfd section */
2568 DBX_STRINGTAB (objfile
), /* input buffer */
2569 0, /* offset into section */
2570 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2573 perror_with_name (name
);
2575 stabsread_new_init ();
2576 buildsym_new_init ();
2577 free_header_files ();
2578 init_header_files ();
2579 install_minimal_symbols (objfile
);
2581 /* Now, do an incremental load */
2583 processing_acc_compilation
= 1;
2584 dbx_symfile_read (objfile
, section_offsets
, 0);
2587 /* Parse the user's idea of an offset for dynamic linking, into our idea
2588 of how to represent it for fast symbol reading. */
2590 static struct section_offsets
*
2591 dbx_symfile_offsets (objfile
, addr
)
2592 struct objfile
*objfile
;
2595 struct section_offsets
*section_offsets
;
2598 objfile
->num_sections
= SECT_OFF_MAX
;
2599 section_offsets
= (struct section_offsets
*)
2600 obstack_alloc (&objfile
-> psymbol_obstack
,
2601 sizeof (struct section_offsets
)
2602 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2604 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2605 ANOFFSET (section_offsets
, i
) = addr
;
2607 return section_offsets
;
2610 static struct sym_fns aout_sym_fns
=
2612 bfd_target_aout_flavour
,
2613 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2614 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2615 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2616 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2617 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2618 NULL
/* next: pointer to next struct sym_fns */
2622 _initialize_dbxread ()
2624 add_symtab_fns(&aout_sym_fns
);