1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This module provides three functions: dbx_symfile_init,
22 which initializes to read a symbol file; dbx_new_init, which
23 discards existing cached information when all symbols are being
24 discarded; and dbx_symfile_read, which reads a symbol table
27 dbx_symfile_read only does the minimum work necessary for letting the
28 user "name" things symbolically; it does not read the entire symtab.
29 Instead, it reads the external and static symbols and puts them in partial
30 symbol tables. When more extensive information is requested of a
31 file, the corresponding partial symbol table is mutated into a full
32 fledged symbol table by going back and reading the symbols
33 for real. dbx_psymtab_to_symtab() is the function that does this */
38 #if defined(USG) || defined(__CYGNUSCLIB__)
39 #include <sys/types.h>
44 #include <sys/param.h>
51 #include "breakpoint.h"
54 #include "gdbcore.h" /* for bfd stuff */
55 #include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
56 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
60 #include "stabsread.h"
61 #include "gdb-stabs.h"
63 #include "language.h" /* Needed inside partial-stab.h */
64 #include "complaints.h"
66 #include "aout/aout64.h"
67 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
69 #if !defined (SEEK_SET)
74 /* Each partial symbol table entry contains a pointer to private data for the
75 read_symtab() function to use when expanding a partial symbol table entry
76 to a full symbol table entry.
78 For dbxread this structure contains the offset within the file symbol table
79 of first local symbol for this file, and length (in bytes) of the section
80 of the symbol table devoted to this file's symbols (actually, the section
81 bracketed may contain more than just this file's symbols). It also contains
82 further information needed to locate the symbols if they are in an ELF file.
84 If ldsymlen is 0, the only reason for this thing's existence is the
85 dependency list. Nothing else will happen when it is read in. */
87 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
88 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
89 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
90 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
91 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
92 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
93 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
101 int file_string_offset
;
104 /* Macro to determine which symbols to ignore when reading the first symbol
105 of a file. Some machines override this definition. */
106 #ifndef IGNORE_SYMBOL
107 /* This code is used on Ultrix systems. Ignore it */
108 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
111 /* Macro for name of symbol to indicate a file compiled with gcc. */
112 #ifndef GCC_COMPILED_FLAG_SYMBOL
113 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
116 /* Macro for name of symbol to indicate a file compiled with gcc2. */
117 #ifndef GCC2_COMPILED_FLAG_SYMBOL
118 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
121 /* Remember what we deduced to be the source language of this psymtab. */
123 static enum language psymtab_language
= language_unknown
;
125 /* Nonzero means give verbose info on gdb action. From main.c. */
126 extern int info_verbose
;
128 /* The BFD for this file -- implicit parameter to next_symbol_text. */
130 static bfd
*symfile_bfd
;
132 /* The size of each symbol in the symbol file (in external form).
133 This is set by dbx_symfile_read when building psymtabs, and by
134 dbx_psymtab_to_symtab when building symtabs. */
136 static unsigned symbol_size
;
138 /* This is the offset of the symbol table in the executable file */
139 static unsigned symbol_table_offset
;
141 /* This is the offset of the string table in the executable file */
142 static unsigned string_table_offset
;
144 /* For elf+stab executables, the n_strx field is not a simple index
145 into the string table. Instead, each .o file has a base offset
146 in the string table, and the associated symbols contain offsets
147 from this base. The following two variables contain the base
148 offset for the current and next .o files. */
149 static unsigned int file_string_table_offset
;
150 static unsigned int next_file_string_table_offset
;
152 /* Complaints about the symbols we have encountered. */
154 struct complaint lbrac_complaint
=
155 {"bad block start address patched", 0, 0};
157 struct complaint string_table_offset_complaint
=
158 {"bad string table offset in symbol %d", 0, 0};
160 struct complaint unknown_symtype_complaint
=
161 {"unknown symbol type %s", 0, 0};
163 struct complaint unknown_symchar_complaint
=
164 {"unknown symbol descriptor `%c'", 0, 0};
166 struct complaint lbrac_rbrac_complaint
=
167 {"block start larger than block end", 0, 0};
169 struct complaint lbrac_unmatched_complaint
=
170 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
172 struct complaint lbrac_mismatch_complaint
=
173 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
175 struct complaint repeated_header_complaint
=
176 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
178 struct complaint repeated_header_name_complaint
=
179 {"\"repeated\" header file not previously seen, named %s", 0, 0};
181 /* During initial symbol readin, we need to have a structure to keep
182 track of which psymtabs have which bincls in them. This structure
183 is used during readin to setup the list of dependencies within each
184 partial symbol table. */
186 struct header_file_location
188 char *name
; /* Name of header file */
189 int instance
; /* See above */
190 struct partial_symtab
*pst
; /* Partial symtab that has the
191 BINCL/EINCL defs for this file */
194 /* The actual list and controling variables */
195 static struct header_file_location
*bincl_list
, *next_bincl
;
196 static int bincls_allocated
;
198 /* Local function prototypes */
201 free_header_files
PARAMS ((void));
204 init_header_files
PARAMS ((void));
207 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
210 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
213 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
216 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
220 free_bincl_list
PARAMS ((struct objfile
*));
222 static struct partial_symtab
*
223 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
226 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
229 init_bincl_list
PARAMS ((int, struct objfile
*));
232 init_psymbol_list
PARAMS ((struct objfile
*));
235 dbx_next_symbol_text
PARAMS ((void));
238 fill_symbuf
PARAMS ((bfd
*));
241 dbx_symfile_init
PARAMS ((struct objfile
*));
244 dbx_new_init
PARAMS ((struct objfile
*));
247 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
250 dbx_symfile_finish
PARAMS ((struct objfile
*));
253 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
256 add_new_header_file
PARAMS ((char *, int));
259 add_old_header_file
PARAMS ((char *, int));
262 add_this_object_header_file
PARAMS ((int));
264 /* Free up old header file tables */
271 if (header_files
!= NULL
)
273 for (i
= 0; i
< n_header_files
; i
++)
275 free (header_files
[i
].name
);
277 free ((PTR
)header_files
);
281 if (this_object_header_files
)
283 free ((PTR
)this_object_header_files
);
284 this_object_header_files
= NULL
;
286 n_allocated_header_files
= 0;
287 n_allocated_this_object_header_files
= 0;
290 /* Allocate new header file tables */
296 n_allocated_header_files
= 10;
297 header_files
= (struct header_file
*)
298 xmalloc (10 * sizeof (struct header_file
));
300 n_allocated_this_object_header_files
= 10;
301 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
304 /* Add header file number I for this object file
305 at the next successive FILENUM. */
308 add_this_object_header_file (i
)
311 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
313 n_allocated_this_object_header_files
*= 2;
314 this_object_header_files
315 = (int *) xrealloc ((char *) this_object_header_files
,
316 n_allocated_this_object_header_files
* sizeof (int));
319 this_object_header_files
[n_this_object_header_files
++] = i
;
322 /* Add to this file an "old" header file, one already seen in
323 a previous object file. NAME is the header file's name.
324 INSTANCE is its instance code, to select among multiple
325 symbol tables for the same header file. */
328 add_old_header_file (name
, instance
)
332 register struct header_file
*p
= header_files
;
335 for (i
= 0; i
< n_header_files
; i
++)
336 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
338 add_this_object_header_file (i
);
341 complain (&repeated_header_complaint
, symnum
);
342 complain (&repeated_header_name_complaint
, name
);
345 /* Add to this file a "new" header file: definitions for its types follow.
346 NAME is the header file's name.
347 Most often this happens only once for each distinct header file,
348 but not necessarily. If it happens more than once, INSTANCE has
349 a different value each time, and references to the header file
350 use INSTANCE values to select among them.
352 dbx output contains "begin" and "end" markers for each new header file,
353 but at this level we just need to know which files there have been;
354 so we record the file when its "begin" is seen and ignore the "end". */
357 add_new_header_file (name
, instance
)
363 /* Make sure there is room for one more header file. */
365 if (n_header_files
== n_allocated_header_files
)
367 n_allocated_header_files
*= 2;
368 header_files
= (struct header_file
*)
369 xrealloc ((char *) header_files
,
370 (n_allocated_header_files
* sizeof (struct header_file
)));
373 /* Create an entry for this header file. */
375 i
= n_header_files
++;
376 header_files
[i
].name
= savestring (name
, strlen(name
));
377 header_files
[i
].instance
= instance
;
378 header_files
[i
].length
= 10;
379 header_files
[i
].vector
380 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
381 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
383 add_this_object_header_file (i
);
387 static struct type
**
388 explicit_lookup_type (real_filenum
, index
)
389 int real_filenum
, index
;
391 register struct header_file
*f
= &header_files
[real_filenum
];
393 if (index
>= f
->length
)
396 f
->vector
= (struct type
**)
397 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
398 memset (&f
->vector
[f
->length
/ 2],
399 '\0', f
->length
* sizeof (struct type
*) / 2);
401 return &f
->vector
[index
];
406 record_minimal_symbol (name
, address
, type
, objfile
)
410 struct objfile
*objfile
;
412 enum minimal_symbol_type ms_type
;
416 case N_TEXT
| N_EXT
: ms_type
= mst_text
; break;
417 case N_DATA
| N_EXT
: ms_type
= mst_data
; break;
418 case N_BSS
| N_EXT
: ms_type
= mst_bss
; break;
419 case N_ABS
| N_EXT
: ms_type
= mst_abs
; break;
421 case N_SETV
| N_EXT
: ms_type
= mst_data
; break;
423 /* I don't think this type actually exists; since a N_SETV is the result
424 of going over many .o files, it doesn't make sense to have one
426 ms_type
= mst_file_data
;
430 /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
431 the minimal symbols, because if there is also another symbol
432 at the same address (e.g. the first function of the file),
433 lookup_minimal_symbol_by_pc would have no way of getting the
436 && (strcmp (name
, GCC_COMPILED_FLAG_SYMBOL
) == 0
437 || strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
) == 0))
441 char *tempstring
= name
;
442 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
444 if (STREQN (tempstring
, "__gnu_compiled", 14))
451 ms_type
= mst_file_text
;
455 ms_type
= mst_file_data
;
457 /* Check for __DYNAMIC, which is used by Sun shared libraries.
458 Record it as global even if it's local, not global, so
459 lookup_minimal_symbol can find it. We don't check symbol_leading_char
460 because for SunOS4 it always is '_'. */
461 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
464 /* Same with virtual function tables, both global and static. */
466 char *tempstring
= name
;
467 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
469 if (VTBL_PREFIX_P ((tempstring
)))
475 ms_type
= mst_file_bss
;
478 default: ms_type
= mst_unknown
; break;
481 prim_record_minimal_symbol
482 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
487 /* Scan and build partial symbols for a symbol file.
488 We have been initialized by a call to dbx_symfile_init, which
489 put all the relevant info into a "struct dbx_symfile_info",
490 hung off the objfile structure.
492 SECTION_OFFSETS contains offsets relative to which the symbols in the
493 various sections are (depending where the sections were actually loaded).
494 MAINLINE is true if we are reading the main symbol
495 table (as opposed to a shared lib or dynamically loaded file). */
498 dbx_symfile_read (objfile
, section_offsets
, mainline
)
499 struct objfile
*objfile
;
500 struct section_offsets
*section_offsets
;
501 int mainline
; /* FIXME comments above */
505 struct cleanup
*back_to
;
507 sym_bfd
= objfile
->obfd
;
508 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
510 perror_with_name (objfile
->name
);
512 /* If we are reinitializing, or if we have never loaded syms yet, init */
513 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
514 init_psymbol_list (objfile
);
516 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
517 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
520 back_to
= make_cleanup (really_free_pendings
, 0);
522 init_minimal_symbol_collection ();
523 make_cleanup (discard_minimal_symbols
, 0);
525 /* Now that the symbol table data of the executable file are all in core,
526 process them and define symbols accordingly. */
528 read_dbx_symtab (section_offsets
, objfile
,
529 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
530 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
532 /* Install any minimal symbols that have been collected as the current
533 minimal symbols for this objfile. */
535 install_minimal_symbols (objfile
);
537 if (!have_partial_symbols ()) {
539 printf_filtered ("(no debugging symbols found)...");
543 do_cleanups (back_to
);
546 /* Initialize anything that needs initializing when a completely new
547 symbol file is specified (not just adding some symbols from another
548 file, e.g. a shared library). */
551 dbx_new_init (ignore
)
552 struct objfile
*ignore
;
554 stabsread_new_init ();
555 buildsym_new_init ();
556 init_header_files ();
560 /* dbx_symfile_init ()
561 is the dbx-specific initialization routine for reading symbols.
562 It is passed a struct objfile which contains, among other things,
563 the BFD for the file whose symbols are being read, and a slot for a pointer
564 to "private data" which we fill with goodies.
566 We read the string table into malloc'd space and stash a pointer to it.
568 Since BFD doesn't know how to read debug symbols in a format-independent
569 way (and may never do so...), we have to do it ourselves. We will never
570 be called unless this is an a.out (or very similar) file.
571 FIXME, there should be a cleaner peephole into the BFD environment here. */
573 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
576 dbx_symfile_init (objfile
)
577 struct objfile
*objfile
;
580 bfd
*sym_bfd
= objfile
->obfd
;
581 char *name
= bfd_get_filename (sym_bfd
);
582 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
584 /* Allocate struct to keep track of the symfile */
585 objfile
->sym_stab_info
= (PTR
)
586 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
588 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
589 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
590 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
592 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
594 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
595 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
596 if (!DBX_TEXT_SECT (objfile
))
597 error ("Can't find .text section in symbol file");
599 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
600 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
601 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
603 /* Read the string table and stash it away in the psymbol_obstack. It is
604 only needed as long as we need to expand psymbols into full symbols,
605 so when we blow away the psymbol the string table goes away as well.
606 Note that gdb used to use the results of attempting to malloc the
607 string table, based on the size it read, as a form of sanity check
608 for botched byte swapping, on the theory that a byte swapped string
609 table size would be so totally bogus that the malloc would fail. Now
610 that we put in on the psymbol_obstack, we can't do this since gdb gets
611 a fatal error (out of virtual memory) if the size is bogus. We can
612 however at least check to see if the size is less than the size of
613 the size field itself, or larger than the size of the entire file.
614 Note that all valid string tables have a size greater than zero, since
615 the bytes used to hold the size are included in the count. */
617 if (STRING_TABLE_OFFSET
== 0)
619 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
620 will never be zero, even when there is no string table. This
621 would appear to be a bug in bfd. */
622 DBX_STRINGTAB_SIZE (objfile
) = 0;
623 DBX_STRINGTAB (objfile
) = NULL
;
627 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
629 perror_with_name (name
);
631 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
632 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
635 perror_with_name (name
);
639 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
640 EOF if there is no string table, and attempting to read the size
641 from EOF will read zero bytes. */
642 DBX_STRINGTAB_SIZE (objfile
) = 0;
643 DBX_STRINGTAB (objfile
) = NULL
;
647 /* Read some data that would appear to be the string table size.
648 If there really is a string table, then it is probably the right
649 size. Byteswap if necessary and validate the size. Note that
650 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
651 random data that happened to be at STRING_TABLE_OFFSET, because
652 bfd can't tell us there is no string table, the sanity checks may
653 or may not catch this. */
654 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
656 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
657 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
658 error ("ridiculous string table size (%d bytes).",
659 DBX_STRINGTAB_SIZE (objfile
));
661 DBX_STRINGTAB (objfile
) =
662 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
663 DBX_STRINGTAB_SIZE (objfile
));
665 /* Now read in the string table in one big gulp. */
667 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
669 perror_with_name (name
);
670 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
672 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
673 perror_with_name (name
);
678 /* Perform any local cleanups required when we are done with a particular
679 objfile. I.E, we are in the process of discarding all symbol information
680 for an objfile, freeing up all memory held for it, and unlinking the
681 objfile struct from the global list of known objfiles. */
684 dbx_symfile_finish (objfile
)
685 struct objfile
*objfile
;
687 if (objfile
->sym_stab_info
!= NULL
)
689 mfree (objfile
-> md
, objfile
->sym_stab_info
);
691 free_header_files ();
695 /* Buffer for reading the symbol table entries. */
696 static struct internal_nlist symbuf
[4096];
697 static int symbuf_idx
;
698 static int symbuf_end
;
700 /* Name of last function encountered. Used in Solaris to approximate
701 object file boundaries. */
702 static char *last_function_name
;
704 /* The address in memory of the string table of the object file we are
705 reading (which might not be the "main" object file, but might be a
706 shared library or some other dynamically loaded thing). This is set
707 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
708 when building symtabs, and is used only by next_symbol_text. */
709 static char *stringtab_global
;
711 /* Refill the symbol table input buffer
712 and set the variables that control fetching entries from it.
713 Reports an error if no data available.
714 This function can read past the end of the symbol table
715 (into the string table) but this does no harm. */
718 fill_symbuf (sym_bfd
)
721 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
723 perror_with_name (bfd_get_filename (sym_bfd
));
724 else if (nbytes
== 0)
725 error ("Premature end of file reading symbol table");
726 symbuf_end
= nbytes
/ symbol_size
;
730 #define SWAP_SYMBOL(symp, abfd) \
732 (symp)->n_strx = bfd_h_get_32(abfd, \
733 (unsigned char *)&(symp)->n_strx); \
734 (symp)->n_desc = bfd_h_get_16 (abfd, \
735 (unsigned char *)&(symp)->n_desc); \
736 (symp)->n_value = bfd_h_get_32 (abfd, \
737 (unsigned char *)&(symp)->n_value); \
740 /* Invariant: The symbol pointed to by symbuf_idx is the first one
741 that hasn't been swapped. Swap the symbol at the same time
742 that symbuf_idx is incremented. */
744 /* dbx allows the text of a symbol name to be continued into the
745 next symbol name! When such a continuation is encountered
746 (a \ at the end of the text of a name)
747 call this function to get the continuation. */
750 dbx_next_symbol_text ()
752 if (symbuf_idx
== symbuf_end
)
753 fill_symbuf (symfile_bfd
);
755 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
756 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
757 + file_string_table_offset
;
760 /* Initializes storage for all of the partial symbols that will be
761 created by read_dbx_symtab and subsidiaries. */
764 init_psymbol_list (objfile
)
765 struct objfile
*objfile
;
767 /* Free any previously allocated psymbol lists. */
768 if (objfile
-> global_psymbols
.list
)
769 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
770 if (objfile
-> static_psymbols
.list
)
771 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
773 /* Current best guess is that there are approximately a twentieth
774 of the total symbols (in a debugging file) are global or static
776 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
777 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
778 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
779 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
780 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
781 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
784 /* Initialize the list of bincls to contain none and have some
788 init_bincl_list (number
, objfile
)
790 struct objfile
*objfile
;
792 bincls_allocated
= number
;
793 next_bincl
= bincl_list
= (struct header_file_location
*)
794 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
797 /* Add a bincl to the list. */
800 add_bincl_to_list (pst
, name
, instance
)
801 struct partial_symtab
*pst
;
805 if (next_bincl
>= bincl_list
+ bincls_allocated
)
807 int offset
= next_bincl
- bincl_list
;
808 bincls_allocated
*= 2;
809 bincl_list
= (struct header_file_location
*)
810 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
811 bincls_allocated
* sizeof (struct header_file_location
));
812 next_bincl
= bincl_list
+ offset
;
814 next_bincl
->pst
= pst
;
815 next_bincl
->instance
= instance
;
816 next_bincl
++->name
= name
;
819 /* Given a name, value pair, find the corresponding
820 bincl in the list. Return the partial symtab associated
821 with that header_file_location. */
823 static struct partial_symtab
*
824 find_corresponding_bincl_psymtab (name
, instance
)
828 struct header_file_location
*bincl
;
830 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
831 if (bincl
->instance
== instance
832 && STREQ (name
, bincl
->name
))
835 return (struct partial_symtab
*) 0;
838 /* Free the storage allocated for the bincl list. */
841 free_bincl_list (objfile
)
842 struct objfile
*objfile
;
844 mfree (objfile
-> md
, (PTR
)bincl_list
);
845 bincls_allocated
= 0;
848 /* Given pointers to an a.out symbol table in core containing dbx
849 style data, setup partial_symtab's describing each source file for
850 which debugging information is available.
851 SYMFILE_NAME is the name of the file we are reading from
852 and SECTION_OFFSETS is the set of offsets for the various sections
853 of the file (a set of zeros if the mainline program). */
856 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
857 struct section_offsets
*section_offsets
;
858 struct objfile
*objfile
;
862 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
863 register char *namestring
;
865 int past_first_source_file
= 0;
866 CORE_ADDR last_o_file_start
= 0;
867 struct cleanup
*back_to
;
870 /* End of the text segment of the executable file. */
871 CORE_ADDR end_of_text_addr
;
873 /* Current partial symtab */
874 struct partial_symtab
*pst
;
876 /* List of current psymtab's include files */
877 char **psymtab_include_list
;
878 int includes_allocated
;
881 /* Index within current psymtab dependency list */
882 struct partial_symtab
**dependency_list
;
883 int dependencies_used
, dependencies_allocated
;
885 /* FIXME. We probably want to change stringtab_global rather than add this
886 while processing every symbol entry. FIXME. */
887 file_string_table_offset
= 0;
888 next_file_string_table_offset
= 0;
890 stringtab_global
= DBX_STRINGTAB (objfile
);
892 pst
= (struct partial_symtab
*) 0;
894 includes_allocated
= 30;
896 psymtab_include_list
= (char **) alloca (includes_allocated
*
899 dependencies_allocated
= 30;
900 dependencies_used
= 0;
902 (struct partial_symtab
**) alloca (dependencies_allocated
*
903 sizeof (struct partial_symtab
*));
905 /* Init bincl list */
906 init_bincl_list (20, objfile
);
907 back_to
= 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 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
925 /* Get the symbol for this run and pull out some info */
926 QUIT
; /* allow this to be interruptable */
927 if (symbuf_idx
== symbuf_end
)
929 bufp
= &symbuf
[symbuf_idx
++];
932 * Special case to speed up readin.
934 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
936 SWAP_SYMBOL (bufp
, abfd
);
938 /* Ok. There is a lot of code duplicated in the rest of this
939 switch statement (for efficiency reasons). Since I don't
940 like duplicating code, I will do my penance here, and
941 describe the code which is duplicated:
943 *) The assignment to namestring.
944 *) The call to strchr.
945 *) The addition of a partial symbol the the two partial
946 symbol lists. This last is a large section of code, so
947 I've imbedded it in the following macro.
950 /* Set namestring based on bufp. If the string table index is invalid,
951 give a fake name, and print a single error message per symbol file read,
952 rather than abort the symbol reading or flood the user with messages. */
954 /*FIXME: Too many adds and indirections in here for the inner loop. */
955 #define SET_NAMESTRING()\
956 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
957 DBX_STRINGTAB_SIZE (objfile)) { \
958 complain (&string_table_offset_complaint, symnum); \
959 namestring = "foo"; \
961 namestring = bufp->n_strx + file_string_table_offset + \
962 DBX_STRINGTAB (objfile)
964 #define CUR_SYMBOL_TYPE bufp->n_type
965 #define CUR_SYMBOL_VALUE bufp->n_value
967 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
968 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
969 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
970 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
972 #include "partial-stab.h"
975 /* If there's stuff to be cleaned up, clean it up. */
976 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
977 /*FIXME, does this have a bug at start address 0? */
979 && objfile
-> ei
.entry_point
< bufp
->n_value
980 && objfile
-> ei
.entry_point
>= last_o_file_start
)
982 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
983 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
988 end_psymtab (pst
, psymtab_include_list
, includes_used
,
989 symnum
* symbol_size
, end_of_text_addr
,
990 dependency_list
, dependencies_used
);
993 do_cleanups (back_to
);
996 /* Allocate and partially fill a partial symtab. It will be
997 completely filled at the end of the symbol list.
999 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1000 is the address relative to which its symbols are (incremental) or 0
1004 struct partial_symtab
*
1005 start_psymtab (objfile
, section_offsets
,
1006 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1007 struct objfile
*objfile
;
1008 struct section_offsets
*section_offsets
;
1012 struct partial_symbol
*global_syms
;
1013 struct partial_symbol
*static_syms
;
1015 struct partial_symtab
*result
=
1016 start_psymtab_common(objfile
, section_offsets
,
1017 filename
, textlow
, global_syms
, static_syms
);
1019 result
->read_symtab_private
= (char *)
1020 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
1021 LDSYMOFF(result
) = ldsymoff
;
1022 result
->read_symtab
= dbx_psymtab_to_symtab
;
1023 SYMBOL_SIZE(result
) = symbol_size
;
1024 SYMBOL_OFFSET(result
) = symbol_table_offset
;
1025 STRING_OFFSET(result
) = string_table_offset
;
1026 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1028 /* If we're handling an ELF file, drag some section-relocation info
1029 for this source file out of the ELF symbol table, to compensate for
1030 Sun brain death. This replaces the section_offsets in this psymtab,
1032 elfstab_offset_sections (objfile
, result
);
1034 /* Deduce the source language from the filename for this psymtab. */
1035 psymtab_language
= deduce_language_from_filename (filename
);
1040 /* Close off the current usage of PST.
1041 Returns PST or NULL if the partial symtab was empty and thrown away.
1043 FIXME: List variables and peculiarities of same. */
1045 struct partial_symtab
*
1046 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1047 capping_text
, dependency_list
, number_dependencies
)
1048 struct partial_symtab
*pst
;
1049 char **include_list
;
1051 int capping_symbol_offset
;
1052 CORE_ADDR capping_text
;
1053 struct partial_symtab
**dependency_list
;
1054 int number_dependencies
;
1055 /* struct partial_symbol *capping_global, *capping_static;*/
1058 struct partial_symtab
*p1
;
1059 struct objfile
*objfile
= pst
-> objfile
;
1061 if (capping_symbol_offset
!= -1)
1062 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1063 pst
->texthigh
= capping_text
;
1065 /* Under Solaris, the N_SO symbols always have a value of 0,
1066 instead of the usual address of the .o file. Therefore,
1067 we have to do some tricks to fill in texthigh and textlow.
1068 The first trick is in partial-stab.h: if we see a static
1069 or global function, and the textlow for the current pst
1070 is still 0, then we use that function's address for
1071 the textlow of the pst.
1073 Now, to fill in texthigh, we remember the last function seen
1074 in the .o file (also in partial-stab.h). Also, there's a hack in
1075 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1076 to here via the misc_info field. Therefore, we can fill in
1077 a reliable texthigh by taking the address plus size of the
1078 last function in the file.
1080 Unfortunately, that does not cover the case where the last function
1081 in the file is static. See the paragraph below for more comments
1084 Finally, if we have a valid textlow for the current file, we run
1085 down the partial_symtab_list filling in previous texthighs that
1086 are still unknown. */
1088 if (pst
->texthigh
== 0 && last_function_name
) {
1091 struct minimal_symbol
*minsym
;
1093 p
= strchr (last_function_name
, ':');
1095 p
= last_function_name
;
1096 n
= p
- last_function_name
;
1098 strncpy (p
, last_function_name
, n
);
1101 minsym
= lookup_minimal_symbol (p
, objfile
);
1104 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1105 (long) MSYMBOL_INFO (minsym
);
1107 /* This file ends with a static function, and it's
1108 difficult to imagine how hard it would be to track down
1109 the elf symbol. Luckily, most of the time no one will notice,
1110 since the next file will likely be compiled with -g, so
1111 the code below will copy the first fuction's start address
1112 back to our texthigh variable. (Also, if this file is the
1113 last one in a dynamically linked program, texthigh already
1114 has the right value.) If the next file isn't compiled
1115 with -g, then the last function in this file winds up owning
1116 all of the text space up to the next -g file, or the end (minus
1117 shared libraries). This only matters for single stepping,
1118 and even then it will still work, except that it will single
1119 step through all of the covered functions, instead of setting
1120 breakpoints around them as it usualy does. This makes it
1121 pretty slow, but at least it doesn't fail.
1123 We can fix this with a fairly big change to bfd, but we need
1124 to coordinate better with Cygnus if we want to do that. FIXME. */
1126 last_function_name
= NULL
;
1129 /* this test will be true if the last .o file is only data */
1130 if (pst
->textlow
== 0)
1131 pst
->textlow
= pst
->texthigh
;
1133 /* If we know our own starting text address, then walk through all other
1134 psymtabs for this objfile, and if any didn't know their ending text
1135 address, set it to our starting address. Take care to not set our
1136 own ending address to our starting address, nor to set addresses on
1137 `dependency' files that have both textlow and texthigh zero. */
1139 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1140 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1141 p1
->texthigh
= pst
->textlow
;
1142 /* if this file has only data, then make textlow match texthigh */
1143 if (p1
->textlow
== 0)
1144 p1
->textlow
= p1
->texthigh
;
1149 /* End of kludge for patching Solaris textlow and texthigh. */
1152 pst
->n_global_syms
=
1153 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1154 pst
->n_static_syms
=
1155 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1157 pst
->number_of_dependencies
= number_dependencies
;
1158 if (number_dependencies
)
1160 pst
->dependencies
= (struct partial_symtab
**)
1161 obstack_alloc (&objfile
->psymbol_obstack
,
1162 number_dependencies
* sizeof (struct partial_symtab
*));
1163 memcpy (pst
->dependencies
, dependency_list
,
1164 number_dependencies
* sizeof (struct partial_symtab
*));
1167 pst
->dependencies
= 0;
1169 for (i
= 0; i
< num_includes
; i
++)
1171 struct partial_symtab
*subpst
=
1172 allocate_psymtab (include_list
[i
], objfile
);
1174 subpst
->section_offsets
= pst
->section_offsets
;
1175 subpst
->read_symtab_private
=
1176 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1177 sizeof (struct symloc
));
1181 subpst
->texthigh
= 0;
1183 /* We could save slight bits of space by only making one of these,
1184 shared by the entire set of include files. FIXME-someday. */
1185 subpst
->dependencies
= (struct partial_symtab
**)
1186 obstack_alloc (&objfile
->psymbol_obstack
,
1187 sizeof (struct partial_symtab
*));
1188 subpst
->dependencies
[0] = pst
;
1189 subpst
->number_of_dependencies
= 1;
1191 subpst
->globals_offset
=
1192 subpst
->n_global_syms
=
1193 subpst
->statics_offset
=
1194 subpst
->n_static_syms
= 0;
1198 subpst
->read_symtab
= pst
->read_symtab
;
1201 sort_pst_symbols (pst
);
1203 /* If there is already a psymtab or symtab for a file of this name, remove it.
1204 (If there is a symtab, more drastic things also happen.)
1205 This happens in VxWorks. */
1206 free_named_symtabs (pst
->filename
);
1208 if (num_includes
== 0
1209 && number_dependencies
== 0
1210 && pst
->n_global_syms
== 0
1211 && pst
->n_static_syms
== 0) {
1212 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1213 it is on the obstack, but we can forget to chain it on the list. */
1214 struct partial_symtab
*prev_pst
;
1216 /* First, snip it out of the psymtab chain */
1218 if (pst
->objfile
->psymtabs
== pst
)
1219 pst
->objfile
->psymtabs
= pst
->next
;
1221 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1222 if (prev_pst
->next
== pst
)
1223 prev_pst
->next
= pst
->next
;
1225 /* Next, put it on a free list for recycling */
1227 pst
->next
= pst
->objfile
->free_psymtabs
;
1228 pst
->objfile
->free_psymtabs
= pst
;
1230 /* Indicate that psymtab was thrown away. */
1231 pst
= (struct partial_symtab
*)NULL
;
1237 dbx_psymtab_to_symtab_1 (pst
)
1238 struct partial_symtab
*pst
;
1240 struct cleanup
*old_chain
;
1248 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1253 /* Read in all partial symtabs on which this one is dependent */
1254 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1255 if (!pst
->dependencies
[i
]->readin
)
1257 /* Inform about additional files that need to be read in. */
1260 fputs_filtered (" ", gdb_stdout
);
1262 fputs_filtered ("and ", gdb_stdout
);
1264 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1265 wrap_here (""); /* Flush output */
1266 gdb_flush (gdb_stdout
);
1268 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1271 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1273 /* Init stuff necessary for reading in symbols */
1276 old_chain
= make_cleanup (really_free_pendings
, 0);
1277 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1278 symbol_size
= SYMBOL_SIZE (pst
);
1280 /* Read in this file's symbols */
1281 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1282 read_ofile_symtab (pst
);
1283 sort_symtab_syms (pst
->symtab
);
1285 do_cleanups (old_chain
);
1291 /* Read in all of the symbols for a given psymtab for real.
1292 Be verbose about it if the user wants that. */
1295 dbx_psymtab_to_symtab (pst
)
1296 struct partial_symtab
*pst
;
1305 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1310 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1312 /* Print the message now, before reading the string table,
1313 to avoid disconcerting pauses. */
1316 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1317 gdb_flush (gdb_stdout
);
1320 sym_bfd
= pst
->objfile
->obfd
;
1322 next_symbol_text_func
= dbx_next_symbol_text
;
1324 dbx_psymtab_to_symtab_1 (pst
);
1326 /* Match with global symbols. This only needs to be done once,
1327 after all of the symtabs and dependencies have been read in. */
1328 scan_file_globals (pst
->objfile
);
1330 /* Finish up the debug error message. */
1332 printf_filtered ("done.\n");
1336 /* Read in a defined section of a specific object file's symbols. */
1339 read_ofile_symtab (pst
)
1340 struct partial_symtab
*pst
;
1342 register char *namestring
;
1343 register struct internal_nlist
*bufp
;
1345 unsigned max_symnum
;
1347 struct objfile
*objfile
;
1348 int sym_offset
; /* Offset to start of symbols to read */
1349 int sym_size
; /* Size of symbols to read */
1350 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1351 int text_size
; /* Size of text segment for symbols */
1352 struct section_offsets
*section_offsets
;
1354 objfile
= pst
->objfile
;
1355 sym_offset
= LDSYMOFF(pst
);
1356 sym_size
= LDSYMLEN(pst
);
1357 text_offset
= pst
->textlow
;
1358 text_size
= pst
->texthigh
- pst
->textlow
;
1359 section_offsets
= pst
->section_offsets
;
1361 current_objfile
= objfile
;
1362 subfile_stack
= NULL
;
1364 stringtab_global
= DBX_STRINGTAB (objfile
);
1365 last_source_file
= NULL
;
1367 abfd
= objfile
->obfd
;
1368 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1369 symbuf_end
= symbuf_idx
= 0;
1371 /* It is necessary to actually read one symbol *before* the start
1372 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1373 occurs before the N_SO symbol.
1375 Detecting this in read_dbx_symtab
1376 would slow down initial readin, so we look for it here instead. */
1377 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1379 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1381 bufp
= &symbuf
[symbuf_idx
++];
1382 SWAP_SYMBOL (bufp
, abfd
);
1386 processing_gcc_compilation
= 0;
1387 if (bufp
->n_type
== N_TEXT
)
1389 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1390 processing_gcc_compilation
= 1;
1391 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1392 processing_gcc_compilation
= 2;
1395 /* Try to select a C++ demangling based on the compilation unit
1398 if (processing_gcc_compilation
)
1400 if (AUTO_DEMANGLING
)
1402 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1408 /* The N_SO starting this symtab is the first symbol, so we
1409 better not check the symbol before it. I'm not this can
1410 happen, but it doesn't hurt to check for it. */
1411 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1412 processing_gcc_compilation
= 0;
1415 if (symbuf_idx
== symbuf_end
)
1417 bufp
= &symbuf
[symbuf_idx
];
1418 if (bufp
->n_type
!= (unsigned char)N_SO
)
1419 error("First symbol in segment of executable not a source symbol");
1421 max_symnum
= sym_size
/ symbol_size
;
1424 symnum
< max_symnum
;
1427 QUIT
; /* Allow this to be interruptable */
1428 if (symbuf_idx
== symbuf_end
)
1430 bufp
= &symbuf
[symbuf_idx
++];
1431 SWAP_SYMBOL (bufp
, abfd
);
1433 type
= bufp
->n_type
;
1437 if (type
& N_STAB
) {
1438 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1439 namestring
, section_offsets
, objfile
);
1441 /* We skip checking for a new .o or -l file; that should never
1442 happen in this routine. */
1443 else if (type
== N_TEXT
)
1445 /* I don't think this code will ever be executed, because
1446 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1447 the N_SO symbol which starts this source file.
1448 However, there is no reason not to accept
1449 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1451 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1452 processing_gcc_compilation
= 1;
1453 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1454 processing_gcc_compilation
= 2;
1456 if (AUTO_DEMANGLING
)
1458 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1461 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1462 || type
== (unsigned char)N_NBTEXT
1464 /* Global symbol: see if we came across a dbx defintion for
1465 a corresponding symbol. If so, store the value. Remove
1466 syms from the chain when their values are stored, but
1467 search the whole chain, as there may be several syms from
1468 different files with the same name. */
1469 /* This is probably not true. Since the files will be read
1470 in one at a time, each reference to a global symbol will
1471 be satisfied in each file as it appears. So we skip this
1477 current_objfile
= NULL
;
1479 /* In a Solaris elf file, this variable, which comes from the
1480 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1481 which comes from pst->textlow is correct. */
1482 if (last_source_start_addr
== 0)
1483 last_source_start_addr
= text_offset
;
1485 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1491 /* This handles a single symbol from the symbol-file, building symbols
1492 into a GDB symtab. It takes these arguments and an implicit argument.
1494 TYPE is the type field of the ".stab" symbol entry.
1495 DESC is the desc field of the ".stab" entry.
1496 VALU is the value field of the ".stab" entry.
1497 NAME is the symbol name, in our address space.
1498 SECTION_OFFSETS is a set of amounts by which the sections of this object
1499 file were relocated when it was loaded into memory.
1500 All symbols that refer
1501 to memory locations need to be offset by these amounts.
1502 OBJFILE is the object file from which we are reading symbols.
1503 It is used in end_symtab. */
1506 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1510 struct section_offsets
*section_offsets
;
1511 struct objfile
*objfile
;
1513 #ifdef SUN_FIXED_LBRAC_BUG
1514 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1515 to correct the address of N_LBRAC's. If it is not defined, then
1516 we never need to correct the addresses. */
1518 /* This records the last pc address we've seen. We depend on there being
1519 an SLINE or FUN or SO before the first LBRAC, since the variable does
1520 not get reset in between reads of different symbol files. */
1521 static CORE_ADDR last_pc_address
;
1524 register struct context_stack
*new;
1525 /* This remembers the address of the start of a function. It is used
1526 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1527 relative to the current function's start address. On systems
1528 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1529 used to relocate these symbol types rather than SECTION_OFFSETS. */
1530 static CORE_ADDR function_start_offset
;
1532 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
1533 to the function start address. */
1534 int block_address_function_relative
;
1536 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1537 file. Used to detect the SunPRO solaris compiler. */
1538 static int n_opt_found
;
1540 /* The stab type used for the definition of the last function.
1541 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1542 static int function_stab_type
= 0;
1544 /* This is true for Solaris (and all other stabs-in-elf systems, hopefully,
1545 since it would be silly to do things differently from Solaris), and
1546 false for SunOS4 and other a.out file formats. */
1547 block_address_function_relative
=
1548 0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3);
1550 if (!block_address_function_relative
)
1551 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1552 function start address, so just use the text offset. */
1553 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1555 /* Something is wrong if we see real data before
1556 seeing a source file name. */
1558 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1560 /* Ignore any symbols which appear before an N_SO symbol. Currently
1561 no one puts symbols there, but we should deal gracefully with the
1562 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1563 but this should not be an error (). */
1571 /* Relocate for dynamic loading */
1572 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1573 goto define_a_symbol
;
1576 /* This "symbol" just indicates the start of an inner lexical
1577 context within a function. */
1579 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1580 /* Relocate for dynamic loading (?). */
1581 valu
+= function_start_offset
;
1583 if (block_address_function_relative
)
1584 /* Relocate for Sun ELF acc fn-relative syms. */
1585 valu
+= function_start_offset
;
1587 /* On most machines, the block addresses are relative to the
1588 N_SO, the linker did not relocate them (sigh). */
1589 valu
+= last_source_start_addr
;
1592 #ifdef SUN_FIXED_LBRAC_BUG
1593 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1594 /* Patch current LBRAC pc value to match last handy pc value */
1595 complain (&lbrac_complaint
);
1596 valu
= last_pc_address
;
1599 new = push_context (desc
, valu
);
1603 /* This "symbol" just indicates the end of an inner lexical
1604 context that was started with N_LBRAC. */
1606 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1607 /* Relocate for dynamic loading (?). */
1608 valu
+= function_start_offset
;
1610 if (block_address_function_relative
)
1611 /* Relocate for Sun ELF acc fn-relative syms. */
1612 valu
+= function_start_offset
;
1614 /* On most machines, the block addresses are relative to the
1615 N_SO, the linker did not relocate them (sigh). */
1616 valu
+= last_source_start_addr
;
1619 new = pop_context();
1620 if (desc
!= new->depth
)
1621 complain (&lbrac_mismatch_complaint
, symnum
);
1623 /* Some compilers put the variable decls inside of an
1624 LBRAC/RBRAC block. This macro should be nonzero if this
1625 is true. DESC is N_DESC from the N_RBRAC symbol.
1626 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1627 or the GCC2_COMPILED_SYMBOL. */
1628 #if !defined (VARIABLES_INSIDE_BLOCK)
1629 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1632 /* Can only use new->locals as local symbols here if we're in
1633 gcc or on a machine that puts them before the lbrack. */
1634 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1635 local_symbols
= new->locals
;
1637 /* If this is not the outermost LBRAC...RBRAC pair in the
1638 function, its local symbols preceded it, and are the ones
1639 just recovered from the context stack. Defined the block for them.
1641 If this is the outermost LBRAC...RBRAC pair, there is no
1642 need to do anything; leave the symbols that preceded it
1643 to be attached to the function's own block. However, if
1644 it is so, we need to indicate that we just moved outside
1647 && (context_stack_depth
1648 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
1650 /* FIXME Muzzle a compiler bug that makes end < start. */
1651 if (new->start_addr
> valu
)
1653 complain (&lbrac_rbrac_complaint
);
1654 new->start_addr
= valu
;
1656 /* Make a block for the local symbols within. */
1657 finish_block (0, &local_symbols
, new->old_blocks
,
1658 new->start_addr
, valu
, objfile
);
1662 within_function
= 0;
1664 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1665 /* Now pop locals of block just finished. */
1666 local_symbols
= new->locals
;
1671 /* This kind of symbol indicates the start of an object file. */
1672 /* Relocate for dynamic loading */
1673 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1677 /* This type of symbol indicates the start of data
1678 for one source file.
1679 Finish the symbol table of the previous source file
1680 (if any) and start accumulating a new symbol table. */
1681 /* Relocate for dynamic loading */
1682 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1686 #ifdef SUN_FIXED_LBRAC_BUG
1687 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1690 #ifdef PCC_SOL_BROKEN
1691 /* pcc bug, occasionally puts out SO for SOL. */
1692 if (context_stack_depth
> 0)
1694 start_subfile (name
, NULL
);
1698 if (last_source_file
)
1700 /* Check if previous symbol was also an N_SO (with some
1701 sanity checks). If so, that one was actually the directory
1702 name, and the current one is the real file name.
1704 if (previous_stab_code
== (unsigned char) N_SO
)
1706 patch_subfile_names (current_subfile
, name
);
1707 break; /* Ignore repeated SOs */
1709 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1713 start_symtab (name
, NULL
, valu
);
1718 /* This type of symbol indicates the start of data for
1719 a sub-source-file, one whose contents were copied or
1720 included in the compilation of the main source file
1721 (whose name was given in the N_SO symbol.) */
1722 /* Relocate for dynamic loading */
1723 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1724 start_subfile (name
, current_subfile
->dirname
);
1729 add_new_header_file (name
, valu
);
1730 start_subfile (name
, current_subfile
->dirname
);
1734 start_subfile (pop_subfile (), current_subfile
->dirname
);
1738 add_old_header_file (name
, valu
);
1742 /* This type of "symbol" really just records
1743 one line-number -- core-address correspondence.
1744 Enter it in the line list for this symbol table. */
1745 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1746 valu
+= function_start_offset
;
1747 #ifdef SUN_FIXED_LBRAC_BUG
1748 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1750 record_line (current_subfile
, desc
, valu
);
1754 common_block_start (name
, objfile
);
1758 common_block_end (objfile
);
1761 /* The following symbol types need to have the appropriate offset added
1762 to their value; then we process symbol definitions in the name. */
1764 case N_STSYM
: /* Static symbol in data seg */
1765 case N_LCSYM
: /* Static symbol in BSS seg */
1766 case N_ROSYM
: /* Static symbol in Read-only data seg */
1767 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1768 Solaris2's stabs-in-elf makes *most* symbols relative
1769 but leaves a few absolute (at least for Solaris 2.1 and version
1770 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1771 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1772 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1773 This leaves us no choice but to search for the 'S' or 'V'...
1774 (or pass the whole section_offsets stuff down ONE MORE function
1775 call level, which we really don't want to do). */
1778 p
= strchr (name
, ':');
1779 if (p
!= 0 && p
[1] == 'S')
1781 /* The linker relocated it. We don't want to add an
1782 elfstab_offset_sections-type offset, but we *do* want
1783 to add whatever solib.c passed to symbol_file_add as
1784 addr (this is known to affect SunOS4, and I suspect ELF
1785 too). Since elfstab_offset_sections currently does not
1786 muck with the text offset (there is no Ttext.text
1787 symbol), we can get addr from the text offset. If
1788 elfstab_offset_sections ever starts dealing with the
1789 text offset, and we still need to do this, we need to
1790 invent a SECT_OFF_ADDR_KLUDGE or something. */
1791 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1792 goto define_a_symbol
;
1794 /* Since it's not the kludge case, re-dispatch to the right handler. */
1796 case N_STSYM
: goto case_N_STSYM
;
1797 case N_LCSYM
: goto case_N_LCSYM
;
1798 case N_ROSYM
: goto case_N_ROSYM
;
1803 case_N_STSYM
: /* Static symbol in data seg */
1804 case N_DSLINE
: /* Source line number, data seg */
1805 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1806 goto define_a_symbol
;
1808 case_N_LCSYM
: /* Static symbol in BSS seg */
1809 case N_BSLINE
: /* Source line number, bss seg */
1810 /* N_BROWS: overlaps with N_BSLINE */
1811 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1812 goto define_a_symbol
;
1814 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1815 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1816 goto define_a_symbol
;
1818 case N_ENTRY
: /* Alternate entry point */
1819 /* Relocate for dynamic loading */
1820 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1821 goto define_a_symbol
;
1823 /* The following symbol types we don't know how to process. Handle
1824 them in a "default" way, but complain to people who care. */
1826 case N_CATCH
: /* Exception handler catcher */
1827 case N_EHDECL
: /* Exception handler name */
1828 case N_PC
: /* Global symbol in Pascal */
1829 case N_M2C
: /* Modula-2 compilation unit */
1830 /* N_MOD2: overlaps with N_EHDECL */
1831 case N_SCOPE
: /* Modula-2 scope information */
1832 case N_ECOML
: /* End common (local name) */
1833 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
1838 complain (&unknown_symtype_complaint
,
1839 local_hex_string((unsigned long) type
));
1842 /* The following symbol types don't need the address field relocated,
1843 since it is either unused, or is absolute. */
1845 case N_GSYM
: /* Global variable */
1846 case N_NSYMS
: /* Number of symbols (ultrix) */
1847 case N_NOMAP
: /* No map? (ultrix) */
1848 case N_RSYM
: /* Register variable */
1849 case N_DEFD
: /* Modula-2 GNU module dependency */
1850 case N_SSYM
: /* Struct or union element */
1851 case N_LSYM
: /* Local symbol in stack */
1852 case N_PSYM
: /* Parameter variable */
1853 case N_LENG
: /* Length of preceding symbol type */
1857 char *colon_pos
= strchr (name
, ':');
1858 if (colon_pos
== NULL
)
1861 deftype
= colon_pos
[1];
1867 function_stab_type
= type
;
1869 #ifdef SUN_FIXED_LBRAC_BUG
1870 /* The Sun acc compiler, under SunOS4, puts out
1871 functions with N_GSYM or N_STSYM. The problem is
1872 that the address of the symbol is no good (for N_GSYM
1873 it doesn't even attept an address; for N_STSYM it
1874 puts out an address but then it gets relocated
1875 relative to the data segment, not the text segment).
1876 Currently we can't fix this up later as we do for
1877 some types of symbol in scan_file_globals.
1878 Fortunately we do have a way of finding the address -
1879 we know that the value in last_pc_address is either
1880 the one we want (if we're dealing with the first
1881 function in an object file), or somewhere in the
1882 previous function. This means that we can use the
1883 minimal symbol table to get the address. */
1885 /* On solaris up to 2.2, the N_FUN stab gets relocated.
1886 On Solaris 2.3, ld no longer relocates stabs (which
1887 is good), and the N_FUN's value is now always zero.
1888 The following code can't deal with this, because
1889 last_pc_address depends on getting the address from a
1890 N_SLINE or some such and in Solaris those are function
1891 relative. Best fix is probably to create a Ttext.text symbol
1892 and handle this like Ddata.data and so on. */
1894 if (type
== N_GSYM
|| type
== N_STSYM
)
1896 struct minimal_symbol
*m
;
1897 int l
= colon_pos
- name
;
1899 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
1900 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
1901 /* last_pc_address was in this function */
1902 valu
= SYMBOL_VALUE (m
);
1903 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
1904 /* last_pc_address was in last function */
1905 valu
= SYMBOL_VALUE (m
+1);
1907 /* Not found - use last_pc_address (for finish_block) */
1908 valu
= last_pc_address
;
1911 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1914 if (block_address_function_relative
)
1915 /* For Solaris 2.0 compilers, the block addresses and
1916 N_SLINE's are relative to the start of the
1917 function. On normal systems, and when using gcc on
1918 Solaris 2.0, these addresses are just absolute, or
1919 relative to the N_SO, depending on
1920 BLOCK_ADDRESS_ABSOLUTE. */
1921 function_start_offset
= valu
;
1923 within_function
= 1;
1924 if (context_stack_depth
> 0)
1926 new = pop_context ();
1927 /* Make a block for the local symbols within. */
1928 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1929 new->start_addr
, valu
, objfile
);
1931 /* Stack must be empty now. */
1932 if (context_stack_depth
!= 0)
1933 complain (&lbrac_unmatched_complaint
, symnum
);
1935 new = push_context (0, valu
);
1936 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1940 define_symbol (valu
, name
, desc
, type
, objfile
);
1946 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1947 for a bunch of other flags, too. Someday we may parse their
1948 flags; for now we ignore theirs and hope they'll ignore ours. */
1949 case N_OPT
: /* Solaris 2: Compiler options */
1952 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
1954 processing_gcc_compilation
= 2;
1955 #if 1 /* Works, but is experimental. -fnf */
1956 if (AUTO_DEMANGLING
)
1958 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1967 /* The following symbol types can be ignored. */
1968 case N_OBJ
: /* Solaris 2: Object file dir and name */
1969 /* N_UNDF: Solaris 2: file separator mark */
1970 /* N_UNDF: -- we will never encounter it, since we only process one
1971 file's symbols at once. */
1972 case N_ENDM
: /* Solaris 2: End of module */
1973 case N_MAIN
: /* Name of main routine. */
1977 previous_stab_code
= type
;
1980 /* FIXME: The only difference between this and elfstab_build_psymtabs is
1981 the call to install_minimal_symbols for elf. If the differences are
1982 really that small, the code should be shared. */
1984 /* Scan and build partial symbols for an coff symbol file.
1985 The coff file has already been processed to get its minimal symbols.
1987 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
1990 OBJFILE is the object file we are reading symbols from.
1991 ADDR is the address relative to which the symbols are (e.g.
1992 the base address of the text segment).
1993 MAINLINE is true if we are reading the main symbol
1994 table (as opposed to a shared lib or dynamically loaded file).
1995 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
1997 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
1998 .stabstr section exists.
2000 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2001 adjusted for coff details. */
2004 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2005 staboffset
, stabsize
,
2006 stabstroffset
, stabstrsize
)
2007 struct objfile
*objfile
;
2008 struct section_offsets
*section_offsets
;
2010 file_ptr staboffset
;
2011 unsigned int stabsize
;
2012 file_ptr stabstroffset
;
2013 unsigned int stabstrsize
;
2016 bfd
*sym_bfd
= objfile
->obfd
;
2017 char *name
= bfd_get_filename (sym_bfd
);
2018 struct dbx_symfile_info
*info
;
2020 /* There is already a dbx_symfile_info allocated by our caller.
2021 It might even contain some info from the coff symtab to help us. */
2022 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2024 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2025 if (!DBX_TEXT_SECT (objfile
))
2026 error ("Can't find .text section in symbol file");
2028 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2029 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2030 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2031 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2032 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2034 if (stabstrsize
> bfd_get_size (sym_bfd
))
2035 error ("ridiculous string table size: %d bytes", stabstrsize
);
2036 DBX_STRINGTAB (objfile
) = (char *)
2037 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2039 /* Now read in the string table in one big gulp. */
2041 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2043 perror_with_name (name
);
2044 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2045 if (val
!= stabstrsize
)
2046 perror_with_name (name
);
2048 stabsread_new_init ();
2049 buildsym_new_init ();
2050 free_header_files ();
2051 init_header_files ();
2053 processing_acc_compilation
= 1;
2055 /* In a coff file, we've already installed the minimal symbols that came
2056 from the coff (non-stab) symbol table, so always act like an
2057 incremental load here. */
2058 dbx_symfile_read (objfile
, section_offsets
, 0);
2061 /* Scan and build partial symbols for an ELF symbol file.
2062 This ELF file has already been processed to get its minimal symbols,
2063 and any DWARF symbols that were in it.
2065 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2068 OBJFILE is the object file we are reading symbols from.
2069 ADDR is the address relative to which the symbols are (e.g.
2070 the base address of the text segment).
2071 MAINLINE is true if we are reading the main symbol
2072 table (as opposed to a shared lib or dynamically loaded file).
2073 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2075 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2076 .stabstr section exists.
2078 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2079 adjusted for elf details. */
2082 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2083 staboffset
, stabsize
,
2084 stabstroffset
, stabstrsize
)
2085 struct objfile
*objfile
;
2086 struct section_offsets
*section_offsets
;
2088 file_ptr staboffset
;
2089 unsigned int stabsize
;
2090 file_ptr stabstroffset
;
2091 unsigned int stabstrsize
;
2094 bfd
*sym_bfd
= objfile
->obfd
;
2095 char *name
= bfd_get_filename (sym_bfd
);
2096 struct dbx_symfile_info
*info
;
2098 /* There is already a dbx_symfile_info allocated by our caller.
2099 It might even contain some info from the ELF symtab to help us. */
2100 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2102 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2103 if (!DBX_TEXT_SECT (objfile
))
2104 error ("Can't find .text section in symbol file");
2106 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2107 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2108 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2109 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2110 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2112 if (stabstrsize
> bfd_get_size (sym_bfd
))
2113 error ("ridiculous string table size: %d bytes", stabstrsize
);
2114 DBX_STRINGTAB (objfile
) = (char *)
2115 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2117 /* Now read in the string table in one big gulp. */
2119 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2121 perror_with_name (name
);
2122 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2123 if (val
!= stabstrsize
)
2124 perror_with_name (name
);
2126 stabsread_new_init ();
2127 buildsym_new_init ();
2128 free_header_files ();
2129 init_header_files ();
2130 install_minimal_symbols (objfile
);
2132 processing_acc_compilation
= 1;
2134 /* In an elf file, we've already installed the minimal symbols that came
2135 from the elf (non-stab) symbol table, so always act like an
2136 incremental load here. */
2137 dbx_symfile_read (objfile
, section_offsets
, 0);
2140 /* Scan and build partial symbols for a PA symbol file.
2141 This PA file has already been processed to get its minimal symbols.
2143 OBJFILE is the object file we are reading symbols from.
2144 ADDR is the address relative to which the symbols are (e.g.
2145 the base address of the text segment).
2146 MAINLINE is true if we are reading the main symbol
2147 table (as opposed to a shared lib or dynamically loaded file).
2152 pastab_build_psymtabs (objfile
, section_offsets
, mainline
)
2153 struct objfile
*objfile
;
2154 struct section_offsets
*section_offsets
;
2157 free_header_files ();
2158 init_header_files ();
2160 /* In a PA file, we've already installed the minimal symbols that came
2161 from the PA (non-stab) symbol table, so always act like an
2162 incremental load here. */
2164 dbx_symfile_read (objfile
, section_offsets
, mainline
);
2167 /* Parse the user's idea of an offset for dynamic linking, into our idea
2168 of how to represent it for fast symbol reading. */
2170 static struct section_offsets
*
2171 dbx_symfile_offsets (objfile
, addr
)
2172 struct objfile
*objfile
;
2175 struct section_offsets
*section_offsets
;
2178 objfile
->num_sections
= SECT_OFF_MAX
;
2179 section_offsets
= (struct section_offsets
*)
2180 obstack_alloc (&objfile
-> psymbol_obstack
,
2181 sizeof (struct section_offsets
)
2182 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2184 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2185 ANOFFSET (section_offsets
, i
) = addr
;
2187 return section_offsets
;
2190 static struct sym_fns aout_sym_fns
=
2192 bfd_target_aout_flavour
,
2193 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2194 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2195 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2196 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2197 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2198 NULL
/* next: pointer to next struct sym_fns */
2202 _initialize_dbxread ()
2204 add_symtab_fns(&aout_sym_fns
);