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 /* Macro for name of symbol to indicate a file compiled with gcc. */
112 #ifndef GCC_COMPILED_FLAG_SYMBOL
113 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
116 /* Macro for name of symbol to indicate a file compiled with gcc2. */
117 #ifndef GCC2_COMPILED_FLAG_SYMBOL
118 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
121 /* Define this as 1 if a pcc declaration of a char or short argument
122 gives the correct address. Otherwise assume pcc gives the
123 address of the corresponding int, which is not the same on a
124 big-endian machine. */
126 #ifndef BELIEVE_PCC_PROMOTION
127 #define BELIEVE_PCC_PROMOTION 0
130 /* Remember what we deduced to be the source language of this psymtab. */
132 static enum language psymtab_language
= language_unknown
;
134 /* Nonzero means give verbose info on gdb action. From main.c. */
135 extern int info_verbose
;
137 /* The BFD for this file -- implicit parameter to next_symbol_text. */
139 static bfd
*symfile_bfd
;
141 /* The size of each symbol in the symbol file (in external form).
142 This is set by dbx_symfile_read when building psymtabs, and by
143 dbx_psymtab_to_symtab when building symtabs. */
145 static unsigned symbol_size
;
147 /* This is the offset of the symbol table in the executable file */
148 static unsigned symbol_table_offset
;
150 /* This is the offset of the string table in the executable file */
151 static unsigned string_table_offset
;
153 /* For elf+stab executables, the n_strx field is not a simple index
154 into the string table. Instead, each .o file has a base offset
155 in the string table, and the associated symbols contain offsets
156 from this base. The following two variables contain the base
157 offset for the current and next .o files. */
158 static unsigned int file_string_table_offset
;
159 static unsigned int next_file_string_table_offset
;
161 /* Complaints about the symbols we have encountered. */
163 struct complaint lbrac_complaint
=
164 {"bad block start address patched", 0, 0};
166 struct complaint string_table_offset_complaint
=
167 {"bad string table offset in symbol %d", 0, 0};
169 struct complaint unknown_symtype_complaint
=
170 {"unknown symbol type %s", 0, 0};
172 struct complaint unknown_symchar_complaint
=
173 {"unknown symbol type character `%c'", 0, 0};
175 struct complaint lbrac_rbrac_complaint
=
176 {"block start larger than block end", 0, 0};
178 struct complaint lbrac_unmatched_complaint
=
179 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
181 struct complaint lbrac_mismatch_complaint
=
182 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
184 struct complaint repeated_header_complaint
=
185 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
187 struct complaint repeated_header_name_complaint
=
188 {"\"repeated\" header file not previously seen, named %s", 0, 0};
190 /* During initial symbol readin, we need to have a structure to keep
191 track of which psymtabs have which bincls in them. This structure
192 is used during readin to setup the list of dependencies within each
193 partial symbol table. */
195 struct header_file_location
197 char *name
; /* Name of header file */
198 int instance
; /* See above */
199 struct partial_symtab
*pst
; /* Partial symtab that has the
200 BINCL/EINCL defs for this file */
203 /* The actual list and controling variables */
204 static struct header_file_location
*bincl_list
, *next_bincl
;
205 static int bincls_allocated
;
207 /* Local function prototypes */
210 free_header_files
PARAMS ((void));
213 init_header_files
PARAMS ((void));
215 static struct pending
*
216 copy_pending
PARAMS ((struct pending
*, int, struct pending
*));
219 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
222 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
225 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
228 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
232 free_bincl_list
PARAMS ((struct objfile
*));
234 static struct partial_symtab
*
235 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
238 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
241 init_bincl_list
PARAMS ((int, struct objfile
*));
244 init_psymbol_list
PARAMS ((struct objfile
*));
247 dbx_next_symbol_text
PARAMS ((void));
250 fill_symbuf
PARAMS ((bfd
*));
253 dbx_symfile_init
PARAMS ((struct objfile
*));
256 dbx_new_init
PARAMS ((struct objfile
*));
259 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
262 dbx_symfile_finish
PARAMS ((struct objfile
*));
265 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
268 add_new_header_file
PARAMS ((char *, int));
271 add_old_header_file
PARAMS ((char *, int));
274 add_this_object_header_file
PARAMS ((int));
276 /* Free up old header file tables */
283 if (header_files
!= NULL
)
285 for (i
= 0; i
< n_header_files
; i
++)
287 free (header_files
[i
].name
);
289 free ((PTR
)header_files
);
293 if (this_object_header_files
)
295 free ((PTR
)this_object_header_files
);
296 this_object_header_files
= NULL
;
298 n_allocated_header_files
= 0;
299 n_allocated_this_object_header_files
= 0;
302 /* Allocate new header file tables */
308 n_allocated_header_files
= 10;
309 header_files
= (struct header_file
*)
310 xmalloc (10 * sizeof (struct header_file
));
312 n_allocated_this_object_header_files
= 10;
313 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
316 /* Add header file number I for this object file
317 at the next successive FILENUM. */
320 add_this_object_header_file (i
)
323 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
325 n_allocated_this_object_header_files
*= 2;
326 this_object_header_files
327 = (int *) xrealloc ((char *) this_object_header_files
,
328 n_allocated_this_object_header_files
* sizeof (int));
331 this_object_header_files
[n_this_object_header_files
++] = i
;
334 /* Add to this file an "old" header file, one already seen in
335 a previous object file. NAME is the header file's name.
336 INSTANCE is its instance code, to select among multiple
337 symbol tables for the same header file. */
340 add_old_header_file (name
, instance
)
344 register struct header_file
*p
= header_files
;
347 for (i
= 0; i
< n_header_files
; i
++)
348 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
350 add_this_object_header_file (i
);
353 complain (&repeated_header_complaint
, symnum
);
354 complain (&repeated_header_name_complaint
, name
);
357 /* Add to this file a "new" header file: definitions for its types follow.
358 NAME is the header file's name.
359 Most often this happens only once for each distinct header file,
360 but not necessarily. If it happens more than once, INSTANCE has
361 a different value each time, and references to the header file
362 use INSTANCE values to select among them.
364 dbx output contains "begin" and "end" markers for each new header file,
365 but at this level we just need to know which files there have been;
366 so we record the file when its "begin" is seen and ignore the "end". */
369 add_new_header_file (name
, instance
)
375 /* Make sure there is room for one more header file. */
377 if (n_header_files
== n_allocated_header_files
)
379 n_allocated_header_files
*= 2;
380 header_files
= (struct header_file
*)
381 xrealloc ((char *) header_files
,
382 (n_allocated_header_files
* sizeof (struct header_file
)));
385 /* Create an entry for this header file. */
387 i
= n_header_files
++;
388 header_files
[i
].name
= savestring (name
, strlen(name
));
389 header_files
[i
].instance
= instance
;
390 header_files
[i
].length
= 10;
391 header_files
[i
].vector
392 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
393 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
395 add_this_object_header_file (i
);
399 static struct type
**
400 explicit_lookup_type (real_filenum
, index
)
401 int real_filenum
, index
;
403 register struct header_file
*f
= &header_files
[real_filenum
];
405 if (index
>= f
->length
)
408 f
->vector
= (struct type
**)
409 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
410 bzero (&f
->vector
[f
->length
/ 2],
411 f
->length
* sizeof (struct type
*) / 2);
413 return &f
->vector
[index
];
418 record_minimal_symbol (name
, address
, type
, objfile
)
422 struct objfile
*objfile
;
424 enum minimal_symbol_type ms_type
;
428 case N_TEXT
| N_EXT
: ms_type
= mst_text
; break;
429 case N_DATA
| N_EXT
: ms_type
= mst_data
; break;
430 case N_BSS
| N_EXT
: ms_type
= mst_bss
; break;
431 case N_ABS
| N_EXT
: ms_type
= mst_abs
; break;
433 case N_SETV
| N_EXT
: ms_type
= mst_data
; break;
435 /* I don't think this type actually exists; since a N_SETV is the result
436 of going over many .o files, it doesn't make sense to have one
438 ms_type
= mst_file_data
;
442 /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
443 the minimal symbols, because if there is also another symbol
444 at the same address (e.g. the first function of the file),
445 lookup_minimal_symbol_by_pc would have no way of getting the
448 && (strcmp (name
, GCC_COMPILED_FLAG_SYMBOL
) == 0
449 || strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
) == 0))
453 char *tempstring
= name
;
454 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
456 if (STREQN (tempstring
, "__gnu_compiled", 14))
463 ms_type
= mst_file_text
;
467 ms_type
= mst_file_data
;
469 /* Check for __DYNAMIC, which is used by Sun shared libraries.
470 Record it as global even if it's local, not global, so
471 lookup_minimal_symbol can find it. We don't check symbol_leading_char
472 because for SunOS4 it always is '_'. */
473 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
476 /* Same with virtual function tables, both global and static. */
478 char *tempstring
= name
;
479 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
481 if (VTBL_PREFIX_P ((tempstring
)))
487 ms_type
= mst_file_bss
;
490 default: ms_type
= mst_unknown
; break;
493 prim_record_minimal_symbol
494 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
499 /* Scan and build partial symbols for a symbol file.
500 We have been initialized by a call to dbx_symfile_init, which
501 put all the relevant info into a "struct dbx_symfile_info",
502 hung off the objfile structure.
504 SECTION_OFFSETS contains offsets relative to which the symbols in the
505 various sections are (depending where the sections were actually loaded).
506 MAINLINE is true if we are reading the main symbol
507 table (as opposed to a shared lib or dynamically loaded file). */
510 dbx_symfile_read (objfile
, section_offsets
, mainline
)
511 struct objfile
*objfile
;
512 struct section_offsets
*section_offsets
;
513 int mainline
; /* FIXME comments above */
517 struct cleanup
*back_to
;
519 sym_bfd
= objfile
->obfd
;
520 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
522 perror_with_name (objfile
->name
);
524 /* If we are reinitializing, or if we have never loaded syms yet, init */
525 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
526 init_psymbol_list (objfile
);
528 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
529 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
532 back_to
= make_cleanup (really_free_pendings
, 0);
534 init_minimal_symbol_collection ();
535 make_cleanup (discard_minimal_symbols
, 0);
537 /* Now that the symbol table data of the executable file are all in core,
538 process them and define symbols accordingly. */
540 read_dbx_symtab (section_offsets
, objfile
,
541 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
542 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
544 /* Install any minimal symbols that have been collected as the current
545 minimal symbols for this objfile. */
547 install_minimal_symbols (objfile
);
549 if (!have_partial_symbols ()) {
551 printf_filtered ("(no debugging symbols found)...");
555 do_cleanups (back_to
);
558 /* Initialize anything that needs initializing when a completely new
559 symbol file is specified (not just adding some symbols from another
560 file, e.g. a shared library). */
563 dbx_new_init (ignore
)
564 struct objfile
*ignore
;
566 stabsread_new_init ();
567 buildsym_new_init ();
568 init_header_files ();
572 /* dbx_symfile_init ()
573 is the dbx-specific initialization routine for reading symbols.
574 It is passed a struct objfile which contains, among other things,
575 the BFD for the file whose symbols are being read, and a slot for a pointer
576 to "private data" which we fill with goodies.
578 We read the string table into malloc'd space and stash a pointer to it.
580 Since BFD doesn't know how to read debug symbols in a format-independent
581 way (and may never do so...), we have to do it ourselves. We will never
582 be called unless this is an a.out (or very similar) file.
583 FIXME, there should be a cleaner peephole into the BFD environment here. */
585 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
588 dbx_symfile_init (objfile
)
589 struct objfile
*objfile
;
592 bfd
*sym_bfd
= objfile
->obfd
;
593 char *name
= bfd_get_filename (sym_bfd
);
594 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
596 /* Allocate struct to keep track of the symfile */
597 objfile
->sym_private
= (PTR
)
598 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
600 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
601 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
602 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
604 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
606 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
607 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
608 if (!DBX_TEXT_SECT (objfile
))
609 error ("Can't find .text section in symbol file");
611 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
612 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
613 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
615 /* Read the string table and stash it away in the psymbol_obstack. It is
616 only needed as long as we need to expand psymbols into full symbols,
617 so when we blow away the psymbol the string table goes away as well.
618 Note that gdb used to use the results of attempting to malloc the
619 string table, based on the size it read, as a form of sanity check
620 for botched byte swapping, on the theory that a byte swapped string
621 table size would be so totally bogus that the malloc would fail. Now
622 that we put in on the psymbol_obstack, we can't do this since gdb gets
623 a fatal error (out of virtual memory) if the size is bogus. We can
624 however at least check to see if the size is less than the size of
625 the size field itself, or larger than the size of the entire file.
626 Note that all valid string tables have a size greater than zero, since
627 the bytes used to hold the size are included in the count. */
629 if (STRING_TABLE_OFFSET
== 0)
631 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
632 will never be zero, even when there is no string table. This
633 would appear to be a bug in bfd. */
634 DBX_STRINGTAB_SIZE (objfile
) = 0;
635 DBX_STRINGTAB (objfile
) = NULL
;
639 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
641 perror_with_name (name
);
643 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
644 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
647 perror_with_name (name
);
651 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
652 EOF if there is no string table, and attempting to read the size
653 from EOF will read zero bytes. */
654 DBX_STRINGTAB_SIZE (objfile
) = 0;
655 DBX_STRINGTAB (objfile
) = NULL
;
659 /* Read some data that would appear to be the string table size.
660 If there really is a string table, then it is probably the right
661 size. Byteswap if necessary and validate the size. Note that
662 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
663 random data that happened to be at STRING_TABLE_OFFSET, because
664 bfd can't tell us there is no string table, the sanity checks may
665 or may not catch this. */
666 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
668 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
669 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
670 error ("ridiculous string table size (%d bytes).",
671 DBX_STRINGTAB_SIZE (objfile
));
673 DBX_STRINGTAB (objfile
) =
674 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
675 DBX_STRINGTAB_SIZE (objfile
));
677 /* Now read in the string table in one big gulp. */
679 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
681 perror_with_name (name
);
682 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
684 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
685 perror_with_name (name
);
690 /* Perform any local cleanups required when we are done with a particular
691 objfile. I.E, we are in the process of discarding all symbol information
692 for an objfile, freeing up all memory held for it, and unlinking the
693 objfile struct from the global list of known objfiles. */
696 dbx_symfile_finish (objfile
)
697 struct objfile
*objfile
;
699 if (objfile
->sym_private
!= NULL
)
701 mfree (objfile
-> md
, objfile
->sym_private
);
703 free_header_files ();
707 /* Buffer for reading the symbol table entries. */
708 static struct internal_nlist symbuf
[4096];
709 static int symbuf_idx
;
710 static int symbuf_end
;
712 /* Name of last function encountered. Used in Solaris to approximate
713 object file boundaries. */
714 static char *last_function_name
;
716 /* The address in memory of the string table of the object file we are
717 reading (which might not be the "main" object file, but might be a
718 shared library or some other dynamically loaded thing). This is set
719 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
720 when building symtabs, and is used only by next_symbol_text. */
721 static char *stringtab_global
;
723 /* Refill the symbol table input buffer
724 and set the variables that control fetching entries from it.
725 Reports an error if no data available.
726 This function can read past the end of the symbol table
727 (into the string table) but this does no harm. */
730 fill_symbuf (sym_bfd
)
733 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
735 perror_with_name (bfd_get_filename (sym_bfd
));
736 else if (nbytes
== 0)
737 error ("Premature end of file reading symbol table");
738 symbuf_end
= nbytes
/ symbol_size
;
742 #define SWAP_SYMBOL(symp, abfd) \
744 (symp)->n_strx = bfd_h_get_32(abfd, \
745 (unsigned char *)&(symp)->n_strx); \
746 (symp)->n_desc = bfd_h_get_16 (abfd, \
747 (unsigned char *)&(symp)->n_desc); \
748 (symp)->n_value = bfd_h_get_32 (abfd, \
749 (unsigned char *)&(symp)->n_value); \
752 /* Invariant: The symbol pointed to by symbuf_idx is the first one
753 that hasn't been swapped. Swap the symbol at the same time
754 that symbuf_idx is incremented. */
756 /* dbx allows the text of a symbol name to be continued into the
757 next symbol name! When such a continuation is encountered
758 (a \ at the end of the text of a name)
759 call this function to get the continuation. */
762 dbx_next_symbol_text ()
764 if (symbuf_idx
== symbuf_end
)
765 fill_symbuf (symfile_bfd
);
767 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
768 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
769 + file_string_table_offset
;
772 /* Initializes storage for all of the partial symbols that will be
773 created by read_dbx_symtab and subsidiaries. */
776 init_psymbol_list (objfile
)
777 struct objfile
*objfile
;
779 /* Free any previously allocated psymbol lists. */
780 if (objfile
-> global_psymbols
.list
)
781 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
782 if (objfile
-> static_psymbols
.list
)
783 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
785 /* Current best guess is that there are approximately a twentieth
786 of the total symbols (in a debugging file) are global or static
788 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
789 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
790 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
791 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
792 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
793 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
796 /* Initialize the list of bincls to contain none and have some
800 init_bincl_list (number
, objfile
)
802 struct objfile
*objfile
;
804 bincls_allocated
= number
;
805 next_bincl
= bincl_list
= (struct header_file_location
*)
806 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
809 /* Add a bincl to the list. */
812 add_bincl_to_list (pst
, name
, instance
)
813 struct partial_symtab
*pst
;
817 if (next_bincl
>= bincl_list
+ bincls_allocated
)
819 int offset
= next_bincl
- bincl_list
;
820 bincls_allocated
*= 2;
821 bincl_list
= (struct header_file_location
*)
822 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
823 bincls_allocated
* sizeof (struct header_file_location
));
824 next_bincl
= bincl_list
+ offset
;
826 next_bincl
->pst
= pst
;
827 next_bincl
->instance
= instance
;
828 next_bincl
++->name
= name
;
831 /* Given a name, value pair, find the corresponding
832 bincl in the list. Return the partial symtab associated
833 with that header_file_location. */
835 static struct partial_symtab
*
836 find_corresponding_bincl_psymtab (name
, instance
)
840 struct header_file_location
*bincl
;
842 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
843 if (bincl
->instance
== instance
844 && STREQ (name
, bincl
->name
))
847 return (struct partial_symtab
*) 0;
850 /* Free the storage allocated for the bincl list. */
853 free_bincl_list (objfile
)
854 struct objfile
*objfile
;
856 mfree (objfile
-> md
, (PTR
)bincl_list
);
857 bincls_allocated
= 0;
860 /* Given pointers to an a.out symbol table in core containing dbx
861 style data, setup partial_symtab's describing each source file for
862 which debugging information is available.
863 SYMFILE_NAME is the name of the file we are reading from
864 and SECTION_OFFSETS is the set of offsets for the various sections
865 of the file (a set of zeros if the mainline program). */
868 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
869 struct section_offsets
*section_offsets
;
870 struct objfile
*objfile
;
874 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
875 register char *namestring
;
877 int past_first_source_file
= 0;
878 CORE_ADDR last_o_file_start
= 0;
879 struct cleanup
*back_to
;
882 /* End of the text segment of the executable file. */
883 CORE_ADDR end_of_text_addr
;
885 /* Current partial symtab */
886 struct partial_symtab
*pst
;
888 /* List of current psymtab's include files */
889 char **psymtab_include_list
;
890 int includes_allocated
;
893 /* Index within current psymtab dependency list */
894 struct partial_symtab
**dependency_list
;
895 int dependencies_used
, dependencies_allocated
;
897 /* FIXME. We probably want to change stringtab_global rather than add this
898 while processing every symbol entry. FIXME. */
899 file_string_table_offset
= 0;
900 next_file_string_table_offset
= 0;
902 stringtab_global
= DBX_STRINGTAB (objfile
);
904 pst
= (struct partial_symtab
*) 0;
906 includes_allocated
= 30;
908 psymtab_include_list
= (char **) alloca (includes_allocated
*
911 dependencies_allocated
= 30;
912 dependencies_used
= 0;
914 (struct partial_symtab
**) alloca (dependencies_allocated
*
915 sizeof (struct partial_symtab
*));
917 /* Init bincl list */
918 init_bincl_list (20, objfile
);
919 back_to
= make_cleanup (free_bincl_list
, objfile
);
921 last_source_file
= NULL
;
923 #ifdef END_OF_TEXT_DEFAULT
924 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
926 end_of_text_addr
= text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
]
927 + text_size
; /* Relocate */
930 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
931 abfd
= objfile
->obfd
;
932 symbuf_end
= symbuf_idx
= 0;
933 next_symbol_text_func
= dbx_next_symbol_text
;
935 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
937 /* Get the symbol for this run and pull out some info */
938 QUIT
; /* allow this to be interruptable */
939 if (symbuf_idx
== symbuf_end
)
941 bufp
= &symbuf
[symbuf_idx
++];
944 * Special case to speed up readin.
946 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
948 SWAP_SYMBOL (bufp
, abfd
);
950 /* Ok. There is a lot of code duplicated in the rest of this
951 switch statement (for efficiency reasons). Since I don't
952 like duplicating code, I will do my penance here, and
953 describe the code which is duplicated:
955 *) The assignment to namestring.
956 *) The call to strchr.
957 *) The addition of a partial symbol the the two partial
958 symbol lists. This last is a large section of code, so
959 I've imbedded it in the following macro.
962 /* Set namestring based on bufp. If the string table index is invalid,
963 give a fake name, and print a single error message per symbol file read,
964 rather than abort the symbol reading or flood the user with messages. */
966 /*FIXME: Too many adds and indirections in here for the inner loop. */
967 #define SET_NAMESTRING()\
968 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
969 DBX_STRINGTAB_SIZE (objfile)) { \
970 complain (&string_table_offset_complaint, symnum); \
971 namestring = "foo"; \
973 namestring = bufp->n_strx + file_string_table_offset + \
974 DBX_STRINGTAB (objfile)
976 #define CUR_SYMBOL_TYPE bufp->n_type
977 #define CUR_SYMBOL_VALUE bufp->n_value
979 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
980 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
981 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
982 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
984 #include "partial-stab.h"
987 /* If there's stuff to be cleaned up, clean it up. */
988 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
989 /*FIXME, does this have a bug at start address 0? */
991 && objfile
-> ei
.entry_point
< bufp
->n_value
992 && objfile
-> ei
.entry_point
>= last_o_file_start
)
994 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
995 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1000 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1001 symnum
* symbol_size
, end_of_text_addr
,
1002 dependency_list
, dependencies_used
);
1005 do_cleanups (back_to
);
1008 /* Allocate and partially fill a partial symtab. It will be
1009 completely filled at the end of the symbol list.
1011 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1012 is the address relative to which its symbols are (incremental) or 0
1016 struct partial_symtab
*
1017 start_psymtab (objfile
, section_offsets
,
1018 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1019 struct objfile
*objfile
;
1020 struct section_offsets
*section_offsets
;
1024 struct partial_symbol
*global_syms
;
1025 struct partial_symbol
*static_syms
;
1027 struct partial_symtab
*result
=
1028 start_psymtab_common(objfile
, section_offsets
,
1029 filename
, textlow
, global_syms
, static_syms
);
1031 result
->read_symtab_private
= (char *)
1032 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1033 LDSYMOFF(result
) = ldsymoff
;
1034 result
->read_symtab
= dbx_psymtab_to_symtab
;
1035 SYMBOL_SIZE(result
) = symbol_size
;
1036 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1037 STRING_OFFSET(result
) = string_table_offset
;
1038 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1040 /* If we're handling an ELF file, drag some section-relocation info
1041 for this source file out of the ELF symbol table, to compensate for
1042 Sun brain death. This replaces the section_offsets in this psymtab,
1044 elfstab_offset_sections (objfile
, result
);
1046 /* Deduce the source language from the filename for this psymtab. */
1047 psymtab_language
= deduce_language_from_filename (filename
);
1052 /* Close off the current usage of a partial_symbol table entry. This
1053 involves setting the correct number of includes (with a realloc),
1054 setting the high text mark, setting the symbol length in the
1055 executable, and setting the length of the global and static lists
1058 The global symbols and static symbols are then seperately sorted.
1060 Then the partial symtab is put on the global list.
1061 *** List variables and peculiarities of same. ***
1065 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1066 capping_text
, dependency_list
, number_dependencies
)
1067 struct partial_symtab
*pst
;
1068 char **include_list
;
1070 int capping_symbol_offset
;
1071 CORE_ADDR capping_text
;
1072 struct partial_symtab
**dependency_list
;
1073 int number_dependencies
;
1074 /* struct partial_symbol *capping_global, *capping_static;*/
1077 struct partial_symtab
*p1
;
1078 struct objfile
*objfile
= pst
-> objfile
;
1080 if (capping_symbol_offset
!= -1)
1081 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1082 pst
->texthigh
= capping_text
;
1084 /* Under Solaris, the N_SO symbols always have a value of 0,
1085 instead of the usual address of the .o file. Therefore,
1086 we have to do some tricks to fill in texthigh and textlow.
1087 The first trick is in partial-stab.h: if we see a static
1088 or global function, and the textlow for the current pst
1089 is still 0, then we use that function's address for
1090 the textlow of the pst.
1092 Now, to fill in texthigh, we remember the last function seen
1093 in the .o file (also in partial-stab.h). Also, there's a hack in
1094 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1095 to here via the misc_info field. Therefore, we can fill in
1096 a reliable texthigh by taking the address plus size of the
1097 last function in the file.
1099 Unfortunately, that does not cover the case where the last function
1100 in the file is static. See the paragraph below for more comments
1103 Finally, if we have a valid textlow for the current file, we run
1104 down the partial_symtab_list filling in previous texthighs that
1105 are still unknown. */
1107 if (pst
->texthigh
== 0 && last_function_name
) {
1110 struct minimal_symbol
*minsym
;
1112 p
= strchr (last_function_name
, ':');
1114 p
= last_function_name
;
1115 n
= p
- last_function_name
;
1117 strncpy (p
, last_function_name
, n
);
1120 minsym
= lookup_minimal_symbol (p
, objfile
);
1123 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1124 (int) MSYMBOL_INFO (minsym
);
1126 /* This file ends with a static function, and it's
1127 difficult to imagine how hard it would be to track down
1128 the elf symbol. Luckily, most of the time no one will notice,
1129 since the next file will likely be compiled with -g, so
1130 the code below will copy the first fuction's start address
1131 back to our texthigh variable. (Also, if this file is the
1132 last one in a dynamically linked program, texthigh already
1133 has the right value.) If the next file isn't compiled
1134 with -g, then the last function in this file winds up owning
1135 all of the text space up to the next -g file, or the end (minus
1136 shared libraries). This only matters for single stepping,
1137 and even then it will still work, except that it will single
1138 step through all of the covered functions, instead of setting
1139 breakpoints around them as it usualy does. This makes it
1140 pretty slow, but at least it doesn't fail.
1142 We can fix this with a fairly big change to bfd, but we need
1143 to coordinate better with Cygnus if we want to do that. FIXME. */
1145 last_function_name
= NULL
;
1148 /* this test will be true if the last .o file is only data */
1149 if (pst
->textlow
== 0)
1150 pst
->textlow
= pst
->texthigh
;
1152 /* If we know our own starting text address, then walk through all other
1153 psymtabs for this objfile, and if any didn't know their ending text
1154 address, set it to our starting address. Take care to not set our
1155 own ending address to our starting address, nor to set addresses on
1156 `dependency' files that have both textlow and texthigh zero. */
1158 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1159 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1160 p1
->texthigh
= pst
->textlow
;
1161 /* if this file has only data, then make textlow match texthigh */
1162 if (p1
->textlow
== 0)
1163 p1
->textlow
= p1
->texthigh
;
1168 /* End of kludge for patching Solaris textlow and texthigh. */
1171 pst
->n_global_syms
=
1172 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1173 pst
->n_static_syms
=
1174 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1176 pst
->number_of_dependencies
= number_dependencies
;
1177 if (number_dependencies
)
1179 pst
->dependencies
= (struct partial_symtab
**)
1180 obstack_alloc (&objfile
->psymbol_obstack
,
1181 number_dependencies
* sizeof (struct partial_symtab
*));
1182 memcpy (pst
->dependencies
, dependency_list
,
1183 number_dependencies
* sizeof (struct partial_symtab
*));
1186 pst
->dependencies
= 0;
1188 for (i
= 0; i
< num_includes
; i
++)
1190 struct partial_symtab
*subpst
=
1191 allocate_psymtab (include_list
[i
], objfile
);
1193 subpst
->section_offsets
= pst
->section_offsets
;
1194 subpst
->read_symtab_private
=
1195 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1196 sizeof (struct symloc
));
1200 subpst
->texthigh
= 0;
1202 /* We could save slight bits of space by only making one of these,
1203 shared by the entire set of include files. FIXME-someday. */
1204 subpst
->dependencies
= (struct partial_symtab
**)
1205 obstack_alloc (&objfile
->psymbol_obstack
,
1206 sizeof (struct partial_symtab
*));
1207 subpst
->dependencies
[0] = pst
;
1208 subpst
->number_of_dependencies
= 1;
1210 subpst
->globals_offset
=
1211 subpst
->n_global_syms
=
1212 subpst
->statics_offset
=
1213 subpst
->n_static_syms
= 0;
1217 subpst
->read_symtab
= pst
->read_symtab
;
1220 sort_pst_symbols (pst
);
1222 /* If there is already a psymtab or symtab for a file of this name, remove it.
1223 (If there is a symtab, more drastic things also happen.)
1224 This happens in VxWorks. */
1225 free_named_symtabs (pst
->filename
);
1227 if (num_includes
== 0
1228 && number_dependencies
== 0
1229 && pst
->n_global_syms
== 0
1230 && pst
->n_static_syms
== 0) {
1231 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1232 it is on the obstack, but we can forget to chain it on the list. */
1233 struct partial_symtab
*prev_pst
;
1235 /* First, snip it out of the psymtab chain */
1237 if (pst
->objfile
->psymtabs
== pst
)
1238 pst
->objfile
->psymtabs
= pst
->next
;
1240 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1241 if (prev_pst
->next
== pst
)
1242 prev_pst
->next
= pst
->next
;
1244 /* Next, put it on a free list for recycling */
1246 pst
->next
= pst
->objfile
->free_psymtabs
;
1247 pst
->objfile
->free_psymtabs
= pst
;
1252 dbx_psymtab_to_symtab_1 (pst
)
1253 struct partial_symtab
*pst
;
1255 struct cleanup
*old_chain
;
1263 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1268 /* Read in all partial symtabs on which this one is dependent */
1269 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1270 if (!pst
->dependencies
[i
]->readin
)
1272 /* Inform about additional files that need to be read in. */
1275 fputs_filtered (" ", stdout
);
1277 fputs_filtered ("and ", stdout
);
1279 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1280 wrap_here (""); /* Flush output */
1283 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1286 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1288 /* Init stuff necessary for reading in symbols */
1291 old_chain
= make_cleanup (really_free_pendings
, 0);
1292 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1293 symbol_size
= SYMBOL_SIZE (pst
);
1295 /* Read in this file's symbols */
1296 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1297 read_ofile_symtab (pst
);
1298 sort_symtab_syms (pst
->symtab
);
1300 do_cleanups (old_chain
);
1306 /* Read in all of the symbols for a given psymtab for real.
1307 Be verbose about it if the user wants that. */
1310 dbx_psymtab_to_symtab (pst
)
1311 struct partial_symtab
*pst
;
1320 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1325 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1327 /* Print the message now, before reading the string table,
1328 to avoid disconcerting pauses. */
1331 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1335 sym_bfd
= pst
->objfile
->obfd
;
1337 next_symbol_text_func
= dbx_next_symbol_text
;
1339 dbx_psymtab_to_symtab_1 (pst
);
1341 /* Match with global symbols. This only needs to be done once,
1342 after all of the symtabs and dependencies have been read in. */
1343 scan_file_globals (pst
->objfile
);
1345 /* Finish up the debug error message. */
1347 printf_filtered ("done.\n");
1351 /* Read in a defined section of a specific object file's symbols. */
1354 read_ofile_symtab (pst
)
1355 struct partial_symtab
*pst
;
1357 register char *namestring
;
1358 register struct internal_nlist
*bufp
;
1360 unsigned max_symnum
;
1363 struct objfile
*objfile
;
1364 int sym_offset
; /* Offset to start of symbols to read */
1365 int sym_size
; /* Size of symbols to read */
1366 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1367 int text_size
; /* Size of text segment for symbols */
1368 struct section_offsets
*section_offsets
;
1370 objfile
= pst
->objfile
;
1371 sym_offset
= LDSYMOFF(pst
);
1372 sym_size
= LDSYMLEN(pst
);
1373 text_offset
= pst
->textlow
;
1374 text_size
= pst
->texthigh
- pst
->textlow
;
1375 section_offsets
= pst
->section_offsets
;
1377 current_objfile
= objfile
;
1378 subfile_stack
= NULL
;
1380 stringtab_global
= DBX_STRINGTAB (objfile
);
1381 last_source_file
= NULL
;
1383 abfd
= objfile
->obfd
;
1384 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1385 symbuf_end
= symbuf_idx
= 0;
1387 /* It is necessary to actually read one symbol *before* the start
1388 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1389 occurs before the N_SO symbol.
1391 Detecting this in read_dbx_symtab
1392 would slow down initial readin, so we look for it here instead. */
1393 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1395 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1397 bufp
= &symbuf
[symbuf_idx
++];
1398 SWAP_SYMBOL (bufp
, abfd
);
1402 processing_gcc_compilation
= 0;
1403 if (bufp
->n_type
== N_TEXT
)
1405 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1406 processing_gcc_compilation
= 1;
1407 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1408 processing_gcc_compilation
= 2;
1411 /* Try to select a C++ demangling based on the compilation unit
1414 if (processing_gcc_compilation
)
1416 if (AUTO_DEMANGLING
)
1418 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1424 /* The N_SO starting this symtab is the first symbol, so we
1425 better not check the symbol before it. I'm not this can
1426 happen, but it doesn't hurt to check for it. */
1427 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1428 processing_gcc_compilation
= 0;
1431 if (symbuf_idx
== symbuf_end
)
1433 bufp
= &symbuf
[symbuf_idx
];
1434 if (bufp
->n_type
!= (unsigned char)N_SO
)
1435 error("First symbol in segment of executable not a source symbol");
1437 max_symnum
= sym_size
/ symbol_size
;
1440 symnum
< max_symnum
;
1443 QUIT
; /* Allow this to be interruptable */
1444 if (symbuf_idx
== symbuf_end
)
1446 bufp
= &symbuf
[symbuf_idx
++];
1447 SWAP_SYMBOL (bufp
, abfd
);
1449 type
= bufp
->n_type
;
1453 if (type
& N_STAB
) {
1454 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1455 namestring
, section_offsets
, objfile
);
1457 /* We skip checking for a new .o or -l file; that should never
1458 happen in this routine. */
1459 else if (type
== N_TEXT
)
1461 /* I don't think this code will ever be executed, because
1462 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1463 the N_SO symbol which starts this source file.
1464 However, there is no reason not to accept
1465 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1467 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1468 processing_gcc_compilation
= 1;
1469 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1470 processing_gcc_compilation
= 2;
1472 if (AUTO_DEMANGLING
)
1474 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1477 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1478 || type
== (unsigned char)N_NBTEXT
1480 /* Global symbol: see if we came across a dbx defintion for
1481 a corresponding symbol. If so, store the value. Remove
1482 syms from the chain when their values are stored, but
1483 search the whole chain, as there may be several syms from
1484 different files with the same name. */
1485 /* This is probably not true. Since the files will be read
1486 in one at a time, each reference to a global symbol will
1487 be satisfied in each file as it appears. So we skip this
1493 current_objfile
= NULL
;
1495 /* In a Solaris elf file, this variable, which comes from the
1496 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1497 which comes from pst->textlow is correct. */
1498 if (last_source_start_addr
== 0)
1499 last_source_start_addr
= text_offset
;
1501 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1507 /* This handles a single symbol from the symbol-file, building symbols
1508 into a GDB symtab. It takes these arguments and an implicit argument.
1510 TYPE is the type field of the ".stab" symbol entry.
1511 DESC is the desc field of the ".stab" entry.
1512 VALU is the value field of the ".stab" entry.
1513 NAME is the symbol name, in our address space.
1514 SECTION_OFFSETS is a set of amounts by which the sections of this object
1515 file were relocated when it was loaded into memory.
1516 All symbols that refer
1517 to memory locations need to be offset by these amounts.
1518 OBJFILE is the object file from which we are reading symbols.
1519 It is used in end_symtab. */
1522 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1526 struct section_offsets
*section_offsets
;
1527 struct objfile
*objfile
;
1529 #ifdef SUN_FIXED_LBRAC_BUG
1530 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1531 to correct the address of N_LBRAC's. If it is not defined, then
1532 we never need to correct the addresses. */
1534 /* This records the last pc address we've seen. We depend on there being
1535 an SLINE or FUN or SO before the first LBRAC, since the variable does
1536 not get reset in between reads of different symbol files. */
1537 static CORE_ADDR last_pc_address
;
1540 register struct context_stack
*new;
1541 /* This remembers the address of the start of a function. It is used
1542 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1543 relative to the current function's start address. On systems
1544 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1545 used to relocate these symbol types rather than SECTION_OFFSETS. */
1546 static CORE_ADDR function_start_offset
;
1548 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
1549 to the function start address. */
1550 int block_address_function_relative
;
1552 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1553 file. Used to detect the SunPRO solaris compiler. */
1556 /* The stab type used for the definition of the last function.
1557 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1558 static int function_stab_type
= 0;
1560 /* This is true for Solaris (and all other stabs-in-elf systems, hopefully,
1561 since it would be silly to do things differently from Solaris), and
1562 false for SunOS4 and other a.out file formats. */
1563 block_address_function_relative
=
1564 0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3);
1566 if (!block_address_function_relative
)
1567 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1568 function start address, so just use the text offset. */
1569 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1571 /* Something is wrong if we see real data before
1572 seeing a source file name. */
1574 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1576 /* Ignore any symbols which appear before an N_SO symbol. Currently
1577 no one puts symbols there, but we should deal gracefully with the
1578 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1579 but this should not be an error (). */
1587 /* Relocate for dynamic loading */
1588 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1589 goto define_a_symbol
;
1592 /* This "symbol" just indicates the start of an inner lexical
1593 context within a function. */
1595 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1596 /* Relocate for dynamic loading (?). */
1597 valu
+= function_start_offset
;
1599 if (block_address_function_relative
)
1600 /* Relocate for Sun ELF acc fn-relative syms. */
1601 valu
+= function_start_offset
;
1603 /* On most machines, the block addresses are relative to the
1604 N_SO, the linker did not relocate them (sigh). */
1605 valu
+= last_source_start_addr
;
1608 #ifdef SUN_FIXED_LBRAC_BUG
1609 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1610 /* Patch current LBRAC pc value to match last handy pc value */
1611 complain (&lbrac_complaint
);
1612 valu
= last_pc_address
;
1615 new = push_context (desc
, valu
);
1619 /* This "symbol" just indicates the end of an inner lexical
1620 context that was started with N_LBRAC. */
1622 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1623 /* Relocate for dynamic loading (?). */
1624 valu
+= function_start_offset
;
1626 if (block_address_function_relative
)
1627 /* Relocate for Sun ELF acc fn-relative syms. */
1628 valu
+= function_start_offset
;
1630 /* On most machines, the block addresses are relative to the
1631 N_SO, the linker did not relocate them (sigh). */
1632 valu
+= last_source_start_addr
;
1635 new = pop_context();
1636 if (desc
!= new->depth
)
1637 complain (&lbrac_mismatch_complaint
, symnum
);
1639 /* Some compilers put the variable decls inside of an
1640 LBRAC/RBRAC block. This macro should be nonzero if this
1641 is true. DESC is N_DESC from the N_RBRAC symbol.
1642 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1643 or the GCC2_COMPILED_SYMBOL. */
1644 #if !defined (VARIABLES_INSIDE_BLOCK)
1645 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1648 /* Can only use new->locals as local symbols here if we're in
1649 gcc or on a machine that puts them before the lbrack. */
1650 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1651 local_symbols
= new->locals
;
1653 /* If this is not the outermost LBRAC...RBRAC pair in the
1654 function, its local symbols preceded it, and are the ones
1655 just recovered from the context stack. Defined the block for them.
1657 If this is the outermost LBRAC...RBRAC pair, there is no
1658 need to do anything; leave the symbols that preceded it
1659 to be attached to the function's own block. However, if
1660 it is so, we need to indicate that we just moved outside
1663 && (context_stack_depth
1664 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
1666 /* FIXME Muzzle a compiler bug that makes end < start. */
1667 if (new->start_addr
> valu
)
1669 complain (&lbrac_rbrac_complaint
);
1670 new->start_addr
= valu
;
1672 /* Make a block for the local symbols within. */
1673 finish_block (0, &local_symbols
, new->old_blocks
,
1674 new->start_addr
, valu
, objfile
);
1678 within_function
= 0;
1680 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1681 /* Now pop locals of block just finished. */
1682 local_symbols
= new->locals
;
1687 /* This kind of symbol indicates the start of an object file. */
1688 /* Relocate for dynamic loading */
1689 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1693 /* This type of symbol indicates the start of data
1694 for one source file.
1695 Finish the symbol table of the previous source file
1696 (if any) and start accumulating a new symbol table. */
1697 /* Relocate for dynamic loading */
1698 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1702 #ifdef SUN_FIXED_LBRAC_BUG
1703 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1706 #ifdef PCC_SOL_BROKEN
1707 /* pcc bug, occasionally puts out SO for SOL. */
1708 if (context_stack_depth
> 0)
1710 start_subfile (name
, NULL
);
1714 if (last_source_file
)
1716 /* Check if previous symbol was also an N_SO (with some
1717 sanity checks). If so, that one was actually the directory
1718 name, and the current one is the real file name.
1720 if (previous_stab_code
== (unsigned char) N_SO
)
1722 patch_subfile_names (current_subfile
, name
);
1723 break; /* Ignore repeated SOs */
1725 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1729 start_symtab (name
, NULL
, valu
);
1734 /* This type of symbol indicates the start of data for
1735 a sub-source-file, one whose contents were copied or
1736 included in the compilation of the main source file
1737 (whose name was given in the N_SO symbol.) */
1738 /* Relocate for dynamic loading */
1739 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1740 start_subfile (name
, current_subfile
->dirname
);
1745 add_new_header_file (name
, valu
);
1746 start_subfile (name
, current_subfile
->dirname
);
1750 start_subfile (pop_subfile (), current_subfile
->dirname
);
1754 add_old_header_file (name
, valu
);
1758 /* This type of "symbol" really just records
1759 one line-number -- core-address correspondence.
1760 Enter it in the line list for this symbol table. */
1761 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1762 valu
+= function_start_offset
;
1763 #ifdef SUN_FIXED_LBRAC_BUG
1764 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1766 record_line (current_subfile
, desc
, valu
);
1772 static struct complaint msg
= {
1773 "Invalid symbol data: common within common at symtab pos %d",
1775 complain (&msg
, symnum
);
1777 common_block
= local_symbols
;
1778 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
1782 /* Symbols declared since the BCOMM are to have the common block
1783 start address added in when we know it. common_block points to
1784 the first symbol after the BCOMM in the local_symbols list;
1785 copy the list and hang it off the symbol for the common block name
1789 struct symbol
*sym
=
1790 (struct symbol
*) xmmalloc (objfile
-> md
, sizeof (struct symbol
));
1791 memset (sym
, 0, sizeof *sym
);
1792 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1793 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1794 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
1795 copy_pending (local_symbols
, common_block_i
, common_block
));
1796 i
= hashname (SYMBOL_NAME (sym
));
1797 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1798 global_sym_chain
[i
] = sym
;
1803 /* The following symbol types need to have the appropriate offset added
1804 to their value; then we process symbol definitions in the name. */
1806 case N_STSYM
: /* Static symbol in data seg */
1807 case N_LCSYM
: /* Static symbol in BSS seg */
1808 case N_ROSYM
: /* Static symbol in Read-only data seg */
1809 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
1810 Solaris2's stabs-in-coff makes *most* symbols relative
1811 but leaves a few absolute. N_STSYM and friends sit on the fence.
1812 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1813 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1814 This leaves us no choice but to search for the 'S' or 'V'...
1815 (or pass the whole section_offsets stuff down ONE MORE function
1816 call level, which we really don't want to do). */
1819 p
= strchr (name
, ':');
1820 if (p
!= 0 && p
[1] == 'S')
1822 /* FIXME! We relocate it by the TEXT offset, in case the
1823 whole module moved in memory. But this is wrong, since
1824 the sections can side around independently. */
1825 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1826 goto define_a_symbol
;
1828 /* Since it's not the kludge case, re-dispatch to the right handler. */
1830 case N_STSYM
: goto case_N_STSYM
;
1831 case N_LCSYM
: goto case_N_LCSYM
;
1832 case N_ROSYM
: goto case_N_ROSYM
;
1837 case_N_STSYM
: /* Static symbol in data seg */
1838 case N_DSLINE
: /* Source line number, data seg */
1839 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1840 goto define_a_symbol
;
1842 case_N_LCSYM
: /* Static symbol in BSS seg */
1843 case N_BSLINE
: /* Source line number, bss seg */
1844 /* N_BROWS: overlaps with N_BSLINE */
1845 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1846 goto define_a_symbol
;
1848 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1849 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1850 goto define_a_symbol
;
1852 case N_ENTRY
: /* Alternate entry point */
1853 /* Relocate for dynamic loading */
1854 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1855 goto define_a_symbol
;
1857 /* The following symbol types we don't know how to process. Handle
1858 them in a "default" way, but complain to people who care. */
1860 case N_CATCH
: /* Exception handler catcher */
1861 case N_EHDECL
: /* Exception handler name */
1862 case N_PC
: /* Global symbol in Pascal */
1863 case N_M2C
: /* Modula-2 compilation unit */
1864 /* N_MOD2: overlaps with N_EHDECL */
1865 case N_SCOPE
: /* Modula-2 scope information */
1866 case N_ECOML
: /* End common (local name) */
1867 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
1872 complain (&unknown_symtype_complaint
, local_hex_string(type
));
1875 /* The following symbol types don't need the address field relocated,
1876 since it is either unused, or is absolute. */
1878 case N_GSYM
: /* Global variable */
1879 case N_NSYMS
: /* Number of symbols (ultrix) */
1880 case N_NOMAP
: /* No map? (ultrix) */
1881 case N_RSYM
: /* Register variable */
1882 case N_DEFD
: /* Modula-2 GNU module dependency */
1883 case N_SSYM
: /* Struct or union element */
1884 case N_LSYM
: /* Local symbol in stack */
1885 case N_PSYM
: /* Parameter variable */
1886 case N_LENG
: /* Length of preceding symbol type */
1890 char *colon_pos
= strchr (name
, ':');
1891 if (colon_pos
== NULL
)
1894 deftype
= colon_pos
[1];
1900 function_stab_type
= type
;
1902 #ifdef SUN_FIXED_LBRAC_BUG
1903 /* The Sun acc compiler, under SunOS4, puts out
1904 functions with N_GSYM or N_STSYM. The problem is
1905 that the address of the symbol is no good (for N_GSYM
1906 it doesn't even attept an address; for N_STSYM it
1907 puts out an address but then it gets relocated
1908 relative to the data segment, not the text segment).
1909 Currently we can't fix this up later as we do for
1910 some types of symbol in scan_file_globals.
1911 Fortunately we do have a way of finding the address -
1912 we know that the value in last_pc_address is either
1913 the one we want (if we're dealing with the first
1914 function in an object file), or somewhere in the
1915 previous function. This means that we can use the
1916 minimal symbol table to get the address. */
1918 if (type
== N_GSYM
|| type
== N_STSYM
)
1920 struct minimal_symbol
*m
;
1921 int l
= colon_pos
- name
;
1923 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
1924 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
1925 /* last_pc_address was in this function */
1926 valu
= SYMBOL_VALUE (m
);
1927 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
1928 /* last_pc_address was in last function */
1929 valu
= SYMBOL_VALUE (m
+1);
1931 /* Not found - use last_pc_address (for finish_block) */
1932 valu
= last_pc_address
;
1935 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1938 if (block_address_function_relative
)
1939 /* For Solaris 2.0 compilers, the block addresses and
1940 N_SLINE's are relative to the start of the
1941 function. On normal systems, and when using gcc on
1942 Solaris 2.0, these addresses are just absolute, or
1943 relative to the N_SO, depending on
1944 BLOCK_ADDRESS_ABSOLUTE. */
1945 function_start_offset
= valu
;
1947 within_function
= 1;
1948 if (context_stack_depth
> 0)
1950 new = pop_context ();
1951 /* Make a block for the local symbols within. */
1952 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1953 new->start_addr
, valu
, objfile
);
1955 /* Stack must be empty now. */
1956 if (context_stack_depth
!= 0)
1957 complain (&lbrac_unmatched_complaint
, symnum
);
1959 new = push_context (0, valu
);
1960 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1964 define_symbol (valu
, name
, desc
, type
, objfile
);
1970 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1971 for a bunch of other flags, too. Someday we may parse their
1972 flags; for now we ignore theirs and hope they'll ignore ours. */
1973 case N_OPT
: /* Solaris 2: Compiler options */
1976 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
1978 processing_gcc_compilation
= 2;
1979 #if 1 /* Works, but is experimental. -fnf */
1980 if (AUTO_DEMANGLING
)
1982 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1991 /* The following symbol types can be ignored. */
1992 case N_OBJ
: /* Solaris 2: Object file dir and name */
1993 /* N_UNDF: Solaris 2: file separator mark */
1994 /* N_UNDF: -- we will never encounter it, since we only process one
1995 file's symbols at once. */
1996 case N_ENDM
: /* Solaris 2: End of module */
1997 case N_MAIN
: /* Name of main routine. */
2001 previous_stab_code
= type
;
2004 /* Copy a pending list, used to record the contents of a common
2005 block for later fixup. We copy the symbols starting with all
2006 symbols in BEG, and ending with the symbols which are in
2007 END at index ENDI. */
2008 static struct pending
*
2009 copy_pending (beg
, endi
, end
)
2010 struct pending
*beg
;
2012 struct pending
*end
;
2014 struct pending
*new = 0;
2015 struct pending
*next
;
2018 /* Copy all the struct pendings before end. */
2019 for (next
= beg
; next
!= NULL
&& next
!= end
; next
= next
->next
)
2021 for (j
= 0; j
< next
->nsyms
; j
++)
2022 add_symbol_to_list (next
->symbol
[j
], &new);
2025 /* Copy however much of END we need. */
2026 for (j
= endi
; j
< end
->nsyms
; j
++)
2027 add_symbol_to_list (end
->symbol
[j
], &new);
2032 /* Scan and build partial symbols for an ELF symbol file.
2033 This ELF file has already been processed to get its minimal symbols,
2034 and any DWARF symbols that were in it.
2036 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2039 OBJFILE is the object file we are reading symbols from.
2040 ADDR is the address relative to which the symbols are (e.g.
2041 the base address of the text segment).
2042 MAINLINE is true if we are reading the main symbol
2043 table (as opposed to a shared lib or dynamically loaded file).
2044 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2046 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2047 .stabstr section exists.
2049 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2050 adjusted for elf details. */
2053 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2054 staboffset
, stabsize
,
2055 stabstroffset
, stabstrsize
)
2056 struct objfile
*objfile
;
2057 struct section_offsets
*section_offsets
;
2059 file_ptr staboffset
;
2060 unsigned int stabsize
;
2061 file_ptr stabstroffset
;
2062 unsigned int stabstrsize
;
2065 bfd
*sym_bfd
= objfile
->obfd
;
2066 char *name
= bfd_get_filename (sym_bfd
);
2067 struct dbx_symfile_info
*info
;
2069 /* There is already a dbx_symfile_info allocated by our caller.
2070 It might even contain some info from the ELF symtab to help us. */
2071 info
= (struct dbx_symfile_info
*) objfile
->sym_private
;
2073 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2074 if (!DBX_TEXT_SECT (objfile
))
2075 error ("Can't find .text section in symbol file");
2077 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2078 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2079 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2080 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2081 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2083 if (stabstrsize
< 0 /* FIXME: stabstrsize is unsigned; never true! */
2084 || stabstrsize
> bfd_get_size (sym_bfd
))
2085 error ("ridiculous string table size: %d bytes", stabstrsize
);
2086 DBX_STRINGTAB (objfile
) = (char *)
2087 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2089 /* Now read in the string table in one big gulp. */
2091 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2093 perror_with_name (name
);
2094 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2095 if (val
!= stabstrsize
)
2096 perror_with_name (name
);
2098 stabsread_new_init ();
2099 buildsym_new_init ();
2100 free_header_files ();
2101 init_header_files ();
2102 install_minimal_symbols (objfile
);
2104 processing_acc_compilation
= 1;
2106 /* In an elf file, we've already installed the minimal symbols that came
2107 from the elf (non-stab) symbol table, so always act like an
2108 incremental load here. */
2109 dbx_symfile_read (objfile
, section_offsets
, 0);
2112 /* Scan and build partial symbols for a PA symbol file.
2113 This PA file has already been processed to get its minimal symbols.
2115 OBJFILE is the object file we are reading symbols from.
2116 ADDR is the address relative to which the symbols are (e.g.
2117 the base address of the text segment).
2118 MAINLINE is true if we are reading the main symbol
2119 table (as opposed to a shared lib or dynamically loaded file).
2124 pastab_build_psymtabs (objfile
, section_offsets
, mainline
)
2125 struct objfile
*objfile
;
2126 struct section_offsets
*section_offsets
;
2129 free_header_files ();
2130 init_header_files ();
2132 /* In a PA file, we've already installed the minimal symbols that came
2133 from the PA (non-stab) symbol table, so always act like an
2134 incremental load here. */
2136 dbx_symfile_read (objfile
, section_offsets
, mainline
);
2139 /* Parse the user's idea of an offset for dynamic linking, into our idea
2140 of how to represent it for fast symbol reading. */
2142 static struct section_offsets
*
2143 dbx_symfile_offsets (objfile
, addr
)
2144 struct objfile
*objfile
;
2147 struct section_offsets
*section_offsets
;
2150 section_offsets
= (struct section_offsets
*)
2151 obstack_alloc (&objfile
-> psymbol_obstack
,
2152 sizeof (struct section_offsets
) +
2153 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2155 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2156 ANOFFSET (section_offsets
, i
) = addr
;
2158 return section_offsets
;
2161 /* Register our willingness to decode symbols for SunOS and a.out and
2162 NetBSD and b.out files handled by BFD... */
2163 static struct sym_fns sunos_sym_fns
=
2165 "sunOs", /* sym_name: name or name prefix of BFD target type */
2166 6, /* sym_namelen: number of significant sym_name chars */
2167 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2168 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2169 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2170 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2171 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2172 NULL
/* next: pointer to next struct sym_fns */
2175 static struct sym_fns aout_sym_fns
=
2177 "a.out", /* sym_name: name or name prefix of BFD target type */
2178 5, /* sym_namelen: number of significant sym_name chars */
2179 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2180 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2181 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2182 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2183 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2184 NULL
/* next: pointer to next struct sym_fns */
2187 static struct sym_fns netbsd386_sym_fns
=
2189 "netbsd-386", /* sym_name: name or name prefix of BFD target type */
2190 10, /* sym_namelen: number of significant sym_name chars */
2191 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2192 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2193 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2194 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2195 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2196 NULL
/* next: pointer to next struct sym_fns */
2199 static struct sym_fns bout_sym_fns
=
2201 "b.out", /* sym_name: name or name prefix of BFD target type */
2202 5, /* sym_namelen: number of significant sym_name chars */
2203 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2204 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2205 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2206 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2207 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2208 NULL
/* next: pointer to next struct sym_fns */
2212 _initialize_dbxread ()
2214 add_symtab_fns(&sunos_sym_fns
);
2215 add_symtab_fns(&aout_sym_fns
);
2216 add_symtab_fns(&netbsd386_sym_fns
);
2217 add_symtab_fns(&bout_sym_fns
);