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
;
426 switch (type
&~ N_EXT
) {
427 case N_TEXT
: ms_type
= mst_text
; break;
428 case N_DATA
: ms_type
= mst_data
; break;
429 case N_BSS
: ms_type
= mst_bss
; break;
430 case N_ABS
: ms_type
= mst_abs
; break;
432 case N_SETV
: ms_type
= mst_data
; break;
434 default: ms_type
= mst_unknown
; break;
437 prim_record_minimal_symbol (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
441 /* Scan and build partial symbols for a symbol file.
442 We have been initialized by a call to dbx_symfile_init, which
443 put all the relevant info into a "struct dbx_symfile_info",
444 hung off the objfile structure.
446 SECTION_OFFSETS contains offsets relative to which the symbols in the
447 various sections are (depending where the sections were actually loaded).
448 MAINLINE is true if we are reading the main symbol
449 table (as opposed to a shared lib or dynamically loaded file). */
452 dbx_symfile_read (objfile
, section_offsets
, mainline
)
453 struct objfile
*objfile
;
454 struct section_offsets
*section_offsets
;
455 int mainline
; /* FIXME comments above */
460 sym_bfd
= objfile
->obfd
;
461 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
463 perror_with_name (objfile
->name
);
465 /* If we are reinitializing, or if we have never loaded syms yet, init */
466 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
467 init_psymbol_list (objfile
);
469 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
470 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
473 make_cleanup (really_free_pendings
, 0);
475 init_minimal_symbol_collection ();
476 make_cleanup (discard_minimal_symbols
, 0);
478 /* Now that the symbol table data of the executable file are all in core,
479 process them and define symbols accordingly. */
481 read_dbx_symtab (section_offsets
, objfile
,
482 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
483 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
485 /* Install any minimal symbols that have been collected as the current
486 minimal symbols for this objfile. */
488 install_minimal_symbols (objfile
);
490 if (!have_partial_symbols ()) {
492 printf_filtered ("(no debugging symbols found)...");
497 /* Initialize anything that needs initializing when a completely new
498 symbol file is specified (not just adding some symbols from another
499 file, e.g. a shared library). */
502 dbx_new_init (ignore
)
503 struct objfile
*ignore
;
505 stabsread_new_init ();
506 buildsym_new_init ();
507 init_header_files ();
511 /* dbx_symfile_init ()
512 is the dbx-specific initialization routine for reading symbols.
513 It is passed a struct objfile which contains, among other things,
514 the BFD for the file whose symbols are being read, and a slot for a pointer
515 to "private data" which we fill with goodies.
517 We read the string table into malloc'd space and stash a pointer to it.
519 Since BFD doesn't know how to read debug symbols in a format-independent
520 way (and may never do so...), we have to do it ourselves. We will never
521 be called unless this is an a.out (or very similar) file.
522 FIXME, there should be a cleaner peephole into the BFD environment here. */
524 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
527 dbx_symfile_init (objfile
)
528 struct objfile
*objfile
;
531 bfd
*sym_bfd
= objfile
->obfd
;
532 char *name
= bfd_get_filename (sym_bfd
);
533 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
535 /* Allocate struct to keep track of the symfile */
536 objfile
->sym_private
= (PTR
)
537 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
539 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
540 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
541 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
543 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
545 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
546 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
547 if (!DBX_TEXT_SECT (objfile
))
548 error ("Can't find .text section in symbol file");
550 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
551 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
552 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
554 /* Read the string table and stash it away in the psymbol_obstack. It is
555 only needed as long as we need to expand psymbols into full symbols,
556 so when we blow away the psymbol the string table goes away as well.
557 Note that gdb used to use the results of attempting to malloc the
558 string table, based on the size it read, as a form of sanity check
559 for botched byte swapping, on the theory that a byte swapped string
560 table size would be so totally bogus that the malloc would fail. Now
561 that we put in on the psymbol_obstack, we can't do this since gdb gets
562 a fatal error (out of virtual memory) if the size is bogus. We can
563 however at least check to see if the size is less than the size of
564 the size field itself, or larger than the size of the entire file.
565 Note that all valid string tables have a size greater than zero, since
566 the bytes used to hold the size are included in the count. */
568 if (STRING_TABLE_OFFSET
== 0)
570 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
571 will never be zero, even when there is no string table. This
572 would appear to be a bug in bfd. */
573 DBX_STRINGTAB_SIZE (objfile
) = 0;
574 DBX_STRINGTAB (objfile
) = NULL
;
578 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
580 perror_with_name (name
);
582 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
583 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
586 perror_with_name (name
);
590 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
591 EOF if there is no string table, and attempting to read the size
592 from EOF will read zero bytes. */
593 DBX_STRINGTAB_SIZE (objfile
) = 0;
594 DBX_STRINGTAB (objfile
) = NULL
;
598 /* Read some data that would appear to be the string table size.
599 If there really is a string table, then it is probably the right
600 size. Byteswap if necessary and validate the size. Note that
601 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
602 random data that happened to be at STRING_TABLE_OFFSET, because
603 bfd can't tell us there is no string table, the sanity checks may
604 or may not catch this. */
605 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
607 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
608 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
609 error ("ridiculous string table size (%d bytes).",
610 DBX_STRINGTAB_SIZE (objfile
));
612 DBX_STRINGTAB (objfile
) =
613 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
614 DBX_STRINGTAB_SIZE (objfile
));
616 /* Now read in the string table in one big gulp. */
618 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
620 perror_with_name (name
);
621 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
623 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
624 perror_with_name (name
);
629 /* Perform any local cleanups required when we are done with a particular
630 objfile. I.E, we are in the process of discarding all symbol information
631 for an objfile, freeing up all memory held for it, and unlinking the
632 objfile struct from the global list of known objfiles. */
635 dbx_symfile_finish (objfile
)
636 struct objfile
*objfile
;
638 if (objfile
->sym_private
!= NULL
)
640 mfree (objfile
-> md
, objfile
->sym_private
);
642 free_header_files ();
646 /* Buffer for reading the symbol table entries. */
647 static struct internal_nlist symbuf
[4096];
648 static int symbuf_idx
;
649 static int symbuf_end
;
651 /* Name of last function encountered. Used in Solaris to approximate
652 object file boundaries. */
653 static char *last_function_name
;
655 /* The address in memory of the string table of the object file we are
656 reading (which might not be the "main" object file, but might be a
657 shared library or some other dynamically loaded thing). This is set
658 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
659 when building symtabs, and is used only by next_symbol_text. */
660 static char *stringtab_global
;
662 /* Refill the symbol table input buffer
663 and set the variables that control fetching entries from it.
664 Reports an error if no data available.
665 This function can read past the end of the symbol table
666 (into the string table) but this does no harm. */
669 fill_symbuf (sym_bfd
)
672 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
674 perror_with_name (bfd_get_filename (sym_bfd
));
675 else if (nbytes
== 0)
676 error ("Premature end of file reading symbol table");
677 symbuf_end
= nbytes
/ symbol_size
;
681 #define SWAP_SYMBOL(symp, abfd) \
683 (symp)->n_strx = bfd_h_get_32(abfd, \
684 (unsigned char *)&(symp)->n_strx); \
685 (symp)->n_desc = bfd_h_get_16 (abfd, \
686 (unsigned char *)&(symp)->n_desc); \
687 (symp)->n_value = bfd_h_get_32 (abfd, \
688 (unsigned char *)&(symp)->n_value); \
691 /* Invariant: The symbol pointed to by symbuf_idx is the first one
692 that hasn't been swapped. Swap the symbol at the same time
693 that symbuf_idx is incremented. */
695 /* dbx allows the text of a symbol name to be continued into the
696 next symbol name! When such a continuation is encountered
697 (a \ at the end of the text of a name)
698 call this function to get the continuation. */
701 dbx_next_symbol_text ()
703 if (symbuf_idx
== symbuf_end
)
704 fill_symbuf (symfile_bfd
);
706 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
707 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
708 + file_string_table_offset
;
711 /* Initializes storage for all of the partial symbols that will be
712 created by read_dbx_symtab and subsidiaries. */
715 init_psymbol_list (objfile
)
716 struct objfile
*objfile
;
718 /* Free any previously allocated psymbol lists. */
719 if (objfile
-> global_psymbols
.list
)
720 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
721 if (objfile
-> static_psymbols
.list
)
722 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
724 /* Current best guess is that there are approximately a twentieth
725 of the total symbols (in a debugging file) are global or static
727 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
728 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
729 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
730 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
731 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
732 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
735 /* Initialize the list of bincls to contain none and have some
739 init_bincl_list (number
, objfile
)
741 struct objfile
*objfile
;
743 bincls_allocated
= number
;
744 next_bincl
= bincl_list
= (struct header_file_location
*)
745 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
748 /* Add a bincl to the list. */
751 add_bincl_to_list (pst
, name
, instance
)
752 struct partial_symtab
*pst
;
756 if (next_bincl
>= bincl_list
+ bincls_allocated
)
758 int offset
= next_bincl
- bincl_list
;
759 bincls_allocated
*= 2;
760 bincl_list
= (struct header_file_location
*)
761 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
762 bincls_allocated
* sizeof (struct header_file_location
));
763 next_bincl
= bincl_list
+ offset
;
765 next_bincl
->pst
= pst
;
766 next_bincl
->instance
= instance
;
767 next_bincl
++->name
= name
;
770 /* Given a name, value pair, find the corresponding
771 bincl in the list. Return the partial symtab associated
772 with that header_file_location. */
774 static struct partial_symtab
*
775 find_corresponding_bincl_psymtab (name
, instance
)
779 struct header_file_location
*bincl
;
781 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
782 if (bincl
->instance
== instance
783 && STREQ (name
, bincl
->name
))
786 return (struct partial_symtab
*) 0;
789 /* Free the storage allocated for the bincl list. */
792 free_bincl_list (objfile
)
793 struct objfile
*objfile
;
795 mfree (objfile
-> md
, (PTR
)bincl_list
);
796 bincls_allocated
= 0;
799 /* Given pointers to an a.out symbol table in core containing dbx
800 style data, setup partial_symtab's describing each source file for
801 which debugging information is available.
802 SYMFILE_NAME is the name of the file we are reading from
803 and SECTION_OFFSETS is the set of offsets for the various sections
804 of the file (a set of zeros if the mainline program). */
807 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
808 struct section_offsets
*section_offsets
;
809 struct objfile
*objfile
;
813 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
814 register char *namestring
;
816 int past_first_source_file
= 0;
817 CORE_ADDR last_o_file_start
= 0;
818 struct cleanup
*old_chain
;
821 /* End of the text segment of the executable file. */
822 CORE_ADDR end_of_text_addr
;
824 /* Current partial symtab */
825 struct partial_symtab
*pst
;
827 /* List of current psymtab's include files */
828 char **psymtab_include_list
;
829 int includes_allocated
;
832 /* Index within current psymtab dependency list */
833 struct partial_symtab
**dependency_list
;
834 int dependencies_used
, dependencies_allocated
;
836 /* FIXME. We probably want to change stringtab_global rather than add this
837 while processing every symbol entry. FIXME. */
838 file_string_table_offset
= 0;
839 next_file_string_table_offset
= 0;
841 stringtab_global
= DBX_STRINGTAB (objfile
);
843 pst
= (struct partial_symtab
*) 0;
845 includes_allocated
= 30;
847 psymtab_include_list
= (char **) alloca (includes_allocated
*
850 dependencies_allocated
= 30;
851 dependencies_used
= 0;
853 (struct partial_symtab
**) alloca (dependencies_allocated
*
854 sizeof (struct partial_symtab
*));
856 old_chain
= make_cleanup (free_objfile
, objfile
);
858 /* Init bincl list */
859 init_bincl_list (20, objfile
);
860 make_cleanup (free_bincl_list
, objfile
);
862 last_source_file
= NULL
;
864 #ifdef END_OF_TEXT_DEFAULT
865 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
867 end_of_text_addr
= text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
]
868 + text_size
; /* Relocate */
871 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
872 abfd
= objfile
->obfd
;
873 symbuf_end
= symbuf_idx
= 0;
874 next_symbol_text_func
= dbx_next_symbol_text
;
876 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
878 /* Get the symbol for this run and pull out some info */
879 QUIT
; /* allow this to be interruptable */
880 if (symbuf_idx
== symbuf_end
)
882 bufp
= &symbuf
[symbuf_idx
++];
885 * Special case to speed up readin.
887 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
889 SWAP_SYMBOL (bufp
, abfd
);
891 /* Ok. There is a lot of code duplicated in the rest of this
892 switch statement (for efficiency reasons). Since I don't
893 like duplicating code, I will do my penance here, and
894 describe the code which is duplicated:
896 *) The assignment to namestring.
897 *) The call to strchr.
898 *) The addition of a partial symbol the the two partial
899 symbol lists. This last is a large section of code, so
900 I've imbedded it in the following macro.
903 /* Set namestring based on bufp. If the string table index is invalid,
904 give a fake name, and print a single error message per symbol file read,
905 rather than abort the symbol reading or flood the user with messages. */
907 /*FIXME: Too many adds and indirections in here for the inner loop. */
908 #define SET_NAMESTRING()\
909 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
910 DBX_STRINGTAB_SIZE (objfile)) { \
911 complain (&string_table_offset_complaint, symnum); \
912 namestring = "foo"; \
914 namestring = bufp->n_strx + file_string_table_offset + \
915 DBX_STRINGTAB (objfile)
917 #define CUR_SYMBOL_TYPE bufp->n_type
918 #define CUR_SYMBOL_VALUE bufp->n_value
920 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
921 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
922 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
923 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
925 #include "partial-stab.h"
928 /* If there's stuff to be cleaned up, clean it up. */
929 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
930 /*FIXME, does this have a bug at start address 0? */
932 && objfile
-> ei
.entry_point
< bufp
->n_value
933 && objfile
-> ei
.entry_point
>= last_o_file_start
)
935 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
936 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
941 end_psymtab (pst
, psymtab_include_list
, includes_used
,
942 symnum
* symbol_size
, end_of_text_addr
,
943 dependency_list
, dependencies_used
);
946 free_bincl_list (objfile
);
947 discard_cleanups (old_chain
);
950 /* Allocate and partially fill a partial symtab. It will be
951 completely filled at the end of the symbol list.
953 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
954 is the address relative to which its symbols are (incremental) or 0
958 struct partial_symtab
*
959 start_psymtab (objfile
, section_offsets
,
960 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
961 struct objfile
*objfile
;
962 struct section_offsets
*section_offsets
;
966 struct partial_symbol
*global_syms
;
967 struct partial_symbol
*static_syms
;
969 struct partial_symtab
*result
=
970 start_psymtab_common(objfile
, section_offsets
,
971 filename
, textlow
, global_syms
, static_syms
);
973 result
->read_symtab_private
= (char *)
974 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
975 LDSYMOFF(result
) = ldsymoff
;
976 result
->read_symtab
= dbx_psymtab_to_symtab
;
977 SYMBOL_SIZE(result
) = symbol_size
;
978 SYMBOL_OFFSET(result
) = symbol_table_offset
;
979 STRING_OFFSET(result
) = string_table_offset
;
980 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
982 /* If we're handling an ELF file, drag some section-relocation info
983 for this source file out of the ELF symbol table, to compensate for
984 Sun brain death. This replaces the section_offsets in this psymtab,
986 elfstab_offset_sections (objfile
, result
);
988 /* Deduce the source language from the filename for this psymtab. */
989 psymtab_language
= deduce_language_from_filename (filename
);
994 /* Close off the current usage of a partial_symbol table entry. This
995 involves setting the correct number of includes (with a realloc),
996 setting the high text mark, setting the symbol length in the
997 executable, and setting the length of the global and static lists
1000 The global symbols and static symbols are then seperately sorted.
1002 Then the partial symtab is put on the global list.
1003 *** List variables and peculiarities of same. ***
1007 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1008 capping_text
, dependency_list
, number_dependencies
)
1009 struct partial_symtab
*pst
;
1010 char **include_list
;
1012 int capping_symbol_offset
;
1013 CORE_ADDR capping_text
;
1014 struct partial_symtab
**dependency_list
;
1015 int number_dependencies
;
1016 /* struct partial_symbol *capping_global, *capping_static;*/
1019 struct partial_symtab
*p1
;
1020 struct objfile
*objfile
= pst
-> objfile
;
1022 if (capping_symbol_offset
!= -1)
1023 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1024 pst
->texthigh
= capping_text
;
1026 /* Under Solaris, the N_SO symbols always have a value of 0,
1027 instead of the usual address of the .o file. Therefore,
1028 we have to do some tricks to fill in texthigh and textlow.
1029 The first trick is in partial-stab.h: if we see a static
1030 or global function, and the textlow for the current pst
1031 is still 0, then we use that function's address for
1032 the textlow of the pst.
1034 Now, to fill in texthigh, we remember the last function seen
1035 in the .o file (also in partial-stab.h). Also, there's a hack in
1036 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1037 to here via the misc_info field. Therefore, we can fill in
1038 a reliable texthigh by taking the address plus size of the
1039 last function in the file.
1041 Unfortunately, that does not cover the case where the last function
1042 in the file is static. See the paragraph below for more comments
1045 Finally, if we have a valid textlow for the current file, we run
1046 down the partial_symtab_list filling in previous texthighs that
1047 are still unknown. */
1049 if (pst
->texthigh
== 0 && last_function_name
) {
1052 struct minimal_symbol
*minsym
;
1054 p
= strchr (last_function_name
, ':');
1056 p
= last_function_name
;
1057 n
= p
- last_function_name
;
1059 strncpy (p
, last_function_name
, n
);
1062 minsym
= lookup_minimal_symbol (p
, objfile
);
1065 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1066 (int) MSYMBOL_INFO (minsym
);
1068 /* This file ends with a static function, and it's
1069 difficult to imagine how hard it would be to track down
1070 the elf symbol. Luckily, most of the time no one will notice,
1071 since the next file will likely be compiled with -g, so
1072 the code below will copy the first fuction's start address
1073 back to our texthigh variable. (Also, if this file is the
1074 last one in a dynamically linked program, texthigh already
1075 has the right value.) If the next file isn't compiled
1076 with -g, then the last function in this file winds up owning
1077 all of the text space up to the next -g file, or the end (minus
1078 shared libraries). This only matters for single stepping,
1079 and even then it will still work, except that it will single
1080 step through all of the covered functions, instead of setting
1081 breakpoints around them as it usualy does. This makes it
1082 pretty slow, but at least it doesn't fail.
1084 We can fix this with a fairly big change to bfd, but we need
1085 to coordinate better with Cygnus if we want to do that. FIXME. */
1087 last_function_name
= NULL
;
1090 /* this test will be true if the last .o file is only data */
1091 if (pst
->textlow
== 0)
1092 pst
->textlow
= pst
->texthigh
;
1094 /* If we know our own starting text address, then walk through all other
1095 psymtabs for this objfile, and if any didn't know their ending text
1096 address, set it to our starting address. Take care to not set our
1097 own ending address to our starting address, nor to set addresses on
1098 `dependency' files that have both textlow and texthigh zero. */
1100 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1101 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1102 p1
->texthigh
= pst
->textlow
;
1103 /* if this file has only data, then make textlow match texthigh */
1104 if (p1
->textlow
== 0)
1105 p1
->textlow
= p1
->texthigh
;
1110 /* End of kludge for patching Solaris textlow and texthigh. */
1113 pst
->n_global_syms
=
1114 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1115 pst
->n_static_syms
=
1116 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1118 pst
->number_of_dependencies
= number_dependencies
;
1119 if (number_dependencies
)
1121 pst
->dependencies
= (struct partial_symtab
**)
1122 obstack_alloc (&objfile
->psymbol_obstack
,
1123 number_dependencies
* sizeof (struct partial_symtab
*));
1124 memcpy (pst
->dependencies
, dependency_list
,
1125 number_dependencies
* sizeof (struct partial_symtab
*));
1128 pst
->dependencies
= 0;
1130 for (i
= 0; i
< num_includes
; i
++)
1132 struct partial_symtab
*subpst
=
1133 allocate_psymtab (include_list
[i
], objfile
);
1135 subpst
->section_offsets
= pst
->section_offsets
;
1136 subpst
->read_symtab_private
=
1137 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1138 sizeof (struct symloc
));
1142 subpst
->texthigh
= 0;
1144 /* We could save slight bits of space by only making one of these,
1145 shared by the entire set of include files. FIXME-someday. */
1146 subpst
->dependencies
= (struct partial_symtab
**)
1147 obstack_alloc (&objfile
->psymbol_obstack
,
1148 sizeof (struct partial_symtab
*));
1149 subpst
->dependencies
[0] = pst
;
1150 subpst
->number_of_dependencies
= 1;
1152 subpst
->globals_offset
=
1153 subpst
->n_global_syms
=
1154 subpst
->statics_offset
=
1155 subpst
->n_static_syms
= 0;
1159 subpst
->read_symtab
= pst
->read_symtab
;
1162 sort_pst_symbols (pst
);
1164 /* If there is already a psymtab or symtab for a file of this name, remove it.
1165 (If there is a symtab, more drastic things also happen.)
1166 This happens in VxWorks. */
1167 free_named_symtabs (pst
->filename
);
1169 if (num_includes
== 0
1170 && number_dependencies
== 0
1171 && pst
->n_global_syms
== 0
1172 && pst
->n_static_syms
== 0) {
1173 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1174 it is on the obstack, but we can forget to chain it on the list. */
1175 struct partial_symtab
*prev_pst
;
1177 /* First, snip it out of the psymtab chain */
1179 if (pst
->objfile
->psymtabs
== pst
)
1180 pst
->objfile
->psymtabs
= pst
->next
;
1182 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1183 if (prev_pst
->next
== pst
)
1184 prev_pst
->next
= pst
->next
;
1186 /* Next, put it on a free list for recycling */
1188 pst
->next
= pst
->objfile
->free_psymtabs
;
1189 pst
->objfile
->free_psymtabs
= pst
;
1194 dbx_psymtab_to_symtab_1 (pst
)
1195 struct partial_symtab
*pst
;
1197 struct cleanup
*old_chain
;
1205 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1210 /* Read in all partial symtabs on which this one is dependent */
1211 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1212 if (!pst
->dependencies
[i
]->readin
)
1214 /* Inform about additional files that need to be read in. */
1217 fputs_filtered (" ", stdout
);
1219 fputs_filtered ("and ", stdout
);
1221 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1222 wrap_here (""); /* Flush output */
1225 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1228 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1230 /* Init stuff necessary for reading in symbols */
1233 old_chain
= make_cleanup (really_free_pendings
, 0);
1234 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1235 symbol_size
= SYMBOL_SIZE (pst
);
1237 /* Read in this file's symbols */
1238 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1239 read_ofile_symtab (pst
);
1240 sort_symtab_syms (pst
->symtab
);
1242 do_cleanups (old_chain
);
1248 /* Read in all of the symbols for a given psymtab for real.
1249 Be verbose about it if the user wants that. */
1252 dbx_psymtab_to_symtab (pst
)
1253 struct partial_symtab
*pst
;
1262 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1267 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1269 /* Print the message now, before reading the string table,
1270 to avoid disconcerting pauses. */
1273 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1277 sym_bfd
= pst
->objfile
->obfd
;
1279 next_symbol_text_func
= dbx_next_symbol_text
;
1281 dbx_psymtab_to_symtab_1 (pst
);
1283 /* Match with global symbols. This only needs to be done once,
1284 after all of the symtabs and dependencies have been read in. */
1285 scan_file_globals (pst
->objfile
);
1287 /* Finish up the debug error message. */
1289 printf_filtered ("done.\n");
1293 /* Read in a defined section of a specific object file's symbols. */
1296 read_ofile_symtab (pst
)
1297 struct partial_symtab
*pst
;
1299 register char *namestring
;
1300 register struct internal_nlist
*bufp
;
1302 unsigned max_symnum
;
1305 struct objfile
*objfile
;
1306 int sym_offset
; /* Offset to start of symbols to read */
1307 int sym_size
; /* Size of symbols to read */
1308 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1309 int text_size
; /* Size of text segment for symbols */
1310 struct section_offsets
*section_offsets
;
1312 objfile
= pst
->objfile
;
1313 sym_offset
= LDSYMOFF(pst
);
1314 sym_size
= LDSYMLEN(pst
);
1315 text_offset
= pst
->textlow
;
1316 text_size
= pst
->texthigh
- pst
->textlow
;
1317 section_offsets
= pst
->section_offsets
;
1319 current_objfile
= objfile
;
1320 subfile_stack
= NULL
;
1322 stringtab_global
= DBX_STRINGTAB (objfile
);
1323 last_source_file
= NULL
;
1325 abfd
= objfile
->obfd
;
1326 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1327 symbuf_end
= symbuf_idx
= 0;
1329 /* It is necessary to actually read one symbol *before* the start
1330 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1331 occurs before the N_SO symbol.
1333 Detecting this in read_dbx_symtab
1334 would slow down initial readin, so we look for it here instead. */
1335 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1337 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1339 bufp
= &symbuf
[symbuf_idx
++];
1340 SWAP_SYMBOL (bufp
, abfd
);
1344 processing_gcc_compilation
= 0;
1345 if (bufp
->n_type
== N_TEXT
)
1347 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1348 processing_gcc_compilation
= 1;
1349 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1350 processing_gcc_compilation
= 2;
1353 /* Try to select a C++ demangling based on the compilation unit
1356 if (processing_gcc_compilation
)
1358 if (AUTO_DEMANGLING
)
1360 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1366 /* The N_SO starting this symtab is the first symbol, so we
1367 better not check the symbol before it. I'm not this can
1368 happen, but it doesn't hurt to check for it. */
1369 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1370 processing_gcc_compilation
= 0;
1373 if (symbuf_idx
== symbuf_end
)
1375 bufp
= &symbuf
[symbuf_idx
];
1376 if (bufp
->n_type
!= (unsigned char)N_SO
)
1377 error("First symbol in segment of executable not a source symbol");
1379 max_symnum
= sym_size
/ symbol_size
;
1382 symnum
< max_symnum
;
1385 QUIT
; /* Allow this to be interruptable */
1386 if (symbuf_idx
== symbuf_end
)
1388 bufp
= &symbuf
[symbuf_idx
++];
1389 SWAP_SYMBOL (bufp
, abfd
);
1391 type
= bufp
->n_type
;
1395 if (type
& N_STAB
) {
1396 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1397 namestring
, section_offsets
, objfile
);
1399 /* We skip checking for a new .o or -l file; that should never
1400 happen in this routine. */
1401 else if (type
== N_TEXT
)
1403 /* I don't think this code will ever be executed, because
1404 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1405 the N_SO symbol which starts this source file.
1406 However, there is no reason not to accept
1407 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1409 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1410 processing_gcc_compilation
= 1;
1411 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1412 processing_gcc_compilation
= 2;
1414 if (AUTO_DEMANGLING
)
1416 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1419 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1420 || type
== (unsigned char)N_NBTEXT
1422 /* Global symbol: see if we came across a dbx defintion for
1423 a corresponding symbol. If so, store the value. Remove
1424 syms from the chain when their values are stored, but
1425 search the whole chain, as there may be several syms from
1426 different files with the same name. */
1427 /* This is probably not true. Since the files will be read
1428 in one at a time, each reference to a global symbol will
1429 be satisfied in each file as it appears. So we skip this
1435 current_objfile
= NULL
;
1437 /* In a Solaris elf file, this variable, which comes from the
1438 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1439 which comes from pst->textlow is correct. */
1440 if (last_source_start_addr
== 0)
1441 last_source_start_addr
= text_offset
;
1443 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1449 /* This handles a single symbol from the symbol-file, building symbols
1450 into a GDB symtab. It takes these arguments and an implicit argument.
1452 TYPE is the type field of the ".stab" symbol entry.
1453 DESC is the desc field of the ".stab" entry.
1454 VALU is the value field of the ".stab" entry.
1455 NAME is the symbol name, in our address space.
1456 SECTION_OFFSETS is a set of amounts by which the sections of this object
1457 file were relocated when it was loaded into memory.
1458 All symbols that refer
1459 to memory locations need to be offset by these amounts.
1460 OBJFILE is the object file from which we are reading symbols.
1461 It is used in end_symtab. */
1464 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1468 struct section_offsets
*section_offsets
;
1469 struct objfile
*objfile
;
1471 #ifdef SUN_FIXED_LBRAC_BUG
1472 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1473 to correct the address of N_LBRAC's. If it is not defined, then
1474 we never need to correct the addresses. */
1476 /* This records the last pc address we've seen. We depend on there being
1477 an SLINE or FUN or SO before the first LBRAC, since the variable does
1478 not get reset in between reads of different symbol files. */
1479 static CORE_ADDR last_pc_address
;
1482 register struct context_stack
*new;
1483 /* This remembers the address of the start of a function. It is used
1484 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1485 relative to the current function's start address. On systems
1486 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1487 used to relocate these symbol types rather than SECTION_OFFSETS. */
1488 static CORE_ADDR function_start_offset
;
1491 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
1492 to the function start address. */
1493 int block_address_function_relative
;
1495 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1499 /* This is true for Solaris (and all other stabs-in-elf systems, hopefully,
1500 since it would be silly to do things differently from Solaris), and
1501 false for SunOS4 and other a.out file formats. */
1502 block_address_function_relative
=
1503 0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3);
1505 if (!block_address_function_relative
)
1506 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1507 function start address, so just use the text offset. */
1508 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1510 /* Something is wrong if we see real data before
1511 seeing a source file name. */
1513 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1515 /* Ignore any symbols which appear before an N_SO symbol. Currently
1516 no one puts symbols there, but we should deal gracefully with the
1517 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1518 but this should not be an error (). */
1527 /* The Sun acc compiler, under SunOS4, puts out functions with N_GSYM
1528 or N_STSYM. The problem is that the address of the symbol is no
1529 good (for N_GSYM it doesn't even attept an address; for N_STSYM
1530 it puts out an address but then it gets relocated relative to the
1531 data segment, not the text segment), so we would have to keep track of
1532 where we would use the address (e.g. to close off the block for
1533 the previous function), and patch it later (we already do this for
1534 some symbols, e.g. 'G', but in that case we just need to patch the
1535 symbol, not other data structures). */
1540 /* Relocate for dynamic loading */
1541 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1543 /* Either of these types of symbols indicates the start of
1544 a new function. We must process its "name" normally for dbx,
1545 but also record the start of a new lexical context, and possibly
1546 also the end of the lexical context for the previous function. */
1547 /* This is not always true. This type of symbol may indicate a
1548 text segment variable. */
1550 colon_pos
= strchr (name
, ':');
1552 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
1554 define_symbol (valu
, name
, desc
, type
, objfile
);
1558 #ifdef SUN_FIXED_LBRAC_BUG
1559 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1562 if (block_address_function_relative
)
1563 /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1564 are relative to the start of the function. On normal systems,
1565 and when using gcc on Solaris 2.0, these addresses are just
1566 absolute, or relative to the N_SO, depending on
1567 BLOCK_ADDRESS_ABSOLUTE. */
1568 function_start_offset
= valu
;
1570 within_function
= 1;
1571 if (context_stack_depth
> 0)
1573 new = pop_context ();
1574 /* Make a block for the local symbols within. */
1575 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1576 new->start_addr
, valu
, objfile
);
1578 /* Stack must be empty now. */
1579 if (context_stack_depth
!= 0)
1580 complain (&lbrac_unmatched_complaint
, symnum
);
1582 new = push_context (0, valu
);
1583 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1587 /* This "symbol" just indicates the start of an inner lexical
1588 context within a function. */
1590 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1591 /* Relocate for dynamic loading (?). */
1592 valu
+= function_start_offset
;
1594 if (block_address_function_relative
)
1595 /* Relocate for Sun ELF acc fn-relative syms. */
1596 valu
+= function_start_offset
;
1598 /* On most machines, the block addresses are relative to the
1599 N_SO, the linker did not relocate them (sigh). */
1600 valu
+= last_source_start_addr
;
1603 #ifdef SUN_FIXED_LBRAC_BUG
1604 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1605 /* Patch current LBRAC pc value to match last handy pc value */
1606 complain (&lbrac_complaint
);
1607 valu
= last_pc_address
;
1610 new = push_context (desc
, valu
);
1614 /* This "symbol" just indicates the end of an inner lexical
1615 context that was started with N_LBRAC. */
1617 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1618 /* Relocate for dynamic loading (?). */
1619 valu
+= function_start_offset
;
1621 if (block_address_function_relative
)
1622 /* Relocate for Sun ELF acc fn-relative syms. */
1623 valu
+= function_start_offset
;
1625 /* On most machines, the block addresses are relative to the
1626 N_SO, the linker did not relocate them (sigh). */
1627 valu
+= last_source_start_addr
;
1630 new = pop_context();
1631 if (desc
!= new->depth
)
1632 complain (&lbrac_mismatch_complaint
, symnum
);
1634 /* Some compilers put the variable decls inside of an
1635 LBRAC/RBRAC block. This macro should be nonzero if this
1636 is true. DESC is N_DESC from the N_RBRAC symbol.
1637 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1638 or the GCC2_COMPILED_SYMBOL. */
1639 #if !defined (VARIABLES_INSIDE_BLOCK)
1640 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1643 /* Can only use new->locals as local symbols here if we're in
1644 gcc or on a machine that puts them before the lbrack. */
1645 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1646 local_symbols
= new->locals
;
1648 /* If this is not the outermost LBRAC...RBRAC pair in the
1649 function, its local symbols preceded it, and are the ones
1650 just recovered from the context stack. Defined the block for them.
1652 If this is the outermost LBRAC...RBRAC pair, there is no
1653 need to do anything; leave the symbols that preceded it
1654 to be attached to the function's own block. However, if
1655 it is so, we need to indicate that we just moved outside
1658 && (context_stack_depth
1659 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
1661 /* FIXME Muzzle a compiler bug that makes end < start. */
1662 if (new->start_addr
> valu
)
1664 complain (&lbrac_rbrac_complaint
);
1665 new->start_addr
= valu
;
1667 /* Make a block for the local symbols within. */
1668 finish_block (0, &local_symbols
, new->old_blocks
,
1669 new->start_addr
, valu
, objfile
);
1673 within_function
= 0;
1675 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1676 /* Now pop locals of block just finished. */
1677 local_symbols
= new->locals
;
1682 /* This kind of symbol indicates the start of an object file. */
1683 /* Relocate for dynamic loading */
1684 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1688 /* This type of symbol indicates the start of data
1689 for one source file.
1690 Finish the symbol table of the previous source file
1691 (if any) and start accumulating a new symbol table. */
1692 /* Relocate for dynamic loading */
1693 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1697 #ifdef SUN_FIXED_LBRAC_BUG
1698 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1701 #ifdef PCC_SOL_BROKEN
1702 /* pcc bug, occasionally puts out SO for SOL. */
1703 if (context_stack_depth
> 0)
1705 start_subfile (name
, NULL
);
1709 if (last_source_file
)
1711 /* Check if previous symbol was also an N_SO (with some
1712 sanity checks). If so, that one was actually the directory
1713 name, and the current one is the real file name.
1715 if (previous_stab_code
== (unsigned char) N_SO
)
1717 patch_subfile_names (current_subfile
, name
);
1718 break; /* Ignore repeated SOs */
1720 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1724 start_symtab (name
, NULL
, valu
);
1729 /* This type of symbol indicates the start of data for
1730 a sub-source-file, one whose contents were copied or
1731 included in the compilation of the main source file
1732 (whose name was given in the N_SO symbol.) */
1733 /* Relocate for dynamic loading */
1734 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1735 start_subfile (name
, current_subfile
->dirname
);
1740 add_new_header_file (name
, valu
);
1741 start_subfile (name
, current_subfile
->dirname
);
1745 start_subfile (pop_subfile (), current_subfile
->dirname
);
1749 add_old_header_file (name
, valu
);
1753 /* This type of "symbol" really just records
1754 one line-number -- core-address correspondence.
1755 Enter it in the line list for this symbol table. */
1756 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1757 valu
+= function_start_offset
;
1758 #ifdef SUN_FIXED_LBRAC_BUG
1759 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1761 record_line (current_subfile
, desc
, valu
);
1767 static struct complaint msg
= {
1768 "Invalid symbol data: common within common at symtab pos %d",
1770 complain (&msg
, symnum
);
1772 common_block
= local_symbols
;
1773 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
1777 /* Symbols declared since the BCOMM are to have the common block
1778 start address added in when we know it. common_block points to
1779 the first symbol after the BCOMM in the local_symbols list;
1780 copy the list and hang it off the symbol for the common block name
1784 struct symbol
*sym
=
1785 (struct symbol
*) xmmalloc (objfile
-> md
, sizeof (struct symbol
));
1786 memset (sym
, 0, sizeof *sym
);
1787 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1788 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1789 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
1790 copy_pending (local_symbols
, common_block_i
, common_block
));
1791 i
= hashname (SYMBOL_NAME (sym
));
1792 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1793 global_sym_chain
[i
] = sym
;
1798 /* The following symbol types need to have the appropriate offset added
1799 to their value; then we process symbol definitions in the name. */
1801 case N_STSYM
: /* Static symbol in data seg */
1802 case N_LCSYM
: /* Static symbol in BSS seg */
1803 case N_ROSYM
: /* Static symbol in Read-only data seg */
1804 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
1805 Solaris2's stabs-in-coff makes *most* symbols relative
1806 but leaves a few absolute. N_STSYM and friends sit on the fence.
1807 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1808 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1809 This leaves us no choice but to search for the 'S' or 'V'...
1810 (or pass the whole section_offsets stuff down ONE MORE function
1811 call level, which we really don't want to do). */
1814 p
= strchr (name
, ':');
1815 if (p
!= 0 && p
[1] == 'S')
1817 /* FIXME! We relocate it by the TEXT offset, in case the
1818 whole module moved in memory. But this is wrong, since
1819 the sections can side around independently. */
1820 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1821 goto define_a_symbol
;
1823 /* Since it's not the kludge case, re-dispatch to the right handler. */
1825 case N_STSYM
: goto case_N_STSYM
;
1826 case N_LCSYM
: goto case_N_LCSYM
;
1827 case N_ROSYM
: goto case_N_ROSYM
;
1832 case_N_STSYM
: /* Static symbol in data seg */
1833 case N_DSLINE
: /* Source line number, data seg */
1834 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1835 goto define_a_symbol
;
1837 case_N_LCSYM
: /* Static symbol in BSS seg */
1838 case N_BSLINE
: /* Source line number, bss seg */
1839 /* N_BROWS: overlaps with N_BSLINE */
1840 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1841 goto define_a_symbol
;
1843 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1844 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1845 goto define_a_symbol
;
1847 case N_ENTRY
: /* Alternate entry point */
1848 /* Relocate for dynamic loading */
1849 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1850 goto define_a_symbol
;
1852 /* The following symbol types we don't know how to process. Handle
1853 them in a "default" way, but complain to people who care. */
1855 case N_CATCH
: /* Exception handler catcher */
1856 case N_EHDECL
: /* Exception handler name */
1857 case N_PC
: /* Global symbol in Pascal */
1858 case N_M2C
: /* Modula-2 compilation unit */
1859 /* N_MOD2: overlaps with N_EHDECL */
1860 case N_SCOPE
: /* Modula-2 scope information */
1861 case N_ECOML
: /* End common (local name) */
1862 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
1867 complain (&unknown_symtype_complaint
, local_hex_string(type
));
1870 /* The following symbol types don't need the address field relocated,
1871 since it is either unused, or is absolute. */
1873 case N_GSYM
: /* Global variable */
1874 case N_NSYMS
: /* Number of symbols (ultrix) */
1875 case N_NOMAP
: /* No map? (ultrix) */
1876 case N_RSYM
: /* Register variable */
1877 case N_DEFD
: /* Modula-2 GNU module dependency */
1878 case N_SSYM
: /* Struct or union element */
1879 case N_LSYM
: /* Local symbol in stack */
1880 case N_PSYM
: /* Parameter variable */
1881 case N_LENG
: /* Length of preceding symbol type */
1885 sym
= define_symbol (valu
, name
, desc
, type
, objfile
);
1886 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1888 /* We're not prepared to deal with this case; we won't
1889 patch up the SYMBOL_BLOCK_VALUE in finish_block.
1890 Setting the class to LOC_STATIC isn't particularly useful,
1891 but at least we won't dump core. */
1892 static struct complaint msg
= {
1893 "function encountered with unexpected n_type", 0, 0};
1895 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1900 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1901 for a bunch of other flags, too. Someday we may parse their
1902 flags; for now we ignore theirs and hope they'll ignore ours. */
1903 case N_OPT
: /* Solaris 2: Compiler options */
1906 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
1908 processing_gcc_compilation
= 2;
1909 #if 1 /* Works, but is experimental. -fnf */
1910 if (AUTO_DEMANGLING
)
1912 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1921 /* The following symbol types can be ignored. */
1922 case N_OBJ
: /* Solaris 2: Object file dir and name */
1923 /* N_UNDF: Solaris 2: file separator mark */
1924 /* N_UNDF: -- we will never encounter it, since we only process one
1925 file's symbols at once. */
1926 case N_ENDM
: /* Solaris 2: End of module */
1927 case N_MAIN
: /* Name of main routine. */
1931 previous_stab_code
= type
;
1934 /* Copy a pending list, used to record the contents of a common
1935 block for later fixup. We copy the symbols starting with all
1936 symbols in BEG, and ending with the symbols which are in
1937 END at index ENDI. */
1938 static struct pending
*
1939 copy_pending (beg
, endi
, end
)
1940 struct pending
*beg
;
1942 struct pending
*end
;
1944 struct pending
*new = 0;
1945 struct pending
*next
;
1948 /* Copy all the struct pendings before end. */
1949 for (next
= beg
; next
!= NULL
&& next
!= end
; next
= next
->next
)
1951 for (j
= 0; j
< next
->nsyms
; j
++)
1952 add_symbol_to_list (next
->symbol
[j
], &new);
1955 /* Copy however much of END we need. */
1956 for (j
= endi
; j
< end
->nsyms
; j
++)
1957 add_symbol_to_list (end
->symbol
[j
], &new);
1962 /* Scan and build partial symbols for an ELF symbol file.
1963 This ELF file has already been processed to get its minimal symbols,
1964 and any DWARF symbols that were in it.
1966 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
1969 OBJFILE is the object file we are reading symbols from.
1970 ADDR is the address relative to which the symbols are (e.g.
1971 the base address of the text segment).
1972 MAINLINE is true if we are reading the main symbol
1973 table (as opposed to a shared lib or dynamically loaded file).
1974 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
1976 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
1977 .stabstr section exists.
1979 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
1980 adjusted for elf details. */
1983 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
1984 staboffset
, stabsize
,
1985 stabstroffset
, stabstrsize
)
1986 struct objfile
*objfile
;
1987 struct section_offsets
*section_offsets
;
1989 file_ptr staboffset
;
1990 unsigned int stabsize
;
1991 file_ptr stabstroffset
;
1992 unsigned int stabstrsize
;
1995 bfd
*sym_bfd
= objfile
->obfd
;
1996 char *name
= bfd_get_filename (sym_bfd
);
1997 struct dbx_symfile_info
*info
;
1999 /* There is already a dbx_symfile_info allocated by our caller.
2000 It might even contain some info from the ELF symtab to help us. */
2001 info
= (struct dbx_symfile_info
*) objfile
->sym_private
;
2003 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2004 if (!DBX_TEXT_SECT (objfile
))
2005 error ("Can't find .text section in symbol file");
2007 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2008 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2009 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2010 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2011 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2013 if (stabstrsize
< 0 /* FIXME: stabstrsize is unsigned; never true! */
2014 || stabstrsize
> bfd_get_size (sym_bfd
))
2015 error ("ridiculous string table size: %d bytes", stabstrsize
);
2016 DBX_STRINGTAB (objfile
) = (char *)
2017 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2019 /* Now read in the string table in one big gulp. */
2021 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2023 perror_with_name (name
);
2024 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2025 if (val
!= stabstrsize
)
2026 perror_with_name (name
);
2028 stabsread_new_init ();
2029 buildsym_new_init ();
2030 free_header_files ();
2031 init_header_files ();
2032 install_minimal_symbols (objfile
);
2034 processing_acc_compilation
= 1;
2036 /* In an elf file, we've already installed the minimal symbols that came
2037 from the elf (non-stab) symbol table, so always act like an
2038 incremental load here. */
2039 dbx_symfile_read (objfile
, section_offsets
, 0);
2042 /* Scan and build partial symbols for a PA symbol file.
2043 This PA file has already been processed to get its minimal symbols.
2045 OBJFILE is the object file we are reading symbols from.
2046 ADDR is the address relative to which the symbols are (e.g.
2047 the base address of the text segment).
2048 MAINLINE is true if we are reading the main symbol
2049 table (as opposed to a shared lib or dynamically loaded file).
2054 pastab_build_psymtabs (objfile
, section_offsets
, mainline
)
2055 struct objfile
*objfile
;
2056 struct section_offsets
*section_offsets
;
2059 free_header_files ();
2060 init_header_files ();
2062 /* In a PA file, we've already installed the minimal symbols that came
2063 from the PA (non-stab) symbol table, so always act like an
2064 incremental load here. */
2066 dbx_symfile_read (objfile
, section_offsets
, mainline
);
2069 /* Parse the user's idea of an offset for dynamic linking, into our idea
2070 of how to represent it for fast symbol reading. */
2072 static struct section_offsets
*
2073 dbx_symfile_offsets (objfile
, addr
)
2074 struct objfile
*objfile
;
2077 struct section_offsets
*section_offsets
;
2080 section_offsets
= (struct section_offsets
*)
2081 obstack_alloc (&objfile
-> psymbol_obstack
,
2082 sizeof (struct section_offsets
) +
2083 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2085 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2086 ANOFFSET (section_offsets
, i
) = addr
;
2088 return section_offsets
;
2091 /* Register our willingness to decode symbols for SunOS and a.out and
2092 b.out files handled by BFD... */
2093 static struct sym_fns sunos_sym_fns
=
2095 "sunOs", /* sym_name: name or name prefix of BFD target type */
2096 6, /* sym_namelen: number of significant sym_name chars */
2097 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2098 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2099 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2100 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2101 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2102 NULL
/* next: pointer to next struct sym_fns */
2105 static struct sym_fns aout_sym_fns
=
2107 "a.out", /* sym_name: name or name prefix of BFD target type */
2108 5, /* sym_namelen: number of significant sym_name chars */
2109 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2110 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2111 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2112 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2113 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2114 NULL
/* next: pointer to next struct sym_fns */
2117 static struct sym_fns bout_sym_fns
=
2119 "b.out", /* sym_name: name or name prefix of BFD target type */
2120 5, /* sym_namelen: number of significant sym_name chars */
2121 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2122 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2123 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2124 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2125 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2126 NULL
/* next: pointer to next struct sym_fns */
2130 _initialize_dbxread ()
2132 add_symtab_fns(&sunos_sym_fns
);
2133 add_symtab_fns(&aout_sym_fns
);
2134 add_symtab_fns(&bout_sym_fns
);