1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This module provides three functions: dbx_symfile_init,
21 which initializes to read a symbol file; dbx_new_init, which
22 discards existing cached information when all symbols are being
23 discarded; and dbx_symfile_read, which reads a symbol table
26 dbx_symfile_read only does the minimum work necessary for letting the
27 user "name" things symbolically; it does not read the entire symtab.
28 Instead, it reads the external and static symbols and puts them in partial
29 symbol tables. When more extensive information is requested of a
30 file, the corresponding partial symbol table is mutated into a full
31 fledged symbol table by going back and reading the symbols
32 for real. dbx_psymtab_to_symtab() is the function that does this */
37 #if defined(USG) || defined(__CYGNUSCLIB__)
38 #include <sys/types.h>
45 /* We don't want to use HP-UX's nlists. */
46 #define _NLIST_INCLUDED
50 #include <sys/param.h>
57 #include "breakpoint.h"
60 #include "gdbcore.h" /* for bfd stuff */
61 #include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
66 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
71 #include "gdb-stabs.h"
73 #include "aout/aout64.h"
74 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
76 /* Each partial symbol table entry contains a pointer to private data for the
77 read_symtab() function to use when expanding a partial symbol table entry
78 to a full symbol table entry.
80 For dbxread this structure contains the offset within the file symbol table
81 of first local symbol for this file, and length (in bytes) of the section
82 of the symbol table devoted to this file's symbols (actually, the section
83 bracketed may contain more than just this file's symbols). It also contains
84 further information needed to locate the symbols if they are in an ELF file.
86 If ldsymlen is 0, the only reason for this thing's existence is the
87 dependency list. Nothing else will happen when it is read in. */
89 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
90 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
91 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
92 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
93 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
94 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
95 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
103 int file_string_offset
;
106 /* Macro to determine which symbols to ignore when reading the first symbol
107 of a file. Some machines override this definition. */
108 #ifndef IGNORE_SYMBOL
109 /* This code is used on Ultrix systems. Ignore it */
110 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
113 /* Macro for name of symbol to indicate a file compiled with gcc. */
114 #ifndef GCC_COMPILED_FLAG_SYMBOL
115 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
118 /* Macro for name of symbol to indicate a file compiled with gcc2. */
119 #ifndef GCC2_COMPILED_FLAG_SYMBOL
120 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
123 /* Define this as 1 if a pcc declaration of a char or short argument
124 gives the correct address. Otherwise assume pcc gives the
125 address of the corresponding int, which is not the same on a
126 big-endian machine. */
128 #ifndef BELIEVE_PCC_PROMOTION
129 #define BELIEVE_PCC_PROMOTION 0
132 /* Nonzero means give verbose info on gdb action. From main.c. */
133 extern int info_verbose
;
135 /* The BFD for this file -- implicit parameter to next_symbol_text. */
137 static bfd
*symfile_bfd
;
139 /* The size of each symbol in the symbol file (in external form).
140 This is set by dbx_symfile_read when building psymtabs, and by
141 dbx_psymtab_to_symtab when building symtabs. */
143 static unsigned symbol_size
;
145 /* This is the offset of the symbol table in the executable file */
146 static unsigned symbol_table_offset
;
148 /* This is the offset of the string table in the executable file */
149 static unsigned string_table_offset
;
151 /* For elf+stab executables, the n_strx field is not a simple index
152 into the string table. Instead, each .o file has a base offset
153 in the string table, and the associated symbols contain offsets
154 from this base. The following two variables contain the base
155 offset for the current and next .o files. */
156 static unsigned int file_string_table_offset
;
157 static unsigned int next_file_string_table_offset
;
159 /* Complaints about the symbols we have encountered. */
161 struct complaint lbrac_complaint
=
162 {"bad block start address patched", 0, 0};
164 struct complaint string_table_offset_complaint
=
165 {"bad string table offset in symbol %d", 0, 0};
167 struct complaint unknown_symtype_complaint
=
168 {"unknown symbol type %s", 0, 0};
170 struct complaint lbrac_rbrac_complaint
=
171 {"block start larger than block end", 0, 0};
173 struct complaint lbrac_unmatched_complaint
=
174 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
176 struct complaint lbrac_mismatch_complaint
=
177 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
179 struct complaint repeated_header_complaint
=
180 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
182 struct complaint repeated_header_name_complaint
=
183 {"\"repeated\" header file not previously seen, named %s", 0, 0};
185 /* During initial symbol readin, we need to have a structure to keep
186 track of which psymtabs have which bincls in them. This structure
187 is used during readin to setup the list of dependencies within each
188 partial symbol table. */
190 struct header_file_location
192 char *name
; /* Name of header file */
193 int instance
; /* See above */
194 struct partial_symtab
*pst
; /* Partial symtab that has the
195 BINCL/EINCL defs for this file */
198 /* The actual list and controling variables */
199 static struct header_file_location
*bincl_list
, *next_bincl
;
200 static int bincls_allocated
;
202 /* Local function prototypes */
205 free_header_files
PARAMS ((void));
208 init_header_files
PARAMS ((void));
210 static struct pending
*
211 copy_pending
PARAMS ((struct pending
*, int, struct pending
*));
213 static struct symtab
*
214 read_ofile_symtab
PARAMS ((struct objfile
*, int, int, CORE_ADDR
, int,
215 struct section_offsets
*));
218 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
221 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
224 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
228 free_bincl_list
PARAMS ((struct objfile
*));
230 static struct partial_symtab
*
231 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
234 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
237 init_bincl_list
PARAMS ((int, struct objfile
*));
240 init_psymbol_list
PARAMS ((struct objfile
*));
243 dbx_next_symbol_text
PARAMS ((void));
246 fill_symbuf
PARAMS ((bfd
*));
249 dbx_symfile_init
PARAMS ((struct objfile
*));
252 dbx_new_init
PARAMS ((struct objfile
*));
255 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
258 dbx_symfile_finish
PARAMS ((struct objfile
*));
261 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
264 add_new_header_file
PARAMS ((char *, int));
267 add_old_header_file
PARAMS ((char *, int));
270 add_this_object_header_file
PARAMS ((int));
272 /* Free up old header file tables */
279 if (header_files
!= NULL
)
281 for (i
= 0; i
< n_header_files
; i
++)
283 free (header_files
[i
].name
);
285 free ((PTR
)header_files
);
289 if (this_object_header_files
)
291 free ((PTR
)this_object_header_files
);
292 this_object_header_files
= NULL
;
294 n_allocated_header_files
= 0;
295 n_allocated_this_object_header_files
= 0;
298 /* Allocate new header file tables */
304 n_allocated_header_files
= 10;
305 header_files
= (struct header_file
*)
306 xmalloc (10 * sizeof (struct header_file
));
308 n_allocated_this_object_header_files
= 10;
309 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
312 /* Add header file number I for this object file
313 at the next successive FILENUM. */
316 add_this_object_header_file (i
)
319 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
321 n_allocated_this_object_header_files
*= 2;
322 this_object_header_files
323 = (int *) xrealloc ((char *) this_object_header_files
,
324 n_allocated_this_object_header_files
* sizeof (int));
327 this_object_header_files
[n_this_object_header_files
++] = i
;
330 /* Add to this file an "old" header file, one already seen in
331 a previous object file. NAME is the header file's name.
332 INSTANCE is its instance code, to select among multiple
333 symbol tables for the same header file. */
336 add_old_header_file (name
, instance
)
340 register struct header_file
*p
= header_files
;
343 for (i
= 0; i
< n_header_files
; i
++)
344 if (!strcmp (p
[i
].name
, name
) && instance
== p
[i
].instance
)
346 add_this_object_header_file (i
);
349 complain (&repeated_header_complaint
, (char *)symnum
);
350 complain (&repeated_header_name_complaint
, name
);
353 /* Add to this file a "new" header file: definitions for its types follow.
354 NAME is the header file's name.
355 Most often this happens only once for each distinct header file,
356 but not necessarily. If it happens more than once, INSTANCE has
357 a different value each time, and references to the header file
358 use INSTANCE values to select among them.
360 dbx output contains "begin" and "end" markers for each new header file,
361 but at this level we just need to know which files there have been;
362 so we record the file when its "begin" is seen and ignore the "end". */
365 add_new_header_file (name
, instance
)
371 /* Make sure there is room for one more header file. */
373 if (n_header_files
== n_allocated_header_files
)
375 n_allocated_header_files
*= 2;
376 header_files
= (struct header_file
*)
377 xrealloc ((char *) header_files
,
378 (n_allocated_header_files
* sizeof (struct header_file
)));
381 /* Create an entry for this header file. */
383 i
= n_header_files
++;
384 header_files
[i
].name
= savestring (name
, strlen(name
));
385 header_files
[i
].instance
= instance
;
386 header_files
[i
].length
= 10;
387 header_files
[i
].vector
388 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
389 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
391 add_this_object_header_file (i
);
395 static struct type
**
396 explicit_lookup_type (real_filenum
, index
)
397 int real_filenum
, index
;
399 register struct header_file
*f
= &header_files
[real_filenum
];
401 if (index
>= f
->length
)
404 f
->vector
= (struct type
**)
405 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
406 bzero (&f
->vector
[f
->length
/ 2],
407 f
->length
* sizeof (struct type
*) / 2);
409 return &f
->vector
[index
];
414 record_minimal_symbol (name
, address
, type
, objfile
)
418 struct objfile
*objfile
;
420 enum minimal_symbol_type ms_type
;
422 switch (type
&~ N_EXT
) {
423 case N_TEXT
: ms_type
= mst_text
; break;
424 case N_DATA
: ms_type
= mst_data
; break;
425 case N_BSS
: ms_type
= mst_bss
; break;
426 case N_ABS
: ms_type
= mst_abs
; break;
428 case N_SETV
: ms_type
= mst_data
; break;
430 default: ms_type
= mst_unknown
; break;
433 prim_record_minimal_symbol (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
437 /* Scan and build partial symbols for a symbol file.
438 We have been initialized by a call to dbx_symfile_init, which
439 put all the relevant info into a "struct dbx_symfile_info",
440 hung off the objfile structure.
442 SECTION_OFFSETS contains offsets relative to which the symbols in the
443 various sections are (depending where the sections were actually loaded).
444 MAINLINE is true if we are reading the main symbol
445 table (as opposed to a shared lib or dynamically loaded file). */
448 dbx_symfile_read (objfile
, section_offsets
, mainline
)
449 struct objfile
*objfile
;
450 struct section_offsets
*section_offsets
;
451 int mainline
; /* FIXME comments above */
456 sym_bfd
= objfile
->obfd
;
457 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), L_SET
);
459 perror_with_name (objfile
->name
);
461 /* If we are reinitializing, or if we have never loaded syms yet, init */
462 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
463 init_psymbol_list (objfile
);
466 symbol_size
= obj_dbx_symbol_entry_size (sym_bfd
);
468 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 buildsym_new_init ();
506 init_header_files ();
510 /* dbx_symfile_init ()
511 is the dbx-specific initialization routine for reading symbols.
512 It is passed a struct objfile which contains, among other things,
513 the BFD for the file whose symbols are being read, and a slot for a pointer
514 to "private data" which we fill with goodies.
516 We read the string table into malloc'd space and stash a pointer to it.
518 Since BFD doesn't know how to read debug symbols in a format-independent
519 way (and may never do so...), we have to do it ourselves. We will never
520 be called unless this is an a.out (or very similar) file.
521 FIXME, there should be a cleaner peephole into the BFD environment here. */
524 dbx_symfile_init (objfile
)
525 struct objfile
*objfile
;
528 bfd
*sym_bfd
= objfile
->obfd
;
529 char *name
= bfd_get_filename (sym_bfd
);
530 unsigned char size_temp
[4];
532 /* Allocate struct to keep track of the symfile */
533 objfile
->sym_private
= (PTR
)
534 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
536 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
538 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_dbx_str_filepos (sym_bfd))
539 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_dbx_sym_filepos (sym_bfd))
540 #define HP_STRING_TABLE_OFFSET (sym_bfd->origin + obj_hp_str_filepos (sym_bfd))
541 #define HP_SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_hp_sym_filepos (sym_bfd))
543 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
544 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
546 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
548 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
549 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
550 if (!DBX_TEXT_SECT (objfile
))
551 error ("Can't find .text section in symbol file");
554 HP_SYMCOUNT (objfile
) = obj_hp_sym_count (sym_bfd
);
555 DBX_SYMCOUNT (objfile
) = obj_dbx_sym_count (sym_bfd
);
557 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
558 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
560 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
562 /* Read the string table and stash it away in the psymbol_obstack. It is
563 only needed as long as we need to expand psymbols into full symbols,
564 so when we blow away the psymbol the string table goes away as well.
565 Note that gdb used to use the results of attempting to malloc the
566 string table, based on the size it read, as a form of sanity check
567 for botched byte swapping, on the theory that a byte swapped string
568 table size would be so totally bogus that the malloc would fail. Now
569 that we put in on the psymbol_obstack, we can't do this since gdb gets
570 a fatal error (out of virtual memory) if the size is bogus. We can
571 however at least check to see if the size is zero or some negative
575 DBX_STRINGTAB_SIZE (objfile
) = obj_dbx_stringtab_size (sym_bfd
);
576 HP_STRINGTAB_SIZE (objfile
) = obj_hp_stringtab_size (sym_bfd
);
578 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, L_SET
);
580 perror_with_name (name
);
582 val
= bfd_read ((PTR
)size_temp
, sizeof (long), 1, sym_bfd
);
584 perror_with_name (name
);
586 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
589 if (DBX_STRINGTAB_SIZE (objfile
) <= 0)
590 error ("ridiculous string table size (%d bytes).",
591 DBX_STRINGTAB_SIZE (objfile
));
593 DBX_STRINGTAB (objfile
) =
594 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
595 DBX_STRINGTAB_SIZE (objfile
));
597 if (HP_STRINGTAB_SIZE (objfile
) <= 0)
598 error ("ridiculous string table size (%d bytes).",
599 HP_STRINGTAB_SIZE (objfile
));
601 HP_STRINGTAB (objfile
) =
602 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
603 HP_STRINGTAB_SIZE (objfile
));
606 /* Now read in the string table in one big gulp. */
608 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, L_SET
);
610 perror_with_name (name
);
611 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
613 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
614 perror_with_name (name
);
616 val
= bfd_seek (sym_bfd
, HP_STRING_TABLE_OFFSET
, L_SET
);
618 perror_with_name (name
);
619 val
= bfd_read (HP_STRINGTAB (objfile
), HP_STRINGTAB_SIZE (objfile
), 1,
621 if (val
!= HP_STRINGTAB_SIZE (objfile
))
622 perror_with_name (name
);
625 HP_SYMTAB_OFFSET (objfile
) = HP_SYMBOL_TABLE_OFFSET
;
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 /* same as above for the HP symbol table */
683 static struct symbol_dictionary_record hp_symbuf
[4096];
684 static int hp_symbuf_idx
;
685 static int hp_symbuf_end
;
688 fill_hp_symbuf (sym_bfd
)
691 int nbytes
= bfd_read ((PTR
)hp_symbuf
, sizeof (hp_symbuf
), 1, sym_bfd
);
693 error ("error or end of file reading symbol table");
694 hp_symbuf_end
= nbytes
/ sizeof (struct symbol_dictionary_record
);
700 #define SWAP_SYMBOL(symp, abfd) \
702 (symp)->n_strx = bfd_h_get_32(abfd, \
703 (unsigned char *)&(symp)->n_strx); \
704 (symp)->n_desc = bfd_h_get_16 (abfd, \
705 (unsigned char *)&(symp)->n_desc); \
706 (symp)->n_value = bfd_h_get_32 (abfd, \
707 (unsigned char *)&(symp)->n_value); \
710 /* Invariant: The symbol pointed to by symbuf_idx is the first one
711 that hasn't been swapped. Swap the symbol at the same time
712 that symbuf_idx is incremented. */
714 /* dbx allows the text of a symbol name to be continued into the
715 next symbol name! When such a continuation is encountered
716 (a \ at the end of the text of a name)
717 call this function to get the continuation. */
720 dbx_next_symbol_text ()
722 if (symbuf_idx
== symbuf_end
)
723 fill_symbuf (symfile_bfd
);
725 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
726 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
727 + file_string_table_offset
;
730 /* Initializes storage for all of the partial symbols that will be
731 created by read_dbx_symtab and subsidiaries. */
734 init_psymbol_list (objfile
)
735 struct objfile
*objfile
;
737 /* Free any previously allocated psymbol lists. */
738 if (objfile
-> global_psymbols
.list
)
739 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
740 if (objfile
-> static_psymbols
.list
)
741 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
743 /* Current best guess is that there are approximately a twentieth
744 of the total symbols (in a debugging file) are global or static
747 objfile
-> global_psymbols
.size
= (DBX_SYMCOUNT (objfile
) +
748 HP_SYMCOUNT (objfile
)) / 10;
749 objfile
-> static_psymbols
.size
= (DBX_SYMCOUNT (objfile
) +
750 HP_SYMCOUNT (objfile
)) / 10;
752 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
753 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
755 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
756 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
757 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
758 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
761 /* Initialize the list of bincls to contain none and have some
765 init_bincl_list (number
, objfile
)
767 struct objfile
*objfile
;
769 bincls_allocated
= number
;
770 next_bincl
= bincl_list
= (struct header_file_location
*)
771 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
774 /* Add a bincl to the list. */
777 add_bincl_to_list (pst
, name
, instance
)
778 struct partial_symtab
*pst
;
782 if (next_bincl
>= bincl_list
+ bincls_allocated
)
784 int offset
= next_bincl
- bincl_list
;
785 bincls_allocated
*= 2;
786 bincl_list
= (struct header_file_location
*)
787 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
788 bincls_allocated
* sizeof (struct header_file_location
));
789 next_bincl
= bincl_list
+ offset
;
791 next_bincl
->pst
= pst
;
792 next_bincl
->instance
= instance
;
793 next_bincl
++->name
= name
;
796 /* Given a name, value pair, find the corresponding
797 bincl in the list. Return the partial symtab associated
798 with that header_file_location. */
800 static struct partial_symtab
*
801 find_corresponding_bincl_psymtab (name
, instance
)
805 struct header_file_location
*bincl
;
807 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
808 if (bincl
->instance
== instance
809 && !strcmp (name
, bincl
->name
))
812 return (struct partial_symtab
*) 0;
815 /* Free the storage allocated for the bincl list. */
818 free_bincl_list (objfile
)
819 struct objfile
*objfile
;
821 mfree (objfile
-> md
, (PTR
)bincl_list
);
822 bincls_allocated
= 0;
825 /* Given pointers to an a.out symbol table in core containing dbx
826 style data, setup partial_symtab's describing each source file for
827 which debugging information is available.
828 SYMFILE_NAME is the name of the file we are reading from
829 and SECTION_OFFSETS is the set of offsets for the various sections
830 of the file (a set of zeros if the mainline program). */
833 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
834 struct section_offsets
*section_offsets
;
835 struct objfile
*objfile
;
839 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
840 register char *namestring
;
842 int past_first_source_file
= 0;
843 CORE_ADDR last_o_file_start
= 0;
844 struct cleanup
*old_chain
;
848 struct symbol_dictionary_record
*hp_bufp
;
850 /* A hack: the first text symbol in the debugging library */
855 /* End of the text segment of the executable file. */
856 CORE_ADDR end_of_text_addr
;
858 /* Current partial symtab */
859 struct partial_symtab
*pst
;
861 /* List of current psymtab's include files */
862 char **psymtab_include_list
;
863 int includes_allocated
;
866 /* Index within current psymtab dependency list */
867 struct partial_symtab
**dependency_list
;
868 int dependencies_used
, dependencies_allocated
;
870 /* FIXME. We probably want to change stringtab_global rather than add this
871 while processing every symbol entry. FIXME. */
872 file_string_table_offset
= 0;
873 next_file_string_table_offset
= 0;
876 stringtab_global
= HP_STRINGTAB (objfile
);
878 stringtab_global
= DBX_STRINGTAB (objfile
);
881 pst
= (struct partial_symtab
*) 0;
883 includes_allocated
= 30;
885 psymtab_include_list
= (char **) alloca (includes_allocated
*
888 dependencies_allocated
= 30;
889 dependencies_used
= 0;
891 (struct partial_symtab
**) alloca (dependencies_allocated
*
892 sizeof (struct partial_symtab
*));
894 old_chain
= make_cleanup (free_objfile
, objfile
);
896 /* Init bincl list */
897 init_bincl_list (20, objfile
);
898 make_cleanup (free_bincl_list
, objfile
);
900 last_source_file
= 0;
902 #ifdef END_OF_TEXT_DEFAULT
903 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
905 end_of_text_addr
= text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
]
906 + text_size
; /* Relocate */
909 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
910 abfd
= objfile
->obfd
;
911 symbuf_end
= symbuf_idx
= 0;
912 next_symbol_text_func
= dbx_next_symbol_text
;
915 /* On pa machines, the global symbols are all in the regular HP-UX
916 symbol table. Read them in first. */
918 hp_symbuf_end
= hp_symbuf_idx
= 0;
919 bfd_seek (abfd
, HP_SYMTAB_OFFSET (objfile
), 0);
921 for (hp_symnum
= 0; hp_symnum
< HP_SYMCOUNT (objfile
); hp_symnum
++)
926 if (hp_symbuf_idx
== hp_symbuf_end
)
927 fill_hp_symbuf (abfd
);
928 hp_bufp
= &hp_symbuf
[hp_symbuf_idx
++];
929 switch (hp_bufp
->symbol_type
)
940 hp_bufp
->symbol_value
&= ~3; /* clear out permission bits */
948 extern int kernel_debugging
;
949 if (!kernel_debugging
)
958 /* Use the address of dbsubc to finish the last psymtab. */
959 if (hp_bufp
->symbol_type
== ST_CODE
&&
960 HP_STRINGTAB (objfile
)[hp_bufp
->name
.n_strx
] == '_' &&
961 !strcmp (HP_STRINGTAB (objfile
) + hp_bufp
->name
.n_strx
, "_dbsubc"))
962 dbsubc_addr
= hp_bufp
->symbol_value
;
963 if (hp_bufp
->symbol_scope
== SS_UNIVERSAL
)
965 if (hp_bufp
->name
.n_strx
> HP_STRINGTAB_SIZE (objfile
))
966 error ("Invalid symbol data; bad HP string table offset: %d",
967 hp_bufp
->name
.n_strx
);
968 /* A hack, but gets the job done. */
969 if (!strcmp (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
971 objfile
-> ei
.entry_file_lowpc
= hp_bufp
->symbol_value
;
972 if (!strcmp (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
974 objfile
-> ei
.entry_file_highpc
= hp_bufp
->symbol_value
;
975 record_minimal_symbol (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
976 hp_bufp
->symbol_value
, dbx_type
| N_EXT
,
980 bfd_seek (abfd
, DBX_SYMTAB_OFFSET (objfile
), 0);
983 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
985 /* Get the symbol for this run and pull out some info */
986 QUIT
; /* allow this to be interruptable */
987 if (symbuf_idx
== symbuf_end
)
989 bufp
= &symbuf
[symbuf_idx
++];
992 * Special case to speed up readin.
994 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
996 SWAP_SYMBOL (bufp
, abfd
);
998 /* Ok. There is a lot of code duplicated in the rest of this
999 switch statement (for efficiency reasons). Since I don't
1000 like duplicating code, I will do my penance here, and
1001 describe the code which is duplicated:
1003 *) The assignment to namestring.
1004 *) The call to strchr.
1005 *) The addition of a partial symbol the the two partial
1006 symbol lists. This last is a large section of code, so
1007 I've imbedded it in the following macro.
1010 /* Set namestring based on bufp. If the string table index is invalid,
1011 give a fake name, and print a single error message per symbol file read,
1012 rather than abort the symbol reading or flood the user with messages. */
1014 /*FIXME: Too many adds and indirections in here for the inner loop. */
1015 #define SET_NAMESTRING()\
1016 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1017 DBX_STRINGTAB_SIZE (objfile)) { \
1018 complain (&string_table_offset_complaint, (char *) symnum); \
1019 namestring = "foo"; \
1021 namestring = bufp->n_strx + file_string_table_offset + \
1022 DBX_STRINGTAB (objfile)
1024 #define CUR_SYMBOL_TYPE bufp->n_type
1025 #define CUR_SYMBOL_VALUE bufp->n_value
1026 #define DBXREAD_ONLY
1027 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1028 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1029 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1030 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1032 #include "partial-stab.h"
1035 /* If there's stuff to be cleaned up, clean it up. */
1037 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1038 /*FIXME, does this have a bug at start address 0? */
1039 && last_o_file_start
1040 && objfile
-> ei
.entry_point
< bufp
->n_value
1041 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1043 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1044 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1051 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1052 symnum
* symbol_size
, dbsubc_addr
,
1053 dependency_list
, dependencies_used
);
1055 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1056 symnum
* symbol_size
, end_of_text_addr
,
1057 dependency_list
, dependencies_used
);
1061 free_bincl_list (objfile
);
1062 discard_cleanups (old_chain
);
1065 /* Allocate and partially fill a partial symtab. It will be
1066 completely filled at the end of the symbol list.
1068 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1069 is the address relative to which its symbols are (incremental) or 0
1073 struct partial_symtab
*
1074 start_psymtab (objfile
, section_offsets
,
1075 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1076 struct objfile
*objfile
;
1077 struct section_offsets
*section_offsets
;
1081 struct partial_symbol
*global_syms
;
1082 struct partial_symbol
*static_syms
;
1084 struct partial_symtab
*result
=
1085 start_psymtab_common(objfile
, section_offsets
,
1086 filename
, textlow
, global_syms
, static_syms
);
1088 result
->read_symtab_private
= (char *)
1089 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1090 LDSYMOFF(result
) = ldsymoff
;
1091 result
->read_symtab
= dbx_psymtab_to_symtab
;
1092 SYMBOL_SIZE(result
) = symbol_size
;
1093 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1094 STRING_OFFSET(result
) = string_table_offset
;
1095 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1097 /* If we're handling an ELF file, drag some section-relocation info
1098 for this source file out of the ELF symbol table, to compensate for
1099 Sun brain death. This replaces the section_offsets in this psymtab,
1101 elfstab_offset_sections (objfile
, result
);
1106 /* Close off the current usage of a partial_symbol table entry. This
1107 involves setting the correct number of includes (with a realloc),
1108 setting the high text mark, setting the symbol length in the
1109 executable, and setting the length of the global and static lists
1112 The global symbols and static symbols are then seperately sorted.
1114 Then the partial symtab is put on the global list.
1115 *** List variables and peculiarities of same. ***
1119 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1120 capping_text
, dependency_list
, number_dependencies
)
1121 struct partial_symtab
*pst
;
1122 char **include_list
;
1124 int capping_symbol_offset
;
1125 CORE_ADDR capping_text
;
1126 struct partial_symtab
**dependency_list
;
1127 int number_dependencies
;
1128 /* struct partial_symbol *capping_global, *capping_static;*/
1131 struct partial_symtab
*p1
;
1132 struct objfile
*objfile
= pst
-> objfile
;
1134 if (capping_symbol_offset
!= -1)
1135 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1136 pst
->texthigh
= capping_text
;
1138 /* Under Solaris, the N_SO symbols always have a value of 0,
1139 instead of the usual address of the .o file. Therefore,
1140 we have to do some tricks to fill in texthigh and textlow.
1141 The first trick is in partial-stab.h: if we see a static
1142 or global function, and the textlow for the current pst
1143 is still 0, then we use that function's address for
1144 the textlow of the pst.
1146 Now, to fill in texthigh, we remember the last function seen
1147 in the .o file (also in partial-stab.h). Also, there's a hack in
1148 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1149 to here via the misc_info field. Therefore, we can fill in
1150 a reliable texthigh by taking the address plus size of the
1151 last function in the file.
1153 Unfortunately, that does not cover the case where the last function
1154 in the file is static. See the paragraph below for more comments
1157 Finally, if we have a valid textlow for the current file, we run
1158 down the partial_symtab_list filling in previous texthighs that
1159 are still unknown. */
1161 if (pst
->texthigh
== 0 && last_function_name
) {
1164 struct minimal_symbol
*minsym
;
1166 p
= strchr (last_function_name
, ':');
1168 p
= last_function_name
;
1169 n
= p
- last_function_name
;
1171 strncpy (p
, last_function_name
, n
);
1174 minsym
= lookup_minimal_symbol (p
, objfile
);
1177 pst
->texthigh
= minsym
->address
+ (int)minsym
->info
;
1179 /* This file ends with a static function, and it's
1180 difficult to imagine how hard it would be to track down
1181 the elf symbol. Luckily, most of the time no one will notice,
1182 since the next file will likely be compiled with -g, so
1183 the code below will copy the first fuction's start address
1184 back to our texthigh variable. (Also, if this file is the
1185 last one in a dynamically linked program, texthigh already
1186 has the right value.) If the next file isn't compiled
1187 with -g, then the last function in this file winds up owning
1188 all of the text space up to the next -g file, or the end (minus
1189 shared libraries). This only matters for single stepping,
1190 and even then it will still work, except that it will single
1191 step through all of the covered functions, instead of setting
1192 breakpoints around them as it usualy does. This makes it
1193 pretty slow, but at least it doesn't fail.
1195 We can fix this with a fairly big change to bfd, but we need
1196 to coordinate better with Cygnus if we want to do that. FIXME. */
1198 last_function_name
= NULL
;
1201 /* this test will be true if the last .o file is only data */
1202 if (pst
->textlow
== 0)
1203 pst
->textlow
= pst
->texthigh
;
1205 /* If we know our own starting text address, then walk through all other
1206 psymtabs for this objfile, and if any didn't know their ending text
1207 address, set it to our starting address. Take care to not set our
1208 own ending address to our starting address, nor to set addresses on
1209 `dependency' files that have both textlow and texthigh zero. */
1211 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1212 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1213 p1
->texthigh
= pst
->textlow
;
1214 /* if this file has only data, then make textlow match texthigh */
1215 if (p1
->textlow
== 0)
1216 p1
->textlow
= p1
->texthigh
;
1221 /* End of kludge for patching Solaris textlow and texthigh. */
1224 pst
->n_global_syms
=
1225 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1226 pst
->n_static_syms
=
1227 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1229 pst
->number_of_dependencies
= number_dependencies
;
1230 if (number_dependencies
)
1232 pst
->dependencies
= (struct partial_symtab
**)
1233 obstack_alloc (&objfile
->psymbol_obstack
,
1234 number_dependencies
* sizeof (struct partial_symtab
*));
1235 memcpy (pst
->dependencies
, dependency_list
,
1236 number_dependencies
* sizeof (struct partial_symtab
*));
1239 pst
->dependencies
= 0;
1241 for (i
= 0; i
< num_includes
; i
++)
1243 struct partial_symtab
*subpst
=
1244 allocate_psymtab (include_list
[i
], objfile
);
1246 subpst
->section_offsets
= pst
->section_offsets
;
1247 subpst
->read_symtab_private
=
1248 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1249 sizeof (struct symloc
));
1253 subpst
->texthigh
= 0;
1255 /* We could save slight bits of space by only making one of these,
1256 shared by the entire set of include files. FIXME-someday. */
1257 subpst
->dependencies
= (struct partial_symtab
**)
1258 obstack_alloc (&objfile
->psymbol_obstack
,
1259 sizeof (struct partial_symtab
*));
1260 subpst
->dependencies
[0] = pst
;
1261 subpst
->number_of_dependencies
= 1;
1263 subpst
->globals_offset
=
1264 subpst
->n_global_syms
=
1265 subpst
->statics_offset
=
1266 subpst
->n_static_syms
= 0;
1270 subpst
->read_symtab
= dbx_psymtab_to_symtab
;
1273 sort_pst_symbols (pst
);
1275 /* If there is already a psymtab or symtab for a file of this name, remove it.
1276 (If there is a symtab, more drastic things also happen.)
1277 This happens in VxWorks. */
1278 free_named_symtabs (pst
->filename
);
1280 if (num_includes
== 0
1281 && number_dependencies
== 0
1282 && pst
->n_global_syms
== 0
1283 && pst
->n_static_syms
== 0) {
1284 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1285 it is on the obstack, but we can forget to chain it on the list. */
1286 struct partial_symtab
*prev_pst
;
1288 /* First, snip it out of the psymtab chain */
1290 if (pst
->objfile
->psymtabs
== pst
)
1291 pst
->objfile
->psymtabs
= pst
->next
;
1293 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1294 if (prev_pst
->next
== pst
)
1295 prev_pst
->next
= pst
->next
;
1297 /* Next, put it on a free list for recycling */
1299 pst
->next
= pst
->objfile
->free_psymtabs
;
1300 pst
->objfile
->free_psymtabs
= pst
;
1305 dbx_psymtab_to_symtab_1 (pst
)
1306 struct partial_symtab
*pst
;
1308 struct cleanup
*old_chain
;
1316 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1321 /* Read in all partial symtabs on which this one is dependent */
1322 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1323 if (!pst
->dependencies
[i
]->readin
)
1325 /* Inform about additional files that need to be read in. */
1328 fputs_filtered (" ", stdout
);
1330 fputs_filtered ("and ", stdout
);
1332 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1333 wrap_here (""); /* Flush output */
1336 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1339 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1341 /* Init stuff necessary for reading in symbols */
1343 old_chain
= make_cleanup (really_free_pendings
, 0);
1344 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1346 symbol_size
= obj_dbx_symbol_entry_size (sym_bfd
);
1348 symbol_size
= SYMBOL_SIZE (pst
);
1351 /* Read in this file's symbols */
1352 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), L_SET
);
1354 read_ofile_symtab (pst
->objfile
, LDSYMOFF(pst
), LDSYMLEN(pst
),
1355 pst
->textlow
, pst
->texthigh
- pst
->textlow
,
1356 pst
->section_offsets
);
1357 sort_symtab_syms (pst
->symtab
);
1359 do_cleanups (old_chain
);
1365 /* Read in all of the symbols for a given psymtab for real.
1366 Be verbose about it if the user wants that. */
1369 dbx_psymtab_to_symtab (pst
)
1370 struct partial_symtab
*pst
;
1379 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1384 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1386 /* Print the message now, before reading the string table,
1387 to avoid disconcerting pauses. */
1390 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1394 sym_bfd
= pst
->objfile
->obfd
;
1396 next_symbol_text_func
= dbx_next_symbol_text
;
1398 dbx_psymtab_to_symtab_1 (pst
);
1400 /* Match with global symbols. This only needs to be done once,
1401 after all of the symtabs and dependencies have been read in. */
1402 scan_file_globals (pst
->objfile
);
1404 /* Finish up the debug error message. */
1406 printf_filtered ("done.\n");
1410 /* Read in a defined section of a specific object file's symbols.
1412 DESC is the file descriptor for the file, positioned at the
1413 beginning of the symtab
1414 SYM_OFFSET is the offset within the file of
1415 the beginning of the symbols we want to read
1416 SYM_SIZE is the size of the symbol info to read in.
1417 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
1418 TEXT_SIZE is the size of the text segment read in.
1419 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
1421 static struct symtab
*
1422 read_ofile_symtab (objfile
, sym_offset
, sym_size
, text_offset
, text_size
,
1424 struct objfile
*objfile
;
1427 CORE_ADDR text_offset
;
1429 struct section_offsets
*section_offsets
;
1431 register char *namestring
;
1432 register struct internal_nlist
*bufp
;
1434 unsigned max_symnum
;
1437 current_objfile
= objfile
;
1441 stringtab_global
= HP_STRINGTAB (objfile
);
1443 stringtab_global
= DBX_STRINGTAB (objfile
);
1445 last_source_file
= 0;
1447 abfd
= objfile
->obfd
;
1448 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1449 symbuf_end
= symbuf_idx
= 0;
1451 /* It is necessary to actually read one symbol *before* the start
1452 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1453 occurs before the N_SO symbol.
1455 Detecting this in read_dbx_symtab
1456 would slow down initial readin, so we look for it here instead. */
1457 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1459 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, L_INCR
);
1461 bufp
= &symbuf
[symbuf_idx
++];
1462 SWAP_SYMBOL (bufp
, abfd
);
1466 processing_gcc_compilation
=
1467 (bufp
->n_type
== N_TEXT
1468 && (strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
) == 0
1469 || strcmp(namestring
, GCC2_COMPILED_FLAG_SYMBOL
) == 0));
1473 /* The N_SO starting this symtab is the first symbol, so we
1474 better not check the symbol before it. I'm not this can
1475 happen, but it doesn't hurt to check for it. */
1476 bfd_seek (symfile_bfd
, sym_offset
, L_INCR
);
1477 processing_gcc_compilation
= 0;
1480 if (symbuf_idx
== symbuf_end
)
1482 bufp
= &symbuf
[symbuf_idx
];
1483 if (bufp
->n_type
!= (unsigned char)N_SO
)
1484 error("First symbol in segment of executable not a source symbol");
1486 max_symnum
= sym_size
/ symbol_size
;
1489 symnum
< max_symnum
;
1492 QUIT
; /* Allow this to be interruptable */
1493 if (symbuf_idx
== symbuf_end
)
1495 bufp
= &symbuf
[symbuf_idx
++];
1496 SWAP_SYMBOL (bufp
, abfd
);
1498 type
= bufp
->n_type
;
1502 if (type
& N_STAB
) {
1503 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1504 namestring
, section_offsets
, objfile
);
1506 /* We skip checking for a new .o or -l file; that should never
1507 happen in this routine. */
1508 else if (type
== N_TEXT
1509 && (strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
) == 0
1510 || strcmp (namestring
, GCC2_COMPILED_FLAG_SYMBOL
) == 0))
1511 /* I don't think this code will ever be executed, because
1512 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1513 the N_SO symbol which starts this source file.
1514 However, there is no reason not to accept
1515 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1516 processing_gcc_compilation
= 1;
1517 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1518 || type
== (unsigned char)N_NBTEXT
1520 /* Global symbol: see if we came across a dbx defintion for
1521 a corresponding symbol. If so, store the value. Remove
1522 syms from the chain when their values are stored, but
1523 search the whole chain, as there may be several syms from
1524 different files with the same name. */
1525 /* This is probably not true. Since the files will be read
1526 in one at a time, each reference to a global symbol will
1527 be satisfied in each file as it appears. So we skip this
1533 current_objfile
= NULL
;
1535 /* In a Solaris elf file, this variable, which comes from the
1536 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1537 which comes from pst->textlow is correct. */
1538 if (last_source_start_addr
== 0)
1539 last_source_start_addr
= text_offset
;
1541 return end_symtab (text_offset
+ text_size
, 0, 0, objfile
);
1544 /* This handles a single symbol from the symbol-file, building symbols
1545 into a GDB symtab. It takes these arguments and an implicit argument.
1547 TYPE is the type field of the ".stab" symbol entry.
1548 DESC is the desc field of the ".stab" entry.
1549 VALU is the value field of the ".stab" entry.
1550 NAME is the symbol name, in our address space.
1551 SECTION_OFFSETS is a set of amounts by which the sections of this object
1552 file were relocated when it was loaded into memory.
1553 All symbols that refer
1554 to memory locations need to be offset by these amounts.
1555 OBJFILE is the object file from which we are reading symbols.
1556 It is used in end_symtab. */
1559 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1563 struct section_offsets
*section_offsets
;
1564 struct objfile
*objfile
;
1566 #ifndef SUN_FIXED_LBRAC_BUG
1567 /* This records the last pc address we've seen. We depend on there being
1568 an SLINE or FUN or SO before the first LBRAC, since the variable does
1569 not get reset in between reads of different symbol files. */
1570 static CORE_ADDR last_pc_address
;
1572 register struct context_stack
*new;
1573 /* This remembers the address of the start of a function. It is used
1574 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1575 relative to the current function's start address. On systems
1576 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1577 used to relocate these symbol types rather than SECTION_OFFSETS. */
1578 static CORE_ADDR function_start_offset
;
1581 /* Something is wrong if we see real data before
1582 seeing a source file name. */
1584 if (last_source_file
== 0 && type
!= (unsigned char)N_SO
)
1586 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
1587 where that code is defined. */
1588 if (IGNORE_SYMBOL (type
))
1591 /* FIXME, this should not be an error, since it precludes extending
1592 the symbol table information in this way... */
1593 error ("Invalid symbol data: does not start by identifying a source file.");
1601 /* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
1602 N_STSYM with a type code of f or F. Can't enable this until we get some
1603 stuff straightened out with psymtabs. FIXME. */
1609 /* Relocate for dynamic loading */
1610 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1612 /* Either of these types of symbols indicates the start of
1613 a new function. We must process its "name" normally for dbx,
1614 but also record the start of a new lexical context, and possibly
1615 also the end of the lexical context for the previous function. */
1616 /* This is not always true. This type of symbol may indicate a
1617 text segment variable. */
1619 colon_pos
= strchr (name
, ':');
1621 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
1623 define_symbol (valu
, name
, desc
, type
, objfile
);
1627 #ifndef SUN_FIXED_LBRAC_BUG
1628 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1631 #ifdef BLOCK_ADDRESS_FUNCTION_RELATIVE
1632 /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1633 are relative to the start of the function. On normal systems,
1634 and when using gcc on Solaris 2.0, these addresses are just
1635 absolute, or relative to the N_SO, depending on
1636 BLOCK_ADDRESS_ABSOLUTE. */
1637 function_start_offset
= valu
;
1639 /* Default on ordinary systems */
1640 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1643 within_function
= 1;
1644 if (context_stack_depth
> 0)
1646 new = pop_context ();
1647 /* Make a block for the local symbols within. */
1648 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1649 new->start_addr
, valu
, objfile
);
1651 /* Stack must be empty now. */
1652 if (context_stack_depth
!= 0)
1653 complain (&lbrac_unmatched_complaint
, (char *) symnum
);
1655 new = push_context (0, valu
);
1656 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1660 /* This "symbol" just indicates the start of an inner lexical
1661 context within a function. */
1663 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1664 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1665 valu
+= function_start_offset
;
1667 /* On most machines, the block addresses are relative to the
1668 N_SO, the linker did not relocate them (sigh). */
1669 valu
+= last_source_start_addr
;
1672 #ifndef SUN_FIXED_LBRAC_BUG
1673 if (valu
< last_pc_address
) {
1674 /* Patch current LBRAC pc value to match last handy pc value */
1675 complain (&lbrac_complaint
, 0);
1676 valu
= last_pc_address
;
1679 new = push_context (desc
, valu
);
1683 /* This "symbol" just indicates the end of an inner lexical
1684 context that was started with N_LBRAC. */
1686 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1687 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1688 valu
+= function_start_offset
;
1690 /* On most machines, the block addresses are relative to the
1691 N_SO, the linker did not relocate them (sigh). */
1692 valu
+= last_source_start_addr
;
1695 new = pop_context();
1696 if (desc
!= new->depth
)
1697 complain (&lbrac_mismatch_complaint
, (char *) symnum
);
1699 /* Some compilers put the variable decls inside of an
1700 LBRAC/RBRAC block. This macro should be nonzero if this
1701 is true. DESC is N_DESC from the N_RBRAC symbol.
1702 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1703 or the GCC2_COMPILED_SYMBOL. */
1704 #if !defined (VARIABLES_INSIDE_BLOCK)
1705 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1708 /* Can only use new->locals as local symbols here if we're in
1709 gcc or on a machine that puts them before the lbrack. */
1710 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1711 local_symbols
= new->locals
;
1713 /* If this is not the outermost LBRAC...RBRAC pair in the
1714 function, its local symbols preceded it, and are the ones
1715 just recovered from the context stack. Defined the block for them.
1717 If this is the outermost LBRAC...RBRAC pair, there is no
1718 need to do anything; leave the symbols that preceded it
1719 to be attached to the function's own block. However, if
1720 it is so, we need to indicate that we just moved outside
1723 && (context_stack_depth
1724 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
1726 /* FIXME Muzzle a compiler bug that makes end < start. */
1727 if (new->start_addr
> valu
)
1729 complain(&lbrac_rbrac_complaint
, 0);
1730 new->start_addr
= valu
;
1732 /* Make a block for the local symbols within. */
1733 finish_block (0, &local_symbols
, new->old_blocks
,
1734 new->start_addr
, valu
, objfile
);
1738 within_function
= 0;
1740 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1741 /* Now pop locals of block just finished. */
1742 local_symbols
= new->locals
;
1747 /* This kind of symbol indicates the start of an object file. */
1748 /* Relocate for dynamic loading */
1749 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1753 /* This type of symbol indicates the start of data
1754 for one source file.
1755 Finish the symbol table of the previous source file
1756 (if any) and start accumulating a new symbol table. */
1757 /* Relocate for dynamic loading */
1758 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1760 #ifndef SUN_FIXED_LBRAC_BUG
1761 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1764 #ifdef PCC_SOL_BROKEN
1765 /* pcc bug, occasionally puts out SO for SOL. */
1766 if (context_stack_depth
> 0)
1768 start_subfile (name
, NULL
);
1772 if (last_source_file
)
1774 /* Check if previous symbol was also an N_SO (with some
1775 sanity checks). If so, that one was actually the directory
1776 name, and the current one is the real file name.
1778 if (previous_stab_code
== N_SO
)
1780 if (current_subfile
&& current_subfile
->dirname
== NULL
1781 && current_subfile
->name
!= NULL
1782 && current_subfile
->name
[strlen(current_subfile
->name
)-1] == '/')
1784 current_subfile
->dirname
= current_subfile
->name
;
1785 current_subfile
->name
=
1786 obsavestring (name
, strlen (name
),
1787 &objfile
-> symbol_obstack
);
1789 break; /* Ignore repeated SOs */
1791 end_symtab (valu
, 0, 0, objfile
);
1793 start_symtab (name
, NULL
, valu
);
1798 /* This type of symbol indicates the start of data for
1799 a sub-source-file, one whose contents were copied or
1800 included in the compilation of the main source file
1801 (whose name was given in the N_SO symbol.) */
1802 /* Relocate for dynamic loading */
1803 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1804 start_subfile (name
, current_subfile
->dirname
);
1809 add_new_header_file (name
, valu
);
1810 start_subfile (name
, current_subfile
->dirname
);
1814 start_subfile (pop_subfile (), current_subfile
->dirname
);
1818 add_old_header_file (name
, valu
);
1822 /* This type of "symbol" really just records
1823 one line-number -- core-address correspondence.
1824 Enter it in the line list for this symbol table. */
1825 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1826 valu
+= function_start_offset
;
1827 #ifndef SUN_FIXED_LBRAC_BUG
1828 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1830 record_line (current_subfile
, desc
, valu
);
1835 error ("Invalid symbol data: common within common at symtab pos %d",
1837 common_block
= local_symbols
;
1838 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
1842 /* Symbols declared since the BCOMM are to have the common block
1843 start address added in when we know it. common_block points to
1844 the first symbol after the BCOMM in the local_symbols list;
1845 copy the list and hang it off the symbol for the common block name
1849 struct symbol
*sym
=
1850 (struct symbol
*) xmmalloc (objfile
-> md
, sizeof (struct symbol
));
1851 memset (sym
, 0, sizeof *sym
);
1852 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1853 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1854 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
1855 copy_pending (local_symbols
, common_block_i
, common_block
));
1856 i
= hashname (SYMBOL_NAME (sym
));
1857 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1858 global_sym_chain
[i
] = sym
;
1863 /* The following symbol types need to have the appropriate offset added
1864 to their value; then we process symbol definitions in the name. */
1866 case N_STSYM
: /* Static symbol in data seg */
1867 case N_LCSYM
: /* Static symbol in BSS seg */
1868 case N_ROSYM
: /* Static symbol in Read-only data seg */
1869 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
1870 Solaris2's stabs-in-coff makes *most* symbols relative
1871 but leaves a few absolute. N_STSYM and friends sit on the fence.
1872 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1873 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1874 This leaves us no choice but to search for the 'S' or 'V'...
1875 (or pass the whole section_offsets stuff down ONE MORE function
1876 call level, which we really don't want to do). */
1879 p
= strchr (name
, ':');
1880 if (p
!= 0 && p
[1] == 'S')
1882 /* FIXME! We relocate it by the TEXT offset, in case the
1883 whole module moved in memory. But this is wrong, since
1884 the sections can side around independently. */
1885 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1886 goto define_a_symbol
;
1888 /* Since it's not the kludge case, re-dispatch to the right handler. */
1890 case N_STSYM
: goto case_N_STSYM
;
1891 case N_LCSYM
: goto case_N_LCSYM
;
1892 case N_ROSYM
: goto case_N_ROSYM
;
1897 case_N_STSYM
: /* Static symbol in data seg */
1898 case N_DSLINE
: /* Source line number, data seg */
1899 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1900 goto define_a_symbol
;
1902 case_N_LCSYM
: /* Static symbol in BSS seg */
1903 case N_BSLINE
: /* Source line number, bss seg */
1904 /* N_BROWS: overlaps with N_BSLINE */
1905 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1906 goto define_a_symbol
;
1908 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1909 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1910 goto define_a_symbol
;
1912 case N_ENTRY
: /* Alternate entry point */
1913 /* Relocate for dynamic loading */
1914 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1915 goto define_a_symbol
;
1917 /* The following symbol types don't need the address field relocated,
1918 since it is either unused, or is absolute. */
1920 case N_GSYM
: /* Global variable */
1921 case N_NSYMS
: /* Number of symbols (ultrix) */
1922 case N_NOMAP
: /* No map? (ultrix) */
1923 case N_RSYM
: /* Register variable */
1924 case N_DEFD
: /* Modula-2 GNU module dependency */
1925 case N_SSYM
: /* Struct or union element */
1926 case N_LSYM
: /* Local symbol in stack */
1927 case N_PSYM
: /* Parameter variable */
1928 case N_LENG
: /* Length of preceding symbol type */
1930 define_symbol (valu
, name
, desc
, type
, objfile
);
1933 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1934 for a bunch of other flags, too. Someday we may parse their
1935 flags; for now we ignore theirs and hope they'll ignore ours. */
1936 case N_OPT
: /* Solaris 2: Compiler options */
1939 if (!strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
))
1940 processing_gcc_compilation
= 1;
1944 /* The following symbol types can be ignored. */
1945 case N_OBJ
: /* Solaris 2: Object file dir and name */
1946 /* N_UNDF: Solaris 2: file separator mark */
1947 /* N_UNDF: -- we will never encounter it, since we only process one
1948 file's symbols at once. */
1949 case N_ENDM
: /* Solaris 2: End of module */
1950 case N_MAIN
: /* Name of main routine. */
1953 /* The following symbol types we don't know how to process. Handle
1954 them in a "default" way, but complain to people who care. */
1956 case N_CATCH
: /* Exception handler catcher */
1957 case N_EHDECL
: /* Exception handler name */
1958 case N_PC
: /* Global symbol in Pascal */
1959 case N_M2C
: /* Modula-2 compilation unit */
1960 /* N_MOD2: overlaps with N_EHDECL */
1961 case N_SCOPE
: /* Modula-2 scope information */
1962 case N_ECOML
: /* End common (local name) */
1963 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
1968 complain (&unknown_symtype_complaint
, local_hex_string(type
));
1970 define_symbol (valu
, name
, desc
, type
, objfile
);
1973 previous_stab_code
= type
;
1976 /* Copy a pending list, used to record the contents of a common
1977 block for later fixup. */
1978 static struct pending
*
1979 copy_pending (beg
, begi
, end
)
1980 struct pending
*beg
;
1982 struct pending
*end
;
1984 struct pending
*new = 0;
1985 struct pending
*next
;
1987 for (next
= beg
; next
!= 0 && (next
!= end
|| begi
< end
->nsyms
);
1988 next
= next
->next
, begi
= 0)
1991 for (j
= begi
; j
< next
->nsyms
; j
++)
1992 add_symbol_to_list (next
->symbol
[j
], &new);
1997 /* Scan and build partial symbols for an ELF symbol file.
1998 This ELF file has already been processed to get its minimal symbols,
1999 and any DWARF symbols that were in it.
2001 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2004 OBJFILE is the object file we are reading symbols from.
2005 ADDR is the address relative to which the symbols are (e.g.
2006 the base address of the text segment).
2007 MAINLINE is true if we are reading the main symbol
2008 table (as opposed to a shared lib or dynamically loaded file).
2009 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2011 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2012 .stabstr section exists.
2014 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2015 adjusted for elf details. */
2018 DEFUN(elfstab_build_psymtabs
, (objfile
, section_offsets
, mainline
,
2019 staboffset
, stabsize
,
2020 stabstroffset
, stabstrsize
),
2021 struct objfile
*objfile AND
2022 struct section_offsets
*section_offsets AND
2024 unsigned int staboffset AND
2025 unsigned int stabsize AND
2026 unsigned int stabstroffset AND
2027 unsigned int stabstrsize
)
2030 bfd
*sym_bfd
= objfile
->obfd
;
2031 char *name
= bfd_get_filename (sym_bfd
);
2032 struct dbx_symfile_info
*info
;
2034 /* There is already a dbx_symfile_info allocated by our caller.
2035 It might even contain some info from the ELF symtab to help us. */
2036 info
= (struct dbx_symfile_info
*) objfile
->sym_private
;
2038 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2039 if (!DBX_TEXT_SECT (objfile
))
2040 error ("Can't find .text section in symbol file");
2042 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2043 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2044 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2045 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2046 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2048 if (stabstrsize
< 0) /* FIXME: stabstrsize is unsigned; never true! */
2049 error ("ridiculous string table size: %d bytes", stabstrsize
);
2050 DBX_STRINGTAB (objfile
) = (char *)
2051 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2053 /* Now read in the string table in one big gulp. */
2055 val
= bfd_seek (sym_bfd
, stabstroffset
, L_SET
);
2057 perror_with_name (name
);
2058 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2059 if (val
!= stabstrsize
)
2060 perror_with_name (name
);
2062 buildsym_new_init ();
2063 free_header_files ();
2064 init_header_files ();
2065 install_minimal_symbols (objfile
);
2067 processing_acc_compilation
= 1;
2069 /* In an elf file, we've already installed the minimal symbols that came
2070 from the elf (non-stab) symbol table, so always act like an
2071 incremental load here. */
2072 dbx_symfile_read (objfile
, section_offsets
, 0);
2075 /* Parse the user's idea of an offset for dynamic linking, into our idea
2076 of how to represent it for fast symbol reading. */
2078 struct section_offsets
*
2079 dbx_symfile_offsets (objfile
, addr
)
2080 struct objfile
*objfile
;
2083 struct section_offsets
*section_offsets
;
2086 section_offsets
= (struct section_offsets
*)
2087 obstack_alloc (&objfile
-> psymbol_obstack
,
2088 sizeof (struct section_offsets
) +
2089 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2091 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2092 ANOFFSET (section_offsets
, i
) = addr
;
2094 return section_offsets
;
2097 /* Register our willingness to decode symbols for SunOS and a.out and
2098 b.out files handled by BFD... */
2099 static struct sym_fns sunos_sym_fns
=
2101 "sunOs", /* sym_name: name or name prefix of BFD target type */
2102 6, /* sym_namelen: number of significant sym_name chars */
2103 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2104 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2105 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2106 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2107 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2108 NULL
/* next: pointer to next struct sym_fns */
2111 static struct sym_fns aout_sym_fns
=
2113 "a.out", /* sym_name: name or name prefix of BFD target type */
2114 5, /* sym_namelen: number of significant sym_name chars */
2115 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2116 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2117 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2118 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2119 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2120 NULL
/* next: pointer to next struct sym_fns */
2123 static struct sym_fns bout_sym_fns
=
2125 "b.out", /* sym_name: name or name prefix of BFD target type */
2126 5, /* sym_namelen: number of significant sym_name chars */
2127 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2128 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2129 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2130 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2131 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2132 NULL
/* next: pointer to next struct sym_fns */
2135 /* This is probably a mistake. FIXME. Why can't the HP's use an ordinary
2136 file format name with an -hppa suffix? */
2137 static struct sym_fns hppa_sym_fns
=
2139 "hppa", /* sym_name: name or name prefix of BFD target type */
2140 4, /* sym_namelen: number of significant sym_name chars */
2141 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2142 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2143 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2144 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2145 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2146 NULL
/* next: pointer to next struct sym_fns */
2150 _initialize_dbxread ()
2152 add_symtab_fns(&sunos_sym_fns
);
2153 add_symtab_fns(&aout_sym_fns
);
2154 add_symtab_fns(&bout_sym_fns
);
2155 add_symtab_fns(&hppa_sym_fns
);