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"
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
);
467 #ifdef GDB_TARGET_IS_HPPA
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 */
540 #ifdef GDB_TARGET_IS_HPPA
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");
556 #ifdef GDB_TARGET_IS_HPPA
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
577 #ifdef GDB_TARGET_IS_HPPA
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
));
599 #ifdef GDB_TARGET_IS_HPPA
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
);
618 #ifdef GDB_TARGET_IS_HPPA
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
);
627 #ifdef GDB_TARGET_IS_HPPA
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
;
683 #ifdef GDB_TARGET_IS_HPPA
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
749 #ifdef GDB_TARGET_IS_HPPA
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
;
849 #ifdef GDB_TARGET_IS_HPPA
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;
878 #ifdef GDB_TARGET_IS_HPPA
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
;
917 #ifdef GDB_TARGET_IS_HPPA
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. */
1039 #ifndef GDB_TARGET_IS_HPPA
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
;
1053 #ifdef GDB_TARGET_IS_HPPA
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
);
1349 #ifdef GDB_TARGET_IS_HPPA
1350 symbol_size
= obj_dbx_symbol_entry_size (pst
->objfile
->obfd
);
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
;
1445 #ifdef GDB_TARGET_IS_HPPA
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
= 0;
1472 if (bufp
->n_type
== N_TEXT
)
1474 if (strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
) == 0)
1475 processing_gcc_compilation
= 1;
1476 else if (strcmp (namestring
, GCC2_COMPILED_FLAG_SYMBOL
) == 0)
1477 processing_gcc_compilation
= 2;
1480 /* Try to select a C++ demangling based on the compilation unit
1483 if (processing_gcc_compilation
)
1485 #if 1 /* Works, but is experimental. -fnf */
1486 if (AUTO_DEMANGLING
)
1488 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1495 /* The N_SO starting this symtab is the first symbol, so we
1496 better not check the symbol before it. I'm not this can
1497 happen, but it doesn't hurt to check for it. */
1498 bfd_seek (symfile_bfd
, sym_offset
, L_INCR
);
1499 processing_gcc_compilation
= 0;
1502 if (symbuf_idx
== symbuf_end
)
1504 bufp
= &symbuf
[symbuf_idx
];
1505 if (bufp
->n_type
!= (unsigned char)N_SO
)
1506 error("First symbol in segment of executable not a source symbol");
1508 max_symnum
= sym_size
/ symbol_size
;
1511 symnum
< max_symnum
;
1514 QUIT
; /* Allow this to be interruptable */
1515 if (symbuf_idx
== symbuf_end
)
1517 bufp
= &symbuf
[symbuf_idx
++];
1518 SWAP_SYMBOL (bufp
, abfd
);
1520 type
= bufp
->n_type
;
1524 if (type
& N_STAB
) {
1525 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1526 namestring
, section_offsets
, objfile
);
1528 /* We skip checking for a new .o or -l file; that should never
1529 happen in this routine. */
1530 else if (type
== N_TEXT
)
1532 /* I don't think this code will ever be executed, because
1533 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1534 the N_SO symbol which starts this source file.
1535 However, there is no reason not to accept
1536 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1538 processing_gcc_compilation
= 0;
1539 if (strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
) == 0)
1540 processing_gcc_compilation
= 1;
1541 else if (strcmp (namestring
, GCC2_COMPILED_FLAG_SYMBOL
) == 0)
1542 processing_gcc_compilation
= 2;
1544 #if 1 /* Works, but is experimental. -fnf */
1545 if (AUTO_DEMANGLING
)
1547 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1551 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1552 || type
== (unsigned char)N_NBTEXT
1554 /* Global symbol: see if we came across a dbx defintion for
1555 a corresponding symbol. If so, store the value. Remove
1556 syms from the chain when their values are stored, but
1557 search the whole chain, as there may be several syms from
1558 different files with the same name. */
1559 /* This is probably not true. Since the files will be read
1560 in one at a time, each reference to a global symbol will
1561 be satisfied in each file as it appears. So we skip this
1567 current_objfile
= NULL
;
1569 /* In a Solaris elf file, this variable, which comes from the
1570 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1571 which comes from pst->textlow is correct. */
1572 if (last_source_start_addr
== 0)
1573 last_source_start_addr
= text_offset
;
1575 rtn
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
);
1580 /* This handles a single symbol from the symbol-file, building symbols
1581 into a GDB symtab. It takes these arguments and an implicit argument.
1583 TYPE is the type field of the ".stab" symbol entry.
1584 DESC is the desc field of the ".stab" entry.
1585 VALU is the value field of the ".stab" entry.
1586 NAME is the symbol name, in our address space.
1587 SECTION_OFFSETS is a set of amounts by which the sections of this object
1588 file were relocated when it was loaded into memory.
1589 All symbols that refer
1590 to memory locations need to be offset by these amounts.
1591 OBJFILE is the object file from which we are reading symbols.
1592 It is used in end_symtab. */
1595 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1599 struct section_offsets
*section_offsets
;
1600 struct objfile
*objfile
;
1602 #ifndef SUN_FIXED_LBRAC_BUG
1603 /* This records the last pc address we've seen. We depend on there being
1604 an SLINE or FUN or SO before the first LBRAC, since the variable does
1605 not get reset in between reads of different symbol files. */
1606 static CORE_ADDR last_pc_address
;
1608 register struct context_stack
*new;
1609 /* This remembers the address of the start of a function. It is used
1610 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1611 relative to the current function's start address. On systems
1612 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1613 used to relocate these symbol types rather than SECTION_OFFSETS. */
1614 static CORE_ADDR function_start_offset
;
1617 /* Something is wrong if we see real data before
1618 seeing a source file name. */
1620 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1622 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
1623 where that code is defined. */
1624 if (IGNORE_SYMBOL (type
))
1627 /* FIXME, this should not be an error, since it precludes extending
1628 the symbol table information in this way... */
1629 error ("Invalid symbol data: does not start by identifying a source file.");
1637 /* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
1638 N_STSYM with a type code of f or F. Can't enable this until we get some
1639 stuff straightened out with psymtabs. FIXME. */
1645 /* Relocate for dynamic loading */
1646 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1648 /* Either of these types of symbols indicates the start of
1649 a new function. We must process its "name" normally for dbx,
1650 but also record the start of a new lexical context, and possibly
1651 also the end of the lexical context for the previous function. */
1652 /* This is not always true. This type of symbol may indicate a
1653 text segment variable. */
1655 colon_pos
= strchr (name
, ':');
1657 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
1659 define_symbol (valu
, name
, desc
, type
, objfile
);
1663 #ifndef SUN_FIXED_LBRAC_BUG
1664 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1667 #ifdef BLOCK_ADDRESS_FUNCTION_RELATIVE
1668 /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1669 are relative to the start of the function. On normal systems,
1670 and when using gcc on Solaris 2.0, these addresses are just
1671 absolute, or relative to the N_SO, depending on
1672 BLOCK_ADDRESS_ABSOLUTE. */
1673 function_start_offset
= valu
;
1675 /* Default on ordinary systems */
1676 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1679 within_function
= 1;
1680 if (context_stack_depth
> 0)
1682 new = pop_context ();
1683 /* Make a block for the local symbols within. */
1684 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1685 new->start_addr
, valu
, objfile
);
1687 /* Stack must be empty now. */
1688 if (context_stack_depth
!= 0)
1689 complain (&lbrac_unmatched_complaint
, (char *) symnum
);
1691 new = push_context (0, valu
);
1692 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1696 /* This "symbol" just indicates the start of an inner lexical
1697 context within a function. */
1699 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1700 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1701 valu
+= function_start_offset
;
1703 /* On most machines, the block addresses are relative to the
1704 N_SO, the linker did not relocate them (sigh). */
1705 valu
+= last_source_start_addr
;
1708 #ifndef SUN_FIXED_LBRAC_BUG
1709 if (valu
< last_pc_address
) {
1710 /* Patch current LBRAC pc value to match last handy pc value */
1711 complain (&lbrac_complaint
, 0);
1712 valu
= last_pc_address
;
1715 new = push_context (desc
, valu
);
1719 /* This "symbol" just indicates the end of an inner lexical
1720 context that was started with N_LBRAC. */
1722 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1723 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1724 valu
+= function_start_offset
;
1726 /* On most machines, the block addresses are relative to the
1727 N_SO, the linker did not relocate them (sigh). */
1728 valu
+= last_source_start_addr
;
1731 new = pop_context();
1732 if (desc
!= new->depth
)
1733 complain (&lbrac_mismatch_complaint
, (char *) symnum
);
1735 /* Some compilers put the variable decls inside of an
1736 LBRAC/RBRAC block. This macro should be nonzero if this
1737 is true. DESC is N_DESC from the N_RBRAC symbol.
1738 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1739 or the GCC2_COMPILED_SYMBOL. */
1740 #if !defined (VARIABLES_INSIDE_BLOCK)
1741 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1744 /* Can only use new->locals as local symbols here if we're in
1745 gcc or on a machine that puts them before the lbrack. */
1746 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1747 local_symbols
= new->locals
;
1749 /* If this is not the outermost LBRAC...RBRAC pair in the
1750 function, its local symbols preceded it, and are the ones
1751 just recovered from the context stack. Defined the block for them.
1753 If this is the outermost LBRAC...RBRAC pair, there is no
1754 need to do anything; leave the symbols that preceded it
1755 to be attached to the function's own block. However, if
1756 it is so, we need to indicate that we just moved outside
1759 && (context_stack_depth
1760 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
1762 /* FIXME Muzzle a compiler bug that makes end < start. */
1763 if (new->start_addr
> valu
)
1765 complain(&lbrac_rbrac_complaint
, 0);
1766 new->start_addr
= valu
;
1768 /* Make a block for the local symbols within. */
1769 finish_block (0, &local_symbols
, new->old_blocks
,
1770 new->start_addr
, valu
, objfile
);
1774 within_function
= 0;
1776 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1777 /* Now pop locals of block just finished. */
1778 local_symbols
= new->locals
;
1783 /* This kind of symbol indicates the start of an object file. */
1784 /* Relocate for dynamic loading */
1785 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1789 /* This type of symbol indicates the start of data
1790 for one source file.
1791 Finish the symbol table of the previous source file
1792 (if any) and start accumulating a new symbol table. */
1793 /* Relocate for dynamic loading */
1794 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1796 #ifndef SUN_FIXED_LBRAC_BUG
1797 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1800 #ifdef PCC_SOL_BROKEN
1801 /* pcc bug, occasionally puts out SO for SOL. */
1802 if (context_stack_depth
> 0)
1804 start_subfile (name
, NULL
);
1808 if (last_source_file
)
1810 /* Check if previous symbol was also an N_SO (with some
1811 sanity checks). If so, that one was actually the directory
1812 name, and the current one is the real file name.
1814 if (previous_stab_code
== N_SO
)
1816 patch_subfile_names (current_subfile
, name
);
1817 break; /* Ignore repeated SOs */
1819 end_symtab (valu
, 0, 0, objfile
);
1823 start_symtab (name
, NULL
, valu
);
1828 /* This type of symbol indicates the start of data for
1829 a sub-source-file, one whose contents were copied or
1830 included in the compilation of the main source file
1831 (whose name was given in the N_SO symbol.) */
1832 /* Relocate for dynamic loading */
1833 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1834 start_subfile (name
, current_subfile
->dirname
);
1839 add_new_header_file (name
, valu
);
1840 start_subfile (name
, current_subfile
->dirname
);
1844 start_subfile (pop_subfile (), current_subfile
->dirname
);
1848 add_old_header_file (name
, valu
);
1852 /* This type of "symbol" really just records
1853 one line-number -- core-address correspondence.
1854 Enter it in the line list for this symbol table. */
1855 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1856 valu
+= function_start_offset
;
1857 #ifndef SUN_FIXED_LBRAC_BUG
1858 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1860 record_line (current_subfile
, desc
, valu
);
1865 error ("Invalid symbol data: common within common at symtab pos %d",
1867 common_block
= local_symbols
;
1868 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
1872 /* Symbols declared since the BCOMM are to have the common block
1873 start address added in when we know it. common_block points to
1874 the first symbol after the BCOMM in the local_symbols list;
1875 copy the list and hang it off the symbol for the common block name
1879 struct symbol
*sym
=
1880 (struct symbol
*) xmmalloc (objfile
-> md
, sizeof (struct symbol
));
1881 memset (sym
, 0, sizeof *sym
);
1882 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1883 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1884 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
1885 copy_pending (local_symbols
, common_block_i
, common_block
));
1886 i
= hashname (SYMBOL_NAME (sym
));
1887 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1888 global_sym_chain
[i
] = sym
;
1893 /* The following symbol types need to have the appropriate offset added
1894 to their value; then we process symbol definitions in the name. */
1896 case N_STSYM
: /* Static symbol in data seg */
1897 case N_LCSYM
: /* Static symbol in BSS seg */
1898 case N_ROSYM
: /* Static symbol in Read-only data seg */
1899 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
1900 Solaris2's stabs-in-coff makes *most* symbols relative
1901 but leaves a few absolute. N_STSYM and friends sit on the fence.
1902 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1903 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1904 This leaves us no choice but to search for the 'S' or 'V'...
1905 (or pass the whole section_offsets stuff down ONE MORE function
1906 call level, which we really don't want to do). */
1909 p
= strchr (name
, ':');
1910 if (p
!= 0 && p
[1] == 'S')
1912 /* FIXME! We relocate it by the TEXT offset, in case the
1913 whole module moved in memory. But this is wrong, since
1914 the sections can side around independently. */
1915 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1916 goto define_a_symbol
;
1918 /* Since it's not the kludge case, re-dispatch to the right handler. */
1920 case N_STSYM
: goto case_N_STSYM
;
1921 case N_LCSYM
: goto case_N_LCSYM
;
1922 case N_ROSYM
: goto case_N_ROSYM
;
1927 case_N_STSYM
: /* Static symbol in data seg */
1928 case N_DSLINE
: /* Source line number, data seg */
1929 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1930 goto define_a_symbol
;
1932 case_N_LCSYM
: /* Static symbol in BSS seg */
1933 case N_BSLINE
: /* Source line number, bss seg */
1934 /* N_BROWS: overlaps with N_BSLINE */
1935 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1936 goto define_a_symbol
;
1938 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1939 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1940 goto define_a_symbol
;
1942 case N_ENTRY
: /* Alternate entry point */
1943 /* Relocate for dynamic loading */
1944 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1945 goto define_a_symbol
;
1947 /* The following symbol types don't need the address field relocated,
1948 since it is either unused, or is absolute. */
1950 case N_GSYM
: /* Global variable */
1951 case N_NSYMS
: /* Number of symbols (ultrix) */
1952 case N_NOMAP
: /* No map? (ultrix) */
1953 case N_RSYM
: /* Register variable */
1954 case N_DEFD
: /* Modula-2 GNU module dependency */
1955 case N_SSYM
: /* Struct or union element */
1956 case N_LSYM
: /* Local symbol in stack */
1957 case N_PSYM
: /* Parameter variable */
1958 case N_LENG
: /* Length of preceding symbol type */
1960 define_symbol (valu
, name
, desc
, type
, objfile
);
1963 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1964 for a bunch of other flags, too. Someday we may parse their
1965 flags; for now we ignore theirs and hope they'll ignore ours. */
1966 case N_OPT
: /* Solaris 2: Compiler options */
1969 if (strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
) == 0)
1971 processing_gcc_compilation
= 2;
1972 #if 1 /* Works, but is experimental. -fnf */
1973 if (AUTO_DEMANGLING
)
1975 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1982 /* The following symbol types can be ignored. */
1983 case N_OBJ
: /* Solaris 2: Object file dir and name */
1984 /* N_UNDF: Solaris 2: file separator mark */
1985 /* N_UNDF: -- we will never encounter it, since we only process one
1986 file's symbols at once. */
1987 case N_ENDM
: /* Solaris 2: End of module */
1988 case N_MAIN
: /* Name of main routine. */
1991 /* The following symbol types we don't know how to process. Handle
1992 them in a "default" way, but complain to people who care. */
1994 case N_CATCH
: /* Exception handler catcher */
1995 case N_EHDECL
: /* Exception handler name */
1996 case N_PC
: /* Global symbol in Pascal */
1997 case N_M2C
: /* Modula-2 compilation unit */
1998 /* N_MOD2: overlaps with N_EHDECL */
1999 case N_SCOPE
: /* Modula-2 scope information */
2000 case N_ECOML
: /* End common (local name) */
2001 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2006 complain (&unknown_symtype_complaint
, local_hex_string(type
));
2008 define_symbol (valu
, name
, desc
, type
, objfile
);
2011 previous_stab_code
= type
;
2014 /* Copy a pending list, used to record the contents of a common
2015 block for later fixup. */
2016 static struct pending
*
2017 copy_pending (beg
, begi
, end
)
2018 struct pending
*beg
;
2020 struct pending
*end
;
2022 struct pending
*new = 0;
2023 struct pending
*next
;
2025 for (next
= beg
; next
!= 0 && (next
!= end
|| begi
< end
->nsyms
);
2026 next
= next
->next
, begi
= 0)
2029 for (j
= begi
; j
< next
->nsyms
; j
++)
2030 add_symbol_to_list (next
->symbol
[j
], &new);
2035 /* Scan and build partial symbols for an ELF symbol file.
2036 This ELF file has already been processed to get its minimal symbols,
2037 and any DWARF symbols that were in it.
2039 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2042 OBJFILE is the object file we are reading symbols from.
2043 ADDR is the address relative to which the symbols are (e.g.
2044 the base address of the text segment).
2045 MAINLINE is true if we are reading the main symbol
2046 table (as opposed to a shared lib or dynamically loaded file).
2047 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2049 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2050 .stabstr section exists.
2052 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2053 adjusted for elf details. */
2056 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2057 staboffset
, stabsize
,
2058 stabstroffset
, stabstrsize
)
2059 struct objfile
*objfile
;
2060 struct section_offsets
*section_offsets
;
2062 unsigned int staboffset
;
2063 unsigned int stabsize
;
2064 unsigned int stabstroffset
;
2065 unsigned int stabstrsize
;
2068 bfd
*sym_bfd
= objfile
->obfd
;
2069 char *name
= bfd_get_filename (sym_bfd
);
2070 struct dbx_symfile_info
*info
;
2072 /* There is already a dbx_symfile_info allocated by our caller.
2073 It might even contain some info from the ELF symtab to help us. */
2074 info
= (struct dbx_symfile_info
*) objfile
->sym_private
;
2076 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2077 if (!DBX_TEXT_SECT (objfile
))
2078 error ("Can't find .text section in symbol file");
2080 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2081 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2082 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2083 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2084 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2086 if (stabstrsize
< 0) /* FIXME: stabstrsize is unsigned; never true! */
2087 error ("ridiculous string table size: %d bytes", stabstrsize
);
2088 DBX_STRINGTAB (objfile
) = (char *)
2089 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2091 /* Now read in the string table in one big gulp. */
2093 val
= bfd_seek (sym_bfd
, stabstroffset
, L_SET
);
2095 perror_with_name (name
);
2096 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2097 if (val
!= stabstrsize
)
2098 perror_with_name (name
);
2100 stabsread_new_init ();
2101 buildsym_new_init ();
2102 free_header_files ();
2103 init_header_files ();
2104 install_minimal_symbols (objfile
);
2106 processing_acc_compilation
= 1;
2108 /* In an elf file, we've already installed the minimal symbols that came
2109 from the elf (non-stab) symbol table, so always act like an
2110 incremental load here. */
2111 dbx_symfile_read (objfile
, section_offsets
, 0);
2114 /* Parse the user's idea of an offset for dynamic linking, into our idea
2115 of how to represent it for fast symbol reading. */
2117 struct section_offsets
*
2118 dbx_symfile_offsets (objfile
, addr
)
2119 struct objfile
*objfile
;
2122 struct section_offsets
*section_offsets
;
2125 section_offsets
= (struct section_offsets
*)
2126 obstack_alloc (&objfile
-> psymbol_obstack
,
2127 sizeof (struct section_offsets
) +
2128 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2130 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2131 ANOFFSET (section_offsets
, i
) = addr
;
2133 return section_offsets
;
2136 /* Register our willingness to decode symbols for SunOS and a.out and
2137 b.out files handled by BFD... */
2138 static struct sym_fns sunos_sym_fns
=
2140 "sunOs", /* sym_name: name or name prefix of BFD target type */
2141 6, /* sym_namelen: number of significant sym_name chars */
2142 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2143 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2144 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2145 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2146 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2147 NULL
/* next: pointer to next struct sym_fns */
2150 static struct sym_fns aout_sym_fns
=
2152 "a.out", /* sym_name: name or name prefix of BFD target type */
2153 5, /* 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 bout_sym_fns
=
2164 "b.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 /* This is probably a mistake. FIXME. Why can't the HP's use an ordinary
2175 file format name with an -hppa suffix? */
2176 static struct sym_fns hppa_sym_fns
=
2178 "hppa", /* sym_name: name or name prefix of BFD target type */
2179 4, /* sym_namelen: number of significant sym_name chars */
2180 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2181 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2182 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2183 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2184 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2185 NULL
/* next: pointer to next struct sym_fns */
2189 _initialize_dbxread ()
2191 add_symtab_fns(&sunos_sym_fns
);
2192 add_symtab_fns(&aout_sym_fns
);
2193 add_symtab_fns(&bout_sym_fns
);
2194 add_symtab_fns(&hppa_sym_fns
);