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>
44 #ifdef GDB_TARGET_IS_HPPA
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) */
62 #ifdef GDB_TARGET_IS_HPPA
66 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
71 #include "stabsread.h"
72 #include "gdb-stabs.h"
74 #include "language.h" /* Needed inside partial-stab.h */
75 #include "complaints.h"
77 #include "aout/aout64.h"
78 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
80 /* Each partial symbol table entry contains a pointer to private data for the
81 read_symtab() function to use when expanding a partial symbol table entry
82 to a full symbol table entry.
84 For dbxread this structure contains the offset within the file symbol table
85 of first local symbol for this file, and length (in bytes) of the section
86 of the symbol table devoted to this file's symbols (actually, the section
87 bracketed may contain more than just this file's symbols). It also contains
88 further information needed to locate the symbols if they are in an ELF file.
90 If ldsymlen is 0, the only reason for this thing's existence is the
91 dependency list. Nothing else will happen when it is read in. */
93 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
94 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
95 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
96 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
97 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
98 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
99 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
107 int file_string_offset
;
110 /* Macro to determine which symbols to ignore when reading the first symbol
111 of a file. Some machines override this definition. */
112 #ifndef IGNORE_SYMBOL
113 /* This code is used on Ultrix systems. Ignore it */
114 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
117 /* Macro for name of symbol to indicate a file compiled with gcc. */
118 #ifndef GCC_COMPILED_FLAG_SYMBOL
119 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
122 /* Macro for name of symbol to indicate a file compiled with gcc2. */
123 #ifndef GCC2_COMPILED_FLAG_SYMBOL
124 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
127 /* Define this as 1 if a pcc declaration of a char or short argument
128 gives the correct address. Otherwise assume pcc gives the
129 address of the corresponding int, which is not the same on a
130 big-endian machine. */
132 #ifndef BELIEVE_PCC_PROMOTION
133 #define BELIEVE_PCC_PROMOTION 0
136 /* Remember what we deduced to be the source language of this psymtab. */
138 static enum language psymtab_language
= language_unknown
;
140 /* Nonzero means give verbose info on gdb action. From main.c. */
141 extern int info_verbose
;
143 /* The BFD for this file -- implicit parameter to next_symbol_text. */
145 static bfd
*symfile_bfd
;
147 /* The size of each symbol in the symbol file (in external form).
148 This is set by dbx_symfile_read when building psymtabs, and by
149 dbx_psymtab_to_symtab when building symtabs. */
151 static unsigned symbol_size
;
153 /* This is the offset of the symbol table in the executable file */
154 static unsigned symbol_table_offset
;
156 /* This is the offset of the string table in the executable file */
157 static unsigned string_table_offset
;
159 /* For elf+stab executables, the n_strx field is not a simple index
160 into the string table. Instead, each .o file has a base offset
161 in the string table, and the associated symbols contain offsets
162 from this base. The following two variables contain the base
163 offset for the current and next .o files. */
164 static unsigned int file_string_table_offset
;
165 static unsigned int next_file_string_table_offset
;
167 /* Complaints about the symbols we have encountered. */
169 struct complaint lbrac_complaint
=
170 {"bad block start address patched", 0, 0};
172 struct complaint string_table_offset_complaint
=
173 {"bad string table offset in symbol %d", 0, 0};
175 struct complaint unknown_symtype_complaint
=
176 {"unknown symbol type %s", 0, 0};
178 struct complaint lbrac_rbrac_complaint
=
179 {"block start larger than block end", 0, 0};
181 struct complaint lbrac_unmatched_complaint
=
182 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
184 struct complaint lbrac_mismatch_complaint
=
185 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
187 struct complaint repeated_header_complaint
=
188 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
190 struct complaint repeated_header_name_complaint
=
191 {"\"repeated\" header file not previously seen, named %s", 0, 0};
193 /* During initial symbol readin, we need to have a structure to keep
194 track of which psymtabs have which bincls in them. This structure
195 is used during readin to setup the list of dependencies within each
196 partial symbol table. */
198 struct header_file_location
200 char *name
; /* Name of header file */
201 int instance
; /* See above */
202 struct partial_symtab
*pst
; /* Partial symtab that has the
203 BINCL/EINCL defs for this file */
206 /* The actual list and controling variables */
207 static struct header_file_location
*bincl_list
, *next_bincl
;
208 static int bincls_allocated
;
210 /* Local function prototypes */
213 free_header_files
PARAMS ((void));
216 init_header_files
PARAMS ((void));
218 static struct pending
*
219 copy_pending
PARAMS ((struct pending
*, int, struct pending
*));
221 static struct symtab
*
222 read_ofile_symtab
PARAMS ((struct objfile
*, int, int, CORE_ADDR
, int,
223 struct section_offsets
*));
226 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
229 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
232 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
236 free_bincl_list
PARAMS ((struct objfile
*));
238 static struct partial_symtab
*
239 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
242 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
245 init_bincl_list
PARAMS ((int, struct objfile
*));
248 init_psymbol_list
PARAMS ((struct objfile
*));
251 dbx_next_symbol_text
PARAMS ((void));
254 fill_symbuf
PARAMS ((bfd
*));
257 dbx_symfile_init
PARAMS ((struct objfile
*));
260 dbx_new_init
PARAMS ((struct objfile
*));
263 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
266 dbx_symfile_finish
PARAMS ((struct objfile
*));
269 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
272 add_new_header_file
PARAMS ((char *, int));
275 add_old_header_file
PARAMS ((char *, int));
278 add_this_object_header_file
PARAMS ((int));
280 /* Free up old header file tables */
287 if (header_files
!= NULL
)
289 for (i
= 0; i
< n_header_files
; i
++)
291 free (header_files
[i
].name
);
293 free ((PTR
)header_files
);
297 if (this_object_header_files
)
299 free ((PTR
)this_object_header_files
);
300 this_object_header_files
= NULL
;
302 n_allocated_header_files
= 0;
303 n_allocated_this_object_header_files
= 0;
306 /* Allocate new header file tables */
312 n_allocated_header_files
= 10;
313 header_files
= (struct header_file
*)
314 xmalloc (10 * sizeof (struct header_file
));
316 n_allocated_this_object_header_files
= 10;
317 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
320 /* Add header file number I for this object file
321 at the next successive FILENUM. */
324 add_this_object_header_file (i
)
327 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
329 n_allocated_this_object_header_files
*= 2;
330 this_object_header_files
331 = (int *) xrealloc ((char *) this_object_header_files
,
332 n_allocated_this_object_header_files
* sizeof (int));
335 this_object_header_files
[n_this_object_header_files
++] = i
;
338 /* Add to this file an "old" header file, one already seen in
339 a previous object file. NAME is the header file's name.
340 INSTANCE is its instance code, to select among multiple
341 symbol tables for the same header file. */
344 add_old_header_file (name
, instance
)
348 register struct header_file
*p
= header_files
;
351 for (i
= 0; i
< n_header_files
; i
++)
352 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
354 add_this_object_header_file (i
);
357 complain (&repeated_header_complaint
, symnum
);
358 complain (&repeated_header_name_complaint
, name
);
361 /* Add to this file a "new" header file: definitions for its types follow.
362 NAME is the header file's name.
363 Most often this happens only once for each distinct header file,
364 but not necessarily. If it happens more than once, INSTANCE has
365 a different value each time, and references to the header file
366 use INSTANCE values to select among them.
368 dbx output contains "begin" and "end" markers for each new header file,
369 but at this level we just need to know which files there have been;
370 so we record the file when its "begin" is seen and ignore the "end". */
373 add_new_header_file (name
, instance
)
379 /* Make sure there is room for one more header file. */
381 if (n_header_files
== n_allocated_header_files
)
383 n_allocated_header_files
*= 2;
384 header_files
= (struct header_file
*)
385 xrealloc ((char *) header_files
,
386 (n_allocated_header_files
* sizeof (struct header_file
)));
389 /* Create an entry for this header file. */
391 i
= n_header_files
++;
392 header_files
[i
].name
= savestring (name
, strlen(name
));
393 header_files
[i
].instance
= instance
;
394 header_files
[i
].length
= 10;
395 header_files
[i
].vector
396 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
397 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
399 add_this_object_header_file (i
);
403 static struct type
**
404 explicit_lookup_type (real_filenum
, index
)
405 int real_filenum
, index
;
407 register struct header_file
*f
= &header_files
[real_filenum
];
409 if (index
>= f
->length
)
412 f
->vector
= (struct type
**)
413 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
414 bzero (&f
->vector
[f
->length
/ 2],
415 f
->length
* sizeof (struct type
*) / 2);
417 return &f
->vector
[index
];
422 record_minimal_symbol (name
, address
, type
, objfile
)
426 struct objfile
*objfile
;
428 enum minimal_symbol_type ms_type
;
430 switch (type
&~ N_EXT
) {
431 case N_TEXT
: ms_type
= mst_text
; break;
432 case N_DATA
: ms_type
= mst_data
; break;
433 case N_BSS
: ms_type
= mst_bss
; break;
434 case N_ABS
: ms_type
= mst_abs
; break;
436 case N_SETV
: ms_type
= mst_data
; break;
438 default: ms_type
= mst_unknown
; break;
441 prim_record_minimal_symbol (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
445 /* Scan and build partial symbols for a symbol file.
446 We have been initialized by a call to dbx_symfile_init, which
447 put all the relevant info into a "struct dbx_symfile_info",
448 hung off the objfile structure.
450 SECTION_OFFSETS contains offsets relative to which the symbols in the
451 various sections are (depending where the sections were actually loaded).
452 MAINLINE is true if we are reading the main symbol
453 table (as opposed to a shared lib or dynamically loaded file). */
456 dbx_symfile_read (objfile
, section_offsets
, mainline
)
457 struct objfile
*objfile
;
458 struct section_offsets
*section_offsets
;
459 int mainline
; /* FIXME comments above */
464 sym_bfd
= objfile
->obfd
;
465 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), L_SET
);
467 perror_with_name (objfile
->name
);
469 /* If we are reinitializing, or if we have never loaded syms yet, init */
470 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
471 init_psymbol_list (objfile
);
473 #ifdef GDB_TARGET_IS_HPPA
474 symbol_size
= obj_dbx_symbol_entry_size (sym_bfd
);
476 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
478 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
481 make_cleanup (really_free_pendings
, 0);
483 init_minimal_symbol_collection ();
484 make_cleanup (discard_minimal_symbols
, 0);
486 /* Now that the symbol table data of the executable file are all in core,
487 process them and define symbols accordingly. */
489 read_dbx_symtab (section_offsets
, objfile
,
490 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
491 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
493 /* Install any minimal symbols that have been collected as the current
494 minimal symbols for this objfile. */
496 install_minimal_symbols (objfile
);
498 if (!have_partial_symbols ()) {
500 printf_filtered ("(no debugging symbols found)...");
505 /* Initialize anything that needs initializing when a completely new
506 symbol file is specified (not just adding some symbols from another
507 file, e.g. a shared library). */
510 dbx_new_init (ignore
)
511 struct objfile
*ignore
;
513 stabsread_new_init ();
514 buildsym_new_init ();
515 init_header_files ();
519 /* dbx_symfile_init ()
520 is the dbx-specific initialization routine for reading symbols.
521 It is passed a struct objfile which contains, among other things,
522 the BFD for the file whose symbols are being read, and a slot for a pointer
523 to "private data" which we fill with goodies.
525 We read the string table into malloc'd space and stash a pointer to it.
527 Since BFD doesn't know how to read debug symbols in a format-independent
528 way (and may never do so...), we have to do it ourselves. We will never
529 be called unless this is an a.out (or very similar) file.
530 FIXME, there should be a cleaner peephole into the BFD environment here. */
533 dbx_symfile_init (objfile
)
534 struct objfile
*objfile
;
537 bfd
*sym_bfd
= objfile
->obfd
;
538 char *name
= bfd_get_filename (sym_bfd
);
539 unsigned char size_temp
[4];
541 /* Allocate struct to keep track of the symfile */
542 objfile
->sym_private
= (PTR
)
543 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
545 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
546 #ifdef GDB_TARGET_IS_HPPA
547 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_dbx_str_filepos (sym_bfd))
548 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_dbx_sym_filepos (sym_bfd))
549 #define HP_STRING_TABLE_OFFSET (sym_bfd->origin + obj_hp_str_filepos (sym_bfd))
550 #define HP_SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_hp_sym_filepos (sym_bfd))
552 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
553 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
555 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
557 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
558 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
559 if (!DBX_TEXT_SECT (objfile
))
560 error ("Can't find .text section in symbol file");
562 #ifdef GDB_TARGET_IS_HPPA
563 HP_SYMCOUNT (objfile
) = obj_hp_sym_count (sym_bfd
);
564 DBX_SYMCOUNT (objfile
) = obj_dbx_sym_count (sym_bfd
);
566 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
567 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
569 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
571 /* Read the string table and stash it away in the psymbol_obstack. It is
572 only needed as long as we need to expand psymbols into full symbols,
573 so when we blow away the psymbol the string table goes away as well.
574 Note that gdb used to use the results of attempting to malloc the
575 string table, based on the size it read, as a form of sanity check
576 for botched byte swapping, on the theory that a byte swapped string
577 table size would be so totally bogus that the malloc would fail. Now
578 that we put in on the psymbol_obstack, we can't do this since gdb gets
579 a fatal error (out of virtual memory) if the size is bogus. We can
580 however at least check to see if the size is zero or some negative
583 #ifdef GDB_TARGET_IS_HPPA
584 DBX_STRINGTAB_SIZE (objfile
) = obj_dbx_stringtab_size (sym_bfd
);
585 HP_STRINGTAB_SIZE (objfile
) = obj_hp_stringtab_size (sym_bfd
);
587 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, L_SET
);
589 perror_with_name (name
);
591 val
= bfd_read ((PTR
)size_temp
, sizeof (long), 1, sym_bfd
);
593 perror_with_name (name
);
595 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
598 if (DBX_STRINGTAB_SIZE (objfile
) <= 0)
599 error ("ridiculous string table size (%d bytes).",
600 DBX_STRINGTAB_SIZE (objfile
));
602 DBX_STRINGTAB (objfile
) =
603 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
604 DBX_STRINGTAB_SIZE (objfile
));
605 #ifdef GDB_TARGET_IS_HPPA
606 if (HP_STRINGTAB_SIZE (objfile
) <= 0)
607 error ("ridiculous string table size (%d bytes).",
608 HP_STRINGTAB_SIZE (objfile
));
610 HP_STRINGTAB (objfile
) =
611 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
612 HP_STRINGTAB_SIZE (objfile
));
615 /* Now read in the string table in one big gulp. */
617 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, L_SET
);
619 perror_with_name (name
);
620 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
622 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
623 perror_with_name (name
);
624 #ifdef GDB_TARGET_IS_HPPA
625 val
= bfd_seek (sym_bfd
, HP_STRING_TABLE_OFFSET
, L_SET
);
627 perror_with_name (name
);
628 val
= bfd_read (HP_STRINGTAB (objfile
), HP_STRINGTAB_SIZE (objfile
), 1,
630 if (val
!= HP_STRINGTAB_SIZE (objfile
))
631 perror_with_name (name
);
633 #ifdef GDB_TARGET_IS_HPPA
634 HP_SYMTAB_OFFSET (objfile
) = HP_SYMBOL_TABLE_OFFSET
;
638 /* Perform any local cleanups required when we are done with a particular
639 objfile. I.E, we are in the process of discarding all symbol information
640 for an objfile, freeing up all memory held for it, and unlinking the
641 objfile struct from the global list of known objfiles. */
644 dbx_symfile_finish (objfile
)
645 struct objfile
*objfile
;
647 if (objfile
->sym_private
!= NULL
)
649 mfree (objfile
-> md
, objfile
->sym_private
);
651 free_header_files ();
655 /* Buffer for reading the symbol table entries. */
656 static struct internal_nlist symbuf
[4096];
657 static int symbuf_idx
;
658 static int symbuf_end
;
660 /* Name of last function encountered. Used in Solaris to approximate
661 object file boundaries. */
662 static char *last_function_name
;
664 /* The address in memory of the string table of the object file we are
665 reading (which might not be the "main" object file, but might be a
666 shared library or some other dynamically loaded thing). This is set
667 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
668 when building symtabs, and is used only by next_symbol_text. */
669 static char *stringtab_global
;
671 /* Refill the symbol table input buffer
672 and set the variables that control fetching entries from it.
673 Reports an error if no data available.
674 This function can read past the end of the symbol table
675 (into the string table) but this does no harm. */
678 fill_symbuf (sym_bfd
)
681 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
683 perror_with_name (bfd_get_filename (sym_bfd
));
684 else if (nbytes
== 0)
685 error ("Premature end of file reading symbol table");
686 symbuf_end
= nbytes
/ symbol_size
;
689 #ifdef GDB_TARGET_IS_HPPA
690 /* same as above for the HP symbol table */
692 static struct symbol_dictionary_record hp_symbuf
[4096];
693 static int hp_symbuf_idx
;
694 static int hp_symbuf_end
;
697 fill_hp_symbuf (sym_bfd
)
700 int nbytes
= bfd_read ((PTR
)hp_symbuf
, sizeof (hp_symbuf
), 1, sym_bfd
);
702 error ("error or end of file reading symbol table");
703 hp_symbuf_end
= nbytes
/ sizeof (struct symbol_dictionary_record
);
709 #define SWAP_SYMBOL(symp, abfd) \
711 (symp)->n_strx = bfd_h_get_32(abfd, \
712 (unsigned char *)&(symp)->n_strx); \
713 (symp)->n_desc = bfd_h_get_16 (abfd, \
714 (unsigned char *)&(symp)->n_desc); \
715 (symp)->n_value = bfd_h_get_32 (abfd, \
716 (unsigned char *)&(symp)->n_value); \
719 /* Invariant: The symbol pointed to by symbuf_idx is the first one
720 that hasn't been swapped. Swap the symbol at the same time
721 that symbuf_idx is incremented. */
723 /* dbx allows the text of a symbol name to be continued into the
724 next symbol name! When such a continuation is encountered
725 (a \ at the end of the text of a name)
726 call this function to get the continuation. */
729 dbx_next_symbol_text ()
731 if (symbuf_idx
== symbuf_end
)
732 fill_symbuf (symfile_bfd
);
734 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
735 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
736 + file_string_table_offset
;
739 /* Initializes storage for all of the partial symbols that will be
740 created by read_dbx_symtab and subsidiaries. */
743 init_psymbol_list (objfile
)
744 struct objfile
*objfile
;
746 /* Free any previously allocated psymbol lists. */
747 if (objfile
-> global_psymbols
.list
)
748 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
749 if (objfile
-> static_psymbols
.list
)
750 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
752 /* Current best guess is that there are approximately a twentieth
753 of the total symbols (in a debugging file) are global or static
755 #ifdef GDB_TARGET_IS_HPPA
756 objfile
-> global_psymbols
.size
= (DBX_SYMCOUNT (objfile
) +
757 HP_SYMCOUNT (objfile
)) / 10;
758 objfile
-> static_psymbols
.size
= (DBX_SYMCOUNT (objfile
) +
759 HP_SYMCOUNT (objfile
)) / 10;
761 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
762 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
764 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
765 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
766 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
767 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
770 /* Initialize the list of bincls to contain none and have some
774 init_bincl_list (number
, objfile
)
776 struct objfile
*objfile
;
778 bincls_allocated
= number
;
779 next_bincl
= bincl_list
= (struct header_file_location
*)
780 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
783 /* Add a bincl to the list. */
786 add_bincl_to_list (pst
, name
, instance
)
787 struct partial_symtab
*pst
;
791 if (next_bincl
>= bincl_list
+ bincls_allocated
)
793 int offset
= next_bincl
- bincl_list
;
794 bincls_allocated
*= 2;
795 bincl_list
= (struct header_file_location
*)
796 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
797 bincls_allocated
* sizeof (struct header_file_location
));
798 next_bincl
= bincl_list
+ offset
;
800 next_bincl
->pst
= pst
;
801 next_bincl
->instance
= instance
;
802 next_bincl
++->name
= name
;
805 /* Given a name, value pair, find the corresponding
806 bincl in the list. Return the partial symtab associated
807 with that header_file_location. */
809 static struct partial_symtab
*
810 find_corresponding_bincl_psymtab (name
, instance
)
814 struct header_file_location
*bincl
;
816 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
817 if (bincl
->instance
== instance
818 && STREQ (name
, bincl
->name
))
821 return (struct partial_symtab
*) 0;
824 /* Free the storage allocated for the bincl list. */
827 free_bincl_list (objfile
)
828 struct objfile
*objfile
;
830 mfree (objfile
-> md
, (PTR
)bincl_list
);
831 bincls_allocated
= 0;
834 /* Given pointers to an a.out symbol table in core containing dbx
835 style data, setup partial_symtab's describing each source file for
836 which debugging information is available.
837 SYMFILE_NAME is the name of the file we are reading from
838 and SECTION_OFFSETS is the set of offsets for the various sections
839 of the file (a set of zeros if the mainline program). */
842 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
843 struct section_offsets
*section_offsets
;
844 struct objfile
*objfile
;
848 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
849 register char *namestring
;
851 int past_first_source_file
= 0;
852 CORE_ADDR last_o_file_start
= 0;
853 struct cleanup
*old_chain
;
855 #ifdef GDB_TARGET_IS_HPPA
857 struct symbol_dictionary_record
*hp_bufp
;
859 /* A hack: the first text symbol in the debugging library */
864 /* End of the text segment of the executable file. */
865 CORE_ADDR end_of_text_addr
;
867 /* Current partial symtab */
868 struct partial_symtab
*pst
;
870 /* List of current psymtab's include files */
871 char **psymtab_include_list
;
872 int includes_allocated
;
875 /* Index within current psymtab dependency list */
876 struct partial_symtab
**dependency_list
;
877 int dependencies_used
, dependencies_allocated
;
879 /* FIXME. We probably want to change stringtab_global rather than add this
880 while processing every symbol entry. FIXME. */
881 file_string_table_offset
= 0;
882 next_file_string_table_offset
= 0;
884 #ifdef GDB_TARGET_IS_HPPA
885 stringtab_global
= HP_STRINGTAB (objfile
);
887 stringtab_global
= DBX_STRINGTAB (objfile
);
890 pst
= (struct partial_symtab
*) 0;
892 includes_allocated
= 30;
894 psymtab_include_list
= (char **) alloca (includes_allocated
*
897 dependencies_allocated
= 30;
898 dependencies_used
= 0;
900 (struct partial_symtab
**) alloca (dependencies_allocated
*
901 sizeof (struct partial_symtab
*));
903 old_chain
= make_cleanup (free_objfile
, objfile
);
905 /* Init bincl list */
906 init_bincl_list (20, objfile
);
907 make_cleanup (free_bincl_list
, objfile
);
909 last_source_file
= NULL
;
911 #ifdef END_OF_TEXT_DEFAULT
912 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
914 end_of_text_addr
= text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
]
915 + text_size
; /* Relocate */
918 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
919 abfd
= objfile
->obfd
;
920 symbuf_end
= symbuf_idx
= 0;
921 next_symbol_text_func
= dbx_next_symbol_text
;
923 #ifdef GDB_TARGET_IS_HPPA
924 /* On pa machines, the global symbols are all in the regular HP-UX
925 symbol table. Read them in first. */
927 hp_symbuf_end
= hp_symbuf_idx
= 0;
928 bfd_seek (abfd
, HP_SYMTAB_OFFSET (objfile
), L_SET
);
930 for (hp_symnum
= 0; hp_symnum
< HP_SYMCOUNT (objfile
); hp_symnum
++)
935 if (hp_symbuf_idx
== hp_symbuf_end
)
936 fill_hp_symbuf (abfd
);
937 hp_bufp
= &hp_symbuf
[hp_symbuf_idx
++];
938 switch (hp_bufp
->symbol_type
)
949 hp_bufp
->symbol_value
&= ~3; /* clear out permission bits */
957 extern int kernel_debugging
;
958 if (!kernel_debugging
)
967 /* Use the address of dbsubc to finish the last psymtab. */
968 if (hp_bufp
->symbol_type
== ST_CODE
&&
969 HP_STRINGTAB (objfile
)[hp_bufp
->name
.n_strx
] == '_' &&
970 STREQ (HP_STRINGTAB (objfile
) + hp_bufp
->name
.n_strx
, "_dbsubc"))
971 dbsubc_addr
= hp_bufp
->symbol_value
;
972 if (hp_bufp
->symbol_scope
== SS_UNIVERSAL
)
974 if (hp_bufp
->name
.n_strx
> HP_STRINGTAB_SIZE (objfile
))
975 error ("Invalid symbol data; bad HP string table offset: %d",
976 hp_bufp
->name
.n_strx
);
977 /* A hack, but gets the job done. */
978 if (STREQ (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
980 objfile
-> ei
.entry_file_lowpc
= hp_bufp
->symbol_value
;
981 if (STREQ (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
983 objfile
-> ei
.entry_file_highpc
= hp_bufp
->symbol_value
;
984 record_minimal_symbol (hp_bufp
->name
.n_strx
+ HP_STRINGTAB (objfile
),
985 hp_bufp
->symbol_value
, dbx_type
| N_EXT
,
989 bfd_seek (abfd
, DBX_SYMTAB_OFFSET (objfile
), L_SET
);
992 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
994 /* Get the symbol for this run and pull out some info */
995 QUIT
; /* allow this to be interruptable */
996 if (symbuf_idx
== symbuf_end
)
998 bufp
= &symbuf
[symbuf_idx
++];
1001 * Special case to speed up readin.
1003 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1005 SWAP_SYMBOL (bufp
, abfd
);
1007 /* Ok. There is a lot of code duplicated in the rest of this
1008 switch statement (for efficiency reasons). Since I don't
1009 like duplicating code, I will do my penance here, and
1010 describe the code which is duplicated:
1012 *) The assignment to namestring.
1013 *) The call to strchr.
1014 *) The addition of a partial symbol the the two partial
1015 symbol lists. This last is a large section of code, so
1016 I've imbedded it in the following macro.
1019 /* Set namestring based on bufp. If the string table index is invalid,
1020 give a fake name, and print a single error message per symbol file read,
1021 rather than abort the symbol reading or flood the user with messages. */
1023 /*FIXME: Too many adds and indirections in here for the inner loop. */
1024 #define SET_NAMESTRING()\
1025 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1026 DBX_STRINGTAB_SIZE (objfile)) { \
1027 complain (&string_table_offset_complaint, symnum); \
1028 namestring = "foo"; \
1030 namestring = bufp->n_strx + file_string_table_offset + \
1031 DBX_STRINGTAB (objfile)
1033 #define CUR_SYMBOL_TYPE bufp->n_type
1034 #define CUR_SYMBOL_VALUE bufp->n_value
1035 #define DBXREAD_ONLY
1036 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1037 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1038 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1039 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1041 #include "partial-stab.h"
1044 /* If there's stuff to be cleaned up, clean it up. */
1045 #ifndef GDB_TARGET_IS_HPPA
1046 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1047 /*FIXME, does this have a bug at start address 0? */
1048 && last_o_file_start
1049 && objfile
-> ei
.entry_point
< bufp
->n_value
1050 && objfile
-> ei
.entry_point
>= last_o_file_start
)
1052 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
1053 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
1059 #ifdef GDB_TARGET_IS_HPPA
1060 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1061 symnum
* symbol_size
, dbsubc_addr
,
1062 dependency_list
, dependencies_used
);
1064 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1065 symnum
* symbol_size
, end_of_text_addr
,
1066 dependency_list
, dependencies_used
);
1070 free_bincl_list (objfile
);
1071 discard_cleanups (old_chain
);
1074 /* Allocate and partially fill a partial symtab. It will be
1075 completely filled at the end of the symbol list.
1077 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1078 is the address relative to which its symbols are (incremental) or 0
1082 struct partial_symtab
*
1083 start_psymtab (objfile
, section_offsets
,
1084 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1085 struct objfile
*objfile
;
1086 struct section_offsets
*section_offsets
;
1090 struct partial_symbol
*global_syms
;
1091 struct partial_symbol
*static_syms
;
1093 struct partial_symtab
*result
=
1094 start_psymtab_common(objfile
, section_offsets
,
1095 filename
, textlow
, global_syms
, static_syms
);
1097 result
->read_symtab_private
= (char *)
1098 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1099 LDSYMOFF(result
) = ldsymoff
;
1100 result
->read_symtab
= dbx_psymtab_to_symtab
;
1101 SYMBOL_SIZE(result
) = symbol_size
;
1102 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1103 STRING_OFFSET(result
) = string_table_offset
;
1104 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1106 /* If we're handling an ELF file, drag some section-relocation info
1107 for this source file out of the ELF symbol table, to compensate for
1108 Sun brain death. This replaces the section_offsets in this psymtab,
1110 elfstab_offset_sections (objfile
, result
);
1112 /* Deduce the source language from the filename for this psymtab. */
1113 psymtab_language
= deduce_language_from_filename (filename
);
1118 /* Close off the current usage of a partial_symbol table entry. This
1119 involves setting the correct number of includes (with a realloc),
1120 setting the high text mark, setting the symbol length in the
1121 executable, and setting the length of the global and static lists
1124 The global symbols and static symbols are then seperately sorted.
1126 Then the partial symtab is put on the global list.
1127 *** List variables and peculiarities of same. ***
1131 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1132 capping_text
, dependency_list
, number_dependencies
)
1133 struct partial_symtab
*pst
;
1134 char **include_list
;
1136 int capping_symbol_offset
;
1137 CORE_ADDR capping_text
;
1138 struct partial_symtab
**dependency_list
;
1139 int number_dependencies
;
1140 /* struct partial_symbol *capping_global, *capping_static;*/
1143 struct partial_symtab
*p1
;
1144 struct objfile
*objfile
= pst
-> objfile
;
1146 if (capping_symbol_offset
!= -1)
1147 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1148 pst
->texthigh
= capping_text
;
1150 /* Under Solaris, the N_SO symbols always have a value of 0,
1151 instead of the usual address of the .o file. Therefore,
1152 we have to do some tricks to fill in texthigh and textlow.
1153 The first trick is in partial-stab.h: if we see a static
1154 or global function, and the textlow for the current pst
1155 is still 0, then we use that function's address for
1156 the textlow of the pst.
1158 Now, to fill in texthigh, we remember the last function seen
1159 in the .o file (also in partial-stab.h). Also, there's a hack in
1160 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1161 to here via the misc_info field. Therefore, we can fill in
1162 a reliable texthigh by taking the address plus size of the
1163 last function in the file.
1165 Unfortunately, that does not cover the case where the last function
1166 in the file is static. See the paragraph below for more comments
1169 Finally, if we have a valid textlow for the current file, we run
1170 down the partial_symtab_list filling in previous texthighs that
1171 are still unknown. */
1173 if (pst
->texthigh
== 0 && last_function_name
) {
1176 struct minimal_symbol
*minsym
;
1178 p
= strchr (last_function_name
, ':');
1180 p
= last_function_name
;
1181 n
= p
- last_function_name
;
1183 strncpy (p
, last_function_name
, n
);
1186 minsym
= lookup_minimal_symbol (p
, objfile
);
1189 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1190 (int) MSYMBOL_INFO (minsym
);
1192 /* This file ends with a static function, and it's
1193 difficult to imagine how hard it would be to track down
1194 the elf symbol. Luckily, most of the time no one will notice,
1195 since the next file will likely be compiled with -g, so
1196 the code below will copy the first fuction's start address
1197 back to our texthigh variable. (Also, if this file is the
1198 last one in a dynamically linked program, texthigh already
1199 has the right value.) If the next file isn't compiled
1200 with -g, then the last function in this file winds up owning
1201 all of the text space up to the next -g file, or the end (minus
1202 shared libraries). This only matters for single stepping,
1203 and even then it will still work, except that it will single
1204 step through all of the covered functions, instead of setting
1205 breakpoints around them as it usualy does. This makes it
1206 pretty slow, but at least it doesn't fail.
1208 We can fix this with a fairly big change to bfd, but we need
1209 to coordinate better with Cygnus if we want to do that. FIXME. */
1211 last_function_name
= NULL
;
1214 /* this test will be true if the last .o file is only data */
1215 if (pst
->textlow
== 0)
1216 pst
->textlow
= pst
->texthigh
;
1218 /* If we know our own starting text address, then walk through all other
1219 psymtabs for this objfile, and if any didn't know their ending text
1220 address, set it to our starting address. Take care to not set our
1221 own ending address to our starting address, nor to set addresses on
1222 `dependency' files that have both textlow and texthigh zero. */
1224 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1225 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1226 p1
->texthigh
= pst
->textlow
;
1227 /* if this file has only data, then make textlow match texthigh */
1228 if (p1
->textlow
== 0)
1229 p1
->textlow
= p1
->texthigh
;
1234 /* End of kludge for patching Solaris textlow and texthigh. */
1237 pst
->n_global_syms
=
1238 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1239 pst
->n_static_syms
=
1240 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1242 pst
->number_of_dependencies
= number_dependencies
;
1243 if (number_dependencies
)
1245 pst
->dependencies
= (struct partial_symtab
**)
1246 obstack_alloc (&objfile
->psymbol_obstack
,
1247 number_dependencies
* sizeof (struct partial_symtab
*));
1248 memcpy (pst
->dependencies
, dependency_list
,
1249 number_dependencies
* sizeof (struct partial_symtab
*));
1252 pst
->dependencies
= 0;
1254 for (i
= 0; i
< num_includes
; i
++)
1256 struct partial_symtab
*subpst
=
1257 allocate_psymtab (include_list
[i
], objfile
);
1259 subpst
->section_offsets
= pst
->section_offsets
;
1260 subpst
->read_symtab_private
=
1261 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1262 sizeof (struct symloc
));
1266 subpst
->texthigh
= 0;
1268 /* We could save slight bits of space by only making one of these,
1269 shared by the entire set of include files. FIXME-someday. */
1270 subpst
->dependencies
= (struct partial_symtab
**)
1271 obstack_alloc (&objfile
->psymbol_obstack
,
1272 sizeof (struct partial_symtab
*));
1273 subpst
->dependencies
[0] = pst
;
1274 subpst
->number_of_dependencies
= 1;
1276 subpst
->globals_offset
=
1277 subpst
->n_global_syms
=
1278 subpst
->statics_offset
=
1279 subpst
->n_static_syms
= 0;
1283 subpst
->read_symtab
= dbx_psymtab_to_symtab
;
1286 sort_pst_symbols (pst
);
1288 /* If there is already a psymtab or symtab for a file of this name, remove it.
1289 (If there is a symtab, more drastic things also happen.)
1290 This happens in VxWorks. */
1291 free_named_symtabs (pst
->filename
);
1293 if (num_includes
== 0
1294 && number_dependencies
== 0
1295 && pst
->n_global_syms
== 0
1296 && pst
->n_static_syms
== 0) {
1297 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1298 it is on the obstack, but we can forget to chain it on the list. */
1299 struct partial_symtab
*prev_pst
;
1301 /* First, snip it out of the psymtab chain */
1303 if (pst
->objfile
->psymtabs
== pst
)
1304 pst
->objfile
->psymtabs
= pst
->next
;
1306 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1307 if (prev_pst
->next
== pst
)
1308 prev_pst
->next
= pst
->next
;
1310 /* Next, put it on a free list for recycling */
1312 pst
->next
= pst
->objfile
->free_psymtabs
;
1313 pst
->objfile
->free_psymtabs
= pst
;
1318 dbx_psymtab_to_symtab_1 (pst
)
1319 struct partial_symtab
*pst
;
1321 struct cleanup
*old_chain
;
1329 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1334 /* Read in all partial symtabs on which this one is dependent */
1335 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1336 if (!pst
->dependencies
[i
]->readin
)
1338 /* Inform about additional files that need to be read in. */
1341 fputs_filtered (" ", stdout
);
1343 fputs_filtered ("and ", stdout
);
1345 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1346 wrap_here (""); /* Flush output */
1349 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1352 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1354 /* Init stuff necessary for reading in symbols */
1357 old_chain
= make_cleanup (really_free_pendings
, 0);
1358 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1359 #ifdef GDB_TARGET_IS_HPPA
1360 symbol_size
= obj_dbx_symbol_entry_size (pst
->objfile
->obfd
);
1362 symbol_size
= SYMBOL_SIZE (pst
);
1365 /* Read in this file's symbols */
1366 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), L_SET
);
1368 read_ofile_symtab (pst
->objfile
, LDSYMOFF(pst
), LDSYMLEN(pst
),
1369 pst
->textlow
, pst
->texthigh
- pst
->textlow
,
1370 pst
->section_offsets
);
1371 sort_symtab_syms (pst
->symtab
);
1373 do_cleanups (old_chain
);
1379 /* Read in all of the symbols for a given psymtab for real.
1380 Be verbose about it if the user wants that. */
1383 dbx_psymtab_to_symtab (pst
)
1384 struct partial_symtab
*pst
;
1393 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1398 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1400 /* Print the message now, before reading the string table,
1401 to avoid disconcerting pauses. */
1404 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1408 sym_bfd
= pst
->objfile
->obfd
;
1410 next_symbol_text_func
= dbx_next_symbol_text
;
1412 dbx_psymtab_to_symtab_1 (pst
);
1414 /* Match with global symbols. This only needs to be done once,
1415 after all of the symtabs and dependencies have been read in. */
1416 scan_file_globals (pst
->objfile
);
1418 /* Finish up the debug error message. */
1420 printf_filtered ("done.\n");
1424 /* Read in a defined section of a specific object file's symbols.
1426 DESC is the file descriptor for the file, positioned at the
1427 beginning of the symtab
1428 SYM_OFFSET is the offset within the file of
1429 the beginning of the symbols we want to read
1430 SYM_SIZE is the size of the symbol info to read in.
1431 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
1432 TEXT_SIZE is the size of the text segment read in.
1433 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
1435 static struct symtab
*
1436 read_ofile_symtab (objfile
, sym_offset
, sym_size
, text_offset
, text_size
,
1438 struct objfile
*objfile
;
1441 CORE_ADDR text_offset
;
1443 struct section_offsets
*section_offsets
;
1445 register char *namestring
;
1446 register struct internal_nlist
*bufp
;
1448 unsigned max_symnum
;
1452 current_objfile
= objfile
;
1453 subfile_stack
= NULL
;
1455 #ifdef GDB_TARGET_IS_HPPA
1456 stringtab_global
= HP_STRINGTAB (objfile
);
1458 stringtab_global
= DBX_STRINGTAB (objfile
);
1460 last_source_file
= NULL
;
1462 abfd
= objfile
->obfd
;
1463 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1464 symbuf_end
= symbuf_idx
= 0;
1466 /* It is necessary to actually read one symbol *before* the start
1467 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1468 occurs before the N_SO symbol.
1470 Detecting this in read_dbx_symtab
1471 would slow down initial readin, so we look for it here instead. */
1472 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1474 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, L_INCR
);
1476 bufp
= &symbuf
[symbuf_idx
++];
1477 SWAP_SYMBOL (bufp
, abfd
);
1481 processing_gcc_compilation
= 0;
1482 if (bufp
->n_type
== N_TEXT
)
1484 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1485 processing_gcc_compilation
= 1;
1486 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1487 processing_gcc_compilation
= 2;
1490 /* Try to select a C++ demangling based on the compilation unit
1493 if (processing_gcc_compilation
)
1495 #if 1 /* Works, but is experimental. -fnf */
1496 if (AUTO_DEMANGLING
)
1498 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1505 /* The N_SO starting this symtab is the first symbol, so we
1506 better not check the symbol before it. I'm not this can
1507 happen, but it doesn't hurt to check for it. */
1508 bfd_seek (symfile_bfd
, sym_offset
, L_INCR
);
1509 processing_gcc_compilation
= 0;
1512 if (symbuf_idx
== symbuf_end
)
1514 bufp
= &symbuf
[symbuf_idx
];
1515 if (bufp
->n_type
!= (unsigned char)N_SO
)
1516 error("First symbol in segment of executable not a source symbol");
1518 max_symnum
= sym_size
/ symbol_size
;
1521 symnum
< max_symnum
;
1524 QUIT
; /* Allow this to be interruptable */
1525 if (symbuf_idx
== symbuf_end
)
1527 bufp
= &symbuf
[symbuf_idx
++];
1528 SWAP_SYMBOL (bufp
, abfd
);
1530 type
= bufp
->n_type
;
1534 if (type
& N_STAB
) {
1535 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1536 namestring
, section_offsets
, objfile
);
1538 /* We skip checking for a new .o or -l file; that should never
1539 happen in this routine. */
1540 else if (type
== N_TEXT
)
1542 /* I don't think this code will ever be executed, because
1543 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1544 the N_SO symbol which starts this source file.
1545 However, there is no reason not to accept
1546 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1548 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1549 processing_gcc_compilation
= 1;
1550 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1551 processing_gcc_compilation
= 2;
1553 #if 1 /* Works, but is experimental. -fnf */
1554 if (AUTO_DEMANGLING
)
1556 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1560 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1561 || type
== (unsigned char)N_NBTEXT
1563 /* Global symbol: see if we came across a dbx defintion for
1564 a corresponding symbol. If so, store the value. Remove
1565 syms from the chain when their values are stored, but
1566 search the whole chain, as there may be several syms from
1567 different files with the same name. */
1568 /* This is probably not true. Since the files will be read
1569 in one at a time, each reference to a global symbol will
1570 be satisfied in each file as it appears. So we skip this
1576 current_objfile
= NULL
;
1578 /* In a Solaris elf file, this variable, which comes from the
1579 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1580 which comes from pst->textlow is correct. */
1581 if (last_source_start_addr
== 0)
1582 last_source_start_addr
= text_offset
;
1584 rtn
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
);
1589 /* This handles a single symbol from the symbol-file, building symbols
1590 into a GDB symtab. It takes these arguments and an implicit argument.
1592 TYPE is the type field of the ".stab" symbol entry.
1593 DESC is the desc field of the ".stab" entry.
1594 VALU is the value field of the ".stab" entry.
1595 NAME is the symbol name, in our address space.
1596 SECTION_OFFSETS is a set of amounts by which the sections of this object
1597 file were relocated when it was loaded into memory.
1598 All symbols that refer
1599 to memory locations need to be offset by these amounts.
1600 OBJFILE is the object file from which we are reading symbols.
1601 It is used in end_symtab. */
1604 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1608 struct section_offsets
*section_offsets
;
1609 struct objfile
*objfile
;
1611 #ifndef SUN_FIXED_LBRAC_BUG
1612 /* This records the last pc address we've seen. We depend on there being
1613 an SLINE or FUN or SO before the first LBRAC, since the variable does
1614 not get reset in between reads of different symbol files. */
1615 static CORE_ADDR last_pc_address
;
1617 register struct context_stack
*new;
1618 /* This remembers the address of the start of a function. It is used
1619 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1620 relative to the current function's start address. On systems
1621 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1622 used to relocate these symbol types rather than SECTION_OFFSETS. */
1623 static CORE_ADDR function_start_offset
;
1626 #ifndef BLOCK_ADDRESS_FUNCTION_RELATIVE
1627 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1628 function start address, so just use the text offset. */
1629 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1632 /* Something is wrong if we see real data before
1633 seeing a source file name. */
1635 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1637 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
1638 where that code is defined. */
1639 if (IGNORE_SYMBOL (type
))
1642 /* FIXME, this should not be an error, since it precludes extending
1643 the symbol table information in this way... */
1644 error ("Invalid symbol data: does not start by identifying a source file.");
1652 /* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
1653 N_STSYM with a type code of f or F. Can't enable this until we get some
1654 stuff straightened out with psymtabs. FIXME. */
1660 /* Relocate for dynamic loading */
1661 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1663 /* Either of these types of symbols indicates the start of
1664 a new function. We must process its "name" normally for dbx,
1665 but also record the start of a new lexical context, and possibly
1666 also the end of the lexical context for the previous function. */
1667 /* This is not always true. This type of symbol may indicate a
1668 text segment variable. */
1670 colon_pos
= strchr (name
, ':');
1672 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
1674 define_symbol (valu
, name
, desc
, type
, objfile
);
1678 #ifndef SUN_FIXED_LBRAC_BUG
1679 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1682 #ifdef BLOCK_ADDRESS_FUNCTION_RELATIVE
1683 /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1684 are relative to the start of the function. On normal systems,
1685 and when using gcc on Solaris 2.0, these addresses are just
1686 absolute, or relative to the N_SO, depending on
1687 BLOCK_ADDRESS_ABSOLUTE. */
1688 function_start_offset
= valu
;
1691 within_function
= 1;
1692 if (context_stack_depth
> 0)
1694 new = pop_context ();
1695 /* Make a block for the local symbols within. */
1696 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1697 new->start_addr
, valu
, objfile
);
1699 /* Stack must be empty now. */
1700 if (context_stack_depth
!= 0)
1701 complain (&lbrac_unmatched_complaint
, symnum
);
1703 new = push_context (0, valu
);
1704 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1708 /* This "symbol" just indicates the start of an inner lexical
1709 context within a function. */
1711 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1712 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1713 valu
+= function_start_offset
;
1715 /* On most machines, the block addresses are relative to the
1716 N_SO, the linker did not relocate them (sigh). */
1717 valu
+= last_source_start_addr
;
1720 #ifndef SUN_FIXED_LBRAC_BUG
1721 if (valu
< last_pc_address
) {
1722 /* Patch current LBRAC pc value to match last handy pc value */
1723 complain (&lbrac_complaint
);
1724 valu
= last_pc_address
;
1727 new = push_context (desc
, valu
);
1731 /* This "symbol" just indicates the end of an inner lexical
1732 context that was started with N_LBRAC. */
1734 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1735 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1736 valu
+= function_start_offset
;
1738 /* On most machines, the block addresses are relative to the
1739 N_SO, the linker did not relocate them (sigh). */
1740 valu
+= last_source_start_addr
;
1743 new = pop_context();
1744 if (desc
!= new->depth
)
1745 complain (&lbrac_mismatch_complaint
, symnum
);
1747 /* Some compilers put the variable decls inside of an
1748 LBRAC/RBRAC block. This macro should be nonzero if this
1749 is true. DESC is N_DESC from the N_RBRAC symbol.
1750 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1751 or the GCC2_COMPILED_SYMBOL. */
1752 #if !defined (VARIABLES_INSIDE_BLOCK)
1753 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1756 /* Can only use new->locals as local symbols here if we're in
1757 gcc or on a machine that puts them before the lbrack. */
1758 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1759 local_symbols
= new->locals
;
1761 /* If this is not the outermost LBRAC...RBRAC pair in the
1762 function, its local symbols preceded it, and are the ones
1763 just recovered from the context stack. Defined the block for them.
1765 If this is the outermost LBRAC...RBRAC pair, there is no
1766 need to do anything; leave the symbols that preceded it
1767 to be attached to the function's own block. However, if
1768 it is so, we need to indicate that we just moved outside
1771 && (context_stack_depth
1772 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
1774 /* FIXME Muzzle a compiler bug that makes end < start. */
1775 if (new->start_addr
> valu
)
1777 complain (&lbrac_rbrac_complaint
);
1778 new->start_addr
= valu
;
1780 /* Make a block for the local symbols within. */
1781 finish_block (0, &local_symbols
, new->old_blocks
,
1782 new->start_addr
, valu
, objfile
);
1786 within_function
= 0;
1788 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1789 /* Now pop locals of block just finished. */
1790 local_symbols
= new->locals
;
1795 /* This kind of symbol indicates the start of an object file. */
1796 /* Relocate for dynamic loading */
1797 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1801 /* This type of symbol indicates the start of data
1802 for one source file.
1803 Finish the symbol table of the previous source file
1804 (if any) and start accumulating a new symbol table. */
1805 /* Relocate for dynamic loading */
1806 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1808 #ifndef SUN_FIXED_LBRAC_BUG
1809 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1812 #ifdef PCC_SOL_BROKEN
1813 /* pcc bug, occasionally puts out SO for SOL. */
1814 if (context_stack_depth
> 0)
1816 start_subfile (name
, NULL
);
1820 if (last_source_file
)
1822 /* Check if previous symbol was also an N_SO (with some
1823 sanity checks). If so, that one was actually the directory
1824 name, and the current one is the real file name.
1826 if (previous_stab_code
== N_SO
)
1828 patch_subfile_names (current_subfile
, name
);
1829 break; /* Ignore repeated SOs */
1831 end_symtab (valu
, 0, 0, objfile
);
1835 start_symtab (name
, NULL
, valu
);
1840 /* This type of symbol indicates the start of data for
1841 a sub-source-file, one whose contents were copied or
1842 included in the compilation of the main source file
1843 (whose name was given in the N_SO symbol.) */
1844 /* Relocate for dynamic loading */
1845 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1846 start_subfile (name
, current_subfile
->dirname
);
1851 add_new_header_file (name
, valu
);
1852 start_subfile (name
, current_subfile
->dirname
);
1856 start_subfile (pop_subfile (), current_subfile
->dirname
);
1860 add_old_header_file (name
, valu
);
1864 /* This type of "symbol" really just records
1865 one line-number -- core-address correspondence.
1866 Enter it in the line list for this symbol table. */
1867 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1868 valu
+= function_start_offset
;
1869 #ifndef SUN_FIXED_LBRAC_BUG
1870 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1872 record_line (current_subfile
, desc
, valu
);
1877 error ("Invalid symbol data: common within common at symtab pos %d",
1879 common_block
= local_symbols
;
1880 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
1884 /* Symbols declared since the BCOMM are to have the common block
1885 start address added in when we know it. common_block points to
1886 the first symbol after the BCOMM in the local_symbols list;
1887 copy the list and hang it off the symbol for the common block name
1891 struct symbol
*sym
=
1892 (struct symbol
*) xmmalloc (objfile
-> md
, sizeof (struct symbol
));
1893 memset (sym
, 0, sizeof *sym
);
1894 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1895 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1896 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
1897 copy_pending (local_symbols
, common_block_i
, common_block
));
1898 i
= hashname (SYMBOL_NAME (sym
));
1899 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1900 global_sym_chain
[i
] = sym
;
1905 /* The following symbol types need to have the appropriate offset added
1906 to their value; then we process symbol definitions in the name. */
1908 case N_STSYM
: /* Static symbol in data seg */
1909 case N_LCSYM
: /* Static symbol in BSS seg */
1910 case N_ROSYM
: /* Static symbol in Read-only data seg */
1911 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
1912 Solaris2's stabs-in-coff makes *most* symbols relative
1913 but leaves a few absolute. N_STSYM and friends sit on the fence.
1914 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1915 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1916 This leaves us no choice but to search for the 'S' or 'V'...
1917 (or pass the whole section_offsets stuff down ONE MORE function
1918 call level, which we really don't want to do). */
1921 p
= strchr (name
, ':');
1922 if (p
!= 0 && p
[1] == 'S')
1924 /* FIXME! We relocate it by the TEXT offset, in case the
1925 whole module moved in memory. But this is wrong, since
1926 the sections can side around independently. */
1927 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1928 goto define_a_symbol
;
1930 /* Since it's not the kludge case, re-dispatch to the right handler. */
1932 case N_STSYM
: goto case_N_STSYM
;
1933 case N_LCSYM
: goto case_N_LCSYM
;
1934 case N_ROSYM
: goto case_N_ROSYM
;
1939 case_N_STSYM
: /* Static symbol in data seg */
1940 case N_DSLINE
: /* Source line number, data seg */
1941 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1942 goto define_a_symbol
;
1944 case_N_LCSYM
: /* Static symbol in BSS seg */
1945 case N_BSLINE
: /* Source line number, bss seg */
1946 /* N_BROWS: overlaps with N_BSLINE */
1947 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1948 goto define_a_symbol
;
1950 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1951 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1952 goto define_a_symbol
;
1954 case N_ENTRY
: /* Alternate entry point */
1955 /* Relocate for dynamic loading */
1956 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1957 goto define_a_symbol
;
1959 /* The following symbol types don't need the address field relocated,
1960 since it is either unused, or is absolute. */
1962 case N_GSYM
: /* Global variable */
1963 case N_NSYMS
: /* Number of symbols (ultrix) */
1964 case N_NOMAP
: /* No map? (ultrix) */
1965 case N_RSYM
: /* Register variable */
1966 case N_DEFD
: /* Modula-2 GNU module dependency */
1967 case N_SSYM
: /* Struct or union element */
1968 case N_LSYM
: /* Local symbol in stack */
1969 case N_PSYM
: /* Parameter variable */
1970 case N_LENG
: /* Length of preceding symbol type */
1972 define_symbol (valu
, name
, desc
, type
, objfile
);
1975 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1976 for a bunch of other flags, too. Someday we may parse their
1977 flags; for now we ignore theirs and hope they'll ignore ours. */
1978 case N_OPT
: /* Solaris 2: Compiler options */
1981 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
1983 processing_gcc_compilation
= 2;
1984 #if 1 /* Works, but is experimental. -fnf */
1985 if (AUTO_DEMANGLING
)
1987 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1994 /* The following symbol types can be ignored. */
1995 case N_OBJ
: /* Solaris 2: Object file dir and name */
1996 /* N_UNDF: Solaris 2: file separator mark */
1997 /* N_UNDF: -- we will never encounter it, since we only process one
1998 file's symbols at once. */
1999 case N_ENDM
: /* Solaris 2: End of module */
2000 case N_MAIN
: /* Name of main routine. */
2003 /* The following symbol types we don't know how to process. Handle
2004 them in a "default" way, but complain to people who care. */
2006 case N_CATCH
: /* Exception handler catcher */
2007 case N_EHDECL
: /* Exception handler name */
2008 case N_PC
: /* Global symbol in Pascal */
2009 case N_M2C
: /* Modula-2 compilation unit */
2010 /* N_MOD2: overlaps with N_EHDECL */
2011 case N_SCOPE
: /* Modula-2 scope information */
2012 case N_ECOML
: /* End common (local name) */
2013 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2018 complain (&unknown_symtype_complaint
, local_hex_string(type
));
2020 define_symbol (valu
, name
, desc
, type
, objfile
);
2023 previous_stab_code
= type
;
2026 /* Copy a pending list, used to record the contents of a common
2027 block for later fixup. */
2028 static struct pending
*
2029 copy_pending (beg
, begi
, end
)
2030 struct pending
*beg
;
2032 struct pending
*end
;
2034 struct pending
*new = 0;
2035 struct pending
*next
;
2037 for (next
= beg
; next
!= 0 && (next
!= end
|| begi
< end
->nsyms
);
2038 next
= next
->next
, begi
= 0)
2041 for (j
= begi
; j
< next
->nsyms
; j
++)
2042 add_symbol_to_list (next
->symbol
[j
], &new);
2047 /* Scan and build partial symbols for an ELF symbol file.
2048 This ELF file has already been processed to get its minimal symbols,
2049 and any DWARF symbols that were in it.
2051 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2054 OBJFILE is the object file we are reading symbols from.
2055 ADDR is the address relative to which the symbols are (e.g.
2056 the base address of the text segment).
2057 MAINLINE is true if we are reading the main symbol
2058 table (as opposed to a shared lib or dynamically loaded file).
2059 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2061 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2062 .stabstr section exists.
2064 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2065 adjusted for elf details. */
2068 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2069 staboffset
, stabsize
,
2070 stabstroffset
, stabstrsize
)
2071 struct objfile
*objfile
;
2072 struct section_offsets
*section_offsets
;
2074 file_ptr staboffset
;
2075 unsigned int stabsize
;
2076 file_ptr stabstroffset
;
2077 unsigned int stabstrsize
;
2080 bfd
*sym_bfd
= objfile
->obfd
;
2081 char *name
= bfd_get_filename (sym_bfd
);
2082 struct dbx_symfile_info
*info
;
2084 /* There is already a dbx_symfile_info allocated by our caller.
2085 It might even contain some info from the ELF symtab to help us. */
2086 info
= (struct dbx_symfile_info
*) objfile
->sym_private
;
2088 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2089 if (!DBX_TEXT_SECT (objfile
))
2090 error ("Can't find .text section in symbol file");
2092 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2093 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2094 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2095 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2096 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2098 if (stabstrsize
< 0) /* FIXME: stabstrsize is unsigned; never true! */
2099 error ("ridiculous string table size: %d bytes", stabstrsize
);
2100 DBX_STRINGTAB (objfile
) = (char *)
2101 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2103 /* Now read in the string table in one big gulp. */
2105 val
= bfd_seek (sym_bfd
, stabstroffset
, L_SET
);
2107 perror_with_name (name
);
2108 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2109 if (val
!= stabstrsize
)
2110 perror_with_name (name
);
2112 stabsread_new_init ();
2113 buildsym_new_init ();
2114 free_header_files ();
2115 init_header_files ();
2116 install_minimal_symbols (objfile
);
2118 processing_acc_compilation
= 1;
2120 /* In an elf file, we've already installed the minimal symbols that came
2121 from the elf (non-stab) symbol table, so always act like an
2122 incremental load here. */
2123 dbx_symfile_read (objfile
, section_offsets
, 0);
2126 /* Parse the user's idea of an offset for dynamic linking, into our idea
2127 of how to represent it for fast symbol reading. */
2129 struct section_offsets
*
2130 dbx_symfile_offsets (objfile
, addr
)
2131 struct objfile
*objfile
;
2134 struct section_offsets
*section_offsets
;
2137 section_offsets
= (struct section_offsets
*)
2138 obstack_alloc (&objfile
-> psymbol_obstack
,
2139 sizeof (struct section_offsets
) +
2140 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2142 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2143 ANOFFSET (section_offsets
, i
) = addr
;
2145 return section_offsets
;
2148 /* Register our willingness to decode symbols for SunOS and a.out and
2149 b.out files handled by BFD... */
2150 static struct sym_fns sunos_sym_fns
=
2152 "sunOs", /* sym_name: name or name prefix of BFD target type */
2153 6, /* sym_namelen: number of significant sym_name chars */
2154 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2155 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2156 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2157 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2158 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2159 NULL
/* next: pointer to next struct sym_fns */
2162 static struct sym_fns aout_sym_fns
=
2164 "a.out", /* sym_name: name or name prefix of BFD target type */
2165 5, /* sym_namelen: number of significant sym_name chars */
2166 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2167 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2168 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2169 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2170 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2171 NULL
/* next: pointer to next struct sym_fns */
2174 static struct sym_fns bout_sym_fns
=
2176 "b.out", /* sym_name: name or name prefix of BFD target type */
2177 5, /* sym_namelen: number of significant sym_name chars */
2178 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2179 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2180 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2181 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2182 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2183 NULL
/* next: pointer to next struct sym_fns */
2186 /* This is probably a mistake. FIXME. Why can't the HP's use an ordinary
2187 file format name with an -hppa suffix? */
2188 static struct sym_fns hppa_sym_fns
=
2190 "hppa", /* sym_name: name or name prefix of BFD target type */
2191 4, /* sym_namelen: number of significant sym_name chars */
2192 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2193 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2194 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2195 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2196 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2197 NULL
/* next: pointer to next struct sym_fns */
2201 _initialize_dbxread ()
2203 add_symtab_fns(&sunos_sym_fns
);
2204 add_symtab_fns(&aout_sym_fns
);
2205 add_symtab_fns(&bout_sym_fns
);
2206 add_symtab_fns(&hppa_sym_fns
);