1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993
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 /* This is the lowest text address we have yet encountered. */
143 static CORE_ADDR lowest_text_address
;
145 /* Complaints about the symbols we have encountered. */
147 struct complaint lbrac_complaint
=
148 {"bad block start address patched", 0, 0};
150 struct complaint string_table_offset_complaint
=
151 {"bad string table offset in symbol %d", 0, 0};
153 struct complaint unknown_symtype_complaint
=
154 {"unknown symbol type %s", 0, 0};
156 struct complaint unknown_symchar_complaint
=
157 {"unknown symbol descriptor `%c'", 0, 0};
159 struct complaint lbrac_rbrac_complaint
=
160 {"block start larger than block end", 0, 0};
162 struct complaint lbrac_unmatched_complaint
=
163 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
165 struct complaint lbrac_mismatch_complaint
=
166 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
168 struct complaint repeated_header_complaint
=
169 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
171 struct complaint repeated_header_name_complaint
=
172 {"\"repeated\" header file not previously seen, named %s", 0, 0};
174 /* During initial symbol readin, we need to have a structure to keep
175 track of which psymtabs have which bincls in them. This structure
176 is used during readin to setup the list of dependencies within each
177 partial symbol table. */
179 struct header_file_location
181 char *name
; /* Name of header file */
182 int instance
; /* See above */
183 struct partial_symtab
*pst
; /* Partial symtab that has the
184 BINCL/EINCL defs for this file */
187 /* The actual list and controling variables */
188 static struct header_file_location
*bincl_list
, *next_bincl
;
189 static int bincls_allocated
;
191 /* Local function prototypes */
194 free_header_files
PARAMS ((void));
197 init_header_files
PARAMS ((void));
200 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
203 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
206 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
209 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
210 struct objfile
*objfile
));
213 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
217 free_bincl_list
PARAMS ((struct objfile
*));
219 static struct partial_symtab
*
220 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
223 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
226 init_bincl_list
PARAMS ((int, struct objfile
*));
229 init_psymbol_list
PARAMS ((struct objfile
*));
232 dbx_next_symbol_text
PARAMS ((void));
235 fill_symbuf
PARAMS ((bfd
*));
238 dbx_symfile_init
PARAMS ((struct objfile
*));
241 dbx_new_init
PARAMS ((struct objfile
*));
244 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
247 dbx_symfile_finish
PARAMS ((struct objfile
*));
250 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
253 add_new_header_file
PARAMS ((char *, int));
256 add_old_header_file
PARAMS ((char *, int));
259 add_this_object_header_file
PARAMS ((int));
261 /* Free up old header file tables */
268 if (header_files
!= NULL
)
270 for (i
= 0; i
< n_header_files
; i
++)
272 free (header_files
[i
].name
);
274 free ((PTR
)header_files
);
278 if (this_object_header_files
)
280 free ((PTR
)this_object_header_files
);
281 this_object_header_files
= NULL
;
283 n_allocated_header_files
= 0;
284 n_allocated_this_object_header_files
= 0;
287 /* Allocate new header file tables */
293 n_allocated_header_files
= 10;
294 header_files
= (struct header_file
*)
295 xmalloc (10 * sizeof (struct header_file
));
297 n_allocated_this_object_header_files
= 10;
298 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
301 /* Add header file number I for this object file
302 at the next successive FILENUM. */
305 add_this_object_header_file (i
)
308 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
310 n_allocated_this_object_header_files
*= 2;
311 this_object_header_files
312 = (int *) xrealloc ((char *) this_object_header_files
,
313 n_allocated_this_object_header_files
* sizeof (int));
316 this_object_header_files
[n_this_object_header_files
++] = i
;
319 /* Add to this file an "old" header file, one already seen in
320 a previous object file. NAME is the header file's name.
321 INSTANCE is its instance code, to select among multiple
322 symbol tables for the same header file. */
325 add_old_header_file (name
, instance
)
329 register struct header_file
*p
= header_files
;
332 for (i
= 0; i
< n_header_files
; i
++)
333 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
335 add_this_object_header_file (i
);
338 complain (&repeated_header_complaint
, symnum
);
339 complain (&repeated_header_name_complaint
, name
);
342 /* Add to this file a "new" header file: definitions for its types follow.
343 NAME is the header file's name.
344 Most often this happens only once for each distinct header file,
345 but not necessarily. If it happens more than once, INSTANCE has
346 a different value each time, and references to the header file
347 use INSTANCE values to select among them.
349 dbx output contains "begin" and "end" markers for each new header file,
350 but at this level we just need to know which files there have been;
351 so we record the file when its "begin" is seen and ignore the "end". */
354 add_new_header_file (name
, instance
)
360 /* Make sure there is room for one more header file. */
362 if (n_header_files
== n_allocated_header_files
)
364 n_allocated_header_files
*= 2;
365 header_files
= (struct header_file
*)
366 xrealloc ((char *) header_files
,
367 (n_allocated_header_files
* sizeof (struct header_file
)));
370 /* Create an entry for this header file. */
372 i
= n_header_files
++;
373 header_files
[i
].name
= savestring (name
, strlen(name
));
374 header_files
[i
].instance
= instance
;
375 header_files
[i
].length
= 10;
376 header_files
[i
].vector
377 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
378 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
380 add_this_object_header_file (i
);
384 static struct type
**
385 explicit_lookup_type (real_filenum
, index
)
386 int real_filenum
, index
;
388 register struct header_file
*f
= &header_files
[real_filenum
];
390 if (index
>= f
->length
)
393 f
->vector
= (struct type
**)
394 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
395 memset (&f
->vector
[f
->length
/ 2],
396 '\0', f
->length
* sizeof (struct type
*) / 2);
398 return &f
->vector
[index
];
403 record_minimal_symbol (name
, address
, type
, objfile
)
407 struct objfile
*objfile
;
409 enum minimal_symbol_type ms_type
;
413 case N_TEXT
| N_EXT
: ms_type
= mst_text
; break;
414 case N_DATA
| N_EXT
: ms_type
= mst_data
; break;
415 case N_BSS
| N_EXT
: ms_type
= mst_bss
; break;
416 case N_ABS
| N_EXT
: ms_type
= mst_abs
; break;
418 case N_SETV
| N_EXT
: ms_type
= mst_data
; break;
420 /* I don't think this type actually exists; since a N_SETV is the result
421 of going over many .o files, it doesn't make sense to have one
423 ms_type
= mst_file_data
;
430 ms_type
= mst_file_text
;
434 ms_type
= mst_file_data
;
436 /* Check for __DYNAMIC, which is used by Sun shared libraries.
437 Record it as global even if it's local, not global, so
438 lookup_minimal_symbol can find it. We don't check symbol_leading_char
439 because for SunOS4 it always is '_'. */
440 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
443 /* Same with virtual function tables, both global and static. */
445 char *tempstring
= name
;
446 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
448 if (VTBL_PREFIX_P ((tempstring
)))
454 ms_type
= mst_file_bss
;
457 default: ms_type
= mst_unknown
; break;
460 if (ms_type
== mst_file_text
|| ms_type
== mst_text
461 && address
< lowest_text_address
)
462 lowest_text_address
= address
;
464 prim_record_minimal_symbol
465 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
471 /* Scan and build partial symbols for a symbol file.
472 We have been initialized by a call to dbx_symfile_init, which
473 put all the relevant info into a "struct dbx_symfile_info",
474 hung off the objfile structure.
476 SECTION_OFFSETS contains offsets relative to which the symbols in the
477 various sections are (depending where the sections were actually loaded).
478 MAINLINE is true if we are reading the main symbol
479 table (as opposed to a shared lib or dynamically loaded file). */
482 dbx_symfile_read (objfile
, section_offsets
, mainline
)
483 struct objfile
*objfile
;
484 struct section_offsets
*section_offsets
;
485 int mainline
; /* FIXME comments above */
489 struct cleanup
*back_to
;
491 sym_bfd
= objfile
->obfd
;
492 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
494 perror_with_name (objfile
->name
);
496 /* If we are reinitializing, or if we have never loaded syms yet, init */
497 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
498 init_psymbol_list (objfile
);
500 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
501 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
504 back_to
= make_cleanup (really_free_pendings
, 0);
506 init_minimal_symbol_collection ();
507 make_cleanup (discard_minimal_symbols
, 0);
509 /* Now that the symbol table data of the executable file are all in core,
510 process them and define symbols accordingly. */
512 read_dbx_symtab (section_offsets
, objfile
,
513 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
514 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
516 /* Add the dynamic symbols if we are reading the main symbol table. */
519 read_dbx_dynamic_symtab (section_offsets
, objfile
);
521 /* Install any minimal symbols that have been collected as the current
522 minimal symbols for this objfile. */
524 install_minimal_symbols (objfile
);
526 if (!have_partial_symbols ()) {
528 printf_filtered ("(no debugging symbols found)...");
532 do_cleanups (back_to
);
535 /* Initialize anything that needs initializing when a completely new
536 symbol file is specified (not just adding some symbols from another
537 file, e.g. a shared library). */
540 dbx_new_init (ignore
)
541 struct objfile
*ignore
;
543 stabsread_new_init ();
544 buildsym_new_init ();
545 init_header_files ();
549 /* dbx_symfile_init ()
550 is the dbx-specific initialization routine for reading symbols.
551 It is passed a struct objfile which contains, among other things,
552 the BFD for the file whose symbols are being read, and a slot for a pointer
553 to "private data" which we fill with goodies.
555 We read the string table into malloc'd space and stash a pointer to it.
557 Since BFD doesn't know how to read debug symbols in a format-independent
558 way (and may never do so...), we have to do it ourselves. We will never
559 be called unless this is an a.out (or very similar) file.
560 FIXME, there should be a cleaner peephole into the BFD environment here. */
562 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
565 dbx_symfile_init (objfile
)
566 struct objfile
*objfile
;
569 bfd
*sym_bfd
= objfile
->obfd
;
570 char *name
= bfd_get_filename (sym_bfd
);
571 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
573 /* Allocate struct to keep track of the symfile */
574 objfile
->sym_stab_info
= (PTR
)
575 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
577 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
578 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
579 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
581 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
583 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
584 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
585 if (!DBX_TEXT_SECT (objfile
))
586 error ("Can't find .text section in symbol file");
588 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
589 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
590 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
592 /* Read the string table and stash it away in the psymbol_obstack. It is
593 only needed as long as we need to expand psymbols into full symbols,
594 so when we blow away the psymbol the string table goes away as well.
595 Note that gdb used to use the results of attempting to malloc the
596 string table, based on the size it read, as a form of sanity check
597 for botched byte swapping, on the theory that a byte swapped string
598 table size would be so totally bogus that the malloc would fail. Now
599 that we put in on the psymbol_obstack, we can't do this since gdb gets
600 a fatal error (out of virtual memory) if the size is bogus. We can
601 however at least check to see if the size is less than the size of
602 the size field itself, or larger than the size of the entire file.
603 Note that all valid string tables have a size greater than zero, since
604 the bytes used to hold the size are included in the count. */
606 if (STRING_TABLE_OFFSET
== 0)
608 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
609 will never be zero, even when there is no string table. This
610 would appear to be a bug in bfd. */
611 DBX_STRINGTAB_SIZE (objfile
) = 0;
612 DBX_STRINGTAB (objfile
) = NULL
;
616 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
618 perror_with_name (name
);
620 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
621 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
624 perror_with_name (name
);
628 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
629 EOF if there is no string table, and attempting to read the size
630 from EOF will read zero bytes. */
631 DBX_STRINGTAB_SIZE (objfile
) = 0;
632 DBX_STRINGTAB (objfile
) = NULL
;
636 /* Read some data that would appear to be the string table size.
637 If there really is a string table, then it is probably the right
638 size. Byteswap if necessary and validate the size. Note that
639 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
640 random data that happened to be at STRING_TABLE_OFFSET, because
641 bfd can't tell us there is no string table, the sanity checks may
642 or may not catch this. */
643 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
645 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
646 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
647 error ("ridiculous string table size (%d bytes).",
648 DBX_STRINGTAB_SIZE (objfile
));
650 DBX_STRINGTAB (objfile
) =
651 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
652 DBX_STRINGTAB_SIZE (objfile
));
654 /* Now read in the string table in one big gulp. */
656 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
658 perror_with_name (name
);
659 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
661 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
662 perror_with_name (name
);
667 /* Perform any local cleanups required when we are done with a particular
668 objfile. I.E, we are in the process of discarding all symbol information
669 for an objfile, freeing up all memory held for it, and unlinking the
670 objfile struct from the global list of known objfiles. */
673 dbx_symfile_finish (objfile
)
674 struct objfile
*objfile
;
676 if (objfile
->sym_stab_info
!= NULL
)
678 mfree (objfile
-> md
, objfile
->sym_stab_info
);
680 free_header_files ();
684 /* Buffer for reading the symbol table entries. */
685 static struct internal_nlist symbuf
[4096];
686 static int symbuf_idx
;
687 static int symbuf_end
;
689 /* Name of last function encountered. Used in Solaris to approximate
690 object file boundaries. */
691 static char *last_function_name
;
693 /* The address in memory of the string table of the object file we are
694 reading (which might not be the "main" object file, but might be a
695 shared library or some other dynamically loaded thing). This is set
696 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
697 when building symtabs, and is used only by next_symbol_text. */
698 static char *stringtab_global
;
700 /* Refill the symbol table input buffer
701 and set the variables that control fetching entries from it.
702 Reports an error if no data available.
703 This function can read past the end of the symbol table
704 (into the string table) but this does no harm. */
707 fill_symbuf (sym_bfd
)
710 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
712 perror_with_name (bfd_get_filename (sym_bfd
));
713 else if (nbytes
== 0)
714 error ("Premature end of file reading symbol table");
715 symbuf_end
= nbytes
/ symbol_size
;
719 #define SWAP_SYMBOL(symp, abfd) \
721 (symp)->n_strx = bfd_h_get_32(abfd, \
722 (unsigned char *)&(symp)->n_strx); \
723 (symp)->n_desc = bfd_h_get_16 (abfd, \
724 (unsigned char *)&(symp)->n_desc); \
725 (symp)->n_value = bfd_h_get_32 (abfd, \
726 (unsigned char *)&(symp)->n_value); \
729 /* Invariant: The symbol pointed to by symbuf_idx is the first one
730 that hasn't been swapped. Swap the symbol at the same time
731 that symbuf_idx is incremented. */
733 /* dbx allows the text of a symbol name to be continued into the
734 next symbol name! When such a continuation is encountered
735 (a \ at the end of the text of a name)
736 call this function to get the continuation. */
739 dbx_next_symbol_text ()
741 if (symbuf_idx
== symbuf_end
)
742 fill_symbuf (symfile_bfd
);
744 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
745 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
746 + file_string_table_offset
;
749 /* Initializes storage for all of the partial symbols that will be
750 created by read_dbx_symtab and subsidiaries. */
753 init_psymbol_list (objfile
)
754 struct objfile
*objfile
;
756 /* Free any previously allocated psymbol lists. */
757 if (objfile
-> global_psymbols
.list
)
758 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
759 if (objfile
-> static_psymbols
.list
)
760 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
762 /* Current best guess is that there are approximately a twentieth
763 of the total symbols (in a debugging file) are global or static
765 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
766 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
767 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
768 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
769 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
770 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
773 /* Initialize the list of bincls to contain none and have some
777 init_bincl_list (number
, objfile
)
779 struct objfile
*objfile
;
781 bincls_allocated
= number
;
782 next_bincl
= bincl_list
= (struct header_file_location
*)
783 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
786 /* Add a bincl to the list. */
789 add_bincl_to_list (pst
, name
, instance
)
790 struct partial_symtab
*pst
;
794 if (next_bincl
>= bincl_list
+ bincls_allocated
)
796 int offset
= next_bincl
- bincl_list
;
797 bincls_allocated
*= 2;
798 bincl_list
= (struct header_file_location
*)
799 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
800 bincls_allocated
* sizeof (struct header_file_location
));
801 next_bincl
= bincl_list
+ offset
;
803 next_bincl
->pst
= pst
;
804 next_bincl
->instance
= instance
;
805 next_bincl
++->name
= name
;
808 /* Given a name, value pair, find the corresponding
809 bincl in the list. Return the partial symtab associated
810 with that header_file_location. */
812 static struct partial_symtab
*
813 find_corresponding_bincl_psymtab (name
, instance
)
817 struct header_file_location
*bincl
;
819 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
820 if (bincl
->instance
== instance
821 && STREQ (name
, bincl
->name
))
824 return (struct partial_symtab
*) 0;
827 /* Free the storage allocated for the bincl list. */
830 free_bincl_list (objfile
)
831 struct objfile
*objfile
;
833 mfree (objfile
-> md
, (PTR
)bincl_list
);
834 bincls_allocated
= 0;
837 /* Scan a SunOs dynamic symbol table for symbols of interest and
838 add them to the minimal symbol table. */
841 read_dbx_dynamic_symtab (section_offsets
, objfile
)
842 struct section_offsets
*section_offsets
;
843 struct objfile
*objfile
;
845 bfd
*abfd
= objfile
->obfd
;
847 bfd_size_type dynsym_count
= 0;
848 struct external_nlist
*dynsyms
= NULL
;
849 char *dynstrs
= NULL
;
850 bfd_size_type dynstr_size
;
851 struct external_nlist
*ext_symptr
;
852 bfd_byte
*ext_relptr
;
853 bfd_size_type dynrel_count
= 0;
859 /* Check that the symbol file has dynamic symbols that we know about.
860 bfd_arch_unknown can happen if we are reading a sun3 symbol file
861 on a sun4 host (and vice versa) and bfd is not configured
862 --with-target=all. This would trigger an assertion in bfd/sunos.c,
863 so we ignore the dynamic symbols in this case. */
864 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
865 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
866 || bfd_get_arch (abfd
) == bfd_arch_unknown
867 || aout_backend_info (abfd
)->read_dynamic_symbols
== NULL
)
870 dynsym_count
= ((*aout_backend_info (abfd
)->read_dynamic_symbols
)
871 (abfd
, &dynsyms
, &dynstrs
, &dynstr_size
));
872 if (dynsym_count
== (bfd_size_type
) -1)
875 /* Enter dynamic symbols into the minimal symbol table
876 if this is a stripped executable. */
877 if (bfd_get_symcount (abfd
) <= 0)
879 ext_symptr
= dynsyms
;
880 for (counter
= 0; counter
< dynsym_count
; counter
++, ext_symptr
++)
882 int type
= bfd_h_get_8 (abfd
, ext_symptr
->e_type
);
887 sym_value
= bfd_h_get_32 (abfd
, ext_symptr
->e_value
)
888 + ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
893 sym_value
= bfd_h_get_32 (abfd
, ext_symptr
->e_value
)
894 + ANOFFSET (section_offsets
, SECT_OFF_DATA
);
899 sym_value
= bfd_h_get_32 (abfd
, ext_symptr
->e_value
)
900 + ANOFFSET (section_offsets
, SECT_OFF_BSS
);
907 strx
= bfd_h_get_32 (abfd
, ext_symptr
->e_strx
);
908 if (strx
>= dynstr_size
)
910 complain (&string_table_offset_complaint
, counter
);
911 namestring
= "<bad dynamic string table offset>";
914 namestring
= strx
+ dynstrs
;
915 record_minimal_symbol (namestring
, sym_value
, type
, objfile
);
919 /* Symbols from shared libraries have a dynamic relocation entry
920 that points to the associated slot in the procedure linkage table.
921 We make a mininal symbol table entry with type mst_solib_trampoline
922 at the address in the procedure linkage table. */
923 if (aout_backend_info (abfd
)->read_dynamic_relocs
== NULL
)
926 dynrel_count
= ((*aout_backend_info (abfd
)->read_dynamic_relocs
)
928 if (dynrel_count
== (bfd_size_type
) -1)
931 for (counter
= 0, ext_relptr
= (bfd_byte
*) dynrels
;
932 counter
< dynrel_count
;
933 counter
++, ext_relptr
+= obj_reloc_entry_size (abfd
))
937 if (bfd_get_arch (abfd
) == bfd_arch_sparc
)
939 struct reloc_ext_external
*rptr
=
940 (struct reloc_ext_external
*) ext_relptr
;
943 r_type
= (rptr
->r_type
[0] & RELOC_EXT_BITS_TYPE_BIG
)
944 >> RELOC_EXT_BITS_TYPE_SH_BIG
;
946 if (r_type
!= RELOC_JMP_SLOT
)
949 r_index
= (rptr
->r_index
[0] << 16)
950 | (rptr
->r_index
[1] << 8)
953 sym_value
= bfd_h_get_32 (abfd
, rptr
->r_address
);
955 else if (bfd_get_arch (abfd
) == bfd_arch_m68k
)
957 struct reloc_std_external
*rptr
=
958 (struct reloc_std_external
*) ext_relptr
;
960 if ((rptr
->r_type
[0] & RELOC_STD_BITS_JMPTABLE_BIG
) == 0)
963 r_index
= (rptr
->r_index
[0] << 16)
964 | (rptr
->r_index
[1] << 8)
967 /* Adjust address in procedure linkage table to point to
968 the start of the bsr instruction. */
969 sym_value
= bfd_h_get_32 (abfd
, rptr
->r_address
) - 2;
976 if (r_index
>= dynsym_count
)
978 ext_symptr
= dynsyms
+ r_index
;
979 if (bfd_h_get_8 (abfd
, ext_symptr
->e_type
) != N_EXT
)
982 strx
= bfd_h_get_32 (abfd
, ext_symptr
->e_strx
);
983 if (strx
>= dynstr_size
)
985 complain (&string_table_offset_complaint
, r_index
);
986 namestring
= "<bad dynamic string table offset>";
989 namestring
= strx
+ dynstrs
;
991 prim_record_minimal_symbol (obsavestring (namestring
,
993 &objfile
-> symbol_obstack
),
995 mst_solib_trampoline
,
1000 /* Given pointers to an a.out symbol table in core containing dbx
1001 style data, setup partial_symtab's describing each source file for
1002 which debugging information is available.
1003 SYMFILE_NAME is the name of the file we are reading from
1004 and SECTION_OFFSETS is the set of offsets for the various sections
1005 of the file (a set of zeros if the mainline program). */
1008 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1009 struct section_offsets
*section_offsets
;
1010 struct objfile
*objfile
;
1011 CORE_ADDR text_addr
;
1014 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1015 register char *namestring
;
1017 int past_first_source_file
= 0;
1018 CORE_ADDR last_o_file_start
= 0;
1019 struct cleanup
*back_to
;
1022 /* End of the text segment of the executable file. */
1023 CORE_ADDR end_of_text_addr
;
1025 /* Current partial symtab */
1026 struct partial_symtab
*pst
;
1028 /* List of current psymtab's include files */
1029 char **psymtab_include_list
;
1030 int includes_allocated
;
1033 /* Index within current psymtab dependency list */
1034 struct partial_symtab
**dependency_list
;
1035 int dependencies_used
, dependencies_allocated
;
1037 /* FIXME. We probably want to change stringtab_global rather than add this
1038 while processing every symbol entry. FIXME. */
1039 file_string_table_offset
= 0;
1040 next_file_string_table_offset
= 0;
1042 stringtab_global
= DBX_STRINGTAB (objfile
);
1044 pst
= (struct partial_symtab
*) 0;
1046 includes_allocated
= 30;
1048 psymtab_include_list
= (char **) alloca (includes_allocated
*
1051 dependencies_allocated
= 30;
1052 dependencies_used
= 0;
1054 (struct partial_symtab
**) alloca (dependencies_allocated
*
1055 sizeof (struct partial_symtab
*));
1057 /* Init bincl list */
1058 init_bincl_list (20, objfile
);
1059 back_to
= make_cleanup (free_bincl_list
, objfile
);
1061 last_source_file
= NULL
;
1063 lowest_text_address
= (CORE_ADDR
)-1;
1065 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1066 abfd
= objfile
->obfd
;
1067 symbuf_end
= symbuf_idx
= 0;
1068 next_symbol_text_func
= dbx_next_symbol_text
;
1070 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1072 /* Get the symbol for this run and pull out some info */
1073 QUIT
; /* allow this to be interruptable */
1074 if (symbuf_idx
== symbuf_end
)
1076 bufp
= &symbuf
[symbuf_idx
++];
1079 * Special case to speed up readin.
1081 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1083 SWAP_SYMBOL (bufp
, abfd
);
1085 /* Ok. There is a lot of code duplicated in the rest of this
1086 switch statement (for efficiency reasons). Since I don't
1087 like duplicating code, I will do my penance here, and
1088 describe the code which is duplicated:
1090 *) The assignment to namestring.
1091 *) The call to strchr.
1092 *) The addition of a partial symbol the the two partial
1093 symbol lists. This last is a large section of code, so
1094 I've imbedded it in the following macro.
1097 /* Set namestring based on bufp. If the string table index is invalid,
1098 give a fake name, and print a single error message per symbol file read,
1099 rather than abort the symbol reading or flood the user with messages. */
1101 /*FIXME: Too many adds and indirections in here for the inner loop. */
1102 #define SET_NAMESTRING()\
1103 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1104 DBX_STRINGTAB_SIZE (objfile)) { \
1105 complain (&string_table_offset_complaint, symnum); \
1106 namestring = "<bad string table offset>"; \
1108 namestring = bufp->n_strx + file_string_table_offset + \
1109 DBX_STRINGTAB (objfile)
1111 #define CUR_SYMBOL_TYPE bufp->n_type
1112 #define CUR_SYMBOL_VALUE bufp->n_value
1113 #define DBXREAD_ONLY
1114 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1115 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1116 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1117 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1119 #include "partial-stab.h"
1122 /* If there's stuff to be cleaned up, clean it up. */
1123 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1124 /*FIXME, does this have a bug at start address 0? */
1125 && last_o_file_start
1126 && objfile
-> ei
.entry_point
< bufp
->n_value
1127 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1129 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1130 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1135 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1136 symnum
* symbol_size
,
1137 (lowest_text_address
== (CORE_ADDR
)-1
1138 ? text_addr
: lowest_text_address
)
1140 dependency_list
, dependencies_used
);
1143 do_cleanups (back_to
);
1146 /* Allocate and partially fill a partial symtab. It will be
1147 completely filled at the end of the symbol list.
1149 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1150 is the address relative to which its symbols are (incremental) or 0
1154 struct partial_symtab
*
1155 start_psymtab (objfile
, section_offsets
,
1156 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1157 struct objfile
*objfile
;
1158 struct section_offsets
*section_offsets
;
1162 struct partial_symbol
*global_syms
;
1163 struct partial_symbol
*static_syms
;
1165 struct partial_symtab
*result
=
1166 start_psymtab_common(objfile
, section_offsets
,
1167 filename
, textlow
, global_syms
, static_syms
);
1169 result
->read_symtab_private
= (char *)
1170 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1171 LDSYMOFF(result
) = ldsymoff
;
1172 result
->read_symtab
= dbx_psymtab_to_symtab
;
1173 SYMBOL_SIZE(result
) = symbol_size
;
1174 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1175 STRING_OFFSET(result
) = string_table_offset
;
1176 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1178 /* If we're handling an ELF file, drag some section-relocation info
1179 for this source file out of the ELF symbol table, to compensate for
1180 Sun brain death. This replaces the section_offsets in this psymtab,
1182 elfstab_offset_sections (objfile
, result
);
1184 /* Deduce the source language from the filename for this psymtab. */
1185 psymtab_language
= deduce_language_from_filename (filename
);
1190 /* Close off the current usage of PST.
1191 Returns PST or NULL if the partial symtab was empty and thrown away.
1193 FIXME: List variables and peculiarities of same. */
1195 struct partial_symtab
*
1196 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1197 capping_text
, dependency_list
, number_dependencies
)
1198 struct partial_symtab
*pst
;
1199 char **include_list
;
1201 int capping_symbol_offset
;
1202 CORE_ADDR capping_text
;
1203 struct partial_symtab
**dependency_list
;
1204 int number_dependencies
;
1207 struct partial_symtab
*p1
;
1208 struct objfile
*objfile
= pst
-> objfile
;
1210 if (capping_symbol_offset
!= -1)
1211 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1212 pst
->texthigh
= capping_text
;
1214 #ifdef N_SO_ADDRESS_MAYBE_MISSING
1215 /* Under Solaris, the N_SO symbols always have a value of 0,
1216 instead of the usual address of the .o file. Therefore,
1217 we have to do some tricks to fill in texthigh and textlow.
1218 The first trick is in partial-stab.h: if we see a static
1219 or global function, and the textlow for the current pst
1220 is still 0, then we use that function's address for
1221 the textlow of the pst.
1223 Now, to fill in texthigh, we remember the last function seen
1224 in the .o file (also in partial-stab.h). Also, there's a hack in
1225 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1226 to here via the misc_info field. Therefore, we can fill in
1227 a reliable texthigh by taking the address plus size of the
1228 last function in the file.
1230 Unfortunately, that does not cover the case where the last function
1231 in the file is static. See the paragraph below for more comments
1234 Finally, if we have a valid textlow for the current file, we run
1235 down the partial_symtab_list filling in previous texthighs that
1236 are still unknown. */
1238 if (pst
->texthigh
== 0 && last_function_name
) {
1241 struct minimal_symbol
*minsym
;
1243 p
= strchr (last_function_name
, ':');
1245 p
= last_function_name
;
1246 n
= p
- last_function_name
;
1248 strncpy (p
, last_function_name
, n
);
1251 minsym
= lookup_minimal_symbol (p
, objfile
);
1254 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1255 (long) MSYMBOL_INFO (minsym
);
1257 /* This file ends with a static function, and it's
1258 difficult to imagine how hard it would be to track down
1259 the elf symbol. Luckily, most of the time no one will notice,
1260 since the next file will likely be compiled with -g, so
1261 the code below will copy the first fuction's start address
1262 back to our texthigh variable. (Also, if this file is the
1263 last one in a dynamically linked program, texthigh already
1264 has the right value.) If the next file isn't compiled
1265 with -g, then the last function in this file winds up owning
1266 all of the text space up to the next -g file, or the end (minus
1267 shared libraries). This only matters for single stepping,
1268 and even then it will still work, except that it will single
1269 step through all of the covered functions, instead of setting
1270 breakpoints around them as it usualy does. This makes it
1271 pretty slow, but at least it doesn't fail.
1273 We can fix this with a fairly big change to bfd, but we need
1274 to coordinate better with Cygnus if we want to do that. FIXME. */
1276 last_function_name
= NULL
;
1279 /* this test will be true if the last .o file is only data */
1280 if (pst
->textlow
== 0)
1281 /* This loses if the text section really starts at address zero
1282 (generally true when we are debugging a .o file, for example).
1283 That is why this whole thing is inside N_SO_ADDRESS_MAYBE_MISSING. */
1284 pst
->textlow
= pst
->texthigh
;
1286 /* If we know our own starting text address, then walk through all other
1287 psymtabs for this objfile, and if any didn't know their ending text
1288 address, set it to our starting address. Take care to not set our
1289 own ending address to our starting address, nor to set addresses on
1290 `dependency' files that have both textlow and texthigh zero. */
1292 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1293 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1294 p1
->texthigh
= pst
->textlow
;
1295 /* if this file has only data, then make textlow match texthigh */
1296 if (p1
->textlow
== 0)
1297 p1
->textlow
= p1
->texthigh
;
1302 /* End of kludge for patching Solaris textlow and texthigh. */
1303 #endif /* N_SO_ADDRESS_MAYBE_MISSING. */
1305 pst
->n_global_syms
=
1306 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1307 pst
->n_static_syms
=
1308 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1310 pst
->number_of_dependencies
= number_dependencies
;
1311 if (number_dependencies
)
1313 pst
->dependencies
= (struct partial_symtab
**)
1314 obstack_alloc (&objfile
->psymbol_obstack
,
1315 number_dependencies
* sizeof (struct partial_symtab
*));
1316 memcpy (pst
->dependencies
, dependency_list
,
1317 number_dependencies
* sizeof (struct partial_symtab
*));
1320 pst
->dependencies
= 0;
1322 for (i
= 0; i
< num_includes
; i
++)
1324 struct partial_symtab
*subpst
=
1325 allocate_psymtab (include_list
[i
], objfile
);
1327 subpst
->section_offsets
= pst
->section_offsets
;
1328 subpst
->read_symtab_private
=
1329 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1330 sizeof (struct symloc
));
1334 subpst
->texthigh
= 0;
1336 /* We could save slight bits of space by only making one of these,
1337 shared by the entire set of include files. FIXME-someday. */
1338 subpst
->dependencies
= (struct partial_symtab
**)
1339 obstack_alloc (&objfile
->psymbol_obstack
,
1340 sizeof (struct partial_symtab
*));
1341 subpst
->dependencies
[0] = pst
;
1342 subpst
->number_of_dependencies
= 1;
1344 subpst
->globals_offset
=
1345 subpst
->n_global_syms
=
1346 subpst
->statics_offset
=
1347 subpst
->n_static_syms
= 0;
1351 subpst
->read_symtab
= pst
->read_symtab
;
1354 sort_pst_symbols (pst
);
1356 /* If there is already a psymtab or symtab for a file of this name, remove it.
1357 (If there is a symtab, more drastic things also happen.)
1358 This happens in VxWorks. */
1359 free_named_symtabs (pst
->filename
);
1361 if (num_includes
== 0
1362 && number_dependencies
== 0
1363 && pst
->n_global_syms
== 0
1364 && pst
->n_static_syms
== 0)
1366 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1367 it is on the obstack, but we can forget to chain it on the list. */
1368 /* Empty psymtabs happen as a result of header files which don't have
1369 any symbols in them. There can be a lot of them. But this check
1370 is wrong, in that a psymtab with N_SLINE entries but nothing else
1371 is not empty, but we don't realize that. Fixing that without slowing
1372 things down might be tricky. */
1373 struct partial_symtab
*prev_pst
;
1375 /* First, snip it out of the psymtab chain */
1377 if (pst
->objfile
->psymtabs
== pst
)
1378 pst
->objfile
->psymtabs
= pst
->next
;
1380 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1381 if (prev_pst
->next
== pst
)
1382 prev_pst
->next
= pst
->next
;
1384 /* Next, put it on a free list for recycling */
1386 pst
->next
= pst
->objfile
->free_psymtabs
;
1387 pst
->objfile
->free_psymtabs
= pst
;
1389 /* Indicate that psymtab was thrown away. */
1390 pst
= (struct partial_symtab
*)NULL
;
1396 dbx_psymtab_to_symtab_1 (pst
)
1397 struct partial_symtab
*pst
;
1399 struct cleanup
*old_chain
;
1407 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1412 /* Read in all partial symtabs on which this one is dependent */
1413 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1414 if (!pst
->dependencies
[i
]->readin
)
1416 /* Inform about additional files that need to be read in. */
1419 fputs_filtered (" ", gdb_stdout
);
1421 fputs_filtered ("and ", gdb_stdout
);
1423 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1424 wrap_here (""); /* Flush output */
1425 gdb_flush (gdb_stdout
);
1427 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1430 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1432 /* Init stuff necessary for reading in symbols */
1435 old_chain
= make_cleanup (really_free_pendings
, 0);
1436 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1437 symbol_size
= SYMBOL_SIZE (pst
);
1439 /* Read in this file's symbols */
1440 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1441 read_ofile_symtab (pst
);
1442 sort_symtab_syms (pst
->symtab
);
1444 do_cleanups (old_chain
);
1450 /* Read in all of the symbols for a given psymtab for real.
1451 Be verbose about it if the user wants that. */
1454 dbx_psymtab_to_symtab (pst
)
1455 struct partial_symtab
*pst
;
1464 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1469 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1471 /* Print the message now, before reading the string table,
1472 to avoid disconcerting pauses. */
1475 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1476 gdb_flush (gdb_stdout
);
1479 sym_bfd
= pst
->objfile
->obfd
;
1481 next_symbol_text_func
= dbx_next_symbol_text
;
1483 dbx_psymtab_to_symtab_1 (pst
);
1485 /* Match with global symbols. This only needs to be done once,
1486 after all of the symtabs and dependencies have been read in. */
1487 scan_file_globals (pst
->objfile
);
1489 /* Finish up the debug error message. */
1491 printf_filtered ("done.\n");
1495 /* Read in a defined section of a specific object file's symbols. */
1498 read_ofile_symtab (pst
)
1499 struct partial_symtab
*pst
;
1501 register char *namestring
;
1502 register struct internal_nlist
*bufp
;
1504 unsigned max_symnum
;
1506 struct objfile
*objfile
;
1507 int sym_offset
; /* Offset to start of symbols to read */
1508 int sym_size
; /* Size of symbols to read */
1509 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1510 int text_size
; /* Size of text segment for symbols */
1511 struct section_offsets
*section_offsets
;
1513 objfile
= pst
->objfile
;
1514 sym_offset
= LDSYMOFF(pst
);
1515 sym_size
= LDSYMLEN(pst
);
1516 text_offset
= pst
->textlow
;
1517 text_size
= pst
->texthigh
- pst
->textlow
;
1518 section_offsets
= pst
->section_offsets
;
1520 current_objfile
= objfile
;
1521 subfile_stack
= NULL
;
1523 stringtab_global
= DBX_STRINGTAB (objfile
);
1524 last_source_file
= NULL
;
1526 abfd
= objfile
->obfd
;
1527 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1528 symbuf_end
= symbuf_idx
= 0;
1530 /* It is necessary to actually read one symbol *before* the start
1531 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1532 occurs before the N_SO symbol.
1534 Detecting this in read_dbx_symtab
1535 would slow down initial readin, so we look for it here instead. */
1536 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1538 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1540 bufp
= &symbuf
[symbuf_idx
++];
1541 SWAP_SYMBOL (bufp
, abfd
);
1545 processing_gcc_compilation
= 0;
1546 if (bufp
->n_type
== N_TEXT
)
1548 const char *tempstring
= namestring
;
1550 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1551 processing_gcc_compilation
= 1;
1552 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1553 processing_gcc_compilation
= 2;
1554 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1556 if (STREQN (tempstring
, "__gnu_compiled", 14))
1557 processing_gcc_compilation
= 2;
1560 /* Try to select a C++ demangling based on the compilation unit
1563 if (processing_gcc_compilation
)
1565 if (AUTO_DEMANGLING
)
1567 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1573 /* The N_SO starting this symtab is the first symbol, so we
1574 better not check the symbol before it. I'm not this can
1575 happen, but it doesn't hurt to check for it. */
1576 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1577 processing_gcc_compilation
= 0;
1580 if (symbuf_idx
== symbuf_end
)
1582 bufp
= &symbuf
[symbuf_idx
];
1583 if (bufp
->n_type
!= (unsigned char)N_SO
)
1584 error("First symbol in segment of executable not a source symbol");
1586 max_symnum
= sym_size
/ symbol_size
;
1589 symnum
< max_symnum
;
1592 QUIT
; /* Allow this to be interruptable */
1593 if (symbuf_idx
== symbuf_end
)
1595 bufp
= &symbuf
[symbuf_idx
++];
1596 SWAP_SYMBOL (bufp
, abfd
);
1598 type
= bufp
->n_type
;
1602 if (type
& N_STAB
) {
1603 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1604 namestring
, section_offsets
, objfile
);
1606 /* We skip checking for a new .o or -l file; that should never
1607 happen in this routine. */
1608 else if (type
== N_TEXT
)
1610 /* I don't think this code will ever be executed, because
1611 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1612 the N_SO symbol which starts this source file.
1613 However, there is no reason not to accept
1614 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1616 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1617 processing_gcc_compilation
= 1;
1618 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1619 processing_gcc_compilation
= 2;
1621 if (AUTO_DEMANGLING
)
1623 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1626 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1627 || type
== (unsigned char)N_NBTEXT
1629 /* Global symbol: see if we came across a dbx defintion for
1630 a corresponding symbol. If so, store the value. Remove
1631 syms from the chain when their values are stored, but
1632 search the whole chain, as there may be several syms from
1633 different files with the same name. */
1634 /* This is probably not true. Since the files will be read
1635 in one at a time, each reference to a global symbol will
1636 be satisfied in each file as it appears. So we skip this
1642 current_objfile
= NULL
;
1644 /* In a Solaris elf file, this variable, which comes from the
1645 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1646 which comes from pst->textlow is correct. */
1647 if (last_source_start_addr
== 0)
1648 last_source_start_addr
= text_offset
;
1650 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1656 /* This handles a single symbol from the symbol-file, building symbols
1657 into a GDB symtab. It takes these arguments and an implicit argument.
1659 TYPE is the type field of the ".stab" symbol entry.
1660 DESC is the desc field of the ".stab" entry.
1661 VALU is the value field of the ".stab" entry.
1662 NAME is the symbol name, in our address space.
1663 SECTION_OFFSETS is a set of amounts by which the sections of this object
1664 file were relocated when it was loaded into memory.
1665 All symbols that refer
1666 to memory locations need to be offset by these amounts.
1667 OBJFILE is the object file from which we are reading symbols.
1668 It is used in end_symtab. */
1671 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1675 struct section_offsets
*section_offsets
;
1676 struct objfile
*objfile
;
1678 #ifdef SUN_FIXED_LBRAC_BUG
1679 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1680 to correct the address of N_LBRAC's. If it is not defined, then
1681 we never need to correct the addresses. */
1683 /* This records the last pc address we've seen. We depend on there being
1684 an SLINE or FUN or SO before the first LBRAC, since the variable does
1685 not get reset in between reads of different symbol files. */
1686 static CORE_ADDR last_pc_address
;
1689 register struct context_stack
*new;
1690 /* This remembers the address of the start of a function. It is used
1691 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1692 relative to the current function's start address. On systems
1693 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1694 used to relocate these symbol types rather than SECTION_OFFSETS. */
1695 static CORE_ADDR function_start_offset
;
1697 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
1698 to the function start address. */
1699 int block_address_function_relative
;
1701 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1702 file. Used to detect the SunPRO solaris compiler. */
1703 static int n_opt_found
;
1705 /* The stab type used for the definition of the last function.
1706 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1707 static int function_stab_type
= 0;
1709 /* This is true for Solaris (and all other systems which put stabs
1710 in sections, hopefully, since it would be silly to do things
1711 differently from Solaris), and false for SunOS4 and other a.out
1713 block_address_function_relative
=
1714 ((0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
1715 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3))
1716 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "coff", 4)));
1718 if (!block_address_function_relative
)
1719 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1720 function start address, so just use the text offset. */
1721 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1723 /* Something is wrong if we see real data before
1724 seeing a source file name. */
1726 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1728 /* Ignore any symbols which appear before an N_SO symbol. Currently
1729 no one puts symbols there, but we should deal gracefully with the
1730 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1731 but this should not be an error (). */
1739 /* Relocate for dynamic loading */
1740 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1741 goto define_a_symbol
;
1744 /* This "symbol" just indicates the start of an inner lexical
1745 context within a function. */
1747 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1748 /* Relocate for dynamic loading (?). */
1749 valu
+= function_start_offset
;
1751 if (block_address_function_relative
)
1752 /* Relocate for Sun ELF acc fn-relative syms. */
1753 valu
+= function_start_offset
;
1755 /* On most machines, the block addresses are relative to the
1756 N_SO, the linker did not relocate them (sigh). */
1757 valu
+= last_source_start_addr
;
1760 #ifdef SUN_FIXED_LBRAC_BUG
1761 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1762 /* Patch current LBRAC pc value to match last handy pc value */
1763 complain (&lbrac_complaint
);
1764 valu
= last_pc_address
;
1767 new = push_context (desc
, valu
);
1771 /* This "symbol" just indicates the end of an inner lexical
1772 context that was started with N_LBRAC. */
1774 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1775 /* Relocate for dynamic loading (?). */
1776 valu
+= function_start_offset
;
1778 if (block_address_function_relative
)
1779 /* Relocate for Sun ELF acc fn-relative syms. */
1780 valu
+= function_start_offset
;
1782 /* On most machines, the block addresses are relative to the
1783 N_SO, the linker did not relocate them (sigh). */
1784 valu
+= last_source_start_addr
;
1787 new = pop_context();
1788 if (desc
!= new->depth
)
1789 complain (&lbrac_mismatch_complaint
, symnum
);
1791 /* Some compilers put the variable decls inside of an
1792 LBRAC/RBRAC block. This macro should be nonzero if this
1793 is true. DESC is N_DESC from the N_RBRAC symbol.
1794 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1795 or the GCC2_COMPILED_SYMBOL. */
1796 #if !defined (VARIABLES_INSIDE_BLOCK)
1797 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1800 /* Can only use new->locals as local symbols here if we're in
1801 gcc or on a machine that puts them before the lbrack. */
1802 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1803 local_symbols
= new->locals
;
1805 if (context_stack_depth
1806 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1808 /* This is not the outermost LBRAC...RBRAC pair in the function,
1809 its local symbols preceded it, and are the ones just recovered
1810 from the context stack. Define the block for them (but don't
1811 bother if the block contains no symbols. Should we complain
1812 on blocks without symbols? I can't think of any useful purpose
1814 if (local_symbols
!= NULL
)
1816 /* Muzzle a compiler bug that makes end < start. (which
1817 compilers? Is this ever harmful?). */
1818 if (new->start_addr
> valu
)
1820 complain (&lbrac_rbrac_complaint
);
1821 new->start_addr
= valu
;
1823 /* Make a block for the local symbols within. */
1824 finish_block (0, &local_symbols
, new->old_blocks
,
1825 new->start_addr
, valu
, objfile
);
1830 /* This is the outermost LBRAC...RBRAC pair. There is no
1831 need to do anything; leave the symbols that preceded it
1832 to be attached to the function's own block. We need to
1833 indicate that we just moved outside of the function. */
1834 within_function
= 0;
1837 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1838 /* Now pop locals of block just finished. */
1839 local_symbols
= new->locals
;
1844 /* This kind of symbol indicates the start of an object file. */
1845 /* Relocate for dynamic loading */
1846 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1850 /* This type of symbol indicates the start of data
1851 for one source file.
1852 Finish the symbol table of the previous source file
1853 (if any) and start accumulating a new symbol table. */
1854 /* Relocate for dynamic loading */
1855 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1859 #ifdef SUN_FIXED_LBRAC_BUG
1860 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1863 #ifdef PCC_SOL_BROKEN
1864 /* pcc bug, occasionally puts out SO for SOL. */
1865 if (context_stack_depth
> 0)
1867 start_subfile (name
, NULL
);
1871 if (last_source_file
)
1873 /* Check if previous symbol was also an N_SO (with some
1874 sanity checks). If so, that one was actually the directory
1875 name, and the current one is the real file name.
1877 if (previous_stab_code
== (unsigned char) N_SO
)
1879 patch_subfile_names (current_subfile
, name
);
1880 break; /* Ignore repeated SOs */
1882 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1886 start_symtab (name
, NULL
, valu
);
1891 /* This type of symbol indicates the start of data for
1892 a sub-source-file, one whose contents were copied or
1893 included in the compilation of the main source file
1894 (whose name was given in the N_SO symbol.) */
1895 /* Relocate for dynamic loading */
1896 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1897 start_subfile (name
, current_subfile
->dirname
);
1902 add_new_header_file (name
, valu
);
1903 start_subfile (name
, current_subfile
->dirname
);
1907 start_subfile (pop_subfile (), current_subfile
->dirname
);
1911 add_old_header_file (name
, valu
);
1915 /* This type of "symbol" really just records
1916 one line-number -- core-address correspondence.
1917 Enter it in the line list for this symbol table. */
1918 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1919 valu
+= function_start_offset
;
1920 #ifdef SUN_FIXED_LBRAC_BUG
1921 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1923 record_line (current_subfile
, desc
, valu
);
1927 common_block_start (name
, objfile
);
1931 common_block_end (objfile
);
1934 /* The following symbol types need to have the appropriate offset added
1935 to their value; then we process symbol definitions in the name. */
1937 case N_STSYM
: /* Static symbol in data seg */
1938 case N_LCSYM
: /* Static symbol in BSS seg */
1939 case N_ROSYM
: /* Static symbol in Read-only data seg */
1940 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1941 Solaris2's stabs-in-elf makes *most* symbols relative
1942 but leaves a few absolute (at least for Solaris 2.1 and version
1943 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1944 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1945 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1946 This leaves us no choice but to search for the 'S' or 'V'...
1947 (or pass the whole section_offsets stuff down ONE MORE function
1948 call level, which we really don't want to do). */
1951 p
= strchr (name
, ':');
1952 if (p
!= 0 && p
[1] == 'S')
1954 /* The linker relocated it. We don't want to add an
1955 elfstab_offset_sections-type offset, but we *do* want
1956 to add whatever solib.c passed to symbol_file_add as
1957 addr (this is known to affect SunOS4, and I suspect ELF
1958 too). Since elfstab_offset_sections currently does not
1959 muck with the text offset (there is no Ttext.text
1960 symbol), we can get addr from the text offset. If
1961 elfstab_offset_sections ever starts dealing with the
1962 text offset, and we still need to do this, we need to
1963 invent a SECT_OFF_ADDR_KLUDGE or something. */
1964 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1965 goto define_a_symbol
;
1967 /* Since it's not the kludge case, re-dispatch to the right handler. */
1969 case N_STSYM
: goto case_N_STSYM
;
1970 case N_LCSYM
: goto case_N_LCSYM
;
1971 case N_ROSYM
: goto case_N_ROSYM
;
1976 case_N_STSYM
: /* Static symbol in data seg */
1977 case N_DSLINE
: /* Source line number, data seg */
1978 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1979 goto define_a_symbol
;
1981 case_N_LCSYM
: /* Static symbol in BSS seg */
1982 case N_BSLINE
: /* Source line number, bss seg */
1983 /* N_BROWS: overlaps with N_BSLINE */
1984 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1985 goto define_a_symbol
;
1987 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1988 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1989 goto define_a_symbol
;
1991 case N_ENTRY
: /* Alternate entry point */
1992 /* Relocate for dynamic loading */
1993 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1994 goto define_a_symbol
;
1996 /* The following symbol types we don't know how to process. Handle
1997 them in a "default" way, but complain to people who care. */
1999 case N_CATCH
: /* Exception handler catcher */
2000 case N_EHDECL
: /* Exception handler name */
2001 case N_PC
: /* Global symbol in Pascal */
2002 case N_M2C
: /* Modula-2 compilation unit */
2003 /* N_MOD2: overlaps with N_EHDECL */
2004 case N_SCOPE
: /* Modula-2 scope information */
2005 case N_ECOML
: /* End common (local name) */
2006 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2011 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2014 /* The following symbol types don't need the address field relocated,
2015 since it is either unused, or is absolute. */
2017 case N_GSYM
: /* Global variable */
2018 case N_NSYMS
: /* Number of symbols (ultrix) */
2019 case N_NOMAP
: /* No map? (ultrix) */
2020 case N_RSYM
: /* Register variable */
2021 case N_DEFD
: /* Modula-2 GNU module dependency */
2022 case N_SSYM
: /* Struct or union element */
2023 case N_LSYM
: /* Local symbol in stack */
2024 case N_PSYM
: /* Parameter variable */
2025 case N_LENG
: /* Length of preceding symbol type */
2029 char *colon_pos
= strchr (name
, ':');
2030 if (colon_pos
== NULL
)
2033 deftype
= colon_pos
[1];
2039 function_stab_type
= type
;
2041 #ifdef SUN_FIXED_LBRAC_BUG
2042 /* The Sun acc compiler, under SunOS4, puts out
2043 functions with N_GSYM or N_STSYM. The problem is
2044 that the address of the symbol is no good (for N_GSYM
2045 it doesn't even attept an address; for N_STSYM it
2046 puts out an address but then it gets relocated
2047 relative to the data segment, not the text segment).
2048 Currently we can't fix this up later as we do for
2049 some types of symbol in scan_file_globals.
2050 Fortunately we do have a way of finding the address -
2051 we know that the value in last_pc_address is either
2052 the one we want (if we're dealing with the first
2053 function in an object file), or somewhere in the
2054 previous function. This means that we can use the
2055 minimal symbol table to get the address. */
2057 /* On solaris up to 2.2, the N_FUN stab gets relocated.
2058 On Solaris 2.3, ld no longer relocates stabs (which
2059 is good), and the N_FUN's value is now always zero.
2060 The following code can't deal with this, because
2061 last_pc_address depends on getting the address from a
2062 N_SLINE or some such and in Solaris those are function
2063 relative. Best fix is probably to create a Ttext.text symbol
2064 and handle this like Ddata.data and so on. */
2066 if (type
== N_GSYM
|| type
== N_STSYM
)
2068 struct minimal_symbol
*m
;
2069 int l
= colon_pos
- name
;
2071 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2072 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
2073 /* last_pc_address was in this function */
2074 valu
= SYMBOL_VALUE (m
);
2075 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
2076 /* last_pc_address was in last function */
2077 valu
= SYMBOL_VALUE (m
+1);
2079 /* Not found - use last_pc_address (for finish_block) */
2080 valu
= last_pc_address
;
2083 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2086 if (block_address_function_relative
)
2087 /* For Solaris 2.0 compilers, the block addresses and
2088 N_SLINE's are relative to the start of the
2089 function. On normal systems, and when using gcc on
2090 Solaris 2.0, these addresses are just absolute, or
2091 relative to the N_SO, depending on
2092 BLOCK_ADDRESS_ABSOLUTE. */
2093 function_start_offset
= valu
;
2095 within_function
= 1;
2096 if (context_stack_depth
> 0)
2098 new = pop_context ();
2099 /* Make a block for the local symbols within. */
2100 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2101 new->start_addr
, valu
, objfile
);
2103 /* Stack must be empty now. */
2104 if (context_stack_depth
!= 0)
2105 complain (&lbrac_unmatched_complaint
, symnum
);
2107 new = push_context (0, valu
);
2108 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2112 define_symbol (valu
, name
, desc
, type
, objfile
);
2118 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2119 for a bunch of other flags, too. Someday we may parse their
2120 flags; for now we ignore theirs and hope they'll ignore ours. */
2121 case N_OPT
: /* Solaris 2: Compiler options */
2124 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2126 processing_gcc_compilation
= 2;
2127 #if 1 /* Works, but is experimental. -fnf */
2128 if (AUTO_DEMANGLING
)
2130 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2139 /* The following symbol types can be ignored. */
2140 case N_OBJ
: /* Solaris 2: Object file dir and name */
2141 /* N_UNDF: Solaris 2: file separator mark */
2142 /* N_UNDF: -- we will never encounter it, since we only process one
2143 file's symbols at once. */
2144 case N_ENDM
: /* Solaris 2: End of module */
2145 case N_MAIN
: /* Name of main routine. */
2149 previous_stab_code
= type
;
2152 /* FIXME: The only difference between this and elfstab_build_psymtabs is
2153 the call to install_minimal_symbols for elf. If the differences are
2154 really that small, the code should be shared. */
2156 /* Scan and build partial symbols for an coff symbol file.
2157 The coff file has already been processed to get its minimal symbols.
2159 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2162 OBJFILE is the object file we are reading symbols from.
2163 ADDR is the address relative to which the symbols are (e.g.
2164 the base address of the text segment).
2165 MAINLINE is true if we are reading the main symbol
2166 table (as opposed to a shared lib or dynamically loaded file).
2167 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2169 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2170 .stabstr section exists.
2172 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2173 adjusted for coff details. */
2176 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2177 staboffset
, stabsize
,
2178 stabstroffset
, stabstrsize
)
2179 struct objfile
*objfile
;
2180 struct section_offsets
*section_offsets
;
2182 file_ptr staboffset
;
2183 unsigned int stabsize
;
2184 file_ptr stabstroffset
;
2185 unsigned int stabstrsize
;
2188 bfd
*sym_bfd
= objfile
->obfd
;
2189 char *name
= bfd_get_filename (sym_bfd
);
2190 struct dbx_symfile_info
*info
;
2192 /* There is already a dbx_symfile_info allocated by our caller.
2193 It might even contain some info from the coff symtab to help us. */
2194 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2196 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2197 if (!DBX_TEXT_SECT (objfile
))
2198 error ("Can't find .text section in symbol file");
2200 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2201 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2202 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2203 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2204 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2206 if (stabstrsize
> bfd_get_size (sym_bfd
))
2207 error ("ridiculous string table size: %d bytes", stabstrsize
);
2208 DBX_STRINGTAB (objfile
) = (char *)
2209 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2211 /* Now read in the string table in one big gulp. */
2213 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2215 perror_with_name (name
);
2216 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2217 if (val
!= stabstrsize
)
2218 perror_with_name (name
);
2220 stabsread_new_init ();
2221 buildsym_new_init ();
2222 free_header_files ();
2223 init_header_files ();
2225 processing_acc_compilation
= 1;
2227 /* In a coff file, we've already installed the minimal symbols that came
2228 from the coff (non-stab) symbol table, so always act like an
2229 incremental load here. */
2230 dbx_symfile_read (objfile
, section_offsets
, 0);
2233 /* Scan and build partial symbols for an ELF symbol file.
2234 This ELF file has already been processed to get its minimal symbols,
2235 and any DWARF symbols that were in it.
2237 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2240 OBJFILE is the object file we are reading symbols from.
2241 ADDR is the address relative to which the symbols are (e.g.
2242 the base address of the text segment).
2243 MAINLINE is true if we are reading the main symbol
2244 table (as opposed to a shared lib or dynamically loaded file).
2245 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2247 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2248 .stabstr section exists.
2250 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2251 adjusted for elf details. */
2254 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2255 staboffset
, stabsize
,
2256 stabstroffset
, stabstrsize
)
2257 struct objfile
*objfile
;
2258 struct section_offsets
*section_offsets
;
2260 file_ptr staboffset
;
2261 unsigned int stabsize
;
2262 file_ptr stabstroffset
;
2263 unsigned int stabstrsize
;
2266 bfd
*sym_bfd
= objfile
->obfd
;
2267 char *name
= bfd_get_filename (sym_bfd
);
2268 struct dbx_symfile_info
*info
;
2270 /* There is already a dbx_symfile_info allocated by our caller.
2271 It might even contain some info from the ELF symtab to help us. */
2272 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2274 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2275 if (!DBX_TEXT_SECT (objfile
))
2276 error ("Can't find .text section in symbol file");
2278 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2279 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2280 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2281 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2282 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2284 if (stabstrsize
> bfd_get_size (sym_bfd
))
2285 error ("ridiculous string table size: %d bytes", stabstrsize
);
2286 DBX_STRINGTAB (objfile
) = (char *)
2287 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2289 /* Now read in the string table in one big gulp. */
2291 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2293 perror_with_name (name
);
2294 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2295 if (val
!= stabstrsize
)
2296 perror_with_name (name
);
2298 stabsread_new_init ();
2299 buildsym_new_init ();
2300 free_header_files ();
2301 init_header_files ();
2302 install_minimal_symbols (objfile
);
2304 processing_acc_compilation
= 1;
2306 /* In an elf file, we've already installed the minimal symbols that came
2307 from the elf (non-stab) symbol table, so always act like an
2308 incremental load here. */
2309 dbx_symfile_read (objfile
, section_offsets
, 0);
2312 /* Scan and build partial symbols for a PA symbol file.
2313 This PA file has already been processed to get its minimal symbols.
2315 OBJFILE is the object file we are reading symbols from.
2316 ADDR is the address relative to which the symbols are (e.g.
2317 the base address of the text segment).
2318 MAINLINE is true if we are reading the main symbol
2319 table (as opposed to a shared lib or dynamically loaded file).
2324 pastab_build_psymtabs (objfile
, section_offsets
, mainline
)
2325 struct objfile
*objfile
;
2326 struct section_offsets
*section_offsets
;
2329 free_header_files ();
2330 init_header_files ();
2332 /* This is needed to debug objects assembled with gas2. */
2333 processing_acc_compilation
= 1;
2335 /* In a PA file, we've already installed the minimal symbols that came
2336 from the PA (non-stab) symbol table, so always act like an
2337 incremental load here. */
2339 dbx_symfile_read (objfile
, section_offsets
, mainline
);
2342 /* Parse the user's idea of an offset for dynamic linking, into our idea
2343 of how to represent it for fast symbol reading. */
2345 static struct section_offsets
*
2346 dbx_symfile_offsets (objfile
, addr
)
2347 struct objfile
*objfile
;
2350 struct section_offsets
*section_offsets
;
2353 objfile
->num_sections
= SECT_OFF_MAX
;
2354 section_offsets
= (struct section_offsets
*)
2355 obstack_alloc (&objfile
-> psymbol_obstack
,
2356 sizeof (struct section_offsets
)
2357 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2359 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2360 ANOFFSET (section_offsets
, i
) = addr
;
2362 return section_offsets
;
2365 static struct sym_fns aout_sym_fns
=
2367 bfd_target_aout_flavour
,
2368 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2369 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2370 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2371 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2372 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2373 NULL
/* next: pointer to next struct sym_fns */
2377 _initialize_dbxread ()
2379 add_symtab_fns(&aout_sym_fns
);