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 /* Remember what we deduced to be the source language of this psymtab. */
113 static enum language psymtab_language
= language_unknown
;
115 /* Nonzero means give verbose info on gdb action. From main.c. */
116 extern int info_verbose
;
118 /* The BFD for this file -- implicit parameter to next_symbol_text. */
120 static bfd
*symfile_bfd
;
122 /* The size of each symbol in the symbol file (in external form).
123 This is set by dbx_symfile_read when building psymtabs, and by
124 dbx_psymtab_to_symtab when building symtabs. */
126 static unsigned symbol_size
;
128 /* This is the offset of the symbol table in the executable file */
129 static unsigned symbol_table_offset
;
131 /* This is the offset of the string table in the executable file */
132 static unsigned string_table_offset
;
134 /* For elf+stab executables, the n_strx field is not a simple index
135 into the string table. Instead, each .o file has a base offset
136 in the string table, and the associated symbols contain offsets
137 from this base. The following two variables contain the base
138 offset for the current and next .o files. */
139 static unsigned int file_string_table_offset
;
140 static unsigned int next_file_string_table_offset
;
142 /* Complaints about the symbols we have encountered. */
144 struct complaint lbrac_complaint
=
145 {"bad block start address patched", 0, 0};
147 struct complaint string_table_offset_complaint
=
148 {"bad string table offset in symbol %d", 0, 0};
150 struct complaint unknown_symtype_complaint
=
151 {"unknown symbol type %s", 0, 0};
153 struct complaint unknown_symchar_complaint
=
154 {"unknown symbol descriptor `%c'", 0, 0};
156 struct complaint lbrac_rbrac_complaint
=
157 {"block start larger than block end", 0, 0};
159 struct complaint lbrac_unmatched_complaint
=
160 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
162 struct complaint lbrac_mismatch_complaint
=
163 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
165 struct complaint repeated_header_complaint
=
166 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
168 struct complaint repeated_header_name_complaint
=
169 {"\"repeated\" header file not previously seen, named %s", 0, 0};
171 /* During initial symbol readin, we need to have a structure to keep
172 track of which psymtabs have which bincls in them. This structure
173 is used during readin to setup the list of dependencies within each
174 partial symbol table. */
176 struct header_file_location
178 char *name
; /* Name of header file */
179 int instance
; /* See above */
180 struct partial_symtab
*pst
; /* Partial symtab that has the
181 BINCL/EINCL defs for this file */
184 /* The actual list and controling variables */
185 static struct header_file_location
*bincl_list
, *next_bincl
;
186 static int bincls_allocated
;
188 /* Local function prototypes */
191 free_header_files
PARAMS ((void));
194 init_header_files
PARAMS ((void));
197 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
200 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
203 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
206 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
210 free_bincl_list
PARAMS ((struct objfile
*));
212 static struct partial_symtab
*
213 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
216 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
219 init_bincl_list
PARAMS ((int, struct objfile
*));
222 init_psymbol_list
PARAMS ((struct objfile
*));
225 dbx_next_symbol_text
PARAMS ((void));
228 fill_symbuf
PARAMS ((bfd
*));
231 dbx_symfile_init
PARAMS ((struct objfile
*));
234 dbx_new_init
PARAMS ((struct objfile
*));
237 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
240 dbx_symfile_finish
PARAMS ((struct objfile
*));
243 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
246 add_new_header_file
PARAMS ((char *, int));
249 add_old_header_file
PARAMS ((char *, int));
252 add_this_object_header_file
PARAMS ((int));
254 /* Free up old header file tables */
261 if (header_files
!= NULL
)
263 for (i
= 0; i
< n_header_files
; i
++)
265 free (header_files
[i
].name
);
267 free ((PTR
)header_files
);
271 if (this_object_header_files
)
273 free ((PTR
)this_object_header_files
);
274 this_object_header_files
= NULL
;
276 n_allocated_header_files
= 0;
277 n_allocated_this_object_header_files
= 0;
280 /* Allocate new header file tables */
286 n_allocated_header_files
= 10;
287 header_files
= (struct header_file
*)
288 xmalloc (10 * sizeof (struct header_file
));
290 n_allocated_this_object_header_files
= 10;
291 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
294 /* Add header file number I for this object file
295 at the next successive FILENUM. */
298 add_this_object_header_file (i
)
301 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
303 n_allocated_this_object_header_files
*= 2;
304 this_object_header_files
305 = (int *) xrealloc ((char *) this_object_header_files
,
306 n_allocated_this_object_header_files
* sizeof (int));
309 this_object_header_files
[n_this_object_header_files
++] = i
;
312 /* Add to this file an "old" header file, one already seen in
313 a previous object file. NAME is the header file's name.
314 INSTANCE is its instance code, to select among multiple
315 symbol tables for the same header file. */
318 add_old_header_file (name
, instance
)
322 register struct header_file
*p
= header_files
;
325 for (i
= 0; i
< n_header_files
; i
++)
326 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
328 add_this_object_header_file (i
);
331 complain (&repeated_header_complaint
, symnum
);
332 complain (&repeated_header_name_complaint
, name
);
335 /* Add to this file a "new" header file: definitions for its types follow.
336 NAME is the header file's name.
337 Most often this happens only once for each distinct header file,
338 but not necessarily. If it happens more than once, INSTANCE has
339 a different value each time, and references to the header file
340 use INSTANCE values to select among them.
342 dbx output contains "begin" and "end" markers for each new header file,
343 but at this level we just need to know which files there have been;
344 so we record the file when its "begin" is seen and ignore the "end". */
347 add_new_header_file (name
, instance
)
353 /* Make sure there is room for one more header file. */
355 if (n_header_files
== n_allocated_header_files
)
357 n_allocated_header_files
*= 2;
358 header_files
= (struct header_file
*)
359 xrealloc ((char *) header_files
,
360 (n_allocated_header_files
* sizeof (struct header_file
)));
363 /* Create an entry for this header file. */
365 i
= n_header_files
++;
366 header_files
[i
].name
= savestring (name
, strlen(name
));
367 header_files
[i
].instance
= instance
;
368 header_files
[i
].length
= 10;
369 header_files
[i
].vector
370 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
371 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
373 add_this_object_header_file (i
);
377 static struct type
**
378 explicit_lookup_type (real_filenum
, index
)
379 int real_filenum
, index
;
381 register struct header_file
*f
= &header_files
[real_filenum
];
383 if (index
>= f
->length
)
386 f
->vector
= (struct type
**)
387 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
388 memset (&f
->vector
[f
->length
/ 2],
389 '\0', f
->length
* sizeof (struct type
*) / 2);
391 return &f
->vector
[index
];
396 record_minimal_symbol (name
, address
, type
, objfile
)
400 struct objfile
*objfile
;
402 enum minimal_symbol_type ms_type
;
406 case N_TEXT
| N_EXT
: ms_type
= mst_text
; break;
407 case N_DATA
| N_EXT
: ms_type
= mst_data
; break;
408 case N_BSS
| N_EXT
: ms_type
= mst_bss
; break;
409 case N_ABS
| N_EXT
: ms_type
= mst_abs
; break;
411 case N_SETV
| N_EXT
: ms_type
= mst_data
; break;
413 /* I don't think this type actually exists; since a N_SETV is the result
414 of going over many .o files, it doesn't make sense to have one
416 ms_type
= mst_file_data
;
423 ms_type
= mst_file_text
;
427 ms_type
= mst_file_data
;
429 /* Check for __DYNAMIC, which is used by Sun shared libraries.
430 Record it as global even if it's local, not global, so
431 lookup_minimal_symbol can find it. We don't check symbol_leading_char
432 because for SunOS4 it always is '_'. */
433 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
436 /* Same with virtual function tables, both global and static. */
438 char *tempstring
= name
;
439 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
441 if (VTBL_PREFIX_P ((tempstring
)))
447 ms_type
= mst_file_bss
;
450 default: ms_type
= mst_unknown
; break;
453 prim_record_minimal_symbol
454 (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
459 /* Scan and build partial symbols for a symbol file.
460 We have been initialized by a call to dbx_symfile_init, which
461 put all the relevant info into a "struct dbx_symfile_info",
462 hung off the objfile structure.
464 SECTION_OFFSETS contains offsets relative to which the symbols in the
465 various sections are (depending where the sections were actually loaded).
466 MAINLINE is true if we are reading the main symbol
467 table (as opposed to a shared lib or dynamically loaded file). */
470 dbx_symfile_read (objfile
, section_offsets
, mainline
)
471 struct objfile
*objfile
;
472 struct section_offsets
*section_offsets
;
473 int mainline
; /* FIXME comments above */
477 struct cleanup
*back_to
;
479 sym_bfd
= objfile
->obfd
;
480 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
482 perror_with_name (objfile
->name
);
484 /* If we are reinitializing, or if we have never loaded syms yet, init */
485 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
486 init_psymbol_list (objfile
);
488 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
489 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
492 back_to
= make_cleanup (really_free_pendings
, 0);
494 init_minimal_symbol_collection ();
495 make_cleanup (discard_minimal_symbols
, 0);
497 /* Now that the symbol table data of the executable file are all in core,
498 process them and define symbols accordingly. */
500 read_dbx_symtab (section_offsets
, objfile
,
501 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
502 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
504 /* Install any minimal symbols that have been collected as the current
505 minimal symbols for this objfile. */
507 install_minimal_symbols (objfile
);
509 if (!have_partial_symbols ()) {
511 printf_filtered ("(no debugging symbols found)...");
515 do_cleanups (back_to
);
518 /* Initialize anything that needs initializing when a completely new
519 symbol file is specified (not just adding some symbols from another
520 file, e.g. a shared library). */
523 dbx_new_init (ignore
)
524 struct objfile
*ignore
;
526 stabsread_new_init ();
527 buildsym_new_init ();
528 init_header_files ();
532 /* dbx_symfile_init ()
533 is the dbx-specific initialization routine for reading symbols.
534 It is passed a struct objfile which contains, among other things,
535 the BFD for the file whose symbols are being read, and a slot for a pointer
536 to "private data" which we fill with goodies.
538 We read the string table into malloc'd space and stash a pointer to it.
540 Since BFD doesn't know how to read debug symbols in a format-independent
541 way (and may never do so...), we have to do it ourselves. We will never
542 be called unless this is an a.out (or very similar) file.
543 FIXME, there should be a cleaner peephole into the BFD environment here. */
545 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
548 dbx_symfile_init (objfile
)
549 struct objfile
*objfile
;
552 bfd
*sym_bfd
= objfile
->obfd
;
553 char *name
= bfd_get_filename (sym_bfd
);
554 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
556 /* Allocate struct to keep track of the symfile */
557 objfile
->sym_stab_info
= (PTR
)
558 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
560 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
561 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
562 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
564 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
566 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
567 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
568 if (!DBX_TEXT_SECT (objfile
))
569 error ("Can't find .text section in symbol file");
571 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
572 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
573 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
575 /* Read the string table and stash it away in the psymbol_obstack. It is
576 only needed as long as we need to expand psymbols into full symbols,
577 so when we blow away the psymbol the string table goes away as well.
578 Note that gdb used to use the results of attempting to malloc the
579 string table, based on the size it read, as a form of sanity check
580 for botched byte swapping, on the theory that a byte swapped string
581 table size would be so totally bogus that the malloc would fail. Now
582 that we put in on the psymbol_obstack, we can't do this since gdb gets
583 a fatal error (out of virtual memory) if the size is bogus. We can
584 however at least check to see if the size is less than the size of
585 the size field itself, or larger than the size of the entire file.
586 Note that all valid string tables have a size greater than zero, since
587 the bytes used to hold the size are included in the count. */
589 if (STRING_TABLE_OFFSET
== 0)
591 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
592 will never be zero, even when there is no string table. This
593 would appear to be a bug in bfd. */
594 DBX_STRINGTAB_SIZE (objfile
) = 0;
595 DBX_STRINGTAB (objfile
) = NULL
;
599 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
601 perror_with_name (name
);
603 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
604 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
607 perror_with_name (name
);
611 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
612 EOF if there is no string table, and attempting to read the size
613 from EOF will read zero bytes. */
614 DBX_STRINGTAB_SIZE (objfile
) = 0;
615 DBX_STRINGTAB (objfile
) = NULL
;
619 /* Read some data that would appear to be the string table size.
620 If there really is a string table, then it is probably the right
621 size. Byteswap if necessary and validate the size. Note that
622 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
623 random data that happened to be at STRING_TABLE_OFFSET, because
624 bfd can't tell us there is no string table, the sanity checks may
625 or may not catch this. */
626 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
628 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
629 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
630 error ("ridiculous string table size (%d bytes).",
631 DBX_STRINGTAB_SIZE (objfile
));
633 DBX_STRINGTAB (objfile
) =
634 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
635 DBX_STRINGTAB_SIZE (objfile
));
637 /* Now read in the string table in one big gulp. */
639 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
641 perror_with_name (name
);
642 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
644 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
645 perror_with_name (name
);
650 /* Perform any local cleanups required when we are done with a particular
651 objfile. I.E, we are in the process of discarding all symbol information
652 for an objfile, freeing up all memory held for it, and unlinking the
653 objfile struct from the global list of known objfiles. */
656 dbx_symfile_finish (objfile
)
657 struct objfile
*objfile
;
659 if (objfile
->sym_stab_info
!= NULL
)
661 mfree (objfile
-> md
, objfile
->sym_stab_info
);
663 free_header_files ();
667 /* Buffer for reading the symbol table entries. */
668 static struct internal_nlist symbuf
[4096];
669 static int symbuf_idx
;
670 static int symbuf_end
;
672 /* Name of last function encountered. Used in Solaris to approximate
673 object file boundaries. */
674 static char *last_function_name
;
676 /* The address in memory of the string table of the object file we are
677 reading (which might not be the "main" object file, but might be a
678 shared library or some other dynamically loaded thing). This is set
679 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
680 when building symtabs, and is used only by next_symbol_text. */
681 static char *stringtab_global
;
683 /* Refill the symbol table input buffer
684 and set the variables that control fetching entries from it.
685 Reports an error if no data available.
686 This function can read past the end of the symbol table
687 (into the string table) but this does no harm. */
690 fill_symbuf (sym_bfd
)
693 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
695 perror_with_name (bfd_get_filename (sym_bfd
));
696 else if (nbytes
== 0)
697 error ("Premature end of file reading symbol table");
698 symbuf_end
= nbytes
/ symbol_size
;
702 #define SWAP_SYMBOL(symp, abfd) \
704 (symp)->n_strx = bfd_h_get_32(abfd, \
705 (unsigned char *)&(symp)->n_strx); \
706 (symp)->n_desc = bfd_h_get_16 (abfd, \
707 (unsigned char *)&(symp)->n_desc); \
708 (symp)->n_value = bfd_h_get_32 (abfd, \
709 (unsigned char *)&(symp)->n_value); \
712 /* Invariant: The symbol pointed to by symbuf_idx is the first one
713 that hasn't been swapped. Swap the symbol at the same time
714 that symbuf_idx is incremented. */
716 /* dbx allows the text of a symbol name to be continued into the
717 next symbol name! When such a continuation is encountered
718 (a \ at the end of the text of a name)
719 call this function to get the continuation. */
722 dbx_next_symbol_text ()
724 if (symbuf_idx
== symbuf_end
)
725 fill_symbuf (symfile_bfd
);
727 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
728 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
729 + file_string_table_offset
;
732 /* Initializes storage for all of the partial symbols that will be
733 created by read_dbx_symtab and subsidiaries. */
736 init_psymbol_list (objfile
)
737 struct objfile
*objfile
;
739 /* Free any previously allocated psymbol lists. */
740 if (objfile
-> global_psymbols
.list
)
741 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
742 if (objfile
-> static_psymbols
.list
)
743 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
745 /* Current best guess is that there are approximately a twentieth
746 of the total symbols (in a debugging file) are global or static
748 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
749 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
750 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
751 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
752 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
753 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
756 /* Initialize the list of bincls to contain none and have some
760 init_bincl_list (number
, objfile
)
762 struct objfile
*objfile
;
764 bincls_allocated
= number
;
765 next_bincl
= bincl_list
= (struct header_file_location
*)
766 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
769 /* Add a bincl to the list. */
772 add_bincl_to_list (pst
, name
, instance
)
773 struct partial_symtab
*pst
;
777 if (next_bincl
>= bincl_list
+ bincls_allocated
)
779 int offset
= next_bincl
- bincl_list
;
780 bincls_allocated
*= 2;
781 bincl_list
= (struct header_file_location
*)
782 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
783 bincls_allocated
* sizeof (struct header_file_location
));
784 next_bincl
= bincl_list
+ offset
;
786 next_bincl
->pst
= pst
;
787 next_bincl
->instance
= instance
;
788 next_bincl
++->name
= name
;
791 /* Given a name, value pair, find the corresponding
792 bincl in the list. Return the partial symtab associated
793 with that header_file_location. */
795 static struct partial_symtab
*
796 find_corresponding_bincl_psymtab (name
, instance
)
800 struct header_file_location
*bincl
;
802 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
803 if (bincl
->instance
== instance
804 && STREQ (name
, bincl
->name
))
807 return (struct partial_symtab
*) 0;
810 /* Free the storage allocated for the bincl list. */
813 free_bincl_list (objfile
)
814 struct objfile
*objfile
;
816 mfree (objfile
-> md
, (PTR
)bincl_list
);
817 bincls_allocated
= 0;
820 /* Given pointers to an a.out symbol table in core containing dbx
821 style data, setup partial_symtab's describing each source file for
822 which debugging information is available.
823 SYMFILE_NAME is the name of the file we are reading from
824 and SECTION_OFFSETS is the set of offsets for the various sections
825 of the file (a set of zeros if the mainline program). */
828 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
829 struct section_offsets
*section_offsets
;
830 struct objfile
*objfile
;
834 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
835 register char *namestring
;
837 int past_first_source_file
= 0;
838 CORE_ADDR last_o_file_start
= 0;
839 struct cleanup
*back_to
;
842 /* End of the text segment of the executable file. */
843 CORE_ADDR end_of_text_addr
;
845 /* Current partial symtab */
846 struct partial_symtab
*pst
;
848 /* List of current psymtab's include files */
849 char **psymtab_include_list
;
850 int includes_allocated
;
853 /* Index within current psymtab dependency list */
854 struct partial_symtab
**dependency_list
;
855 int dependencies_used
, dependencies_allocated
;
857 /* FIXME. We probably want to change stringtab_global rather than add this
858 while processing every symbol entry. FIXME. */
859 file_string_table_offset
= 0;
860 next_file_string_table_offset
= 0;
862 stringtab_global
= DBX_STRINGTAB (objfile
);
864 pst
= (struct partial_symtab
*) 0;
866 includes_allocated
= 30;
868 psymtab_include_list
= (char **) alloca (includes_allocated
*
871 dependencies_allocated
= 30;
872 dependencies_used
= 0;
874 (struct partial_symtab
**) alloca (dependencies_allocated
*
875 sizeof (struct partial_symtab
*));
877 /* Init bincl list */
878 init_bincl_list (20, objfile
);
879 back_to
= make_cleanup (free_bincl_list
, objfile
);
881 last_source_file
= NULL
;
883 #ifdef END_OF_TEXT_DEFAULT
884 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
886 end_of_text_addr
= text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
]
887 + text_size
; /* Relocate */
890 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
891 abfd
= objfile
->obfd
;
892 symbuf_end
= symbuf_idx
= 0;
893 next_symbol_text_func
= dbx_next_symbol_text
;
895 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
897 /* Get the symbol for this run and pull out some info */
898 QUIT
; /* allow this to be interruptable */
899 if (symbuf_idx
== symbuf_end
)
901 bufp
= &symbuf
[symbuf_idx
++];
904 * Special case to speed up readin.
906 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
908 SWAP_SYMBOL (bufp
, abfd
);
910 /* Ok. There is a lot of code duplicated in the rest of this
911 switch statement (for efficiency reasons). Since I don't
912 like duplicating code, I will do my penance here, and
913 describe the code which is duplicated:
915 *) The assignment to namestring.
916 *) The call to strchr.
917 *) The addition of a partial symbol the the two partial
918 symbol lists. This last is a large section of code, so
919 I've imbedded it in the following macro.
922 /* Set namestring based on bufp. If the string table index is invalid,
923 give a fake name, and print a single error message per symbol file read,
924 rather than abort the symbol reading or flood the user with messages. */
926 /*FIXME: Too many adds and indirections in here for the inner loop. */
927 #define SET_NAMESTRING()\
928 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
929 DBX_STRINGTAB_SIZE (objfile)) { \
930 complain (&string_table_offset_complaint, symnum); \
931 namestring = "foo"; \
933 namestring = bufp->n_strx + file_string_table_offset + \
934 DBX_STRINGTAB (objfile)
936 #define CUR_SYMBOL_TYPE bufp->n_type
937 #define CUR_SYMBOL_VALUE bufp->n_value
939 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
940 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
941 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
942 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
944 #include "partial-stab.h"
947 /* If there's stuff to be cleaned up, clean it up. */
948 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
949 /*FIXME, does this have a bug at start address 0? */
951 && objfile
-> ei
.entry_point
< bufp
->n_value
952 && objfile
-> ei
.entry_point
>= last_o_file_start
)
954 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
955 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
960 end_psymtab (pst
, psymtab_include_list
, includes_used
,
961 symnum
* symbol_size
, end_of_text_addr
,
962 dependency_list
, dependencies_used
);
965 do_cleanups (back_to
);
968 /* Allocate and partially fill a partial symtab. It will be
969 completely filled at the end of the symbol list.
971 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
972 is the address relative to which its symbols are (incremental) or 0
976 struct partial_symtab
*
977 start_psymtab (objfile
, section_offsets
,
978 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
979 struct objfile
*objfile
;
980 struct section_offsets
*section_offsets
;
984 struct partial_symbol
*global_syms
;
985 struct partial_symbol
*static_syms
;
987 struct partial_symtab
*result
=
988 start_psymtab_common(objfile
, section_offsets
,
989 filename
, textlow
, global_syms
, static_syms
);
991 result
->read_symtab_private
= (char *)
992 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
993 LDSYMOFF(result
) = ldsymoff
;
994 result
->read_symtab
= dbx_psymtab_to_symtab
;
995 SYMBOL_SIZE(result
) = symbol_size
;
996 SYMBOL_OFFSET(result
) = symbol_table_offset
;
997 STRING_OFFSET(result
) = string_table_offset
;
998 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
1000 /* If we're handling an ELF file, drag some section-relocation info
1001 for this source file out of the ELF symbol table, to compensate for
1002 Sun brain death. This replaces the section_offsets in this psymtab,
1004 elfstab_offset_sections (objfile
, result
);
1006 /* Deduce the source language from the filename for this psymtab. */
1007 psymtab_language
= deduce_language_from_filename (filename
);
1012 /* Close off the current usage of PST.
1013 Returns PST or NULL if the partial symtab was empty and thrown away.
1015 FIXME: List variables and peculiarities of same. */
1017 struct partial_symtab
*
1018 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1019 capping_text
, dependency_list
, number_dependencies
)
1020 struct partial_symtab
*pst
;
1021 char **include_list
;
1023 int capping_symbol_offset
;
1024 CORE_ADDR capping_text
;
1025 struct partial_symtab
**dependency_list
;
1026 int number_dependencies
;
1027 /* struct partial_symbol *capping_global, *capping_static;*/
1030 struct partial_symtab
*p1
;
1031 struct objfile
*objfile
= pst
-> objfile
;
1033 if (capping_symbol_offset
!= -1)
1034 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
1035 pst
->texthigh
= capping_text
;
1037 /* Under Solaris, the N_SO symbols always have a value of 0,
1038 instead of the usual address of the .o file. Therefore,
1039 we have to do some tricks to fill in texthigh and textlow.
1040 The first trick is in partial-stab.h: if we see a static
1041 or global function, and the textlow for the current pst
1042 is still 0, then we use that function's address for
1043 the textlow of the pst.
1045 Now, to fill in texthigh, we remember the last function seen
1046 in the .o file (also in partial-stab.h). Also, there's a hack in
1047 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1048 to here via the misc_info field. Therefore, we can fill in
1049 a reliable texthigh by taking the address plus size of the
1050 last function in the file.
1052 Unfortunately, that does not cover the case where the last function
1053 in the file is static. See the paragraph below for more comments
1056 Finally, if we have a valid textlow for the current file, we run
1057 down the partial_symtab_list filling in previous texthighs that
1058 are still unknown. */
1060 if (pst
->texthigh
== 0 && last_function_name
) {
1063 struct minimal_symbol
*minsym
;
1065 p
= strchr (last_function_name
, ':');
1067 p
= last_function_name
;
1068 n
= p
- last_function_name
;
1070 strncpy (p
, last_function_name
, n
);
1073 minsym
= lookup_minimal_symbol (p
, objfile
);
1076 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1077 (long) MSYMBOL_INFO (minsym
);
1079 /* This file ends with a static function, and it's
1080 difficult to imagine how hard it would be to track down
1081 the elf symbol. Luckily, most of the time no one will notice,
1082 since the next file will likely be compiled with -g, so
1083 the code below will copy the first fuction's start address
1084 back to our texthigh variable. (Also, if this file is the
1085 last one in a dynamically linked program, texthigh already
1086 has the right value.) If the next file isn't compiled
1087 with -g, then the last function in this file winds up owning
1088 all of the text space up to the next -g file, or the end (minus
1089 shared libraries). This only matters for single stepping,
1090 and even then it will still work, except that it will single
1091 step through all of the covered functions, instead of setting
1092 breakpoints around them as it usualy does. This makes it
1093 pretty slow, but at least it doesn't fail.
1095 We can fix this with a fairly big change to bfd, but we need
1096 to coordinate better with Cygnus if we want to do that. FIXME. */
1098 last_function_name
= NULL
;
1101 /* this test will be true if the last .o file is only data */
1102 if (pst
->textlow
== 0)
1103 pst
->textlow
= pst
->texthigh
;
1105 /* If we know our own starting text address, then walk through all other
1106 psymtabs for this objfile, and if any didn't know their ending text
1107 address, set it to our starting address. Take care to not set our
1108 own ending address to our starting address, nor to set addresses on
1109 `dependency' files that have both textlow and texthigh zero. */
1111 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1112 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1113 p1
->texthigh
= pst
->textlow
;
1114 /* if this file has only data, then make textlow match texthigh */
1115 if (p1
->textlow
== 0)
1116 p1
->textlow
= p1
->texthigh
;
1121 /* End of kludge for patching Solaris textlow and texthigh. */
1124 pst
->n_global_syms
=
1125 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1126 pst
->n_static_syms
=
1127 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1129 pst
->number_of_dependencies
= number_dependencies
;
1130 if (number_dependencies
)
1132 pst
->dependencies
= (struct partial_symtab
**)
1133 obstack_alloc (&objfile
->psymbol_obstack
,
1134 number_dependencies
* sizeof (struct partial_symtab
*));
1135 memcpy (pst
->dependencies
, dependency_list
,
1136 number_dependencies
* sizeof (struct partial_symtab
*));
1139 pst
->dependencies
= 0;
1141 for (i
= 0; i
< num_includes
; i
++)
1143 struct partial_symtab
*subpst
=
1144 allocate_psymtab (include_list
[i
], objfile
);
1146 subpst
->section_offsets
= pst
->section_offsets
;
1147 subpst
->read_symtab_private
=
1148 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1149 sizeof (struct symloc
));
1153 subpst
->texthigh
= 0;
1155 /* We could save slight bits of space by only making one of these,
1156 shared by the entire set of include files. FIXME-someday. */
1157 subpst
->dependencies
= (struct partial_symtab
**)
1158 obstack_alloc (&objfile
->psymbol_obstack
,
1159 sizeof (struct partial_symtab
*));
1160 subpst
->dependencies
[0] = pst
;
1161 subpst
->number_of_dependencies
= 1;
1163 subpst
->globals_offset
=
1164 subpst
->n_global_syms
=
1165 subpst
->statics_offset
=
1166 subpst
->n_static_syms
= 0;
1170 subpst
->read_symtab
= pst
->read_symtab
;
1173 sort_pst_symbols (pst
);
1175 /* If there is already a psymtab or symtab for a file of this name, remove it.
1176 (If there is a symtab, more drastic things also happen.)
1177 This happens in VxWorks. */
1178 free_named_symtabs (pst
->filename
);
1180 if (num_includes
== 0
1181 && number_dependencies
== 0
1182 && pst
->n_global_syms
== 0
1183 && pst
->n_static_syms
== 0) {
1184 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1185 it is on the obstack, but we can forget to chain it on the list. */
1186 struct partial_symtab
*prev_pst
;
1188 /* First, snip it out of the psymtab chain */
1190 if (pst
->objfile
->psymtabs
== pst
)
1191 pst
->objfile
->psymtabs
= pst
->next
;
1193 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1194 if (prev_pst
->next
== pst
)
1195 prev_pst
->next
= pst
->next
;
1197 /* Next, put it on a free list for recycling */
1199 pst
->next
= pst
->objfile
->free_psymtabs
;
1200 pst
->objfile
->free_psymtabs
= pst
;
1202 /* Indicate that psymtab was thrown away. */
1203 pst
= (struct partial_symtab
*)NULL
;
1209 dbx_psymtab_to_symtab_1 (pst
)
1210 struct partial_symtab
*pst
;
1212 struct cleanup
*old_chain
;
1220 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1225 /* Read in all partial symtabs on which this one is dependent */
1226 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1227 if (!pst
->dependencies
[i
]->readin
)
1229 /* Inform about additional files that need to be read in. */
1232 fputs_filtered (" ", gdb_stdout
);
1234 fputs_filtered ("and ", gdb_stdout
);
1236 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1237 wrap_here (""); /* Flush output */
1238 gdb_flush (gdb_stdout
);
1240 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1243 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1245 /* Init stuff necessary for reading in symbols */
1248 old_chain
= make_cleanup (really_free_pendings
, 0);
1249 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1250 symbol_size
= SYMBOL_SIZE (pst
);
1252 /* Read in this file's symbols */
1253 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1254 read_ofile_symtab (pst
);
1255 sort_symtab_syms (pst
->symtab
);
1257 do_cleanups (old_chain
);
1263 /* Read in all of the symbols for a given psymtab for real.
1264 Be verbose about it if the user wants that. */
1267 dbx_psymtab_to_symtab (pst
)
1268 struct partial_symtab
*pst
;
1277 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1282 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1284 /* Print the message now, before reading the string table,
1285 to avoid disconcerting pauses. */
1288 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1289 gdb_flush (gdb_stdout
);
1292 sym_bfd
= pst
->objfile
->obfd
;
1294 next_symbol_text_func
= dbx_next_symbol_text
;
1296 dbx_psymtab_to_symtab_1 (pst
);
1298 /* Match with global symbols. This only needs to be done once,
1299 after all of the symtabs and dependencies have been read in. */
1300 scan_file_globals (pst
->objfile
);
1302 /* Finish up the debug error message. */
1304 printf_filtered ("done.\n");
1308 /* Read in a defined section of a specific object file's symbols. */
1311 read_ofile_symtab (pst
)
1312 struct partial_symtab
*pst
;
1314 register char *namestring
;
1315 register struct internal_nlist
*bufp
;
1317 unsigned max_symnum
;
1319 struct objfile
*objfile
;
1320 int sym_offset
; /* Offset to start of symbols to read */
1321 int sym_size
; /* Size of symbols to read */
1322 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1323 int text_size
; /* Size of text segment for symbols */
1324 struct section_offsets
*section_offsets
;
1326 objfile
= pst
->objfile
;
1327 sym_offset
= LDSYMOFF(pst
);
1328 sym_size
= LDSYMLEN(pst
);
1329 text_offset
= pst
->textlow
;
1330 text_size
= pst
->texthigh
- pst
->textlow
;
1331 section_offsets
= pst
->section_offsets
;
1333 current_objfile
= objfile
;
1334 subfile_stack
= NULL
;
1336 stringtab_global
= DBX_STRINGTAB (objfile
);
1337 last_source_file
= NULL
;
1339 abfd
= objfile
->obfd
;
1340 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1341 symbuf_end
= symbuf_idx
= 0;
1343 /* It is necessary to actually read one symbol *before* the start
1344 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1345 occurs before the N_SO symbol.
1347 Detecting this in read_dbx_symtab
1348 would slow down initial readin, so we look for it here instead. */
1349 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1351 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1353 bufp
= &symbuf
[symbuf_idx
++];
1354 SWAP_SYMBOL (bufp
, abfd
);
1358 processing_gcc_compilation
= 0;
1359 if (bufp
->n_type
== N_TEXT
)
1361 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1362 processing_gcc_compilation
= 1;
1363 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1364 processing_gcc_compilation
= 2;
1367 /* Try to select a C++ demangling based on the compilation unit
1370 if (processing_gcc_compilation
)
1372 if (AUTO_DEMANGLING
)
1374 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1380 /* The N_SO starting this symtab is the first symbol, so we
1381 better not check the symbol before it. I'm not this can
1382 happen, but it doesn't hurt to check for it. */
1383 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1384 processing_gcc_compilation
= 0;
1387 if (symbuf_idx
== symbuf_end
)
1389 bufp
= &symbuf
[symbuf_idx
];
1390 if (bufp
->n_type
!= (unsigned char)N_SO
)
1391 error("First symbol in segment of executable not a source symbol");
1393 max_symnum
= sym_size
/ symbol_size
;
1396 symnum
< max_symnum
;
1399 QUIT
; /* Allow this to be interruptable */
1400 if (symbuf_idx
== symbuf_end
)
1402 bufp
= &symbuf
[symbuf_idx
++];
1403 SWAP_SYMBOL (bufp
, abfd
);
1405 type
= bufp
->n_type
;
1409 if (type
& N_STAB
) {
1410 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1411 namestring
, section_offsets
, objfile
);
1413 /* We skip checking for a new .o or -l file; that should never
1414 happen in this routine. */
1415 else if (type
== N_TEXT
)
1417 /* I don't think this code will ever be executed, because
1418 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1419 the N_SO symbol which starts this source file.
1420 However, there is no reason not to accept
1421 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1423 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1424 processing_gcc_compilation
= 1;
1425 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1426 processing_gcc_compilation
= 2;
1428 if (AUTO_DEMANGLING
)
1430 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1433 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1434 || type
== (unsigned char)N_NBTEXT
1436 /* Global symbol: see if we came across a dbx defintion for
1437 a corresponding symbol. If so, store the value. Remove
1438 syms from the chain when their values are stored, but
1439 search the whole chain, as there may be several syms from
1440 different files with the same name. */
1441 /* This is probably not true. Since the files will be read
1442 in one at a time, each reference to a global symbol will
1443 be satisfied in each file as it appears. So we skip this
1449 current_objfile
= NULL
;
1451 /* In a Solaris elf file, this variable, which comes from the
1452 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1453 which comes from pst->textlow is correct. */
1454 if (last_source_start_addr
== 0)
1455 last_source_start_addr
= text_offset
;
1457 pst
->symtab
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
,
1463 /* This handles a single symbol from the symbol-file, building symbols
1464 into a GDB symtab. It takes these arguments and an implicit argument.
1466 TYPE is the type field of the ".stab" symbol entry.
1467 DESC is the desc field of the ".stab" entry.
1468 VALU is the value field of the ".stab" entry.
1469 NAME is the symbol name, in our address space.
1470 SECTION_OFFSETS is a set of amounts by which the sections of this object
1471 file were relocated when it was loaded into memory.
1472 All symbols that refer
1473 to memory locations need to be offset by these amounts.
1474 OBJFILE is the object file from which we are reading symbols.
1475 It is used in end_symtab. */
1478 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1482 struct section_offsets
*section_offsets
;
1483 struct objfile
*objfile
;
1485 #ifdef SUN_FIXED_LBRAC_BUG
1486 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1487 to correct the address of N_LBRAC's. If it is not defined, then
1488 we never need to correct the addresses. */
1490 /* This records the last pc address we've seen. We depend on there being
1491 an SLINE or FUN or SO before the first LBRAC, since the variable does
1492 not get reset in between reads of different symbol files. */
1493 static CORE_ADDR last_pc_address
;
1496 register struct context_stack
*new;
1497 /* This remembers the address of the start of a function. It is used
1498 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1499 relative to the current function's start address. On systems
1500 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1501 used to relocate these symbol types rather than SECTION_OFFSETS. */
1502 static CORE_ADDR function_start_offset
;
1504 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
1505 to the function start address. */
1506 int block_address_function_relative
;
1508 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1509 file. Used to detect the SunPRO solaris compiler. */
1510 static int n_opt_found
;
1512 /* The stab type used for the definition of the last function.
1513 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1514 static int function_stab_type
= 0;
1516 /* This is true for Solaris (and all other stabs-in-elf systems, hopefully,
1517 since it would be silly to do things differently from Solaris), and
1518 false for SunOS4 and other a.out file formats. */
1519 block_address_function_relative
=
1520 (0 == strncmp (bfd_get_target (objfile
->obfd
), "elf", 3))
1521 || (0 == strncmp (bfd_get_target (objfile
->obfd
), "som", 3));
1523 if (!block_address_function_relative
)
1524 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1525 function start address, so just use the text offset. */
1526 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1528 /* Something is wrong if we see real data before
1529 seeing a source file name. */
1531 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1533 /* Ignore any symbols which appear before an N_SO symbol. Currently
1534 no one puts symbols there, but we should deal gracefully with the
1535 case. A complain()t might be in order (if !IGNORE_SYMBOL (type)),
1536 but this should not be an error (). */
1544 /* Relocate for dynamic loading */
1545 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1546 goto define_a_symbol
;
1549 /* This "symbol" just indicates the start of an inner lexical
1550 context within a function. */
1552 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1553 /* Relocate for dynamic loading (?). */
1554 valu
+= function_start_offset
;
1556 if (block_address_function_relative
)
1557 /* Relocate for Sun ELF acc fn-relative syms. */
1558 valu
+= function_start_offset
;
1560 /* On most machines, the block addresses are relative to the
1561 N_SO, the linker did not relocate them (sigh). */
1562 valu
+= last_source_start_addr
;
1565 #ifdef SUN_FIXED_LBRAC_BUG
1566 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
) {
1567 /* Patch current LBRAC pc value to match last handy pc value */
1568 complain (&lbrac_complaint
);
1569 valu
= last_pc_address
;
1572 new = push_context (desc
, valu
);
1576 /* This "symbol" just indicates the end of an inner lexical
1577 context that was started with N_LBRAC. */
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 new = pop_context();
1593 if (desc
!= new->depth
)
1594 complain (&lbrac_mismatch_complaint
, symnum
);
1596 /* Some compilers put the variable decls inside of an
1597 LBRAC/RBRAC block. This macro should be nonzero if this
1598 is true. DESC is N_DESC from the N_RBRAC symbol.
1599 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1600 or the GCC2_COMPILED_SYMBOL. */
1601 #if !defined (VARIABLES_INSIDE_BLOCK)
1602 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1605 /* Can only use new->locals as local symbols here if we're in
1606 gcc or on a machine that puts them before the lbrack. */
1607 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1608 local_symbols
= new->locals
;
1610 if (context_stack_depth
1611 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1613 /* This is not the outermost LBRAC...RBRAC pair in the function,
1614 its local symbols preceded it, and are the ones just recovered
1615 from the context stack. Define the block for them (but don't
1616 bother if the block contains no symbols. Should we complain
1617 on blocks without symbols? I can't think of any useful purpose
1619 if (local_symbols
!= NULL
)
1621 /* Muzzle a compiler bug that makes end < start. (which
1622 compilers? Is this ever harmful?). */
1623 if (new->start_addr
> valu
)
1625 complain (&lbrac_rbrac_complaint
);
1626 new->start_addr
= valu
;
1628 /* Make a block for the local symbols within. */
1629 finish_block (0, &local_symbols
, new->old_blocks
,
1630 new->start_addr
, valu
, objfile
);
1635 /* This is the outermost LBRAC...RBRAC pair. There is no
1636 need to do anything; leave the symbols that preceded it
1637 to be attached to the function's own block. We need to
1638 indicate that we just moved outside of the function. */
1639 within_function
= 0;
1642 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1643 /* Now pop locals of block just finished. */
1644 local_symbols
= new->locals
;
1649 /* This kind of symbol indicates the start of an object file. */
1650 /* Relocate for dynamic loading */
1651 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1655 /* This type of symbol indicates the start of data
1656 for one source file.
1657 Finish the symbol table of the previous source file
1658 (if any) and start accumulating a new symbol table. */
1659 /* Relocate for dynamic loading */
1660 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1664 #ifdef SUN_FIXED_LBRAC_BUG
1665 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1668 #ifdef PCC_SOL_BROKEN
1669 /* pcc bug, occasionally puts out SO for SOL. */
1670 if (context_stack_depth
> 0)
1672 start_subfile (name
, NULL
);
1676 if (last_source_file
)
1678 /* Check if previous symbol was also an N_SO (with some
1679 sanity checks). If so, that one was actually the directory
1680 name, and the current one is the real file name.
1682 if (previous_stab_code
== (unsigned char) N_SO
)
1684 patch_subfile_names (current_subfile
, name
);
1685 break; /* Ignore repeated SOs */
1687 end_symtab (valu
, 0, 0, objfile
, SECT_OFF_TEXT
);
1691 start_symtab (name
, NULL
, valu
);
1696 /* This type of symbol indicates the start of data for
1697 a sub-source-file, one whose contents were copied or
1698 included in the compilation of the main source file
1699 (whose name was given in the N_SO symbol.) */
1700 /* Relocate for dynamic loading */
1701 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1702 start_subfile (name
, current_subfile
->dirname
);
1707 add_new_header_file (name
, valu
);
1708 start_subfile (name
, current_subfile
->dirname
);
1712 start_subfile (pop_subfile (), current_subfile
->dirname
);
1716 add_old_header_file (name
, valu
);
1720 /* This type of "symbol" really just records
1721 one line-number -- core-address correspondence.
1722 Enter it in the line list for this symbol table. */
1723 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1724 valu
+= function_start_offset
;
1725 #ifdef SUN_FIXED_LBRAC_BUG
1726 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1728 record_line (current_subfile
, desc
, valu
);
1732 common_block_start (name
, objfile
);
1736 common_block_end (objfile
);
1739 /* The following symbol types need to have the appropriate offset added
1740 to their value; then we process symbol definitions in the name. */
1742 case N_STSYM
: /* Static symbol in data seg */
1743 case N_LCSYM
: /* Static symbol in BSS seg */
1744 case N_ROSYM
: /* Static symbol in Read-only data seg */
1745 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
1746 Solaris2's stabs-in-elf makes *most* symbols relative
1747 but leaves a few absolute (at least for Solaris 2.1 and version
1748 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
1749 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1750 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1751 This leaves us no choice but to search for the 'S' or 'V'...
1752 (or pass the whole section_offsets stuff down ONE MORE function
1753 call level, which we really don't want to do). */
1756 p
= strchr (name
, ':');
1757 if (p
!= 0 && p
[1] == 'S')
1759 /* The linker relocated it. We don't want to add an
1760 elfstab_offset_sections-type offset, but we *do* want
1761 to add whatever solib.c passed to symbol_file_add as
1762 addr (this is known to affect SunOS4, and I suspect ELF
1763 too). Since elfstab_offset_sections currently does not
1764 muck with the text offset (there is no Ttext.text
1765 symbol), we can get addr from the text offset. If
1766 elfstab_offset_sections ever starts dealing with the
1767 text offset, and we still need to do this, we need to
1768 invent a SECT_OFF_ADDR_KLUDGE or something. */
1769 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1770 goto define_a_symbol
;
1772 /* Since it's not the kludge case, re-dispatch to the right handler. */
1774 case N_STSYM
: goto case_N_STSYM
;
1775 case N_LCSYM
: goto case_N_LCSYM
;
1776 case N_ROSYM
: goto case_N_ROSYM
;
1781 case_N_STSYM
: /* Static symbol in data seg */
1782 case N_DSLINE
: /* Source line number, data seg */
1783 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1784 goto define_a_symbol
;
1786 case_N_LCSYM
: /* Static symbol in BSS seg */
1787 case N_BSLINE
: /* Source line number, bss seg */
1788 /* N_BROWS: overlaps with N_BSLINE */
1789 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1790 goto define_a_symbol
;
1792 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1793 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1794 goto define_a_symbol
;
1796 case N_ENTRY
: /* Alternate entry point */
1797 /* Relocate for dynamic loading */
1798 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1799 goto define_a_symbol
;
1801 /* The following symbol types we don't know how to process. Handle
1802 them in a "default" way, but complain to people who care. */
1804 case N_CATCH
: /* Exception handler catcher */
1805 case N_EHDECL
: /* Exception handler name */
1806 case N_PC
: /* Global symbol in Pascal */
1807 case N_M2C
: /* Modula-2 compilation unit */
1808 /* N_MOD2: overlaps with N_EHDECL */
1809 case N_SCOPE
: /* Modula-2 scope information */
1810 case N_ECOML
: /* End common (local name) */
1811 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
1816 complain (&unknown_symtype_complaint
,
1817 local_hex_string((unsigned long) type
));
1820 /* The following symbol types don't need the address field relocated,
1821 since it is either unused, or is absolute. */
1823 case N_GSYM
: /* Global variable */
1824 case N_NSYMS
: /* Number of symbols (ultrix) */
1825 case N_NOMAP
: /* No map? (ultrix) */
1826 case N_RSYM
: /* Register variable */
1827 case N_DEFD
: /* Modula-2 GNU module dependency */
1828 case N_SSYM
: /* Struct or union element */
1829 case N_LSYM
: /* Local symbol in stack */
1830 case N_PSYM
: /* Parameter variable */
1831 case N_LENG
: /* Length of preceding symbol type */
1835 char *colon_pos
= strchr (name
, ':');
1836 if (colon_pos
== NULL
)
1839 deftype
= colon_pos
[1];
1845 function_stab_type
= type
;
1847 #ifdef SUN_FIXED_LBRAC_BUG
1848 /* The Sun acc compiler, under SunOS4, puts out
1849 functions with N_GSYM or N_STSYM. The problem is
1850 that the address of the symbol is no good (for N_GSYM
1851 it doesn't even attept an address; for N_STSYM it
1852 puts out an address but then it gets relocated
1853 relative to the data segment, not the text segment).
1854 Currently we can't fix this up later as we do for
1855 some types of symbol in scan_file_globals.
1856 Fortunately we do have a way of finding the address -
1857 we know that the value in last_pc_address is either
1858 the one we want (if we're dealing with the first
1859 function in an object file), or somewhere in the
1860 previous function. This means that we can use the
1861 minimal symbol table to get the address. */
1863 /* On solaris up to 2.2, the N_FUN stab gets relocated.
1864 On Solaris 2.3, ld no longer relocates stabs (which
1865 is good), and the N_FUN's value is now always zero.
1866 The following code can't deal with this, because
1867 last_pc_address depends on getting the address from a
1868 N_SLINE or some such and in Solaris those are function
1869 relative. Best fix is probably to create a Ttext.text symbol
1870 and handle this like Ddata.data and so on. */
1872 if (type
== N_GSYM
|| type
== N_STSYM
)
1874 struct minimal_symbol
*m
;
1875 int l
= colon_pos
- name
;
1877 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
1878 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
))
1879 /* last_pc_address was in this function */
1880 valu
= SYMBOL_VALUE (m
);
1881 else if (m
&& STREQN (SYMBOL_NAME (m
+1), name
, l
))
1882 /* last_pc_address was in last function */
1883 valu
= SYMBOL_VALUE (m
+1);
1885 /* Not found - use last_pc_address (for finish_block) */
1886 valu
= last_pc_address
;
1889 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1892 if (block_address_function_relative
)
1893 /* For Solaris 2.0 compilers, the block addresses and
1894 N_SLINE's are relative to the start of the
1895 function. On normal systems, and when using gcc on
1896 Solaris 2.0, these addresses are just absolute, or
1897 relative to the N_SO, depending on
1898 BLOCK_ADDRESS_ABSOLUTE. */
1899 function_start_offset
= valu
;
1901 within_function
= 1;
1902 if (context_stack_depth
> 0)
1904 new = pop_context ();
1905 /* Make a block for the local symbols within. */
1906 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1907 new->start_addr
, valu
, objfile
);
1909 /* Stack must be empty now. */
1910 if (context_stack_depth
!= 0)
1911 complain (&lbrac_unmatched_complaint
, symnum
);
1913 new = push_context (0, valu
);
1914 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1918 define_symbol (valu
, name
, desc
, type
, objfile
);
1924 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1925 for a bunch of other flags, too. Someday we may parse their
1926 flags; for now we ignore theirs and hope they'll ignore ours. */
1927 case N_OPT
: /* Solaris 2: Compiler options */
1930 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
1932 processing_gcc_compilation
= 2;
1933 #if 1 /* Works, but is experimental. -fnf */
1934 if (AUTO_DEMANGLING
)
1936 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1945 /* The following symbol types can be ignored. */
1946 case N_OBJ
: /* Solaris 2: Object file dir and name */
1947 /* N_UNDF: Solaris 2: file separator mark */
1948 /* N_UNDF: -- we will never encounter it, since we only process one
1949 file's symbols at once. */
1950 case N_ENDM
: /* Solaris 2: End of module */
1951 case N_MAIN
: /* Name of main routine. */
1955 previous_stab_code
= type
;
1958 /* FIXME: The only difference between this and elfstab_build_psymtabs is
1959 the call to install_minimal_symbols for elf. If the differences are
1960 really that small, the code should be shared. */
1962 /* Scan and build partial symbols for an coff symbol file.
1963 The coff file has already been processed to get its minimal symbols.
1965 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
1968 OBJFILE is the object file we are reading symbols from.
1969 ADDR is the address relative to which the symbols are (e.g.
1970 the base address of the text segment).
1971 MAINLINE is true if we are reading the main symbol
1972 table (as opposed to a shared lib or dynamically loaded file).
1973 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
1975 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
1976 .stabstr section exists.
1978 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
1979 adjusted for coff details. */
1982 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
1983 staboffset
, stabsize
,
1984 stabstroffset
, stabstrsize
)
1985 struct objfile
*objfile
;
1986 struct section_offsets
*section_offsets
;
1988 file_ptr staboffset
;
1989 unsigned int stabsize
;
1990 file_ptr stabstroffset
;
1991 unsigned int stabstrsize
;
1994 bfd
*sym_bfd
= objfile
->obfd
;
1995 char *name
= bfd_get_filename (sym_bfd
);
1996 struct dbx_symfile_info
*info
;
1998 /* There is already a dbx_symfile_info allocated by our caller.
1999 It might even contain some info from the coff symtab to help us. */
2000 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2002 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2003 if (!DBX_TEXT_SECT (objfile
))
2004 error ("Can't find .text section in symbol file");
2006 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2007 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2008 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2009 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2010 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2012 if (stabstrsize
> bfd_get_size (sym_bfd
))
2013 error ("ridiculous string table size: %d bytes", stabstrsize
);
2014 DBX_STRINGTAB (objfile
) = (char *)
2015 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2017 /* Now read in the string table in one big gulp. */
2019 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2021 perror_with_name (name
);
2022 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2023 if (val
!= stabstrsize
)
2024 perror_with_name (name
);
2026 stabsread_new_init ();
2027 buildsym_new_init ();
2028 free_header_files ();
2029 init_header_files ();
2031 processing_acc_compilation
= 1;
2033 /* In a coff file, we've already installed the minimal symbols that came
2034 from the coff (non-stab) symbol table, so always act like an
2035 incremental load here. */
2036 dbx_symfile_read (objfile
, section_offsets
, 0);
2039 /* Scan and build partial symbols for an ELF symbol file.
2040 This ELF file has already been processed to get its minimal symbols,
2041 and any DWARF symbols that were in it.
2043 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2046 OBJFILE is the object file we are reading symbols from.
2047 ADDR is the address relative to which the symbols are (e.g.
2048 the base address of the text segment).
2049 MAINLINE is true if we are reading the main symbol
2050 table (as opposed to a shared lib or dynamically loaded file).
2051 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2053 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2054 .stabstr section exists.
2056 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2057 adjusted for elf details. */
2060 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2061 staboffset
, stabsize
,
2062 stabstroffset
, stabstrsize
)
2063 struct objfile
*objfile
;
2064 struct section_offsets
*section_offsets
;
2066 file_ptr staboffset
;
2067 unsigned int stabsize
;
2068 file_ptr stabstroffset
;
2069 unsigned int stabstrsize
;
2072 bfd
*sym_bfd
= objfile
->obfd
;
2073 char *name
= bfd_get_filename (sym_bfd
);
2074 struct dbx_symfile_info
*info
;
2076 /* There is already a dbx_symfile_info allocated by our caller.
2077 It might even contain some info from the ELF symtab to help us. */
2078 info
= (struct dbx_symfile_info
*) objfile
->sym_stab_info
;
2080 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
2081 if (!DBX_TEXT_SECT (objfile
))
2082 error ("Can't find .text section in symbol file");
2084 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2085 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2086 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2087 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2088 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2090 if (stabstrsize
> bfd_get_size (sym_bfd
))
2091 error ("ridiculous string table size: %d bytes", stabstrsize
);
2092 DBX_STRINGTAB (objfile
) = (char *)
2093 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
2095 /* Now read in the string table in one big gulp. */
2097 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2099 perror_with_name (name
);
2100 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2101 if (val
!= stabstrsize
)
2102 perror_with_name (name
);
2104 stabsread_new_init ();
2105 buildsym_new_init ();
2106 free_header_files ();
2107 init_header_files ();
2108 install_minimal_symbols (objfile
);
2110 processing_acc_compilation
= 1;
2112 /* In an elf file, we've already installed the minimal symbols that came
2113 from the elf (non-stab) symbol table, so always act like an
2114 incremental load here. */
2115 dbx_symfile_read (objfile
, section_offsets
, 0);
2118 /* Scan and build partial symbols for a PA symbol file.
2119 This PA file has already been processed to get its minimal symbols.
2121 OBJFILE is the object file we are reading symbols from.
2122 ADDR is the address relative to which the symbols are (e.g.
2123 the base address of the text segment).
2124 MAINLINE is true if we are reading the main symbol
2125 table (as opposed to a shared lib or dynamically loaded file).
2130 pastab_build_psymtabs (objfile
, section_offsets
, mainline
)
2131 struct objfile
*objfile
;
2132 struct section_offsets
*section_offsets
;
2135 free_header_files ();
2136 init_header_files ();
2138 /* This is needed to debug objects assembled with gas2. */
2139 processing_acc_compilation
= 1;
2141 /* In a PA file, we've already installed the minimal symbols that came
2142 from the PA (non-stab) symbol table, so always act like an
2143 incremental load here. */
2145 dbx_symfile_read (objfile
, section_offsets
, mainline
);
2148 /* Parse the user's idea of an offset for dynamic linking, into our idea
2149 of how to represent it for fast symbol reading. */
2151 static struct section_offsets
*
2152 dbx_symfile_offsets (objfile
, addr
)
2153 struct objfile
*objfile
;
2156 struct section_offsets
*section_offsets
;
2159 objfile
->num_sections
= SECT_OFF_MAX
;
2160 section_offsets
= (struct section_offsets
*)
2161 obstack_alloc (&objfile
-> psymbol_obstack
,
2162 sizeof (struct section_offsets
)
2163 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2165 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2166 ANOFFSET (section_offsets
, i
) = addr
;
2168 return section_offsets
;
2171 static struct sym_fns aout_sym_fns
=
2173 bfd_target_aout_flavour
,
2174 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2175 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2176 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2177 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2178 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2179 NULL
/* next: pointer to next struct sym_fns */
2183 _initialize_dbxread ()
2185 add_symtab_fns(&aout_sym_fns
);