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 "stabsread.h"
72 #include "gdb-stabs.h"
75 #include "aout/aout64.h"
76 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
78 /* Each partial symbol table entry contains a pointer to private data for the
79 read_symtab() function to use when expanding a partial symbol table entry
80 to a full symbol table entry.
82 For dbxread this structure contains the offset within the file symbol table
83 of first local symbol for this file, and length (in bytes) of the section
84 of the symbol table devoted to this file's symbols (actually, the section
85 bracketed may contain more than just this file's symbols). It also contains
86 further information needed to locate the symbols if they are in an ELF file.
88 If ldsymlen is 0, the only reason for this thing's existence is the
89 dependency list. Nothing else will happen when it is read in. */
91 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
92 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
93 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
94 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
95 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
96 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
97 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
105 int file_string_offset
;
108 /* Macro to determine which symbols to ignore when reading the first symbol
109 of a file. Some machines override this definition. */
110 #ifndef IGNORE_SYMBOL
111 /* This code is used on Ultrix systems. Ignore it */
112 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
115 /* Macro for name of symbol to indicate a file compiled with gcc. */
116 #ifndef GCC_COMPILED_FLAG_SYMBOL
117 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
120 /* Macro for name of symbol to indicate a file compiled with gcc2. */
121 #ifndef GCC2_COMPILED_FLAG_SYMBOL
122 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
125 /* Define this as 1 if a pcc declaration of a char or short argument
126 gives the correct address. Otherwise assume pcc gives the
127 address of the corresponding int, which is not the same on a
128 big-endian machine. */
130 #ifndef BELIEVE_PCC_PROMOTION
131 #define BELIEVE_PCC_PROMOTION 0
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 lbrac_rbrac_complaint
=
173 {"block start larger than block end", 0, 0};
175 struct complaint lbrac_unmatched_complaint
=
176 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
178 struct complaint lbrac_mismatch_complaint
=
179 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
181 struct complaint repeated_header_complaint
=
182 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
184 struct complaint repeated_header_name_complaint
=
185 {"\"repeated\" header file not previously seen, named %s", 0, 0};
187 /* During initial symbol readin, we need to have a structure to keep
188 track of which psymtabs have which bincls in them. This structure
189 is used during readin to setup the list of dependencies within each
190 partial symbol table. */
192 struct header_file_location
194 char *name
; /* Name of header file */
195 int instance
; /* See above */
196 struct partial_symtab
*pst
; /* Partial symtab that has the
197 BINCL/EINCL defs for this file */
200 /* The actual list and controling variables */
201 static struct header_file_location
*bincl_list
, *next_bincl
;
202 static int bincls_allocated
;
204 /* Local function prototypes */
207 free_header_files
PARAMS ((void));
210 init_header_files
PARAMS ((void));
212 static struct pending
*
213 copy_pending
PARAMS ((struct pending
*, int, struct pending
*));
215 static struct symtab
*
216 read_ofile_symtab
PARAMS ((struct objfile
*, int, int, CORE_ADDR
, int,
217 struct section_offsets
*));
220 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
223 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
226 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
230 free_bincl_list
PARAMS ((struct objfile
*));
232 static struct partial_symtab
*
233 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
236 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
239 init_bincl_list
PARAMS ((int, struct objfile
*));
242 init_psymbol_list
PARAMS ((struct objfile
*));
245 dbx_next_symbol_text
PARAMS ((void));
248 fill_symbuf
PARAMS ((bfd
*));
251 dbx_symfile_init
PARAMS ((struct objfile
*));
254 dbx_new_init
PARAMS ((struct objfile
*));
257 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
260 dbx_symfile_finish
PARAMS ((struct objfile
*));
263 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
266 add_new_header_file
PARAMS ((char *, int));
269 add_old_header_file
PARAMS ((char *, int));
272 add_this_object_header_file
PARAMS ((int));
274 /* Free up old header file tables */
281 if (header_files
!= NULL
)
283 for (i
= 0; i
< n_header_files
; i
++)
285 free (header_files
[i
].name
);
287 free ((PTR
)header_files
);
291 if (this_object_header_files
)
293 free ((PTR
)this_object_header_files
);
294 this_object_header_files
= NULL
;
296 n_allocated_header_files
= 0;
297 n_allocated_this_object_header_files
= 0;
300 /* Allocate new header file tables */
306 n_allocated_header_files
= 10;
307 header_files
= (struct header_file
*)
308 xmalloc (10 * sizeof (struct header_file
));
310 n_allocated_this_object_header_files
= 10;
311 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
314 /* Add header file number I for this object file
315 at the next successive FILENUM. */
318 add_this_object_header_file (i
)
321 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
323 n_allocated_this_object_header_files
*= 2;
324 this_object_header_files
325 = (int *) xrealloc ((char *) this_object_header_files
,
326 n_allocated_this_object_header_files
* sizeof (int));
329 this_object_header_files
[n_this_object_header_files
++] = i
;
332 /* Add to this file an "old" header file, one already seen in
333 a previous object file. NAME is the header file's name.
334 INSTANCE is its instance code, to select among multiple
335 symbol tables for the same header file. */
338 add_old_header_file (name
, instance
)
342 register struct header_file
*p
= header_files
;
345 for (i
= 0; i
< n_header_files
; i
++)
346 if (!strcmp (p
[i
].name
, name
) && instance
== p
[i
].instance
)
348 add_this_object_header_file (i
);
351 complain (&repeated_header_complaint
, (char *)symnum
);
352 complain (&repeated_header_name_complaint
, name
);
355 /* Add to this file a "new" header file: definitions for its types follow.
356 NAME is the header file's name.
357 Most often this happens only once for each distinct header file,
358 but not necessarily. If it happens more than once, INSTANCE has
359 a different value each time, and references to the header file
360 use INSTANCE values to select among them.
362 dbx output contains "begin" and "end" markers for each new header file,
363 but at this level we just need to know which files there have been;
364 so we record the file when its "begin" is seen and ignore the "end". */
367 add_new_header_file (name
, instance
)
373 /* Make sure there is room for one more header file. */
375 if (n_header_files
== n_allocated_header_files
)
377 n_allocated_header_files
*= 2;
378 header_files
= (struct header_file
*)
379 xrealloc ((char *) header_files
,
380 (n_allocated_header_files
* sizeof (struct header_file
)));
383 /* Create an entry for this header file. */
385 i
= n_header_files
++;
386 header_files
[i
].name
= savestring (name
, strlen(name
));
387 header_files
[i
].instance
= instance
;
388 header_files
[i
].length
= 10;
389 header_files
[i
].vector
390 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
391 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
393 add_this_object_header_file (i
);
397 static struct type
**
398 explicit_lookup_type (real_filenum
, index
)
399 int real_filenum
, index
;
401 register struct header_file
*f
= &header_files
[real_filenum
];
403 if (index
>= f
->length
)
406 f
->vector
= (struct type
**)
407 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
408 bzero (&f
->vector
[f
->length
/ 2],
409 f
->length
* sizeof (struct type
*) / 2);
411 return &f
->vector
[index
];
416 record_minimal_symbol (name
, address
, type
, objfile
)
420 struct objfile
*objfile
;
422 enum minimal_symbol_type ms_type
;
424 switch (type
&~ N_EXT
) {
425 case N_TEXT
: ms_type
= mst_text
; break;
426 case N_DATA
: ms_type
= mst_data
; break;
427 case N_BSS
: ms_type
= mst_bss
; break;
428 case N_ABS
: ms_type
= mst_abs
; break;
430 case N_SETV
: ms_type
= mst_data
; break;
432 default: ms_type
= mst_unknown
; break;
435 prim_record_minimal_symbol (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
439 /* Scan and build partial symbols for a symbol file.
440 We have been initialized by a call to dbx_symfile_init, which
441 put all the relevant info into a "struct dbx_symfile_info",
442 hung off the objfile structure.
444 SECTION_OFFSETS contains offsets relative to which the symbols in the
445 various sections are (depending where the sections were actually loaded).
446 MAINLINE is true if we are reading the main symbol
447 table (as opposed to a shared lib or dynamically loaded file). */
450 dbx_symfile_read (objfile
, section_offsets
, mainline
)
451 struct objfile
*objfile
;
452 struct section_offsets
*section_offsets
;
453 int mainline
; /* FIXME comments above */
458 sym_bfd
= objfile
->obfd
;
459 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), L_SET
);
461 perror_with_name (objfile
->name
);
463 /* If we are reinitializing, or if we have never loaded syms yet, init */
464 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
465 init_psymbol_list (objfile
);
468 symbol_size
= obj_dbx_symbol_entry_size (sym_bfd
);
470 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
472 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
475 make_cleanup (really_free_pendings
, 0);
477 init_minimal_symbol_collection ();
478 make_cleanup (discard_minimal_symbols
, 0);
480 /* Now that the symbol table data of the executable file are all in core,
481 process them and define symbols accordingly. */
483 read_dbx_symtab (section_offsets
, objfile
,
484 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
485 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
487 /* Install any minimal symbols that have been collected as the current
488 minimal symbols for this objfile. */
490 install_minimal_symbols (objfile
);
492 if (!have_partial_symbols ()) {
494 printf_filtered ("(no debugging symbols found)...");
499 /* Initialize anything that needs initializing when a completely new
500 symbol file is specified (not just adding some symbols from another
501 file, e.g. a shared library). */
504 dbx_new_init (ignore
)
505 struct objfile
*ignore
;
507 stabsread_new_init ();
508 buildsym_new_init ();
509 init_header_files ();
513 /* dbx_symfile_init ()
514 is the dbx-specific initialization routine for reading symbols.
515 It is passed a struct objfile which contains, among other things,
516 the BFD for the file whose symbols are being read, and a slot for a pointer
517 to "private data" which we fill with goodies.
519 We read the string table into malloc'd space and stash a pointer to it.
521 Since BFD doesn't know how to read debug symbols in a format-independent
522 way (and may never do so...), we have to do it ourselves. We will never
523 be called unless this is an a.out (or very similar) file.
524 FIXME, there should be a cleaner peephole into the BFD environment here. */
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
[4];
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 */
541 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_dbx_str_filepos (sym_bfd))
542 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_dbx_sym_filepos (sym_bfd))
543 #define HP_STRING_TABLE_OFFSET (sym_bfd->origin + obj_hp_str_filepos (sym_bfd))
544 #define HP_SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_hp_sym_filepos (sym_bfd))
546 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
547 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
549 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
551 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
552 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
553 if (!DBX_TEXT_SECT (objfile
))
554 error ("Can't find .text section in symbol file");
557 HP_SYMCOUNT (objfile
) = obj_hp_sym_count (sym_bfd
);
558 DBX_SYMCOUNT (objfile
) = obj_dbx_sym_count (sym_bfd
);
560 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
561 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
563 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
565 /* Read the string table and stash it away in the psymbol_obstack. It is
566 only needed as long as we need to expand psymbols into full symbols,
567 so when we blow away the psymbol the string table goes away as well.
568 Note that gdb used to use the results of attempting to malloc the
569 string table, based on the size it read, as a form of sanity check
570 for botched byte swapping, on the theory that a byte swapped string
571 table size would be so totally bogus that the malloc would fail. Now
572 that we put in on the psymbol_obstack, we can't do this since gdb gets
573 a fatal error (out of virtual memory) if the size is bogus. We can
574 however at least check to see if the size is zero or some negative
578 DBX_STRINGTAB_SIZE (objfile
) = obj_dbx_stringtab_size (sym_bfd
);
579 HP_STRINGTAB_SIZE (objfile
) = obj_hp_stringtab_size (sym_bfd
);
581 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, L_SET
);
583 perror_with_name (name
);
585 val
= bfd_read ((PTR
)size_temp
, sizeof (long), 1, sym_bfd
);
587 perror_with_name (name
);
589 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
592 if (DBX_STRINGTAB_SIZE (objfile
) <= 0)
593 error ("ridiculous string table size (%d bytes).",
594 DBX_STRINGTAB_SIZE (objfile
));
596 DBX_STRINGTAB (objfile
) =
597 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
598 DBX_STRINGTAB_SIZE (objfile
));
600 if (HP_STRINGTAB_SIZE (objfile
) <= 0)
601 error ("ridiculous string table size (%d bytes).",
602 HP_STRINGTAB_SIZE (objfile
));
604 HP_STRINGTAB (objfile
) =
605 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
606 HP_STRINGTAB_SIZE (objfile
));
609 /* Now read in the string table in one big gulp. */
611 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, L_SET
);
613 perror_with_name (name
);
614 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
616 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
617 perror_with_name (name
);
619 val
= bfd_seek (sym_bfd
, HP_STRING_TABLE_OFFSET
, L_SET
);
621 perror_with_name (name
);
622 val
= bfd_read (HP_STRINGTAB (objfile
), HP_STRINGTAB_SIZE (objfile
), 1,
624 if (val
!= HP_STRINGTAB_SIZE (objfile
))
625 perror_with_name (name
);
628 HP_SYMTAB_OFFSET (objfile
) = HP_SYMBOL_TABLE_OFFSET
;
632 /* Perform any local cleanups required when we are done with a particular
633 objfile. I.E, we are in the process of discarding all symbol information
634 for an objfile, freeing up all memory held for it, and unlinking the
635 objfile struct from the global list of known objfiles. */
638 dbx_symfile_finish (objfile
)
639 struct objfile
*objfile
;
641 if (objfile
->sym_private
!= NULL
)
643 mfree (objfile
-> md
, objfile
->sym_private
);
645 free_header_files ();
649 /* Buffer for reading the symbol table entries. */
650 static struct internal_nlist symbuf
[4096];
651 static int symbuf_idx
;
652 static int symbuf_end
;
654 /* Name of last function encountered. Used in Solaris to approximate
655 object file boundaries. */
656 static char *last_function_name
;
658 /* The address in memory of the string table of the object file we are
659 reading (which might not be the "main" object file, but might be a
660 shared library or some other dynamically loaded thing). This is set
661 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
662 when building symtabs, and is used only by next_symbol_text. */
663 static char *stringtab_global
;
665 /* Refill the symbol table input buffer
666 and set the variables that control fetching entries from it.
667 Reports an error if no data available.
668 This function can read past the end of the symbol table
669 (into the string table) but this does no harm. */
672 fill_symbuf (sym_bfd
)
675 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
677 perror_with_name (bfd_get_filename (sym_bfd
));
678 else if (nbytes
== 0)
679 error ("Premature end of file reading symbol table");
680 symbuf_end
= nbytes
/ symbol_size
;
684 /* same as above for the HP symbol table */
686 static struct symbol_dictionary_record hp_symbuf
[4096];
687 static int hp_symbuf_idx
;
688 static int hp_symbuf_end
;
691 fill_hp_symbuf (sym_bfd
)
694 int nbytes
= bfd_read ((PTR
)hp_symbuf
, sizeof (hp_symbuf
), 1, sym_bfd
);
696 error ("error or end of file reading symbol table");
697 hp_symbuf_end
= nbytes
/ sizeof (struct symbol_dictionary_record
);
703 #define SWAP_SYMBOL(symp, abfd) \
705 (symp)->n_strx = bfd_h_get_32(abfd, \
706 (unsigned char *)&(symp)->n_strx); \
707 (symp)->n_desc = bfd_h_get_16 (abfd, \
708 (unsigned char *)&(symp)->n_desc); \
709 (symp)->n_value = bfd_h_get_32 (abfd, \
710 (unsigned char *)&(symp)->n_value); \
713 /* Invariant: The symbol pointed to by symbuf_idx is the first one
714 that hasn't been swapped. Swap the symbol at the same time
715 that symbuf_idx is incremented. */
717 /* dbx allows the text of a symbol name to be continued into the
718 next symbol name! When such a continuation is encountered
719 (a \ at the end of the text of a name)
720 call this function to get the continuation. */
723 dbx_next_symbol_text ()
725 if (symbuf_idx
== symbuf_end
)
726 fill_symbuf (symfile_bfd
);
728 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
729 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
730 + file_string_table_offset
;
733 /* Initializes storage for all of the partial symbols that will be
734 created by read_dbx_symtab and subsidiaries. */
737 init_psymbol_list (objfile
)
738 struct objfile
*objfile
;
740 /* Free any previously allocated psymbol lists. */
741 if (objfile
-> global_psymbols
.list
)
742 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
743 if (objfile
-> static_psymbols
.list
)
744 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
746 /* Current best guess is that there are approximately a twentieth
747 of the total symbols (in a debugging file) are global or static
750 objfile
-> global_psymbols
.size
= (DBX_SYMCOUNT (objfile
) +
751 HP_SYMCOUNT (objfile
)) / 10;
752 objfile
-> static_psymbols
.size
= (DBX_SYMCOUNT (objfile
) +
753 HP_SYMCOUNT (objfile
)) / 10;
755 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
756 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
758 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
759 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
760 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
761 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
764 /* Initialize the list of bincls to contain none and have some
768 init_bincl_list (number
, objfile
)
770 struct objfile
*objfile
;
772 bincls_allocated
= number
;
773 next_bincl
= bincl_list
= (struct header_file_location
*)
774 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
777 /* Add a bincl to the list. */
780 add_bincl_to_list (pst
, name
, instance
)
781 struct partial_symtab
*pst
;
785 if (next_bincl
>= bincl_list
+ bincls_allocated
)
787 int offset
= next_bincl
- bincl_list
;
788 bincls_allocated
*= 2;
789 bincl_list
= (struct header_file_location
*)
790 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
791 bincls_allocated
* sizeof (struct header_file_location
));
792 next_bincl
= bincl_list
+ offset
;
794 next_bincl
->pst
= pst
;
795 next_bincl
->instance
= instance
;
796 next_bincl
++->name
= name
;
799 /* Given a name, value pair, find the corresponding
800 bincl in the list. Return the partial symtab associated
801 with that header_file_location. */
803 static struct partial_symtab
*
804 find_corresponding_bincl_psymtab (name
, instance
)
808 struct header_file_location
*bincl
;
810 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
811 if (bincl
->instance
== instance
812 && !strcmp (name
, bincl
->name
))
815 return (struct partial_symtab
*) 0;
818 /* Free the storage allocated for the bincl list. */
821 free_bincl_list (objfile
)
822 struct objfile
*objfile
;
824 mfree (objfile
-> md
, (PTR
)bincl_list
);
825 bincls_allocated
= 0;
828 /* Given pointers to an a.out symbol table in core containing dbx
829 style data, setup partial_symtab's describing each source file for
830 which debugging information is available.
831 SYMFILE_NAME is the name of the file we are reading from
832 and SECTION_OFFSETS is the set of offsets for the various sections
833 of the file (a set of zeros if the mainline program). */
836 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
837 struct section_offsets
*section_offsets
;
838 struct objfile
*objfile
;
842 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
843 register char *namestring
;
845 int past_first_source_file
= 0;
846 CORE_ADDR last_o_file_start
= 0;
847 struct cleanup
*old_chain
;
851 struct symbol_dictionary_record
*hp_bufp
;
853 /* A hack: the first text symbol in the debugging library */
858 /* End of the text segment of the executable file. */
859 CORE_ADDR end_of_text_addr
;
861 /* Current partial symtab */
862 struct partial_symtab
*pst
;
864 /* List of current psymtab's include files */
865 char **psymtab_include_list
;
866 int includes_allocated
;
869 /* Index within current psymtab dependency list */
870 struct partial_symtab
**dependency_list
;
871 int dependencies_used
, dependencies_allocated
;
873 /* FIXME. We probably want to change stringtab_global rather than add this
874 while processing every symbol entry. FIXME. */
875 file_string_table_offset
= 0;
876 next_file_string_table_offset
= 0;
879 stringtab_global
= HP_STRINGTAB (objfile
);
881 stringtab_global
= DBX_STRINGTAB (objfile
);
884 pst
= (struct partial_symtab
*) 0;
886 includes_allocated
= 30;
888 psymtab_include_list
= (char **) alloca (includes_allocated
*
891 dependencies_allocated
= 30;
892 dependencies_used
= 0;
894 (struct partial_symtab
**) alloca (dependencies_allocated
*
895 sizeof (struct partial_symtab
*));
897 old_chain
= make_cleanup (free_objfile
, objfile
);
899 /* Init bincl list */
900 init_bincl_list (20, objfile
);
901 make_cleanup (free_bincl_list
, objfile
);
903 last_source_file
= NULL
;
905 #ifdef END_OF_TEXT_DEFAULT
906 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
908 end_of_text_addr
= text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
]
909 + text_size
; /* Relocate */
912 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
913 abfd
= objfile
->obfd
;
914 symbuf_end
= symbuf_idx
= 0;
915 next_symbol_text_func
= dbx_next_symbol_text
;
918 /* On pa machines, the global symbols are all in the regular HP-UX
919 symbol table. Read them in first. */
921 hp_symbuf_end
= hp_symbuf_idx
= 0;
922 bfd_seek (abfd
, HP_SYMTAB_OFFSET (objfile
), 0);
924 for (hp_symnum
= 0; hp_symnum
< HP_SYMCOUNT (objfile
); hp_symnum
++)
929 if (hp_symbuf_idx
== hp_symbuf_end
)
930 fill_hp_symbuf (abfd
);
931 hp_bufp
= &hp_symbuf
[hp_symbuf_idx
++];
932 switch (hp_bufp
->symbol_type
)
943 hp_bufp
->symbol_value
&= ~3; /* clear out permission bits */
951 extern int kernel_debugging
;
952 if (!kernel_debugging
)
961 /* Use the address of dbsubc to finish the last psymtab. */
962 if (hp_bufp
->symbol_type
== ST_CODE
&&
963 HP_STRINGTAB (objfile
)[hp_bufp
->name
.n_strx
] == '_' &&
964 !strcmp (HP_STRINGTAB (objfile
) + hp_bufp
->name
.n_strx
, "_dbsubc"))
965 dbsubc_addr
= hp_bufp
->symbol_value
;
966 if (hp_bufp
->symbol_scope
== SS_UNIVERSAL
)
968 if (hp_bufp
->name
.n_strx
> HP_STRINGTAB_SIZE (objfile
))
969 error ("Invalid symbol data; bad HP string table offset: %d",
970 hp_bufp
->name
.n_strx
);
971 /* A hack, but gets the job done. */
972 if (!strcmp (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
974 objfile
-> ei
.entry_file_lowpc
= hp_bufp
->symbol_value
;
975 if (!strcmp (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
977 objfile
-> ei
.entry_file_highpc
= hp_bufp
->symbol_value
;
978 record_minimal_symbol (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
979 hp_bufp
->symbol_value
, dbx_type
| N_EXT
,
983 bfd_seek (abfd
, DBX_SYMTAB_OFFSET (objfile
), 0);
986 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
988 /* Get the symbol for this run and pull out some info */
989 QUIT
; /* allow this to be interruptable */
990 if (symbuf_idx
== symbuf_end
)
992 bufp
= &symbuf
[symbuf_idx
++];
995 * Special case to speed up readin.
997 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
999 SWAP_SYMBOL (bufp
, abfd
);
1001 /* Ok. There is a lot of code duplicated in the rest of this
1002 switch statement (for efficiency reasons). Since I don't
1003 like duplicating code, I will do my penance here, and
1004 describe the code which is duplicated:
1006 *) The assignment to namestring.
1007 *) The call to strchr.
1008 *) The addition of a partial symbol the the two partial
1009 symbol lists. This last is a large section of code, so
1010 I've imbedded it in the following macro.
1013 /* Set namestring based on bufp. If the string table index is invalid,
1014 give a fake name, and print a single error message per symbol file read,
1015 rather than abort the symbol reading or flood the user with messages. */
1017 /*FIXME: Too many adds and indirections in here for the inner loop. */
1018 #define SET_NAMESTRING()\
1019 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1020 DBX_STRINGTAB_SIZE (objfile)) { \
1021 complain (&string_table_offset_complaint, (char *) symnum); \
1022 namestring = "foo"; \
1024 namestring = bufp->n_strx + file_string_table_offset + \
1025 DBX_STRINGTAB (objfile)
1027 #define CUR_SYMBOL_TYPE bufp->n_type
1028 #define CUR_SYMBOL_VALUE bufp->n_value
1029 #define DBXREAD_ONLY
1030 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1031 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1032 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1033 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1035 #include "partial-stab.h"
1038 /* If there's stuff to be cleaned up, clean it up. */
1040 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1041 /*FIXME, does this have a bug at start address 0? */
1042 && last_o_file_start
1043 && objfile
-> ei
.entry_point
< bufp
->n_value
1044 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1046 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1047 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1054 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1055 symnum
* symbol_size
, dbsubc_addr
,
1056 dependency_list
, dependencies_used
);
1058 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1059 symnum
* symbol_size
, end_of_text_addr
,
1060 dependency_list
, dependencies_used
);
1064 free_bincl_list (objfile
);
1065 discard_cleanups (old_chain
);
1068 /* Allocate and partially fill a partial symtab. It will be
1069 completely filled at the end of the symbol list.
1071 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1072 is the address relative to which its symbols are (incremental) or 0
1076 struct partial_symtab
*
1077 start_psymtab (objfile
, section_offsets
,
1078 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1079 struct objfile
*objfile
;
1080 struct section_offsets
*section_offsets
;
1084 struct partial_symbol
*global_syms
;
1085 struct partial_symbol
*static_syms
;
1087 struct partial_symtab
*result
=
1088 start_psymtab_common(objfile
, section_offsets
,
1089 filename
, textlow
, global_syms
, static_syms
);
1091 result
->read_symtab_private
= (char *)
1092 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1093 LDSYMOFF(result
) = ldsymoff
;
1094 result
->read_symtab
= dbx_psymtab_to_symtab
;
1095 SYMBOL_SIZE(result
) = symbol_size
;
1096 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1097 STRING_OFFSET(result
) = string_table_offset
;
1098 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1100 /* If we're handling an ELF file, drag some section-relocation info
1101 for this source file out of the ELF symbol table, to compensate for
1102 Sun brain death. This replaces the section_offsets in this psymtab,
1104 elfstab_offset_sections (objfile
, result
);
1109 /* Close off the current usage of a partial_symbol table entry. This
1110 involves setting the correct number of includes (with a realloc),
1111 setting the high text mark, setting the symbol length in the
1112 executable, and setting the length of the global and static lists
1115 The global symbols and static symbols are then seperately sorted.
1117 Then the partial symtab is put on the global list.
1118 *** List variables and peculiarities of same. ***
1122 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1123 capping_text
, dependency_list
, number_dependencies
)
1124 struct partial_symtab
*pst
;
1125 char **include_list
;
1127 int capping_symbol_offset
;
1128 CORE_ADDR capping_text
;
1129 struct partial_symtab
**dependency_list
;
1130 int number_dependencies
;
1131 /* struct partial_symbol *capping_global, *capping_static;*/
1134 struct partial_symtab
*p1
;
1135 struct objfile
*objfile
= pst
-> objfile
;
1137 if (capping_symbol_offset
!= -1)
1138 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1139 pst
->texthigh
= capping_text
;
1141 /* Under Solaris, the N_SO symbols always have a value of 0,
1142 instead of the usual address of the .o file. Therefore,
1143 we have to do some tricks to fill in texthigh and textlow.
1144 The first trick is in partial-stab.h: if we see a static
1145 or global function, and the textlow for the current pst
1146 is still 0, then we use that function's address for
1147 the textlow of the pst.
1149 Now, to fill in texthigh, we remember the last function seen
1150 in the .o file (also in partial-stab.h). Also, there's a hack in
1151 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1152 to here via the misc_info field. Therefore, we can fill in
1153 a reliable texthigh by taking the address plus size of the
1154 last function in the file.
1156 Unfortunately, that does not cover the case where the last function
1157 in the file is static. See the paragraph below for more comments
1160 Finally, if we have a valid textlow for the current file, we run
1161 down the partial_symtab_list filling in previous texthighs that
1162 are still unknown. */
1164 if (pst
->texthigh
== 0 && last_function_name
) {
1167 struct minimal_symbol
*minsym
;
1169 p
= strchr (last_function_name
, ':');
1171 p
= last_function_name
;
1172 n
= p
- last_function_name
;
1174 strncpy (p
, last_function_name
, n
);
1177 minsym
= lookup_minimal_symbol (p
, objfile
);
1180 pst
->texthigh
= minsym
->address
+ (int)minsym
->info
;
1182 /* This file ends with a static function, and it's
1183 difficult to imagine how hard it would be to track down
1184 the elf symbol. Luckily, most of the time no one will notice,
1185 since the next file will likely be compiled with -g, so
1186 the code below will copy the first fuction's start address
1187 back to our texthigh variable. (Also, if this file is the
1188 last one in a dynamically linked program, texthigh already
1189 has the right value.) If the next file isn't compiled
1190 with -g, then the last function in this file winds up owning
1191 all of the text space up to the next -g file, or the end (minus
1192 shared libraries). This only matters for single stepping,
1193 and even then it will still work, except that it will single
1194 step through all of the covered functions, instead of setting
1195 breakpoints around them as it usualy does. This makes it
1196 pretty slow, but at least it doesn't fail.
1198 We can fix this with a fairly big change to bfd, but we need
1199 to coordinate better with Cygnus if we want to do that. FIXME. */
1201 last_function_name
= NULL
;
1204 /* this test will be true if the last .o file is only data */
1205 if (pst
->textlow
== 0)
1206 pst
->textlow
= pst
->texthigh
;
1208 /* If we know our own starting text address, then walk through all other
1209 psymtabs for this objfile, and if any didn't know their ending text
1210 address, set it to our starting address. Take care to not set our
1211 own ending address to our starting address, nor to set addresses on
1212 `dependency' files that have both textlow and texthigh zero. */
1214 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1215 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1216 p1
->texthigh
= pst
->textlow
;
1217 /* if this file has only data, then make textlow match texthigh */
1218 if (p1
->textlow
== 0)
1219 p1
->textlow
= p1
->texthigh
;
1224 /* End of kludge for patching Solaris textlow and texthigh. */
1227 pst
->n_global_syms
=
1228 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1229 pst
->n_static_syms
=
1230 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1232 pst
->number_of_dependencies
= number_dependencies
;
1233 if (number_dependencies
)
1235 pst
->dependencies
= (struct partial_symtab
**)
1236 obstack_alloc (&objfile
->psymbol_obstack
,
1237 number_dependencies
* sizeof (struct partial_symtab
*));
1238 memcpy (pst
->dependencies
, dependency_list
,
1239 number_dependencies
* sizeof (struct partial_symtab
*));
1242 pst
->dependencies
= 0;
1244 for (i
= 0; i
< num_includes
; i
++)
1246 struct partial_symtab
*subpst
=
1247 allocate_psymtab (include_list
[i
], objfile
);
1249 subpst
->section_offsets
= pst
->section_offsets
;
1250 subpst
->read_symtab_private
=
1251 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1252 sizeof (struct symloc
));
1256 subpst
->texthigh
= 0;
1258 /* We could save slight bits of space by only making one of these,
1259 shared by the entire set of include files. FIXME-someday. */
1260 subpst
->dependencies
= (struct partial_symtab
**)
1261 obstack_alloc (&objfile
->psymbol_obstack
,
1262 sizeof (struct partial_symtab
*));
1263 subpst
->dependencies
[0] = pst
;
1264 subpst
->number_of_dependencies
= 1;
1266 subpst
->globals_offset
=
1267 subpst
->n_global_syms
=
1268 subpst
->statics_offset
=
1269 subpst
->n_static_syms
= 0;
1273 subpst
->read_symtab
= dbx_psymtab_to_symtab
;
1276 sort_pst_symbols (pst
);
1278 /* If there is already a psymtab or symtab for a file of this name, remove it.
1279 (If there is a symtab, more drastic things also happen.)
1280 This happens in VxWorks. */
1281 free_named_symtabs (pst
->filename
);
1283 if (num_includes
== 0
1284 && number_dependencies
== 0
1285 && pst
->n_global_syms
== 0
1286 && pst
->n_static_syms
== 0) {
1287 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1288 it is on the obstack, but we can forget to chain it on the list. */
1289 struct partial_symtab
*prev_pst
;
1291 /* First, snip it out of the psymtab chain */
1293 if (pst
->objfile
->psymtabs
== pst
)
1294 pst
->objfile
->psymtabs
= pst
->next
;
1296 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1297 if (prev_pst
->next
== pst
)
1298 prev_pst
->next
= pst
->next
;
1300 /* Next, put it on a free list for recycling */
1302 pst
->next
= pst
->objfile
->free_psymtabs
;
1303 pst
->objfile
->free_psymtabs
= pst
;
1308 dbx_psymtab_to_symtab_1 (pst
)
1309 struct partial_symtab
*pst
;
1311 struct cleanup
*old_chain
;
1319 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1324 /* Read in all partial symtabs on which this one is dependent */
1325 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1326 if (!pst
->dependencies
[i
]->readin
)
1328 /* Inform about additional files that need to be read in. */
1331 fputs_filtered (" ", stdout
);
1333 fputs_filtered ("and ", stdout
);
1335 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1336 wrap_here (""); /* Flush output */
1339 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1342 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1344 /* Init stuff necessary for reading in symbols */
1347 old_chain
= make_cleanup (really_free_pendings
, 0);
1348 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1350 symbol_size
= obj_dbx_symbol_entry_size (sym_bfd
);
1352 symbol_size
= SYMBOL_SIZE (pst
);
1355 /* Read in this file's symbols */
1356 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), L_SET
);
1358 read_ofile_symtab (pst
->objfile
, LDSYMOFF(pst
), LDSYMLEN(pst
),
1359 pst
->textlow
, pst
->texthigh
- pst
->textlow
,
1360 pst
->section_offsets
);
1361 sort_symtab_syms (pst
->symtab
);
1363 do_cleanups (old_chain
);
1369 /* Read in all of the symbols for a given psymtab for real.
1370 Be verbose about it if the user wants that. */
1373 dbx_psymtab_to_symtab (pst
)
1374 struct partial_symtab
*pst
;
1383 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1388 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1390 /* Print the message now, before reading the string table,
1391 to avoid disconcerting pauses. */
1394 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1398 sym_bfd
= pst
->objfile
->obfd
;
1400 next_symbol_text_func
= dbx_next_symbol_text
;
1402 dbx_psymtab_to_symtab_1 (pst
);
1404 /* Match with global symbols. This only needs to be done once,
1405 after all of the symtabs and dependencies have been read in. */
1406 scan_file_globals (pst
->objfile
);
1408 /* Finish up the debug error message. */
1410 printf_filtered ("done.\n");
1414 /* Read in a defined section of a specific object file's symbols.
1416 DESC is the file descriptor for the file, positioned at the
1417 beginning of the symtab
1418 SYM_OFFSET is the offset within the file of
1419 the beginning of the symbols we want to read
1420 SYM_SIZE is the size of the symbol info to read in.
1421 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
1422 TEXT_SIZE is the size of the text segment read in.
1423 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
1425 static struct symtab
*
1426 read_ofile_symtab (objfile
, sym_offset
, sym_size
, text_offset
, text_size
,
1428 struct objfile
*objfile
;
1431 CORE_ADDR text_offset
;
1433 struct section_offsets
*section_offsets
;
1435 register char *namestring
;
1436 register struct internal_nlist
*bufp
;
1438 unsigned max_symnum
;
1442 current_objfile
= objfile
;
1443 subfile_stack
= NULL
;
1446 stringtab_global
= HP_STRINGTAB (objfile
);
1448 stringtab_global
= DBX_STRINGTAB (objfile
);
1450 last_source_file
= NULL
;
1452 abfd
= objfile
->obfd
;
1453 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1454 symbuf_end
= symbuf_idx
= 0;
1456 /* It is necessary to actually read one symbol *before* the start
1457 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1458 occurs before the N_SO symbol.
1460 Detecting this in read_dbx_symtab
1461 would slow down initial readin, so we look for it here instead. */
1462 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1464 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, L_INCR
);
1466 bufp
= &symbuf
[symbuf_idx
++];
1467 SWAP_SYMBOL (bufp
, abfd
);
1471 processing_gcc_compilation
=
1472 (bufp
->n_type
== N_TEXT
1473 && (strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
) == 0
1474 || strcmp(namestring
, GCC2_COMPILED_FLAG_SYMBOL
) == 0));
1476 /* Try to select a C++ demangling based on the compilation unit
1479 if (processing_gcc_compilation
)
1481 #if 1 /* Works, but is experimental. -fnf */
1482 if (current_demangling_style
== auto_demangling
)
1484 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1491 /* The N_SO starting this symtab is the first symbol, so we
1492 better not check the symbol before it. I'm not this can
1493 happen, but it doesn't hurt to check for it. */
1494 bfd_seek (symfile_bfd
, sym_offset
, L_INCR
);
1495 processing_gcc_compilation
= 0;
1498 if (symbuf_idx
== symbuf_end
)
1500 bufp
= &symbuf
[symbuf_idx
];
1501 if (bufp
->n_type
!= (unsigned char)N_SO
)
1502 error("First symbol in segment of executable not a source symbol");
1504 max_symnum
= sym_size
/ symbol_size
;
1507 symnum
< max_symnum
;
1510 QUIT
; /* Allow this to be interruptable */
1511 if (symbuf_idx
== symbuf_end
)
1513 bufp
= &symbuf
[symbuf_idx
++];
1514 SWAP_SYMBOL (bufp
, abfd
);
1516 type
= bufp
->n_type
;
1520 if (type
& N_STAB
) {
1521 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1522 namestring
, section_offsets
, objfile
);
1524 /* We skip checking for a new .o or -l file; that should never
1525 happen in this routine. */
1526 else if (type
== N_TEXT
1527 && (strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
) == 0
1528 || strcmp (namestring
, GCC2_COMPILED_FLAG_SYMBOL
) == 0))
1530 /* I don't think this code will ever be executed, because
1531 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1532 the N_SO symbol which starts this source file.
1533 However, there is no reason not to accept
1534 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1535 processing_gcc_compilation
= 1;
1536 #if 1 /* Works, but is experimental. -fnf */
1537 if (current_demangling_style
== auto_demangling
)
1539 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1543 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1544 || type
== (unsigned char)N_NBTEXT
1546 /* Global symbol: see if we came across a dbx defintion for
1547 a corresponding symbol. If so, store the value. Remove
1548 syms from the chain when their values are stored, but
1549 search the whole chain, as there may be several syms from
1550 different files with the same name. */
1551 /* This is probably not true. Since the files will be read
1552 in one at a time, each reference to a global symbol will
1553 be satisfied in each file as it appears. So we skip this
1559 current_objfile
= NULL
;
1561 /* In a Solaris elf file, this variable, which comes from the
1562 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1563 which comes from pst->textlow is correct. */
1564 if (last_source_start_addr
== 0)
1565 last_source_start_addr
= text_offset
;
1567 rtn
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
);
1572 /* This handles a single symbol from the symbol-file, building symbols
1573 into a GDB symtab. It takes these arguments and an implicit argument.
1575 TYPE is the type field of the ".stab" symbol entry.
1576 DESC is the desc field of the ".stab" entry.
1577 VALU is the value field of the ".stab" entry.
1578 NAME is the symbol name, in our address space.
1579 SECTION_OFFSETS is a set of amounts by which the sections of this object
1580 file were relocated when it was loaded into memory.
1581 All symbols that refer
1582 to memory locations need to be offset by these amounts.
1583 OBJFILE is the object file from which we are reading symbols.
1584 It is used in end_symtab. */
1587 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1591 struct section_offsets
*section_offsets
;
1592 struct objfile
*objfile
;
1594 #ifndef SUN_FIXED_LBRAC_BUG
1595 /* This records the last pc address we've seen. We depend on there being
1596 an SLINE or FUN or SO before the first LBRAC, since the variable does
1597 not get reset in between reads of different symbol files. */
1598 static CORE_ADDR last_pc_address
;
1600 register struct context_stack
*new;
1601 /* This remembers the address of the start of a function. It is used
1602 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1603 relative to the current function's start address. On systems
1604 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1605 used to relocate these symbol types rather than SECTION_OFFSETS. */
1606 static CORE_ADDR function_start_offset
;
1609 /* Something is wrong if we see real data before
1610 seeing a source file name. */
1612 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1614 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
1615 where that code is defined. */
1616 if (IGNORE_SYMBOL (type
))
1619 /* FIXME, this should not be an error, since it precludes extending
1620 the symbol table information in this way... */
1621 error ("Invalid symbol data: does not start by identifying a source file.");
1629 /* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
1630 N_STSYM with a type code of f or F. Can't enable this until we get some
1631 stuff straightened out with psymtabs. FIXME. */
1637 /* Relocate for dynamic loading */
1638 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1640 /* Either of these types of symbols indicates the start of
1641 a new function. We must process its "name" normally for dbx,
1642 but also record the start of a new lexical context, and possibly
1643 also the end of the lexical context for the previous function. */
1644 /* This is not always true. This type of symbol may indicate a
1645 text segment variable. */
1647 colon_pos
= strchr (name
, ':');
1649 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
1651 define_symbol (valu
, name
, desc
, type
, objfile
);
1655 #ifndef SUN_FIXED_LBRAC_BUG
1656 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1659 #ifdef BLOCK_ADDRESS_FUNCTION_RELATIVE
1660 /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1661 are relative to the start of the function. On normal systems,
1662 and when using gcc on Solaris 2.0, these addresses are just
1663 absolute, or relative to the N_SO, depending on
1664 BLOCK_ADDRESS_ABSOLUTE. */
1665 function_start_offset
= valu
;
1667 /* Default on ordinary systems */
1668 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1671 within_function
= 1;
1672 if (context_stack_depth
> 0)
1674 new = pop_context ();
1675 /* Make a block for the local symbols within. */
1676 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1677 new->start_addr
, valu
, objfile
);
1679 /* Stack must be empty now. */
1680 if (context_stack_depth
!= 0)
1681 complain (&lbrac_unmatched_complaint
, (char *) symnum
);
1683 new = push_context (0, valu
);
1684 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1688 /* This "symbol" just indicates the start of an inner lexical
1689 context within a function. */
1691 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1692 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1693 valu
+= function_start_offset
;
1695 /* On most machines, the block addresses are relative to the
1696 N_SO, the linker did not relocate them (sigh). */
1697 valu
+= last_source_start_addr
;
1700 #ifndef SUN_FIXED_LBRAC_BUG
1701 if (valu
< last_pc_address
) {
1702 /* Patch current LBRAC pc value to match last handy pc value */
1703 complain (&lbrac_complaint
, 0);
1704 valu
= last_pc_address
;
1707 new = push_context (desc
, valu
);
1711 /* This "symbol" just indicates the end of an inner lexical
1712 context that was started with N_LBRAC. */
1714 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1715 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1716 valu
+= function_start_offset
;
1718 /* On most machines, the block addresses are relative to the
1719 N_SO, the linker did not relocate them (sigh). */
1720 valu
+= last_source_start_addr
;
1723 new = pop_context();
1724 if (desc
!= new->depth
)
1725 complain (&lbrac_mismatch_complaint
, (char *) symnum
);
1727 /* Some compilers put the variable decls inside of an
1728 LBRAC/RBRAC block. This macro should be nonzero if this
1729 is true. DESC is N_DESC from the N_RBRAC symbol.
1730 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1731 or the GCC2_COMPILED_SYMBOL. */
1732 #if !defined (VARIABLES_INSIDE_BLOCK)
1733 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1736 /* Can only use new->locals as local symbols here if we're in
1737 gcc or on a machine that puts them before the lbrack. */
1738 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1739 local_symbols
= new->locals
;
1741 /* If this is not the outermost LBRAC...RBRAC pair in the
1742 function, its local symbols preceded it, and are the ones
1743 just recovered from the context stack. Defined the block for them.
1745 If this is the outermost LBRAC...RBRAC pair, there is no
1746 need to do anything; leave the symbols that preceded it
1747 to be attached to the function's own block. However, if
1748 it is so, we need to indicate that we just moved outside
1751 && (context_stack_depth
1752 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
1754 /* FIXME Muzzle a compiler bug that makes end < start. */
1755 if (new->start_addr
> valu
)
1757 complain(&lbrac_rbrac_complaint
, 0);
1758 new->start_addr
= valu
;
1760 /* Make a block for the local symbols within. */
1761 finish_block (0, &local_symbols
, new->old_blocks
,
1762 new->start_addr
, valu
, objfile
);
1766 within_function
= 0;
1768 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1769 /* Now pop locals of block just finished. */
1770 local_symbols
= new->locals
;
1775 /* This kind of symbol indicates the start of an object file. */
1776 /* Relocate for dynamic loading */
1777 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1781 /* This type of symbol indicates the start of data
1782 for one source file.
1783 Finish the symbol table of the previous source file
1784 (if any) and start accumulating a new symbol table. */
1785 /* Relocate for dynamic loading */
1786 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1788 #ifndef SUN_FIXED_LBRAC_BUG
1789 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1792 #ifdef PCC_SOL_BROKEN
1793 /* pcc bug, occasionally puts out SO for SOL. */
1794 if (context_stack_depth
> 0)
1796 start_subfile (name
, NULL
);
1800 if (last_source_file
)
1802 /* Check if previous symbol was also an N_SO (with some
1803 sanity checks). If so, that one was actually the directory
1804 name, and the current one is the real file name.
1806 if (previous_stab_code
== N_SO
)
1808 patch_subfile_names (current_subfile
, name
);
1809 break; /* Ignore repeated SOs */
1811 end_symtab (valu
, 0, 0, objfile
);
1815 start_symtab (name
, NULL
, valu
);
1820 /* This type of symbol indicates the start of data for
1821 a sub-source-file, one whose contents were copied or
1822 included in the compilation of the main source file
1823 (whose name was given in the N_SO symbol.) */
1824 /* Relocate for dynamic loading */
1825 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1826 start_subfile (name
, current_subfile
->dirname
);
1831 add_new_header_file (name
, valu
);
1832 start_subfile (name
, current_subfile
->dirname
);
1836 start_subfile (pop_subfile (), current_subfile
->dirname
);
1840 add_old_header_file (name
, valu
);
1844 /* This type of "symbol" really just records
1845 one line-number -- core-address correspondence.
1846 Enter it in the line list for this symbol table. */
1847 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1848 valu
+= function_start_offset
;
1849 #ifndef SUN_FIXED_LBRAC_BUG
1850 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1852 record_line (current_subfile
, desc
, valu
);
1857 error ("Invalid symbol data: common within common at symtab pos %d",
1859 common_block
= local_symbols
;
1860 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
1864 /* Symbols declared since the BCOMM are to have the common block
1865 start address added in when we know it. common_block points to
1866 the first symbol after the BCOMM in the local_symbols list;
1867 copy the list and hang it off the symbol for the common block name
1871 struct symbol
*sym
=
1872 (struct symbol
*) xmmalloc (objfile
-> md
, sizeof (struct symbol
));
1873 memset (sym
, 0, sizeof *sym
);
1874 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1875 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1876 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
1877 copy_pending (local_symbols
, common_block_i
, common_block
));
1878 i
= hashname (SYMBOL_NAME (sym
));
1879 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1880 global_sym_chain
[i
] = sym
;
1885 /* The following symbol types need to have the appropriate offset added
1886 to their value; then we process symbol definitions in the name. */
1888 case N_STSYM
: /* Static symbol in data seg */
1889 case N_LCSYM
: /* Static symbol in BSS seg */
1890 case N_ROSYM
: /* Static symbol in Read-only data seg */
1891 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
1892 Solaris2's stabs-in-coff makes *most* symbols relative
1893 but leaves a few absolute. N_STSYM and friends sit on the fence.
1894 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1895 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1896 This leaves us no choice but to search for the 'S' or 'V'...
1897 (or pass the whole section_offsets stuff down ONE MORE function
1898 call level, which we really don't want to do). */
1901 p
= strchr (name
, ':');
1902 if (p
!= 0 && p
[1] == 'S')
1904 /* FIXME! We relocate it by the TEXT offset, in case the
1905 whole module moved in memory. But this is wrong, since
1906 the sections can side around independently. */
1907 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1908 goto define_a_symbol
;
1910 /* Since it's not the kludge case, re-dispatch to the right handler. */
1912 case N_STSYM
: goto case_N_STSYM
;
1913 case N_LCSYM
: goto case_N_LCSYM
;
1914 case N_ROSYM
: goto case_N_ROSYM
;
1919 case_N_STSYM
: /* Static symbol in data seg */
1920 case N_DSLINE
: /* Source line number, data seg */
1921 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1922 goto define_a_symbol
;
1924 case_N_LCSYM
: /* Static symbol in BSS seg */
1925 case N_BSLINE
: /* Source line number, bss seg */
1926 /* N_BROWS: overlaps with N_BSLINE */
1927 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1928 goto define_a_symbol
;
1930 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1931 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1932 goto define_a_symbol
;
1934 case N_ENTRY
: /* Alternate entry point */
1935 /* Relocate for dynamic loading */
1936 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1937 goto define_a_symbol
;
1939 /* The following symbol types don't need the address field relocated,
1940 since it is either unused, or is absolute. */
1942 case N_GSYM
: /* Global variable */
1943 case N_NSYMS
: /* Number of symbols (ultrix) */
1944 case N_NOMAP
: /* No map? (ultrix) */
1945 case N_RSYM
: /* Register variable */
1946 case N_DEFD
: /* Modula-2 GNU module dependency */
1947 case N_SSYM
: /* Struct or union element */
1948 case N_LSYM
: /* Local symbol in stack */
1949 case N_PSYM
: /* Parameter variable */
1950 case N_LENG
: /* Length of preceding symbol type */
1952 define_symbol (valu
, name
, desc
, type
, objfile
);
1955 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1956 for a bunch of other flags, too. Someday we may parse their
1957 flags; for now we ignore theirs and hope they'll ignore ours. */
1958 case N_OPT
: /* Solaris 2: Compiler options */
1961 if (!strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
))
1963 processing_gcc_compilation
= 1;
1964 #if 1 /* Works, but is experimental. -fnf */
1965 if (current_demangling_style
== auto_demangling
)
1967 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1974 /* The following symbol types can be ignored. */
1975 case N_OBJ
: /* Solaris 2: Object file dir and name */
1976 /* N_UNDF: Solaris 2: file separator mark */
1977 /* N_UNDF: -- we will never encounter it, since we only process one
1978 file's symbols at once. */
1979 case N_ENDM
: /* Solaris 2: End of module */
1980 case N_MAIN
: /* Name of main routine. */
1983 /* The following symbol types we don't know how to process. Handle
1984 them in a "default" way, but complain to people who care. */
1986 case N_CATCH
: /* Exception handler catcher */
1987 case N_EHDECL
: /* Exception handler name */
1988 case N_PC
: /* Global symbol in Pascal */
1989 case N_M2C
: /* Modula-2 compilation unit */
1990 /* N_MOD2: overlaps with N_EHDECL */
1991 case N_SCOPE
: /* Modula-2 scope information */
1992 case N_ECOML
: /* End common (local name) */
1993 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
1998 complain (&unknown_symtype_complaint
, local_hex_string(type
));
2000 define_symbol (valu
, name
, desc
, type
, objfile
);
2003 previous_stab_code
= type
;
2006 /* Copy a pending list, used to record the contents of a common
2007 block for later fixup. */
2008 static struct pending
*
2009 copy_pending (beg
, begi
, end
)
2010 struct pending
*beg
;
2012 struct pending
*end
;
2014 struct pending
*new = 0;
2015 struct pending
*next
;
2017 for (next
= beg
; next
!= 0 && (next
!= end
|| begi
< end
->nsyms
);
2018 next
= next
->next
, begi
= 0)
2021 for (j
= begi
; j
< next
->nsyms
; j
++)
2022 add_symbol_to_list (next
->symbol
[j
], &new);
2027 /* Scan and build partial symbols for an ELF symbol file.
2028 This ELF file has already been processed to get its minimal symbols,
2029 and any DWARF symbols that were in it.
2031 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2034 OBJFILE is the object file we are reading symbols from.
2035 ADDR is the address relative to which the symbols are (e.g.
2036 the base address of the text segment).
2037 MAINLINE is true if we are reading the main symbol
2038 table (as opposed to a shared lib or dynamically loaded file).
2039 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2041 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2042 .stabstr section exists.
2044 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2045 adjusted for elf details. */
2048 DEFUN(elfstab_build_psymtabs
, (objfile
, section_offsets
, mainline
,
2049 staboffset
, stabsize
,
2050 stabstroffset
, stabstrsize
),
2051 struct objfile
*objfile AND
2052 struct section_offsets
*section_offsets AND
2054 unsigned int staboffset AND
2055 unsigned int stabsize AND
2056 unsigned int stabstroffset AND
2057 unsigned int stabstrsize
)
2060 bfd
*sym_bfd
= objfile
->obfd
;
2061 char *name
= bfd_get_filename (sym_bfd
);
2062 struct dbx_symfile_info
*info
;
2064 /* There is already a dbx_symfile_info allocated by our caller.
2065 It might even contain some info from the ELF symtab to help us. */
2066 info
= (struct dbx_symfile_info
*) objfile
->sym_private
;
2068 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2069 if (!DBX_TEXT_SECT (objfile
))
2070 error ("Can't find .text section in symbol file");
2072 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2073 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2074 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2075 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2076 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2078 if (stabstrsize
< 0) /* FIXME: stabstrsize is unsigned; never true! */
2079 error ("ridiculous string table size: %d bytes", stabstrsize
);
2080 DBX_STRINGTAB (objfile
) = (char *)
2081 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2083 /* Now read in the string table in one big gulp. */
2085 val
= bfd_seek (sym_bfd
, stabstroffset
, L_SET
);
2087 perror_with_name (name
);
2088 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2089 if (val
!= stabstrsize
)
2090 perror_with_name (name
);
2092 stabsread_new_init ();
2093 buildsym_new_init ();
2094 free_header_files ();
2095 init_header_files ();
2096 install_minimal_symbols (objfile
);
2098 processing_acc_compilation
= 1;
2100 /* In an elf file, we've already installed the minimal symbols that came
2101 from the elf (non-stab) symbol table, so always act like an
2102 incremental load here. */
2103 dbx_symfile_read (objfile
, section_offsets
, 0);
2106 /* Parse the user's idea of an offset for dynamic linking, into our idea
2107 of how to represent it for fast symbol reading. */
2109 struct section_offsets
*
2110 dbx_symfile_offsets (objfile
, addr
)
2111 struct objfile
*objfile
;
2114 struct section_offsets
*section_offsets
;
2117 section_offsets
= (struct section_offsets
*)
2118 obstack_alloc (&objfile
-> psymbol_obstack
,
2119 sizeof (struct section_offsets
) +
2120 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2122 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2123 ANOFFSET (section_offsets
, i
) = addr
;
2125 return section_offsets
;
2128 /* Register our willingness to decode symbols for SunOS and a.out and
2129 b.out files handled by BFD... */
2130 static struct sym_fns sunos_sym_fns
=
2132 "sunOs", /* sym_name: name or name prefix of BFD target type */
2133 6, /* sym_namelen: number of significant sym_name chars */
2134 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2135 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2136 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2137 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2138 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2139 NULL
/* next: pointer to next struct sym_fns */
2142 static struct sym_fns aout_sym_fns
=
2144 "a.out", /* sym_name: name or name prefix of BFD target type */
2145 5, /* sym_namelen: number of significant sym_name chars */
2146 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2147 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2148 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2149 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2150 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2151 NULL
/* next: pointer to next struct sym_fns */
2154 static struct sym_fns bout_sym_fns
=
2156 "b.out", /* sym_name: name or name prefix of BFD target type */
2157 5, /* sym_namelen: number of significant sym_name chars */
2158 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2159 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2160 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2161 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2162 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2163 NULL
/* next: pointer to next struct sym_fns */
2166 /* This is probably a mistake. FIXME. Why can't the HP's use an ordinary
2167 file format name with an -hppa suffix? */
2168 static struct sym_fns hppa_sym_fns
=
2170 "hppa", /* sym_name: name or name prefix of BFD target type */
2171 4, /* sym_namelen: number of significant sym_name chars */
2172 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2173 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2174 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2175 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2176 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2177 NULL
/* next: pointer to next struct sym_fns */
2181 _initialize_dbxread ()
2183 add_symtab_fns(&sunos_sym_fns
);
2184 add_symtab_fns(&aout_sym_fns
);
2185 add_symtab_fns(&bout_sym_fns
);
2186 add_symtab_fns(&hppa_sym_fns
);