1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
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., 675 Mass Ave, Cambridge, MA 02139, 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 */
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 "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
56 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
60 #include "stabsread.h"
61 #include "gdb-stabs.h"
63 #include "language.h" /* Needed inside partial-stab.h */
64 #include "complaints.h"
66 #include "aout/aout64.h"
67 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
69 #if !defined (SEEK_SET)
74 /* Each partial symbol table entry contains a pointer to private data for the
75 read_symtab() function to use when expanding a partial symbol table entry
76 to a full symbol table entry.
78 For dbxread this structure contains the offset within the file symbol table
79 of first local symbol for this file, and length (in bytes) of the section
80 of the symbol table devoted to this file's symbols (actually, the section
81 bracketed may contain more than just this file's symbols). It also contains
82 further information needed to locate the symbols if they are in an ELF file.
84 If ldsymlen is 0, the only reason for this thing's existence is the
85 dependency list. Nothing else will happen when it is read in. */
87 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
88 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
89 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
90 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
91 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
92 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
93 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
101 int file_string_offset
;
104 /* Macro to determine which symbols to ignore when reading the first symbol
105 of a file. Some machines override this definition. */
106 #ifndef IGNORE_SYMBOL
107 /* This code is used on Ultrix systems. Ignore it */
108 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
111 /* Remember what we deduced to be the source language of this psymtab. */
113 static enum language psymtab_language
= language_unknown
;
115 /* Nonzero means give verbose info on gdb action. From main.c. */
116 extern int info_verbose
;
118 /* The BFD for this file -- implicit parameter to next_symbol_text. */
120 static bfd
*symfile_bfd
;
122 /* The size of each symbol in the symbol file (in external form).
123 This is set by dbx_symfile_read when building psymtabs, and by
124 dbx_psymtab_to_symtab when building symtabs. */
126 static unsigned symbol_size
;
128 /* This is the offset of the symbol table in the executable file */
129 static unsigned symbol_table_offset
;
131 /* This is the offset of the string table in the executable file */
132 static unsigned string_table_offset
;
134 /* For elf+stab executables, the n_strx field is not a simple index
135 into the string table. Instead, each .o file has a base offset
136 in the string table, and the associated symbols contain offsets
137 from this base. The following two variables contain the base
138 offset for the current and next .o files. */
139 static unsigned int file_string_table_offset
;
140 static unsigned int next_file_string_table_offset
;
142 /* .o and NLM files contain unrelocated addresses which are based at 0. When
143 non-zero, this flag disables some of the special cases for Solaris elf+stab
144 text addresses at location 0. */
146 static int symfile_relocatable
= 0;
148 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
149 to the function start address. */
151 static int block_address_function_relative
= 0;
153 /* This is the lowest text address we have yet encountered. */
154 static CORE_ADDR lowest_text_address
;
156 /* Complaints about the symbols we have encountered. */
158 struct complaint lbrac_complaint
=
159 {"bad block start address patched", 0, 0};
161 struct complaint string_table_offset_complaint
=
162 {"bad string table offset in symbol %d", 0, 0};
164 struct complaint unknown_symtype_complaint
=
165 {"unknown symbol type %s", 0, 0};
167 struct complaint unknown_symchar_complaint
=
168 {"unknown symbol descriptor `%c'", 0, 0};
170 struct complaint lbrac_rbrac_complaint
=
171 {"block start larger than block end", 0, 0};
173 struct complaint lbrac_unmatched_complaint
=
174 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
176 struct complaint lbrac_mismatch_complaint
=
177 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
179 struct complaint repeated_header_complaint
=
180 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
182 struct complaint repeated_header_name_complaint
=
183 {"\"repeated\" header file not previously seen, named %s", 0, 0};
185 /* During initial symbol readin, we need to have a structure to keep
186 track of which psymtabs have which bincls in them. This structure
187 is used during readin to setup the list of dependencies within each
188 partial symbol table. */
190 struct header_file_location
192 char *name
; /* Name of header file */
193 int instance
; /* See above */
194 struct partial_symtab
*pst
; /* Partial symtab that has the
195 BINCL/EINCL defs for this file */
198 /* The actual list and controling variables */
199 static struct header_file_location
*bincl_list
, *next_bincl
;
200 static int bincls_allocated
;
202 /* Local function prototypes */
205 free_header_files
PARAMS ((void));
208 init_header_files
PARAMS ((void));
211 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
214 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
217 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
220 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
221 struct objfile
*objfile
));
224 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
228 free_bincl_list
PARAMS ((struct objfile
*));
230 static struct partial_symtab
*
231 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
234 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
237 init_bincl_list
PARAMS ((int, struct objfile
*));
240 init_psymbol_list
PARAMS ((struct objfile
*));
243 dbx_next_symbol_text
PARAMS ((void));
246 fill_symbuf
PARAMS ((bfd
*));
249 dbx_symfile_init
PARAMS ((struct objfile
*));
252 dbx_new_init
PARAMS ((struct objfile
*));
255 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
258 dbx_symfile_finish
PARAMS ((struct objfile
*));
261 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
264 add_new_header_file
PARAMS ((char *, int));
267 add_old_header_file
PARAMS ((char *, int));
270 add_this_object_header_file
PARAMS ((int));
272 /* Free up old header file tables */
279 if (header_files
!= NULL
)
281 for (i
= 0; i
< n_header_files
; i
++)
283 free (header_files
[i
].name
);
285 free ((PTR
)header_files
);
289 if (this_object_header_files
)
291 free ((PTR
)this_object_header_files
);
292 this_object_header_files
= NULL
;
294 n_allocated_header_files
= 0;
295 n_allocated_this_object_header_files
= 0;
298 /* Allocate new header file tables */
304 n_allocated_header_files
= 10;
305 header_files
= (struct header_file
*)
306 xmalloc (10 * sizeof (struct header_file
));
308 n_allocated_this_object_header_files
= 10;
309 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
312 /* Add header file number I for this object file
313 at the next successive FILENUM. */
316 add_this_object_header_file (i
)
319 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
321 n_allocated_this_object_header_files
*= 2;
322 this_object_header_files
323 = (int *) xrealloc ((char *) this_object_header_files
,
324 n_allocated_this_object_header_files
* sizeof (int));
327 this_object_header_files
[n_this_object_header_files
++] = i
;
330 /* Add to this file an "old" header file, one already seen in
331 a previous object file. NAME is the header file's name.
332 INSTANCE is its instance code, to select among multiple
333 symbol tables for the same header file. */
336 add_old_header_file (name
, instance
)
340 register struct header_file
*p
= header_files
;
343 for (i
= 0; i
< n_header_files
; i
++)
344 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
346 add_this_object_header_file (i
);
349 complain (&repeated_header_complaint
, symnum
);
350 complain (&repeated_header_name_complaint
, name
);
353 /* Add to this file a "new" header file: definitions for its types follow.
354 NAME is the header file's name.
355 Most often this happens only once for each distinct header file,
356 but not necessarily. If it happens more than once, INSTANCE has
357 a different value each time, and references to the header file
358 use INSTANCE values to select among them.
360 dbx output contains "begin" and "end" markers for each new header file,
361 but at this level we just need to know which files there have been;
362 so we record the file when its "begin" is seen and ignore the "end". */
365 add_new_header_file (name
, instance
)
371 /* Make sure there is room for one more header file. */
373 if (n_header_files
== n_allocated_header_files
)
375 n_allocated_header_files
*= 2;
376 header_files
= (struct header_file
*)
377 xrealloc ((char *) header_files
,
378 (n_allocated_header_files
* sizeof (struct header_file
)));
381 /* Create an entry for this header file. */
383 i
= n_header_files
++;
384 header_files
[i
].name
= savestring (name
, strlen(name
));
385 header_files
[i
].instance
= instance
;
386 header_files
[i
].length
= 10;
387 header_files
[i
].vector
388 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
389 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
391 add_this_object_header_file (i
);
395 static struct type
**
396 explicit_lookup_type (real_filenum
, index
)
397 int real_filenum
, index
;
399 register struct header_file
*f
= &header_files
[real_filenum
];
401 if (index
>= f
->length
)
404 f
->vector
= (struct type
**)
405 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
406 memset (&f
->vector
[f
->length
/ 2],
407 '\0', f
->length
* sizeof (struct type
*) / 2);
409 return &f
->vector
[index
];
414 record_minimal_symbol (name
, address
, type
, objfile
)
418 struct objfile
*objfile
;
420 enum minimal_symbol_type ms_type
;
427 section
= SECT_OFF_TEXT
;
431 section
= SECT_OFF_DATA
;
435 section
= SECT_OFF_BSS
;
444 section
= SECT_OFF_DATA
;
447 /* I don't think this type actually exists; since a N_SETV is the result
448 of going over many .o files, it doesn't make sense to have one
450 ms_type
= mst_file_data
;
451 section
= SECT_OFF_DATA
;
458 ms_type
= mst_file_text
;
459 section
= SECT_OFF_TEXT
;
462 ms_type
= mst_file_data
;
464 /* Check for __DYNAMIC, which is used by Sun shared libraries.
465 Record it as global even if it's local, not global, so
466 lookup_minimal_symbol can find it. We don't check symbol_leading_char
467 because for SunOS4 it always is '_'. */
468 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
471 /* Same with virtual function tables, both global and static. */
473 char *tempstring
= name
;
474 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
476 if (VTBL_PREFIX_P ((tempstring
)))
479 section
= SECT_OFF_DATA
;
482 ms_type
= mst_file_bss
;
483 section
= SECT_OFF_BSS
;
486 ms_type
= mst_unknown
;
491 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
492 && address
< lowest_text_address
)
493 lowest_text_address
= address
;
495 prim_record_minimal_symbol_and_info
496 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
504 /* Scan and build partial symbols for a symbol file.
505 We have been initialized by a call to dbx_symfile_init, which
506 put all the relevant info into a "struct dbx_symfile_info",
507 hung off the objfile structure.
509 SECTION_OFFSETS contains offsets relative to which the symbols in the
510 various sections are (depending where the sections were actually loaded).
511 MAINLINE is true if we are reading the main symbol
512 table (as opposed to a shared lib or dynamically loaded file). */
515 dbx_symfile_read (objfile
, section_offsets
, mainline
)
516 struct objfile
*objfile
;
517 struct section_offsets
*section_offsets
;
518 int mainline
; /* FIXME comments above */
522 struct cleanup
*back_to
;
524 val
= strlen (objfile
->name
);
526 /* .o and .nlm files are relocatables with text, data and bss segs based at
527 0. This flag disables special (Solaris stabs-in-elf only) fixups for
528 symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
529 should be fixed to determine pst->textlow without using this text seg of
532 if (strcmp (&objfile
->name
[val
-2], ".o") == 0
533 || strcmp (&objfile
->name
[val
-4], ".nlm") == 0)
534 symfile_relocatable
= 1;
536 /* This is true for Solaris (and all other systems which put stabs
537 in sections, hopefully, since it would be silly to do things
538 differently from Solaris), and false for SunOS4 and other a.out
540 block_address_function_relative
=
541 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
542 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
543 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4))
544 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "nlm", 3)));
546 sym_bfd
= objfile
->obfd
;
547 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
549 perror_with_name (objfile
->name
);
551 /* If we are reinitializing, or if we have never loaded syms yet, init */
552 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
553 init_psymbol_list (objfile
);
555 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
556 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
559 back_to
= make_cleanup (really_free_pendings
, 0);
561 init_minimal_symbol_collection ();
562 make_cleanup (discard_minimal_symbols
, 0);
564 /* Now that the symbol table data of the executable file are all in core,
565 process them and define symbols accordingly. */
567 read_dbx_symtab (section_offsets
, objfile
,
568 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
569 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
571 /* Add the dynamic symbols if we are reading the main symbol table. */
574 read_dbx_dynamic_symtab (section_offsets
, objfile
);
576 /* Install any minimal symbols that have been collected as the current
577 minimal symbols for this objfile. */
579 install_minimal_symbols (objfile
);
581 if (!have_partial_symbols ()) {
583 printf_filtered ("(no debugging symbols found)...");
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
);
626 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
628 /* Allocate struct to keep track of the symfile */
629 objfile
->sym_stab_info
= (PTR
)
630 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
632 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
633 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
634 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
636 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
638 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
639 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
640 if (!DBX_TEXT_SECT (objfile
))
641 error ("Can't find .text section in symbol file");
643 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
644 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
645 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
647 /* Read the string table and stash it away in the psymbol_obstack. It is
648 only needed as long as we need to expand psymbols into full symbols,
649 so when we blow away the psymbol the string table goes away as well.
650 Note that gdb used to use the results of attempting to malloc the
651 string table, based on the size it read, as a form of sanity check
652 for botched byte swapping, on the theory that a byte swapped string
653 table size would be so totally bogus that the malloc would fail. Now
654 that we put in on the psymbol_obstack, we can't do this since gdb gets
655 a fatal error (out of virtual memory) if the size is bogus. We can
656 however at least check to see if the size is less than the size of
657 the size field itself, or larger than the size of the entire file.
658 Note that all valid string tables have a size greater than zero, since
659 the bytes used to hold the size are included in the count. */
661 if (STRING_TABLE_OFFSET
== 0)
663 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
664 will never be zero, even when there is no string table. This
665 would appear to be a bug in bfd. */
666 DBX_STRINGTAB_SIZE (objfile
) = 0;
667 DBX_STRINGTAB (objfile
) = NULL
;
671 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
673 perror_with_name (name
);
675 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
676 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
679 perror_with_name (name
);
683 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
684 EOF if there is no string table, and attempting to read the size
685 from EOF will read zero bytes. */
686 DBX_STRINGTAB_SIZE (objfile
) = 0;
687 DBX_STRINGTAB (objfile
) = NULL
;
691 /* Read some data that would appear to be the string table size.
692 If there really is a string table, then it is probably the right
693 size. Byteswap if necessary and validate the size. Note that
694 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
695 random data that happened to be at STRING_TABLE_OFFSET, because
696 bfd can't tell us there is no string table, the sanity checks may
697 or may not catch this. */
698 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
700 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
701 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
702 error ("ridiculous string table size (%d bytes).",
703 DBX_STRINGTAB_SIZE (objfile
));
705 DBX_STRINGTAB (objfile
) =
706 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
707 DBX_STRINGTAB_SIZE (objfile
));
709 /* Now read in the string table in one big gulp. */
711 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
713 perror_with_name (name
);
714 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
716 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
717 perror_with_name (name
);
722 /* Perform any local cleanups required when we are done with a particular
723 objfile. I.E, we are in the process of discarding all symbol information
724 for an objfile, freeing up all memory held for it, and unlinking the
725 objfile struct from the global list of known objfiles. */
728 dbx_symfile_finish (objfile
)
729 struct objfile
*objfile
;
731 if (objfile
->sym_stab_info
!= NULL
)
733 mfree (objfile
-> md
, objfile
->sym_stab_info
);
735 free_header_files ();
739 /* Buffer for reading the symbol table entries. */
740 static struct internal_nlist symbuf
[4096];
741 static int symbuf_idx
;
742 static int symbuf_end
;
744 /* Name of last function encountered. Used in Solaris to approximate
745 object file boundaries. */
746 static char *last_function_name
;
748 /* The address in memory of the string table of the object file we are
749 reading (which might not be the "main" object file, but might be a
750 shared library or some other dynamically loaded thing). This is set
751 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
752 when building symtabs, and is used only by next_symbol_text. */
753 static char *stringtab_global
;
755 /* Refill the symbol table input buffer
756 and set the variables that control fetching entries from it.
757 Reports an error if no data available.
758 This function can read past the end of the symbol table
759 (into the string table) but this does no harm. */
762 fill_symbuf (sym_bfd
)
765 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
767 perror_with_name (bfd_get_filename (sym_bfd
));
768 else if (nbytes
== 0)
769 error ("Premature end of file reading symbol table");
770 symbuf_end
= nbytes
/ symbol_size
;
774 #define SWAP_SYMBOL(symp, abfd) \
776 (symp)->n_strx = bfd_h_get_32(abfd, \
777 (unsigned char *)&(symp)->n_strx); \
778 (symp)->n_desc = bfd_h_get_16 (abfd, \
779 (unsigned char *)&(symp)->n_desc); \
780 (symp)->n_value = bfd_h_get_32 (abfd, \
781 (unsigned char *)&(symp)->n_value); \
784 /* Invariant: The symbol pointed to by symbuf_idx is the first one
785 that hasn't been swapped. Swap the symbol at the same time
786 that symbuf_idx is incremented. */
788 /* dbx allows the text of a symbol name to be continued into the
789 next symbol name! When such a continuation is encountered
790 (a \ at the end of the text of a name)
791 call this function to get the continuation. */
794 dbx_next_symbol_text ()
796 if (symbuf_idx
== symbuf_end
)
797 fill_symbuf (symfile_bfd
);
799 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
800 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
801 + file_string_table_offset
;
804 /* Initializes storage for all of the partial symbols that will be
805 created by read_dbx_symtab and subsidiaries. */
808 init_psymbol_list (objfile
)
809 struct objfile
*objfile
;
811 /* Free any previously allocated psymbol lists. */
812 if (objfile
-> global_psymbols
.list
)
813 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
814 if (objfile
-> static_psymbols
.list
)
815 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
817 /* Current best guess is that there are approximately a twentieth
818 of the total symbols (in a debugging file) are global or static
820 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
821 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
822 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
823 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
824 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
825 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
828 /* Initialize the list of bincls to contain none and have some
832 init_bincl_list (number
, objfile
)
834 struct objfile
*objfile
;
836 bincls_allocated
= number
;
837 next_bincl
= bincl_list
= (struct header_file_location
*)
838 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
841 /* Add a bincl to the list. */
844 add_bincl_to_list (pst
, name
, instance
)
845 struct partial_symtab
*pst
;
849 if (next_bincl
>= bincl_list
+ bincls_allocated
)
851 int offset
= next_bincl
- bincl_list
;
852 bincls_allocated
*= 2;
853 bincl_list
= (struct header_file_location
*)
854 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
855 bincls_allocated
* sizeof (struct header_file_location
));
856 next_bincl
= bincl_list
+ offset
;
858 next_bincl
->pst
= pst
;
859 next_bincl
->instance
= instance
;
860 next_bincl
++->name
= name
;
863 /* Given a name, value pair, find the corresponding
864 bincl in the list. Return the partial symtab associated
865 with that header_file_location. */
867 static struct partial_symtab
*
868 find_corresponding_bincl_psymtab (name
, instance
)
872 struct header_file_location
*bincl
;
874 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
875 if (bincl
->instance
== instance
876 && STREQ (name
, bincl
->name
))
879 return (struct partial_symtab
*) 0;
882 /* Free the storage allocated for the bincl list. */
885 free_bincl_list (objfile
)
886 struct objfile
*objfile
;
888 mfree (objfile
-> md
, (PTR
)bincl_list
);
889 bincls_allocated
= 0;
892 /* Scan a SunOs dynamic symbol table for symbols of interest and
893 add them to the minimal symbol table. */
896 read_dbx_dynamic_symtab (section_offsets
, objfile
)
897 struct section_offsets
*section_offsets
;
898 struct objfile
*objfile
;
900 bfd
*abfd
= objfile
->obfd
;
901 struct cleanup
*back_to
;
913 /* Check that the symbol file has dynamic symbols that we know about.
914 bfd_arch_unknown can happen if we are reading a sun3 symbol file
915 on a sun4 host (and vice versa) and bfd is not configured
916 --with-target=all. This would trigger an assertion in bfd/sunos.c,
917 so we ignore the dynamic symbols in this case. */
918 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
919 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
920 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
923 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
927 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
928 back_to
= make_cleanup (free
, dynsyms
);
930 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
931 if (dynsym_count
< 0)
933 do_cleanups (back_to
);
937 /* Enter dynamic symbols into the minimal symbol table
938 if this is a stripped executable. */
939 if (bfd_get_symcount (abfd
) <= 0)
942 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
944 asymbol
*sym
= *symptr
;
948 sec
= bfd_get_section (sym
);
950 /* BFD symbols are section relative. */
951 sym_value
= sym
->value
+ sec
->vma
;
953 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
955 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
958 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
960 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
963 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
965 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
971 if (sym
->flags
& BSF_GLOBAL
)
974 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
979 /* Symbols from shared libraries have a dynamic relocation entry
980 that points to the associated slot in the procedure linkage table.
981 We make a mininal symbol table entry with type mst_solib_trampoline
982 at the address in the procedure linkage table. */
983 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
986 do_cleanups (back_to
);
990 dynrels
= (arelent
**) xmalloc (dynrel_size
);
991 make_cleanup (free
, dynrels
);
993 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
994 if (dynrel_count
< 0)
996 do_cleanups (back_to
);
1000 for (counter
= 0, relptr
= dynrels
;
1001 counter
< dynrel_count
;
1002 counter
++, relptr
++)
1004 arelent
*rel
= *relptr
;
1005 CORE_ADDR address
= rel
->address
;
1007 switch (bfd_get_arch (abfd
))
1009 case bfd_arch_sparc
:
1010 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1014 /* `16' is the type BFD produces for a jump table relocation. */
1015 if (rel
->howto
->type
!= 16)
1018 /* Adjust address in the jump table to point to
1019 the start of the bsr instruction. */
1026 prim_record_minimal_symbol (bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1028 mst_solib_trampoline
,
1032 do_cleanups (back_to
);
1035 /* Given pointers to an a.out symbol table in core containing dbx
1036 style data, setup partial_symtab's describing each source file for
1037 which debugging information is available.
1038 SYMFILE_NAME is the name of the file we are reading from
1039 and SECTION_OFFSETS is the set of offsets for the various sections
1040 of the file (a set of zeros if the mainline program). */
1043 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1044 struct section_offsets
*section_offsets
;
1045 struct objfile
*objfile
;
1046 CORE_ADDR text_addr
;
1049 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1050 register char *namestring
;
1052 int past_first_source_file
= 0;
1053 CORE_ADDR last_o_file_start
= 0;
1054 struct cleanup
*back_to
;
1057 /* Current partial symtab */
1058 struct partial_symtab
*pst
;
1060 /* List of current psymtab's include files */
1061 char **psymtab_include_list
;
1062 int includes_allocated
;
1065 /* Index within current psymtab dependency list */
1066 struct partial_symtab
**dependency_list
;
1067 int dependencies_used
, dependencies_allocated
;
1069 /* FIXME. We probably want to change stringtab_global rather than add this
1070 while processing every symbol entry. FIXME. */
1071 file_string_table_offset
= 0;
1072 next_file_string_table_offset
= 0;
1074 stringtab_global
= DBX_STRINGTAB (objfile
);
1076 pst
= (struct partial_symtab
*) 0;
1078 includes_allocated
= 30;
1080 psymtab_include_list
= (char **) alloca (includes_allocated
*
1083 dependencies_allocated
= 30;
1084 dependencies_used
= 0;
1086 (struct partial_symtab
**) alloca (dependencies_allocated
*
1087 sizeof (struct partial_symtab
*));
1089 /* Init bincl list */
1090 init_bincl_list (20, objfile
);
1091 back_to
= make_cleanup (free_bincl_list
, objfile
);
1093 last_source_file
= NULL
;
1095 lowest_text_address
= (CORE_ADDR
)-1;
1097 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1098 abfd
= objfile
->obfd
;
1099 symbuf_end
= symbuf_idx
= 0;
1100 next_symbol_text_func
= dbx_next_symbol_text
;
1102 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1104 /* Get the symbol for this run and pull out some info */
1105 QUIT
; /* allow this to be interruptable */
1106 if (symbuf_idx
== symbuf_end
)
1108 bufp
= &symbuf
[symbuf_idx
++];
1111 * Special case to speed up readin.
1113 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1115 SWAP_SYMBOL (bufp
, abfd
);
1117 /* Ok. There is a lot of code duplicated in the rest of this
1118 switch statement (for efficiency reasons). Since I don't
1119 like duplicating code, I will do my penance here, and
1120 describe the code which is duplicated:
1122 *) The assignment to namestring.
1123 *) The call to strchr.
1124 *) The addition of a partial symbol the the two partial
1125 symbol lists. This last is a large section of code, so
1126 I've imbedded it in the following macro.
1129 /* Set namestring based on bufp. If the string table index is invalid,
1130 give a fake name, and print a single error message per symbol file read,
1131 rather than abort the symbol reading or flood the user with messages. */
1133 /*FIXME: Too many adds and indirections in here for the inner loop. */
1134 #define SET_NAMESTRING()\
1135 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1136 DBX_STRINGTAB_SIZE (objfile)) { \
1137 complain (&string_table_offset_complaint, symnum); \
1138 namestring = "<bad string table offset>"; \
1140 namestring = bufp->n_strx + file_string_table_offset + \
1141 DBX_STRINGTAB (objfile)
1143 #define CUR_SYMBOL_TYPE bufp->n_type
1144 #define CUR_SYMBOL_VALUE bufp->n_value
1145 #define DBXREAD_ONLY
1146 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1147 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1148 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1149 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1151 #include "partial-stab.h"
1154 /* If there's stuff to be cleaned up, clean it up. */
1155 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1156 /*FIXME, does this have a bug at start address 0? */
1157 && last_o_file_start
1158 && objfile
-> ei
.entry_point
< bufp
->n_value
1159 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1161 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1162 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1167 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1168 symnum
* symbol_size
,
1169 (lowest_text_address
== (CORE_ADDR
)-1
1170 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1171 : lowest_text_address
)
1173 dependency_list
, dependencies_used
);
1176 do_cleanups (back_to
);
1179 /* Allocate and partially fill a partial symtab. It will be
1180 completely filled at the end of the symbol list.
1182 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1183 is the address relative to which its symbols are (incremental) or 0
1187 struct partial_symtab
*
1188 start_psymtab (objfile
, section_offsets
,
1189 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1190 struct objfile
*objfile
;
1191 struct section_offsets
*section_offsets
;
1195 struct partial_symbol
*global_syms
;
1196 struct partial_symbol
*static_syms
;
1198 struct partial_symtab
*result
=
1199 start_psymtab_common(objfile
, section_offsets
,
1200 filename
, textlow
, global_syms
, static_syms
);
1202 result
->read_symtab_private
= (char *)
1203 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1204 LDSYMOFF(result
) = ldsymoff
;
1205 result
->read_symtab
= dbx_psymtab_to_symtab
;
1206 SYMBOL_SIZE(result
) = symbol_size
;
1207 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1208 STRING_OFFSET(result
) = string_table_offset
;
1209 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1211 /* If we're handling an ELF file, drag some section-relocation info
1212 for this source file out of the ELF symbol table, to compensate for
1213 Sun brain death. This replaces the section_offsets in this psymtab,
1215 elfstab_offset_sections (objfile
, result
);
1217 /* Deduce the source language from the filename for this psymtab. */
1218 psymtab_language
= deduce_language_from_filename (filename
);
1223 /* Close off the current usage of PST.
1224 Returns PST or NULL if the partial symtab was empty and thrown away.
1226 FIXME: List variables and peculiarities of same. */
1228 struct partial_symtab
*
1229 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1230 capping_text
, dependency_list
, number_dependencies
)
1231 struct partial_symtab
*pst
;
1232 char **include_list
;
1234 int capping_symbol_offset
;
1235 CORE_ADDR capping_text
;
1236 struct partial_symtab
**dependency_list
;
1237 int number_dependencies
;
1240 struct objfile
*objfile
= pst
-> objfile
;
1242 if (capping_symbol_offset
!= -1)
1243 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1244 pst
->texthigh
= capping_text
;
1246 #ifdef N_SO_ADDRESS_MAYBE_MISSING
1247 /* Under Solaris, the N_SO symbols always have a value of 0,
1248 instead of the usual address of the .o file. Therefore,
1249 we have to do some tricks to fill in texthigh and textlow.
1250 The first trick is in partial-stab.h: if we see a static
1251 or global function, and the textlow for the current pst
1252 is still 0, then we use that function's address for
1253 the textlow of the pst.
1255 Now, to fill in texthigh, we remember the last function seen
1256 in the .o file (also in partial-stab.h). Also, there's a hack in
1257 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1258 to here via the misc_info field. Therefore, we can fill in
1259 a reliable texthigh by taking the address plus size of the
1260 last function in the file.
1262 Unfortunately, that does not cover the case where the last function
1263 in the file is static. See the paragraph below for more comments
1266 Finally, if we have a valid textlow for the current file, we run
1267 down the partial_symtab_list filling in previous texthighs that
1268 are still unknown. */
1270 if (pst
->texthigh
== 0 && last_function_name
) {
1273 struct minimal_symbol
*minsym
;
1275 p
= strchr (last_function_name
, ':');
1277 p
= last_function_name
;
1278 n
= p
- last_function_name
;
1280 strncpy (p
, last_function_name
, n
);
1283 minsym
= lookup_minimal_symbol (p
, objfile
);
1286 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1287 (long) MSYMBOL_INFO (minsym
);
1289 /* This file ends with a static function, and it's
1290 difficult to imagine how hard it would be to track down
1291 the elf symbol. Luckily, most of the time no one will notice,
1292 since the next file will likely be compiled with -g, so
1293 the code below will copy the first fuction's start address
1294 back to our texthigh variable. (Also, if this file is the
1295 last one in a dynamically linked program, texthigh already
1296 has the right value.) If the next file isn't compiled
1297 with -g, then the last function in this file winds up owning
1298 all of the text space up to the next -g file, or the end (minus
1299 shared libraries). This only matters for single stepping,
1300 and even then it will still work, except that it will single
1301 step through all of the covered functions, instead of setting
1302 breakpoints around them as it usualy does. This makes it
1303 pretty slow, but at least it doesn't fail.
1305 We can fix this with a fairly big change to bfd, but we need
1306 to coordinate better with Cygnus if we want to do that. FIXME. */
1308 last_function_name
= NULL
;
1311 /* this test will be true if the last .o file is only data */
1312 if (pst
->textlow
== 0)
1313 /* This loses if the text section really starts at address zero
1314 (generally true when we are debugging a .o file, for example).
1315 That is why this whole thing is inside N_SO_ADDRESS_MAYBE_MISSING. */
1316 pst
->textlow
= pst
->texthigh
;
1318 /* If we know our own starting text address, then walk through all other
1319 psymtabs for this objfile, and if any didn't know their ending text
1320 address, set it to our starting address. Take care to not set our
1321 own ending address to our starting address, nor to set addresses on
1322 `dependency' files that have both textlow and texthigh zero. */
1324 struct partial_symtab
*p1
;
1326 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1327 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1328 p1
->texthigh
= pst
->textlow
;
1329 /* if this file has only data, then make textlow match texthigh */
1330 if (p1
->textlow
== 0)
1331 p1
->textlow
= p1
->texthigh
;
1336 /* End of kludge for patching Solaris textlow and texthigh. */
1337 #endif /* N_SO_ADDRESS_MAYBE_MISSING. */
1339 pst
->n_global_syms
=
1340 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1341 pst
->n_static_syms
=
1342 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1344 pst
->number_of_dependencies
= number_dependencies
;
1345 if (number_dependencies
)
1347 pst
->dependencies
= (struct partial_symtab
**)
1348 obstack_alloc (&objfile
->psymbol_obstack
,
1349 number_dependencies
* sizeof (struct partial_symtab
*));
1350 memcpy (pst
->dependencies
, dependency_list
,
1351 number_dependencies
* sizeof (struct partial_symtab
*));
1354 pst
->dependencies
= 0;
1356 for (i
= 0; i
< num_includes
; i
++)
1358 struct partial_symtab
*subpst
=
1359 allocate_psymtab (include_list
[i
], objfile
);
1361 subpst
->section_offsets
= pst
->section_offsets
;
1362 subpst
->read_symtab_private
=
1363 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1364 sizeof (struct symloc
));
1368 subpst
->texthigh
= 0;
1370 /* We could save slight bits of space by only making one of these,
1371 shared by the entire set of include files. FIXME-someday. */
1372 subpst
->dependencies
= (struct partial_symtab
**)
1373 obstack_alloc (&objfile
->psymbol_obstack
,
1374 sizeof (struct partial_symtab
*));
1375 subpst
->dependencies
[0] = pst
;
1376 subpst
->number_of_dependencies
= 1;
1378 subpst
->globals_offset
=
1379 subpst
->n_global_syms
=
1380 subpst
->statics_offset
=
1381 subpst
->n_static_syms
= 0;
1385 subpst
->read_symtab
= pst
->read_symtab
;
1388 sort_pst_symbols (pst
);
1390 /* If there is already a psymtab or symtab for a file of this name, remove it.
1391 (If there is a symtab, more drastic things also happen.)
1392 This happens in VxWorks. */
1393 free_named_symtabs (pst
->filename
);
1395 if (num_includes
== 0
1396 && number_dependencies
== 0
1397 && pst
->n_global_syms
== 0
1398 && pst
->n_static_syms
== 0)
1400 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1401 it is on the obstack, but we can forget to chain it on the list. */
1402 /* Empty psymtabs happen as a result of header files which don't have
1403 any symbols in them. There can be a lot of them. But this check
1404 is wrong, in that a psymtab with N_SLINE entries but nothing else
1405 is not empty, but we don't realize that. Fixing that without slowing
1406 things down might be tricky. */
1407 struct partial_symtab
*prev_pst
;
1409 /* First, snip it out of the psymtab chain */
1411 if (pst
->objfile
->psymtabs
== pst
)
1412 pst
->objfile
->psymtabs
= pst
->next
;
1414 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1415 if (prev_pst
->next
== pst
)
1416 prev_pst
->next
= pst
->next
;
1418 /* Next, put it on a free list for recycling */
1420 pst
->next
= pst
->objfile
->free_psymtabs
;
1421 pst
->objfile
->free_psymtabs
= pst
;
1423 /* Indicate that psymtab was thrown away. */
1424 pst
= (struct partial_symtab
*)NULL
;
1430 dbx_psymtab_to_symtab_1 (pst
)
1431 struct partial_symtab
*pst
;
1433 struct cleanup
*old_chain
;
1441 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1446 /* Read in all partial symtabs on which this one is dependent */
1447 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1448 if (!pst
->dependencies
[i
]->readin
)
1450 /* Inform about additional files that need to be read in. */
1453 fputs_filtered (" ", gdb_stdout
);
1455 fputs_filtered ("and ", gdb_stdout
);
1457 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1458 wrap_here (""); /* Flush output */
1459 gdb_flush (gdb_stdout
);
1461 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1464 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1466 /* Init stuff necessary for reading in symbols */
1469 old_chain
= make_cleanup (really_free_pendings
, 0);
1470 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1471 symbol_size
= SYMBOL_SIZE (pst
);
1473 /* Read in this file's symbols */
1474 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1475 read_ofile_symtab (pst
);
1476 sort_symtab_syms (pst
->symtab
);
1478 do_cleanups (old_chain
);
1484 /* Read in all of the symbols for a given psymtab for real.
1485 Be verbose about it if the user wants that. */
1488 dbx_psymtab_to_symtab (pst
)
1489 struct partial_symtab
*pst
;
1498 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1503 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1505 /* Print the message now, before reading the string table,
1506 to avoid disconcerting pauses. */
1509 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1510 gdb_flush (gdb_stdout
);
1513 sym_bfd
= pst
->objfile
->obfd
;
1515 next_symbol_text_func
= dbx_next_symbol_text
;
1517 dbx_psymtab_to_symtab_1 (pst
);
1519 /* Match with global symbols. This only needs to be done once,
1520 after all of the symtabs and dependencies have been read in. */
1521 scan_file_globals (pst
->objfile
);
1523 /* Finish up the debug error message. */
1525 printf_filtered ("done.\n");
1529 /* Read in a defined section of a specific object file's symbols. */
1532 read_ofile_symtab (pst
)
1533 struct partial_symtab
*pst
;
1535 register char *namestring
;
1536 register struct internal_nlist
*bufp
;
1538 unsigned max_symnum
;
1540 struct objfile
*objfile
;
1541 int sym_offset
; /* Offset to start of symbols to read */
1542 int sym_size
; /* Size of symbols to read */
1543 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1544 int text_size
; /* Size of text segment for symbols */
1545 struct section_offsets
*section_offsets
;
1547 objfile
= pst
->objfile
;
1548 sym_offset
= LDSYMOFF(pst
);
1549 sym_size
= LDSYMLEN(pst
);
1550 text_offset
= pst
->textlow
;
1551 text_size
= pst
->texthigh
- pst
->textlow
;
1552 section_offsets
= pst
->section_offsets
;
1554 current_objfile
= objfile
;
1555 subfile_stack
= NULL
;
1557 stringtab_global
= DBX_STRINGTAB (objfile
);
1558 last_source_file
= NULL
;
1560 abfd
= objfile
->obfd
;
1561 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1562 symbuf_end
= symbuf_idx
= 0;
1564 /* It is necessary to actually read one symbol *before* the start
1565 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1566 occurs before the N_SO symbol.
1568 Detecting this in read_dbx_symtab
1569 would slow down initial readin, so we look for it here instead. */
1570 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1572 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1574 bufp
= &symbuf
[symbuf_idx
++];
1575 SWAP_SYMBOL (bufp
, abfd
);
1579 processing_gcc_compilation
= 0;
1580 if (bufp
->n_type
== N_TEXT
)
1582 const char *tempstring
= namestring
;
1584 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1585 processing_gcc_compilation
= 1;
1586 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1587 processing_gcc_compilation
= 2;
1588 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1590 if (STREQN (tempstring
, "__gnu_compiled", 14))
1591 processing_gcc_compilation
= 2;
1594 /* Try to select a C++ demangling based on the compilation unit
1597 if (processing_gcc_compilation
)
1599 if (AUTO_DEMANGLING
)
1601 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1607 /* The N_SO starting this symtab is the first symbol, so we
1608 better not check the symbol before it. I'm not this can
1609 happen, but it doesn't hurt to check for it. */
1610 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1611 processing_gcc_compilation
= 0;
1614 if (symbuf_idx
== symbuf_end
)
1616 bufp
= &symbuf
[symbuf_idx
];
1617 if (bufp
->n_type
!= (unsigned char)N_SO
)
1618 error("First symbol in segment of executable not a source symbol");
1620 max_symnum
= sym_size
/ symbol_size
;
1623 symnum
< max_symnum
;
1626 QUIT
; /* Allow this to be interruptable */
1627 if (symbuf_idx
== symbuf_end
)
1629 bufp
= &symbuf
[symbuf_idx
++];
1630 SWAP_SYMBOL (bufp
, abfd
);
1632 type
= bufp
->n_type
;
1636 if (type
& N_STAB
) {
1637 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1638 namestring
, section_offsets
, objfile
);
1640 /* We skip checking for a new .o or -l file; that should never
1641 happen in this routine. */
1642 else if (type
== N_TEXT
)
1644 /* I don't think this code will ever be executed, because
1645 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1646 the N_SO symbol which starts this source file.
1647 However, there is no reason not to accept
1648 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1650 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1651 processing_gcc_compilation
= 1;
1652 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1653 processing_gcc_compilation
= 2;
1655 if (AUTO_DEMANGLING
)
1657 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1660 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1661 || type
== (unsigned char)N_NBTEXT
1663 /* Global symbol: see if we came across a dbx defintion for
1664 a corresponding symbol. If so, store the value. Remove
1665 syms from the chain when their values are stored, but
1666 search the whole chain, as there may be several syms from
1667 different files with the same name. */
1668 /* This is probably not true. Since the files will be read
1669 in one at a time, each reference to a global symbol will
1670 be satisfied in each file as it appears. So we skip this
1676 current_objfile
= NULL
;
1678 /* In a Solaris elf file, this variable, which comes from the
1679 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1680 which comes from pst->textlow is correct. */
1681 if (last_source_start_addr
== 0)
1682 last_source_start_addr
= text_offset
;
1684 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1690 /* This handles a single symbol from the symbol-file, building symbols
1691 into a GDB symtab. It takes these arguments and an implicit argument.
1693 TYPE is the type field of the ".stab" symbol entry.
1694 DESC is the desc field of the ".stab" entry.
1695 VALU is the value field of the ".stab" entry.
1696 NAME is the symbol name, in our address space.
1697 SECTION_OFFSETS is a set of amounts by which the sections of this object
1698 file were relocated when it was loaded into memory.
1699 All symbols that refer
1700 to memory locations need to be offset by these amounts.
1701 OBJFILE is the object file from which we are reading symbols.
1702 It is used in end_symtab. */
1705 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1709 struct section_offsets
*section_offsets
;
1710 struct objfile
*objfile
;
1712 #ifdef SUN_FIXED_LBRAC_BUG
1713 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1714 to correct the address of N_LBRAC's. If it is not defined, then
1715 we never need to correct the addresses. */
1717 /* This records the last pc address we've seen. We depend on there being
1718 an SLINE or FUN or SO before the first LBRAC, since the variable does
1719 not get reset in between reads of different symbol files. */
1720 static CORE_ADDR last_pc_address
;
1723 register struct context_stack
*new;
1724 /* This remembers the address of the start of a function. It is used
1725 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1726 relative to the current function's start address. On systems
1727 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1728 used to relocate these symbol types rather than SECTION_OFFSETS. */
1729 static CORE_ADDR function_start_offset
;
1731 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1732 file. Used to detect the SunPRO solaris compiler. */
1733 static int n_opt_found
;
1735 /* The stab type used for the definition of the last function.
1736 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1737 static int function_stab_type
= 0;
1739 if (!block_address_function_relative
)
1740 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1741 function start address, so just use the text offset. */
1742 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1744 /* Something is wrong if we see real data before
1745 seeing a source file name. */
1747 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1749 /* Ignore any symbols which appear before an N_SO symbol. Currently
1750 no one puts symbols there, but we should deal gracefully with the
1751 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1752 but this should not be an error (). */
1760 /* Relocate for dynamic loading */
1761 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1762 goto define_a_symbol
;
1765 /* This "symbol" just indicates the start of an inner lexical
1766 context within a function. */
1768 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1769 /* Relocate for dynamic loading (?). */
1770 valu
+= function_start_offset
;
1772 if (block_address_function_relative
)
1773 /* Relocate for Sun ELF acc fn-relative syms. */
1774 valu
+= function_start_offset
;
1776 /* On most machines, the block addresses are relative to the
1777 N_SO, the linker did not relocate them (sigh). */
1778 valu
+= last_source_start_addr
;
1781 #ifdef SUN_FIXED_LBRAC_BUG
1782 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1783 /* Patch current LBRAC pc value to match last handy pc value */
1784 complain (&lbrac_complaint
);
1785 valu
= last_pc_address
;
1788 new = push_context (desc
, valu
);
1792 /* This "symbol" just indicates the end of an inner lexical
1793 context that was started with N_LBRAC. */
1795 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1796 /* Relocate for dynamic loading (?). */
1797 valu
+= function_start_offset
;
1799 if (block_address_function_relative
)
1800 /* Relocate for Sun ELF acc fn-relative syms. */
1801 valu
+= function_start_offset
;
1803 /* On most machines, the block addresses are relative to the
1804 N_SO, the linker did not relocate them (sigh). */
1805 valu
+= last_source_start_addr
;
1808 new = pop_context();
1809 if (desc
!= new->depth
)
1810 complain (&lbrac_mismatch_complaint
, symnum
);
1812 /* Some compilers put the variable decls inside of an
1813 LBRAC/RBRAC block. This macro should be nonzero if this
1814 is true. DESC is N_DESC from the N_RBRAC symbol.
1815 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1816 or the GCC2_COMPILED_SYMBOL. */
1817 #if !defined (VARIABLES_INSIDE_BLOCK)
1818 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1821 /* Can only use new->locals as local symbols here if we're in
1822 gcc or on a machine that puts them before the lbrack. */
1823 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1824 local_symbols
= new->locals
;
1826 if (context_stack_depth
1827 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1829 /* This is not the outermost LBRAC...RBRAC pair in the function,
1830 its local symbols preceded it, and are the ones just recovered
1831 from the context stack. Define the block for them (but don't
1832 bother if the block contains no symbols. Should we complain
1833 on blocks without symbols? I can't think of any useful purpose
1835 if (local_symbols
!= NULL
)
1837 /* Muzzle a compiler bug that makes end < start. (which
1838 compilers? Is this ever harmful?). */
1839 if (new->start_addr
> valu
)
1841 complain (&lbrac_rbrac_complaint
);
1842 new->start_addr
= valu
;
1844 /* Make a block for the local symbols within. */
1845 finish_block (0, &local_symbols
, new->old_blocks
,
1846 new->start_addr
, valu
, objfile
);
1851 /* This is the outermost LBRAC...RBRAC pair. There is no
1852 need to do anything; leave the symbols that preceded it
1853 to be attached to the function's own block. We need to
1854 indicate that we just moved outside of the function. */
1855 within_function
= 0;
1858 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1859 /* Now pop locals of block just finished. */
1860 local_symbols
= new->locals
;
1865 /* This kind of symbol indicates the start of an object file. */
1866 /* Relocate for dynamic loading */
1867 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1871 /* This type of symbol indicates the start of data
1872 for one source file.
1873 Finish the symbol table of the previous source file
1874 (if any) and start accumulating a new symbol table. */
1875 /* Relocate for dynamic loading */
1876 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1880 #ifdef SUN_FIXED_LBRAC_BUG
1881 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1884 #ifdef PCC_SOL_BROKEN
1885 /* pcc bug, occasionally puts out SO for SOL. */
1886 if (context_stack_depth
> 0)
1888 start_subfile (name
, NULL
);
1892 if (last_source_file
)
1894 /* Check if previous symbol was also an N_SO (with some
1895 sanity checks). If so, that one was actually the directory
1896 name, and the current one is the real file name.
1898 if (previous_stab_code
== (unsigned char) N_SO
)
1900 patch_subfile_names (current_subfile
, name
);
1901 break; /* Ignore repeated SOs */
1903 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1907 /* Null name means this just marks the end of text for this .o file.
1908 Don't start a new symtab in this case. */
1909 if (*name
== '\000')
1913 start_symtab (name
, NULL
, valu
);
1917 /* This type of symbol indicates the start of data for
1918 a sub-source-file, one whose contents were copied or
1919 included in the compilation of the main source file
1920 (whose name was given in the N_SO symbol.) */
1921 /* Relocate for dynamic loading */
1922 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1923 start_subfile (name
, current_subfile
->dirname
);
1928 add_new_header_file (name
, valu
);
1929 start_subfile (name
, current_subfile
->dirname
);
1933 start_subfile (pop_subfile (), current_subfile
->dirname
);
1937 add_old_header_file (name
, valu
);
1941 /* This type of "symbol" really just records
1942 one line-number -- core-address correspondence.
1943 Enter it in the line list for this symbol table. */
1944 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1945 valu
+= function_start_offset
;
1946 #ifdef SUN_FIXED_LBRAC_BUG
1947 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1949 record_line (current_subfile
, desc
, valu
);
1953 common_block_start (name
, objfile
);
1957 common_block_end (objfile
);
1960 /* The following symbol types need to have the appropriate offset added
1961 to their value; then we process symbol definitions in the name. */
1963 case N_STSYM
: /* Static symbol in data seg */
1964 case N_LCSYM
: /* Static symbol in BSS seg */
1965 case N_ROSYM
: /* Static symbol in Read-only data seg */
1966 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1967 Solaris2's stabs-in-elf makes *most* symbols relative
1968 but leaves a few absolute (at least for Solaris 2.1 and version
1969 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1970 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1971 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1972 This leaves us no choice but to search for the 'S' or 'V'...
1973 (or pass the whole section_offsets stuff down ONE MORE function
1974 call level, which we really don't want to do). */
1978 /* .o files and NLMs have non-zero text seg offsets, but don't need
1979 their static syms offset in this fashion. XXX - This is really a
1980 crock that should be fixed in the solib handling code so that I
1981 don't have to work around it here. */
1983 if (!symfile_relocatable
)
1985 p
= strchr (name
, ':');
1986 if (p
!= 0 && p
[1] == 'S')
1988 /* The linker relocated it. We don't want to add an
1989 elfstab_offset_sections-type offset, but we *do* want
1990 to add whatever solib.c passed to symbol_file_add as
1991 addr (this is known to affect SunOS4, and I suspect ELF
1992 too). Since elfstab_offset_sections currently does not
1993 muck with the text offset (there is no Ttext.text
1994 symbol), we can get addr from the text offset. If
1995 elfstab_offset_sections ever starts dealing with the
1996 text offset, and we still need to do this, we need to
1997 invent a SECT_OFF_ADDR_KLUDGE or something. */
1998 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1999 goto define_a_symbol
;
2002 /* Since it's not the kludge case, re-dispatch to the right handler. */
2004 case N_STSYM
: goto case_N_STSYM
;
2005 case N_LCSYM
: goto case_N_LCSYM
;
2006 case N_ROSYM
: goto case_N_ROSYM
;
2011 case_N_STSYM
: /* Static symbol in data seg */
2012 case N_DSLINE
: /* Source line number, data seg */
2013 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2014 goto define_a_symbol
;
2016 case_N_LCSYM
: /* Static symbol in BSS seg */
2017 case N_BSLINE
: /* Source line number, bss seg */
2018 /* N_BROWS: overlaps with N_BSLINE */
2019 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2020 goto define_a_symbol
;
2022 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2023 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2024 goto define_a_symbol
;
2026 case N_ENTRY
: /* Alternate entry point */
2027 /* Relocate for dynamic loading */
2028 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2029 goto define_a_symbol
;
2031 /* The following symbol types we don't know how to process. Handle
2032 them in a "default" way, but complain to people who care. */
2034 case N_CATCH
: /* Exception handler catcher */
2035 case N_EHDECL
: /* Exception handler name */
2036 case N_PC
: /* Global symbol in Pascal */
2037 case N_M2C
: /* Modula-2 compilation unit */
2038 /* N_MOD2: overlaps with N_EHDECL */
2039 case N_SCOPE
: /* Modula-2 scope information */
2040 case N_ECOML
: /* End common (local name) */
2041 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2046 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2049 /* The following symbol types don't need the address field relocated,
2050 since it is either unused, or is absolute. */
2052 case N_GSYM
: /* Global variable */
2053 case N_NSYMS
: /* Number of symbols (ultrix) */
2054 case N_NOMAP
: /* No map? (ultrix) */
2055 case N_RSYM
: /* Register variable */
2056 case N_DEFD
: /* Modula-2 GNU module dependency */
2057 case N_SSYM
: /* Struct or union element */
2058 case N_LSYM
: /* Local symbol in stack */
2059 case N_PSYM
: /* Parameter variable */
2060 case N_LENG
: /* Length of preceding symbol type */
2064 char *colon_pos
= strchr (name
, ':');
2065 if (colon_pos
== NULL
)
2068 deftype
= colon_pos
[1];
2074 function_stab_type
= type
;
2076 #ifdef SUN_FIXED_LBRAC_BUG
2077 /* The Sun acc compiler, under SunOS4, puts out
2078 functions with N_GSYM or N_STSYM. The problem is
2079 that the address of the symbol is no good (for N_GSYM
2080 it doesn't even attept an address; for N_STSYM it
2081 puts out an address but then it gets relocated
2082 relative to the data segment, not the text segment).
2083 Currently we can't fix this up later as we do for
2084 some types of symbol in scan_file_globals.
2085 Fortunately we do have a way of finding the address -
2086 we know that the value in last_pc_address is either
2087 the one we want (if we're dealing with the first
2088 function in an object file), or somewhere in the
2089 previous function. This means that we can use the
2090 minimal symbol table to get the address. */
2092 /* On solaris up to 2.2, the N_FUN stab gets relocated.
2093 On Solaris 2.3, ld no longer relocates stabs (which
2094 is good), and the N_FUN's value is now always zero.
2095 The following code can't deal with this, because
2096 last_pc_address depends on getting the address from a
2097 N_SLINE or some such and in Solaris those are function
2098 relative. Best fix is probably to create a Ttext.text symbol
2099 and handle this like Ddata.data and so on. */
2101 if (type
== N_GSYM
|| type
== N_STSYM
)
2103 struct minimal_symbol
*m
;
2104 int l
= colon_pos
- name
;
2106 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2107 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
2108 /* last_pc_address was in this function */
2109 valu
= SYMBOL_VALUE (m
);
2110 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
2111 /* last_pc_address was in last function */
2112 valu
= SYMBOL_VALUE (m
+1);
2114 /* Not found - use last_pc_address (for finish_block) */
2115 valu
= last_pc_address
;
2118 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2121 if (block_address_function_relative
)
2122 /* For Solaris 2.0 compilers, the block addresses and
2123 N_SLINE's are relative to the start of the
2124 function. On normal systems, and when using gcc on
2125 Solaris 2.0, these addresses are just absolute, or
2126 relative to the N_SO, depending on
2127 BLOCK_ADDRESS_ABSOLUTE. */
2128 function_start_offset
= valu
;
2130 within_function
= 1;
2131 if (context_stack_depth
> 0)
2133 new = pop_context ();
2134 /* Make a block for the local symbols within. */
2135 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2136 new->start_addr
, valu
, objfile
);
2138 /* Stack must be empty now. */
2139 if (context_stack_depth
!= 0)
2140 complain (&lbrac_unmatched_complaint
, symnum
);
2142 new = push_context (0, valu
);
2143 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2147 define_symbol (valu
, name
, desc
, type
, objfile
);
2153 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2154 for a bunch of other flags, too. Someday we may parse their
2155 flags; for now we ignore theirs and hope they'll ignore ours. */
2156 case N_OPT
: /* Solaris 2: Compiler options */
2159 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2161 processing_gcc_compilation
= 2;
2162 #if 1 /* Works, but is experimental. -fnf */
2163 if (AUTO_DEMANGLING
)
2165 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2174 /* The following symbol types can be ignored. */
2175 case N_OBJ
: /* Solaris 2: Object file dir and name */
2176 /* N_UNDF: Solaris 2: file separator mark */
2177 /* N_UNDF: -- we will never encounter it, since we only process one
2178 file's symbols at once. */
2179 case N_ENDM
: /* Solaris 2: End of module */
2180 case N_MAIN
: /* Name of main routine. */
2184 previous_stab_code
= type
;
2187 /* FIXME: The only difference between this and elfstab_build_psymtabs is
2188 the call to install_minimal_symbols for elf. If the differences are
2189 really that small, the code should be shared. */
2191 /* Scan and build partial symbols for an coff symbol file.
2192 The coff file has already been processed to get its minimal symbols.
2194 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2197 OBJFILE is the object file we are reading symbols from.
2198 ADDR is the address relative to which the symbols are (e.g.
2199 the base address of the text segment).
2200 MAINLINE is true if we are reading the main symbol
2201 table (as opposed to a shared lib or dynamically loaded file).
2202 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2204 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2205 .stabstr section exists.
2207 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2208 adjusted for coff details. */
2211 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2212 staboffset
, stabsize
,
2213 stabstroffset
, stabstrsize
)
2214 struct objfile
*objfile
;
2215 struct section_offsets
*section_offsets
;
2217 file_ptr staboffset
;
2218 unsigned int stabsize
;
2219 file_ptr stabstroffset
;
2220 unsigned int stabstrsize
;
2223 bfd
*sym_bfd
= objfile
->obfd
;
2224 char *name
= bfd_get_filename (sym_bfd
);
2225 struct dbx_symfile_info
*info
;
2227 /* There is already a dbx_symfile_info allocated by our caller.
2228 It might even contain some info from the coff symtab to help us. */
2229 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2231 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2232 if (!DBX_TEXT_SECT (objfile
))
2233 error ("Can't find .text section in symbol file");
2235 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2236 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2237 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2238 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2239 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2241 if (stabstrsize
> bfd_get_size (sym_bfd
))
2242 error ("ridiculous string table size: %d bytes", stabstrsize
);
2243 DBX_STRINGTAB (objfile
) = (char *)
2244 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2246 /* Now read in the string table in one big gulp. */
2248 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2250 perror_with_name (name
);
2251 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2252 if (val
!= stabstrsize
)
2253 perror_with_name (name
);
2255 stabsread_new_init ();
2256 buildsym_new_init ();
2257 free_header_files ();
2258 init_header_files ();
2260 processing_acc_compilation
= 1;
2262 /* In a coff file, we've already installed the minimal symbols that came
2263 from the coff (non-stab) symbol table, so always act like an
2264 incremental load here. */
2265 dbx_symfile_read (objfile
, section_offsets
, 0);
2268 /* Scan and build partial symbols for an ELF symbol file.
2269 This ELF file has already been processed to get its minimal symbols,
2270 and any DWARF symbols that were in it.
2272 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2275 OBJFILE is the object file we are reading symbols from.
2276 ADDR is the address relative to which the symbols are (e.g.
2277 the base address of the text segment).
2278 MAINLINE is true if we are reading the main symbol
2279 table (as opposed to a shared lib or dynamically loaded file).
2280 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2282 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2283 .stabstr section exists.
2285 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2286 adjusted for elf details. */
2289 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2290 staboffset
, stabsize
,
2291 stabstroffset
, stabstrsize
)
2292 struct objfile
*objfile
;
2293 struct section_offsets
*section_offsets
;
2295 file_ptr staboffset
;
2296 unsigned int stabsize
;
2297 file_ptr stabstroffset
;
2298 unsigned int stabstrsize
;
2301 bfd
*sym_bfd
= objfile
->obfd
;
2302 char *name
= bfd_get_filename (sym_bfd
);
2303 struct dbx_symfile_info
*info
;
2305 /* There is already a dbx_symfile_info allocated by our caller.
2306 It might even contain some info from the ELF symtab to help us. */
2307 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2309 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2310 if (!DBX_TEXT_SECT (objfile
))
2311 error ("Can't find .text section in symbol file");
2313 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2314 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2315 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2316 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2317 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2319 if (stabstrsize
> bfd_get_size (sym_bfd
))
2320 error ("ridiculous string table size: %d bytes", stabstrsize
);
2321 DBX_STRINGTAB (objfile
) = (char *)
2322 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2324 /* Now read in the string table in one big gulp. */
2326 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2328 perror_with_name (name
);
2329 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2330 if (val
!= stabstrsize
)
2331 perror_with_name (name
);
2333 stabsread_new_init ();
2334 buildsym_new_init ();
2335 free_header_files ();
2336 init_header_files ();
2337 install_minimal_symbols (objfile
);
2339 processing_acc_compilation
= 1;
2341 /* In an elf file, we've already installed the minimal symbols that came
2342 from the elf (non-stab) symbol table, so always act like an
2343 incremental load here. */
2344 dbx_symfile_read (objfile
, section_offsets
, 0);
2347 /* Scan and build partial symbols for a file with special sections for stabs
2348 and stabstrings. The file has already been processed to get its minimal
2349 symbols, and any other symbols that might be necessary to resolve GSYMs.
2351 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2354 OBJFILE is the object file we are reading symbols from.
2355 ADDR is the address relative to which the symbols are (e.g. the base address
2356 of the text segment).
2357 MAINLINE is true if we are reading the main symbol table (as opposed to a
2358 shared lib or dynamically loaded file).
2359 STAB_NAME is the name of the section that contains the stabs.
2360 STABSTR_NAME is the name of the section that contains the stab strings.
2362 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2365 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2366 stabstr_name
, text_name
)
2367 struct objfile
*objfile
;
2368 struct section_offsets
*section_offsets
;
2375 bfd
*sym_bfd
= objfile
->obfd
;
2376 char *name
= bfd_get_filename (sym_bfd
);
2378 asection
*stabstrsect
;
2380 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2381 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2387 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2388 stab_name
, stabstr_name
);
2390 objfile
->sym_stab_info
= (PTR
) xmalloc (sizeof (struct dbx_symfile_info
));
2391 memset (DBX_SYMFILE_INFO (objfile
), 0, sizeof (struct dbx_symfile_info
));
2393 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, text_name
);
2394 if (!DBX_TEXT_SECT (objfile
))
2395 error ("Can't find %s section in symbol file", text_name
);
2397 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2398 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2399 / DBX_SYMBOL_SIZE (objfile
);
2400 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2401 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2403 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2404 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2405 DBX_STRINGTAB (objfile
) = (char *)
2406 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2408 /* Now read in the string table in one big gulp. */
2410 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2411 stabstrsect
, /* bfd section */
2412 DBX_STRINGTAB (objfile
), /* input buffer */
2413 0, /* offset into section */
2414 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2417 perror_with_name (name
);
2419 stabsread_new_init ();
2420 buildsym_new_init ();
2421 free_header_files ();
2422 init_header_files ();
2423 install_minimal_symbols (objfile
);
2425 /* Now, do an incremental load */
2427 processing_acc_compilation
= 1;
2428 dbx_symfile_read (objfile
, section_offsets
, 0);
2431 /* Parse the user's idea of an offset for dynamic linking, into our idea
2432 of how to represent it for fast symbol reading. */
2434 static struct section_offsets
*
2435 dbx_symfile_offsets (objfile
, addr
)
2436 struct objfile
*objfile
;
2439 struct section_offsets
*section_offsets
;
2442 objfile
->num_sections
= SECT_OFF_MAX
;
2443 section_offsets
= (struct section_offsets
*)
2444 obstack_alloc (&objfile
-> psymbol_obstack
,
2445 sizeof (struct section_offsets
)
2446 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2448 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2449 ANOFFSET (section_offsets
, i
) = addr
;
2451 return section_offsets
;
2454 static struct sym_fns aout_sym_fns
=
2456 bfd_target_aout_flavour
,
2457 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2458 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2459 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2460 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2461 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2462 NULL
/* next: pointer to next struct sym_fns */
2466 _initialize_dbxread ()
2468 add_symtab_fns(&aout_sym_fns
);