1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This module provides three functions: dbx_symfile_init,
21 which initializes to read a symbol file; dbx_new_init, which
22 discards existing cached information when all symbols are being
23 discarded; and dbx_symfile_read, which reads a symbol table
26 dbx_symfile_read only does the minimum work necessary for letting the
27 user "name" things symbolically; it does not read the entire symtab.
28 Instead, it reads the external and static symbols and puts them in partial
29 symbol tables. When more extensive information is requested of a
30 file, the corresponding partial symbol table is mutated into a full
31 fledged symbol table by going back and reading the symbols
32 for real. dbx_psymtab_to_symtab() is the function that does this */
37 #if defined(USG) || defined(__CYGNUSCLIB__)
38 #include <sys/types.h>
45 #include <sys/param.h>
52 #include "breakpoint.h"
55 #include "gdbcore.h" /* for bfd stuff */
56 #include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
57 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
61 #include "stabsread.h"
62 #include "gdb-stabs.h"
64 #include "language.h" /* Needed inside partial-stab.h */
65 #include "complaints.h"
67 #include "aout/aout64.h"
68 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
70 /* Each partial symbol table entry contains a pointer to private data for the
71 read_symtab() function to use when expanding a partial symbol table entry
72 to a full symbol table entry.
74 For dbxread this structure contains the offset within the file symbol table
75 of first local symbol for this file, and length (in bytes) of the section
76 of the symbol table devoted to this file's symbols (actually, the section
77 bracketed may contain more than just this file's symbols). It also contains
78 further information needed to locate the symbols if they are in an ELF file.
80 If ldsymlen is 0, the only reason for this thing's existence is the
81 dependency list. Nothing else will happen when it is read in. */
83 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
84 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
85 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
86 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
87 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
88 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
89 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
97 int file_string_offset
;
100 /* Macro to determine which symbols to ignore when reading the first symbol
101 of a file. Some machines override this definition. */
102 #ifndef IGNORE_SYMBOL
103 /* This code is used on Ultrix systems. Ignore it */
104 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
107 /* Macro for name of symbol to indicate a file compiled with gcc. */
108 #ifndef GCC_COMPILED_FLAG_SYMBOL
109 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
112 /* Macro for name of symbol to indicate a file compiled with gcc2. */
113 #ifndef GCC2_COMPILED_FLAG_SYMBOL
114 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
117 /* Define this as 1 if a pcc declaration of a char or short argument
118 gives the correct address. Otherwise assume pcc gives the
119 address of the corresponding int, which is not the same on a
120 big-endian machine. */
122 #ifndef BELIEVE_PCC_PROMOTION
123 #define BELIEVE_PCC_PROMOTION 0
126 /* Remember what we deduced to be the source language of this psymtab. */
128 static enum language psymtab_language
= language_unknown
;
130 /* Nonzero means give verbose info on gdb action. From main.c. */
131 extern int info_verbose
;
133 /* The BFD for this file -- implicit parameter to next_symbol_text. */
135 static bfd
*symfile_bfd
;
137 /* The size of each symbol in the symbol file (in external form).
138 This is set by dbx_symfile_read when building psymtabs, and by
139 dbx_psymtab_to_symtab when building symtabs. */
141 static unsigned symbol_size
;
143 /* This is the offset of the symbol table in the executable file */
144 static unsigned symbol_table_offset
;
146 /* This is the offset of the string table in the executable file */
147 static unsigned string_table_offset
;
149 /* For elf+stab executables, the n_strx field is not a simple index
150 into the string table. Instead, each .o file has a base offset
151 in the string table, and the associated symbols contain offsets
152 from this base. The following two variables contain the base
153 offset for the current and next .o files. */
154 static unsigned int file_string_table_offset
;
155 static unsigned int next_file_string_table_offset
;
157 /* Complaints about the symbols we have encountered. */
159 struct complaint lbrac_complaint
=
160 {"bad block start address patched", 0, 0};
162 struct complaint string_table_offset_complaint
=
163 {"bad string table offset in symbol %d", 0, 0};
165 struct complaint unknown_symtype_complaint
=
166 {"unknown symbol type %s", 0, 0};
168 struct complaint lbrac_rbrac_complaint
=
169 {"block start larger than block end", 0, 0};
171 struct complaint lbrac_unmatched_complaint
=
172 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
174 struct complaint lbrac_mismatch_complaint
=
175 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
177 struct complaint repeated_header_complaint
=
178 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
180 struct complaint repeated_header_name_complaint
=
181 {"\"repeated\" header file not previously seen, named %s", 0, 0};
183 /* During initial symbol readin, we need to have a structure to keep
184 track of which psymtabs have which bincls in them. This structure
185 is used during readin to setup the list of dependencies within each
186 partial symbol table. */
188 struct header_file_location
190 char *name
; /* Name of header file */
191 int instance
; /* See above */
192 struct partial_symtab
*pst
; /* Partial symtab that has the
193 BINCL/EINCL defs for this file */
196 /* The actual list and controling variables */
197 static struct header_file_location
*bincl_list
, *next_bincl
;
198 static int bincls_allocated
;
200 /* Local function prototypes */
203 free_header_files
PARAMS ((void));
206 init_header_files
PARAMS ((void));
208 static struct pending
*
209 copy_pending
PARAMS ((struct pending
*, int, struct pending
*));
211 static struct symtab
*
212 read_ofile_symtab
PARAMS ((struct objfile
*, int, int, CORE_ADDR
, int,
213 struct section_offsets
*));
216 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
219 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
222 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
226 free_bincl_list
PARAMS ((struct objfile
*));
228 static struct partial_symtab
*
229 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
232 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
235 init_bincl_list
PARAMS ((int, struct objfile
*));
238 init_psymbol_list
PARAMS ((struct objfile
*));
241 dbx_next_symbol_text
PARAMS ((void));
244 fill_symbuf
PARAMS ((bfd
*));
247 dbx_symfile_init
PARAMS ((struct objfile
*));
250 dbx_new_init
PARAMS ((struct objfile
*));
253 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
256 dbx_symfile_finish
PARAMS ((struct objfile
*));
259 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
262 add_new_header_file
PARAMS ((char *, int));
265 add_old_header_file
PARAMS ((char *, int));
268 add_this_object_header_file
PARAMS ((int));
270 /* Free up old header file tables */
277 if (header_files
!= NULL
)
279 for (i
= 0; i
< n_header_files
; i
++)
281 free (header_files
[i
].name
);
283 free ((PTR
)header_files
);
287 if (this_object_header_files
)
289 free ((PTR
)this_object_header_files
);
290 this_object_header_files
= NULL
;
292 n_allocated_header_files
= 0;
293 n_allocated_this_object_header_files
= 0;
296 /* Allocate new header file tables */
302 n_allocated_header_files
= 10;
303 header_files
= (struct header_file
*)
304 xmalloc (10 * sizeof (struct header_file
));
306 n_allocated_this_object_header_files
= 10;
307 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
310 /* Add header file number I for this object file
311 at the next successive FILENUM. */
314 add_this_object_header_file (i
)
317 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
319 n_allocated_this_object_header_files
*= 2;
320 this_object_header_files
321 = (int *) xrealloc ((char *) this_object_header_files
,
322 n_allocated_this_object_header_files
* sizeof (int));
325 this_object_header_files
[n_this_object_header_files
++] = i
;
328 /* Add to this file an "old" header file, one already seen in
329 a previous object file. NAME is the header file's name.
330 INSTANCE is its instance code, to select among multiple
331 symbol tables for the same header file. */
334 add_old_header_file (name
, instance
)
338 register struct header_file
*p
= header_files
;
341 for (i
= 0; i
< n_header_files
; i
++)
342 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
344 add_this_object_header_file (i
);
347 complain (&repeated_header_complaint
, symnum
);
348 complain (&repeated_header_name_complaint
, name
);
351 /* Add to this file a "new" header file: definitions for its types follow.
352 NAME is the header file's name.
353 Most often this happens only once for each distinct header file,
354 but not necessarily. If it happens more than once, INSTANCE has
355 a different value each time, and references to the header file
356 use INSTANCE values to select among them.
358 dbx output contains "begin" and "end" markers for each new header file,
359 but at this level we just need to know which files there have been;
360 so we record the file when its "begin" is seen and ignore the "end". */
363 add_new_header_file (name
, instance
)
369 /* Make sure there is room for one more header file. */
371 if (n_header_files
== n_allocated_header_files
)
373 n_allocated_header_files
*= 2;
374 header_files
= (struct header_file
*)
375 xrealloc ((char *) header_files
,
376 (n_allocated_header_files
* sizeof (struct header_file
)));
379 /* Create an entry for this header file. */
381 i
= n_header_files
++;
382 header_files
[i
].name
= savestring (name
, strlen(name
));
383 header_files
[i
].instance
= instance
;
384 header_files
[i
].length
= 10;
385 header_files
[i
].vector
386 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
387 memset (header_files
[i
].vector
, 0, 10 * sizeof (struct type
*));
389 add_this_object_header_file (i
);
393 static struct type
**
394 explicit_lookup_type (real_filenum
, index
)
395 int real_filenum
, index
;
397 register struct header_file
*f
= &header_files
[real_filenum
];
399 if (index
>= f
->length
)
402 f
->vector
= (struct type
**)
403 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
404 bzero (&f
->vector
[f
->length
/ 2],
405 f
->length
* sizeof (struct type
*) / 2);
407 return &f
->vector
[index
];
412 record_minimal_symbol (name
, address
, type
, objfile
)
416 struct objfile
*objfile
;
418 enum minimal_symbol_type ms_type
;
420 switch (type
&~ N_EXT
) {
421 case N_TEXT
: ms_type
= mst_text
; break;
422 case N_DATA
: ms_type
= mst_data
; break;
423 case N_BSS
: ms_type
= mst_bss
; break;
424 case N_ABS
: ms_type
= mst_abs
; break;
426 case N_SETV
: ms_type
= mst_data
; break;
428 default: ms_type
= mst_unknown
; break;
431 prim_record_minimal_symbol (obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
),
435 /* Scan and build partial symbols for a symbol file.
436 We have been initialized by a call to dbx_symfile_init, which
437 put all the relevant info into a "struct dbx_symfile_info",
438 hung off the objfile structure.
440 SECTION_OFFSETS contains offsets relative to which the symbols in the
441 various sections are (depending where the sections were actually loaded).
442 MAINLINE is true if we are reading the main symbol
443 table (as opposed to a shared lib or dynamically loaded file). */
446 dbx_symfile_read (objfile
, section_offsets
, mainline
)
447 struct objfile
*objfile
;
448 struct section_offsets
*section_offsets
;
449 int mainline
; /* FIXME comments above */
454 sym_bfd
= objfile
->obfd
;
455 val
= bfd_seek (objfile
->obfd
, DBX_SYMTAB_OFFSET (objfile
), L_SET
);
457 perror_with_name (objfile
->name
);
459 /* If we are reinitializing, or if we have never loaded syms yet, init */
460 if (mainline
|| objfile
->global_psymbols
.size
== 0 || objfile
->static_psymbols
.size
== 0)
461 init_psymbol_list (objfile
);
463 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
464 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
467 make_cleanup (really_free_pendings
, 0);
469 init_minimal_symbol_collection ();
470 make_cleanup (discard_minimal_symbols
, 0);
472 /* Now that the symbol table data of the executable file are all in core,
473 process them and define symbols accordingly. */
475 read_dbx_symtab (section_offsets
, objfile
,
476 bfd_section_vma (sym_bfd
, DBX_TEXT_SECT (objfile
)),
477 bfd_section_size (sym_bfd
, DBX_TEXT_SECT (objfile
)));
479 /* Install any minimal symbols that have been collected as the current
480 minimal symbols for this objfile. */
482 install_minimal_symbols (objfile
);
484 if (!have_partial_symbols ()) {
486 printf_filtered ("(no debugging symbols found)...");
491 /* Initialize anything that needs initializing when a completely new
492 symbol file is specified (not just adding some symbols from another
493 file, e.g. a shared library). */
496 dbx_new_init (ignore
)
497 struct objfile
*ignore
;
499 stabsread_new_init ();
500 buildsym_new_init ();
501 init_header_files ();
505 /* dbx_symfile_init ()
506 is the dbx-specific initialization routine for reading symbols.
507 It is passed a struct objfile which contains, among other things,
508 the BFD for the file whose symbols are being read, and a slot for a pointer
509 to "private data" which we fill with goodies.
511 We read the string table into malloc'd space and stash a pointer to it.
513 Since BFD doesn't know how to read debug symbols in a format-independent
514 way (and may never do so...), we have to do it ourselves. We will never
515 be called unless this is an a.out (or very similar) file.
516 FIXME, there should be a cleaner peephole into the BFD environment here. */
519 dbx_symfile_init (objfile
)
520 struct objfile
*objfile
;
523 bfd
*sym_bfd
= objfile
->obfd
;
524 char *name
= bfd_get_filename (sym_bfd
);
525 unsigned char size_temp
[sizeof(long)];
527 /* Allocate struct to keep track of the symfile */
528 objfile
->sym_private
= (PTR
)
529 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
531 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
532 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
533 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
535 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
537 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
538 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
539 if (!DBX_TEXT_SECT (objfile
))
540 error ("Can't find .text section in symbol file");
542 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
543 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
544 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
546 /* Read the string table and stash it away in the psymbol_obstack. It is
547 only needed as long as we need to expand psymbols into full symbols,
548 so when we blow away the psymbol the string table goes away as well.
549 Note that gdb used to use the results of attempting to malloc the
550 string table, based on the size it read, as a form of sanity check
551 for botched byte swapping, on the theory that a byte swapped string
552 table size would be so totally bogus that the malloc would fail. Now
553 that we put in on the psymbol_obstack, we can't do this since gdb gets
554 a fatal error (out of virtual memory) if the size is bogus. We can
555 however at least check to see if the size is zero or some negative
558 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, L_SET
);
560 perror_with_name (name
);
562 val
= bfd_read ((PTR
)size_temp
, sizeof (long), 1, sym_bfd
);
564 perror_with_name (name
);
566 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
568 if (DBX_STRINGTAB_SIZE (objfile
) <= 0
569 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
570 error ("ridiculous string table size (%d bytes).",
571 DBX_STRINGTAB_SIZE (objfile
));
573 DBX_STRINGTAB (objfile
) =
574 (char *) obstack_alloc (&objfile
-> psymbol_obstack
,
575 DBX_STRINGTAB_SIZE (objfile
));
577 /* Now read in the string table in one big gulp. */
579 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, L_SET
);
581 perror_with_name (name
);
582 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
584 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
585 perror_with_name (name
);
588 /* Perform any local cleanups required when we are done with a particular
589 objfile. I.E, we are in the process of discarding all symbol information
590 for an objfile, freeing up all memory held for it, and unlinking the
591 objfile struct from the global list of known objfiles. */
594 dbx_symfile_finish (objfile
)
595 struct objfile
*objfile
;
597 if (objfile
->sym_private
!= NULL
)
599 mfree (objfile
-> md
, objfile
->sym_private
);
601 free_header_files ();
605 /* Buffer for reading the symbol table entries. */
606 static struct internal_nlist symbuf
[4096];
607 static int symbuf_idx
;
608 static int symbuf_end
;
610 /* Name of last function encountered. Used in Solaris to approximate
611 object file boundaries. */
612 static char *last_function_name
;
614 /* The address in memory of the string table of the object file we are
615 reading (which might not be the "main" object file, but might be a
616 shared library or some other dynamically loaded thing). This is set
617 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
618 when building symtabs, and is used only by next_symbol_text. */
619 static char *stringtab_global
;
621 /* Refill the symbol table input buffer
622 and set the variables that control fetching entries from it.
623 Reports an error if no data available.
624 This function can read past the end of the symbol table
625 (into the string table) but this does no harm. */
628 fill_symbuf (sym_bfd
)
631 int nbytes
= bfd_read ((PTR
)symbuf
, sizeof (symbuf
), 1, sym_bfd
);
633 perror_with_name (bfd_get_filename (sym_bfd
));
634 else if (nbytes
== 0)
635 error ("Premature end of file reading symbol table");
636 symbuf_end
= nbytes
/ symbol_size
;
640 #define SWAP_SYMBOL(symp, abfd) \
642 (symp)->n_strx = bfd_h_get_32(abfd, \
643 (unsigned char *)&(symp)->n_strx); \
644 (symp)->n_desc = bfd_h_get_16 (abfd, \
645 (unsigned char *)&(symp)->n_desc); \
646 (symp)->n_value = bfd_h_get_32 (abfd, \
647 (unsigned char *)&(symp)->n_value); \
650 /* Invariant: The symbol pointed to by symbuf_idx is the first one
651 that hasn't been swapped. Swap the symbol at the same time
652 that symbuf_idx is incremented. */
654 /* dbx allows the text of a symbol name to be continued into the
655 next symbol name! When such a continuation is encountered
656 (a \ at the end of the text of a name)
657 call this function to get the continuation. */
660 dbx_next_symbol_text ()
662 if (symbuf_idx
== symbuf_end
)
663 fill_symbuf (symfile_bfd
);
665 SWAP_SYMBOL(&symbuf
[symbuf_idx
], symfile_bfd
);
666 return symbuf
[symbuf_idx
++].n_strx
+ stringtab_global
667 + file_string_table_offset
;
670 /* Initializes storage for all of the partial symbols that will be
671 created by read_dbx_symtab and subsidiaries. */
674 init_psymbol_list (objfile
)
675 struct objfile
*objfile
;
677 /* Free any previously allocated psymbol lists. */
678 if (objfile
-> global_psymbols
.list
)
679 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
680 if (objfile
-> static_psymbols
.list
)
681 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
683 /* Current best guess is that there are approximately a twentieth
684 of the total symbols (in a debugging file) are global or static
686 objfile
-> global_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
687 objfile
-> static_psymbols
.size
= DBX_SYMCOUNT (objfile
) / 10;
688 objfile
-> global_psymbols
.next
= objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
689 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
* sizeof (struct partial_symbol
));
690 objfile
-> static_psymbols
.next
= objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
691 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
* sizeof (struct partial_symbol
));
694 /* Initialize the list of bincls to contain none and have some
698 init_bincl_list (number
, objfile
)
700 struct objfile
*objfile
;
702 bincls_allocated
= number
;
703 next_bincl
= bincl_list
= (struct header_file_location
*)
704 xmmalloc (objfile
-> md
, bincls_allocated
* sizeof(struct header_file_location
));
707 /* Add a bincl to the list. */
710 add_bincl_to_list (pst
, name
, instance
)
711 struct partial_symtab
*pst
;
715 if (next_bincl
>= bincl_list
+ bincls_allocated
)
717 int offset
= next_bincl
- bincl_list
;
718 bincls_allocated
*= 2;
719 bincl_list
= (struct header_file_location
*)
720 xmrealloc (pst
->objfile
->md
, (char *)bincl_list
,
721 bincls_allocated
* sizeof (struct header_file_location
));
722 next_bincl
= bincl_list
+ offset
;
724 next_bincl
->pst
= pst
;
725 next_bincl
->instance
= instance
;
726 next_bincl
++->name
= name
;
729 /* Given a name, value pair, find the corresponding
730 bincl in the list. Return the partial symtab associated
731 with that header_file_location. */
733 static struct partial_symtab
*
734 find_corresponding_bincl_psymtab (name
, instance
)
738 struct header_file_location
*bincl
;
740 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
741 if (bincl
->instance
== instance
742 && STREQ (name
, bincl
->name
))
745 return (struct partial_symtab
*) 0;
748 /* Free the storage allocated for the bincl list. */
751 free_bincl_list (objfile
)
752 struct objfile
*objfile
;
754 mfree (objfile
-> md
, (PTR
)bincl_list
);
755 bincls_allocated
= 0;
758 /* Given pointers to an a.out symbol table in core containing dbx
759 style data, setup partial_symtab's describing each source file for
760 which debugging information is available.
761 SYMFILE_NAME is the name of the file we are reading from
762 and SECTION_OFFSETS is the set of offsets for the various sections
763 of the file (a set of zeros if the mainline program). */
766 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
767 struct section_offsets
*section_offsets
;
768 struct objfile
*objfile
;
772 register struct internal_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
773 register char *namestring
;
775 int past_first_source_file
= 0;
776 CORE_ADDR last_o_file_start
= 0;
777 struct cleanup
*old_chain
;
780 /* End of the text segment of the executable file. */
781 CORE_ADDR end_of_text_addr
;
783 /* Current partial symtab */
784 struct partial_symtab
*pst
;
786 /* List of current psymtab's include files */
787 char **psymtab_include_list
;
788 int includes_allocated
;
791 /* Index within current psymtab dependency list */
792 struct partial_symtab
**dependency_list
;
793 int dependencies_used
, dependencies_allocated
;
795 /* FIXME. We probably want to change stringtab_global rather than add this
796 while processing every symbol entry. FIXME. */
797 file_string_table_offset
= 0;
798 next_file_string_table_offset
= 0;
800 stringtab_global
= DBX_STRINGTAB (objfile
);
802 pst
= (struct partial_symtab
*) 0;
804 includes_allocated
= 30;
806 psymtab_include_list
= (char **) alloca (includes_allocated
*
809 dependencies_allocated
= 30;
810 dependencies_used
= 0;
812 (struct partial_symtab
**) alloca (dependencies_allocated
*
813 sizeof (struct partial_symtab
*));
815 old_chain
= make_cleanup (free_objfile
, objfile
);
817 /* Init bincl list */
818 init_bincl_list (20, objfile
);
819 make_cleanup (free_bincl_list
, objfile
);
821 last_source_file
= NULL
;
823 #ifdef END_OF_TEXT_DEFAULT
824 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
826 end_of_text_addr
= text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
]
827 + text_size
; /* Relocate */
830 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
831 abfd
= objfile
->obfd
;
832 symbuf_end
= symbuf_idx
= 0;
833 next_symbol_text_func
= dbx_next_symbol_text
;
835 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
837 /* Get the symbol for this run and pull out some info */
838 QUIT
; /* allow this to be interruptable */
839 if (symbuf_idx
== symbuf_end
)
841 bufp
= &symbuf
[symbuf_idx
++];
844 * Special case to speed up readin.
846 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
848 SWAP_SYMBOL (bufp
, abfd
);
850 /* Ok. There is a lot of code duplicated in the rest of this
851 switch statement (for efficiency reasons). Since I don't
852 like duplicating code, I will do my penance here, and
853 describe the code which is duplicated:
855 *) The assignment to namestring.
856 *) The call to strchr.
857 *) The addition of a partial symbol the the two partial
858 symbol lists. This last is a large section of code, so
859 I've imbedded it in the following macro.
862 /* Set namestring based on bufp. If the string table index is invalid,
863 give a fake name, and print a single error message per symbol file read,
864 rather than abort the symbol reading or flood the user with messages. */
866 /*FIXME: Too many adds and indirections in here for the inner loop. */
867 #define SET_NAMESTRING()\
868 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
869 DBX_STRINGTAB_SIZE (objfile)) { \
870 complain (&string_table_offset_complaint, symnum); \
871 namestring = "foo"; \
873 namestring = bufp->n_strx + file_string_table_offset + \
874 DBX_STRINGTAB (objfile)
876 #define CUR_SYMBOL_TYPE bufp->n_type
877 #define CUR_SYMBOL_VALUE bufp->n_value
879 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
880 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
881 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
882 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
884 #include "partial-stab.h"
887 /* If there's stuff to be cleaned up, clean it up. */
888 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
889 /*FIXME, does this have a bug at start address 0? */
891 && objfile
-> ei
.entry_point
< bufp
->n_value
892 && objfile
-> ei
.entry_point
>= last_o_file_start
)
894 objfile
-> ei
.entry_file_lowpc
= last_o_file_start
;
895 objfile
-> ei
.entry_file_highpc
= bufp
->n_value
;
900 end_psymtab (pst
, psymtab_include_list
, includes_used
,
901 symnum
* symbol_size
, end_of_text_addr
,
902 dependency_list
, dependencies_used
);
905 free_bincl_list (objfile
);
906 discard_cleanups (old_chain
);
909 /* Allocate and partially fill a partial symtab. It will be
910 completely filled at the end of the symbol list.
912 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
913 is the address relative to which its symbols are (incremental) or 0
917 struct partial_symtab
*
918 start_psymtab (objfile
, section_offsets
,
919 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
920 struct objfile
*objfile
;
921 struct section_offsets
*section_offsets
;
925 struct partial_symbol
*global_syms
;
926 struct partial_symbol
*static_syms
;
928 struct partial_symtab
*result
=
929 start_psymtab_common(objfile
, section_offsets
,
930 filename
, textlow
, global_syms
, static_syms
);
932 result
->read_symtab_private
= (char *)
933 obstack_alloc (&objfile
-> psymbol_obstack
, sizeof (struct symloc
));
934 LDSYMOFF(result
) = ldsymoff
;
935 result
->read_symtab
= dbx_psymtab_to_symtab
;
936 SYMBOL_SIZE(result
) = symbol_size
;
937 SYMBOL_OFFSET(result
) = symbol_table_offset
;
938 STRING_OFFSET(result
) = string_table_offset
;
939 FILE_STRING_OFFSET(result
) = file_string_table_offset
;
941 /* If we're handling an ELF file, drag some section-relocation info
942 for this source file out of the ELF symbol table, to compensate for
943 Sun brain death. This replaces the section_offsets in this psymtab,
945 elfstab_offset_sections (objfile
, result
);
947 /* Deduce the source language from the filename for this psymtab. */
948 psymtab_language
= deduce_language_from_filename (filename
);
953 /* Close off the current usage of a partial_symbol table entry. This
954 involves setting the correct number of includes (with a realloc),
955 setting the high text mark, setting the symbol length in the
956 executable, and setting the length of the global and static lists
959 The global symbols and static symbols are then seperately sorted.
961 Then the partial symtab is put on the global list.
962 *** List variables and peculiarities of same. ***
966 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
967 capping_text
, dependency_list
, number_dependencies
)
968 struct partial_symtab
*pst
;
971 int capping_symbol_offset
;
972 CORE_ADDR capping_text
;
973 struct partial_symtab
**dependency_list
;
974 int number_dependencies
;
975 /* struct partial_symbol *capping_global, *capping_static;*/
978 struct partial_symtab
*p1
;
979 struct objfile
*objfile
= pst
-> objfile
;
981 if (capping_symbol_offset
!= -1)
982 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
983 pst
->texthigh
= capping_text
;
985 /* Under Solaris, the N_SO symbols always have a value of 0,
986 instead of the usual address of the .o file. Therefore,
987 we have to do some tricks to fill in texthigh and textlow.
988 The first trick is in partial-stab.h: if we see a static
989 or global function, and the textlow for the current pst
990 is still 0, then we use that function's address for
991 the textlow of the pst.
993 Now, to fill in texthigh, we remember the last function seen
994 in the .o file (also in partial-stab.h). Also, there's a hack in
995 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
996 to here via the misc_info field. Therefore, we can fill in
997 a reliable texthigh by taking the address plus size of the
998 last function in the file.
1000 Unfortunately, that does not cover the case where the last function
1001 in the file is static. See the paragraph below for more comments
1004 Finally, if we have a valid textlow for the current file, we run
1005 down the partial_symtab_list filling in previous texthighs that
1006 are still unknown. */
1008 if (pst
->texthigh
== 0 && last_function_name
) {
1011 struct minimal_symbol
*minsym
;
1013 p
= strchr (last_function_name
, ':');
1015 p
= last_function_name
;
1016 n
= p
- last_function_name
;
1018 strncpy (p
, last_function_name
, n
);
1021 minsym
= lookup_minimal_symbol (p
, objfile
);
1024 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) +
1025 (int) MSYMBOL_INFO (minsym
);
1027 /* This file ends with a static function, and it's
1028 difficult to imagine how hard it would be to track down
1029 the elf symbol. Luckily, most of the time no one will notice,
1030 since the next file will likely be compiled with -g, so
1031 the code below will copy the first fuction's start address
1032 back to our texthigh variable. (Also, if this file is the
1033 last one in a dynamically linked program, texthigh already
1034 has the right value.) If the next file isn't compiled
1035 with -g, then the last function in this file winds up owning
1036 all of the text space up to the next -g file, or the end (minus
1037 shared libraries). This only matters for single stepping,
1038 and even then it will still work, except that it will single
1039 step through all of the covered functions, instead of setting
1040 breakpoints around them as it usualy does. This makes it
1041 pretty slow, but at least it doesn't fail.
1043 We can fix this with a fairly big change to bfd, but we need
1044 to coordinate better with Cygnus if we want to do that. FIXME. */
1046 last_function_name
= NULL
;
1049 /* this test will be true if the last .o file is only data */
1050 if (pst
->textlow
== 0)
1051 pst
->textlow
= pst
->texthigh
;
1053 /* If we know our own starting text address, then walk through all other
1054 psymtabs for this objfile, and if any didn't know their ending text
1055 address, set it to our starting address. Take care to not set our
1056 own ending address to our starting address, nor to set addresses on
1057 `dependency' files that have both textlow and texthigh zero. */
1059 ALL_OBJFILE_PSYMTABS (objfile
, p1
) {
1060 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
) {
1061 p1
->texthigh
= pst
->textlow
;
1062 /* if this file has only data, then make textlow match texthigh */
1063 if (p1
->textlow
== 0)
1064 p1
->textlow
= p1
->texthigh
;
1069 /* End of kludge for patching Solaris textlow and texthigh. */
1072 pst
->n_global_syms
=
1073 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1074 pst
->n_static_syms
=
1075 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1077 pst
->number_of_dependencies
= number_dependencies
;
1078 if (number_dependencies
)
1080 pst
->dependencies
= (struct partial_symtab
**)
1081 obstack_alloc (&objfile
->psymbol_obstack
,
1082 number_dependencies
* sizeof (struct partial_symtab
*));
1083 memcpy (pst
->dependencies
, dependency_list
,
1084 number_dependencies
* sizeof (struct partial_symtab
*));
1087 pst
->dependencies
= 0;
1089 for (i
= 0; i
< num_includes
; i
++)
1091 struct partial_symtab
*subpst
=
1092 allocate_psymtab (include_list
[i
], objfile
);
1094 subpst
->section_offsets
= pst
->section_offsets
;
1095 subpst
->read_symtab_private
=
1096 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1097 sizeof (struct symloc
));
1101 subpst
->texthigh
= 0;
1103 /* We could save slight bits of space by only making one of these,
1104 shared by the entire set of include files. FIXME-someday. */
1105 subpst
->dependencies
= (struct partial_symtab
**)
1106 obstack_alloc (&objfile
->psymbol_obstack
,
1107 sizeof (struct partial_symtab
*));
1108 subpst
->dependencies
[0] = pst
;
1109 subpst
->number_of_dependencies
= 1;
1111 subpst
->globals_offset
=
1112 subpst
->n_global_syms
=
1113 subpst
->statics_offset
=
1114 subpst
->n_static_syms
= 0;
1118 subpst
->read_symtab
= dbx_psymtab_to_symtab
;
1121 sort_pst_symbols (pst
);
1123 /* If there is already a psymtab or symtab for a file of this name, remove it.
1124 (If there is a symtab, more drastic things also happen.)
1125 This happens in VxWorks. */
1126 free_named_symtabs (pst
->filename
);
1128 if (num_includes
== 0
1129 && number_dependencies
== 0
1130 && pst
->n_global_syms
== 0
1131 && pst
->n_static_syms
== 0) {
1132 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1133 it is on the obstack, but we can forget to chain it on the list. */
1134 struct partial_symtab
*prev_pst
;
1136 /* First, snip it out of the psymtab chain */
1138 if (pst
->objfile
->psymtabs
== pst
)
1139 pst
->objfile
->psymtabs
= pst
->next
;
1141 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
1142 if (prev_pst
->next
== pst
)
1143 prev_pst
->next
= pst
->next
;
1145 /* Next, put it on a free list for recycling */
1147 pst
->next
= pst
->objfile
->free_psymtabs
;
1148 pst
->objfile
->free_psymtabs
= pst
;
1153 dbx_psymtab_to_symtab_1 (pst
)
1154 struct partial_symtab
*pst
;
1156 struct cleanup
*old_chain
;
1164 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1169 /* Read in all partial symtabs on which this one is dependent */
1170 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1171 if (!pst
->dependencies
[i
]->readin
)
1173 /* Inform about additional files that need to be read in. */
1176 fputs_filtered (" ", stdout
);
1178 fputs_filtered ("and ", stdout
);
1180 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1181 wrap_here (""); /* Flush output */
1184 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1187 if (LDSYMLEN(pst
)) /* Otherwise it's a dummy */
1189 /* Init stuff necessary for reading in symbols */
1192 old_chain
= make_cleanup (really_free_pendings
, 0);
1193 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1194 symbol_size
= SYMBOL_SIZE (pst
);
1196 /* Read in this file's symbols */
1197 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), L_SET
);
1199 read_ofile_symtab (pst
->objfile
, LDSYMOFF(pst
), LDSYMLEN(pst
),
1200 pst
->textlow
, pst
->texthigh
- pst
->textlow
,
1201 pst
->section_offsets
);
1202 sort_symtab_syms (pst
->symtab
);
1204 do_cleanups (old_chain
);
1210 /* Read in all of the symbols for a given psymtab for real.
1211 Be verbose about it if the user wants that. */
1214 dbx_psymtab_to_symtab (pst
)
1215 struct partial_symtab
*pst
;
1224 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1229 if (LDSYMLEN(pst
) || pst
->number_of_dependencies
)
1231 /* Print the message now, before reading the string table,
1232 to avoid disconcerting pauses. */
1235 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1239 sym_bfd
= pst
->objfile
->obfd
;
1241 next_symbol_text_func
= dbx_next_symbol_text
;
1243 dbx_psymtab_to_symtab_1 (pst
);
1245 /* Match with global symbols. This only needs to be done once,
1246 after all of the symtabs and dependencies have been read in. */
1247 scan_file_globals (pst
->objfile
);
1249 /* Finish up the debug error message. */
1251 printf_filtered ("done.\n");
1255 /* Read in a defined section of a specific object file's symbols.
1257 DESC is the file descriptor for the file, positioned at the
1258 beginning of the symtab
1259 SYM_OFFSET is the offset within the file of
1260 the beginning of the symbols we want to read
1261 SYM_SIZE is the size of the symbol info to read in.
1262 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
1263 TEXT_SIZE is the size of the text segment read in.
1264 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
1266 static struct symtab
*
1267 read_ofile_symtab (objfile
, sym_offset
, sym_size
, text_offset
, text_size
,
1269 struct objfile
*objfile
;
1272 CORE_ADDR text_offset
;
1274 struct section_offsets
*section_offsets
;
1276 register char *namestring
;
1277 register struct internal_nlist
*bufp
;
1279 unsigned max_symnum
;
1283 current_objfile
= objfile
;
1284 subfile_stack
= NULL
;
1286 stringtab_global
= DBX_STRINGTAB (objfile
);
1287 last_source_file
= NULL
;
1289 abfd
= objfile
->obfd
;
1290 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1291 symbuf_end
= symbuf_idx
= 0;
1293 /* It is necessary to actually read one symbol *before* the start
1294 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1295 occurs before the N_SO symbol.
1297 Detecting this in read_dbx_symtab
1298 would slow down initial readin, so we look for it here instead. */
1299 if (!processing_acc_compilation
&& sym_offset
>= (int)symbol_size
)
1301 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, L_INCR
);
1303 bufp
= &symbuf
[symbuf_idx
++];
1304 SWAP_SYMBOL (bufp
, abfd
);
1308 processing_gcc_compilation
= 0;
1309 if (bufp
->n_type
== N_TEXT
)
1311 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1312 processing_gcc_compilation
= 1;
1313 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1314 processing_gcc_compilation
= 2;
1317 /* Try to select a C++ demangling based on the compilation unit
1320 if (processing_gcc_compilation
)
1322 #if 1 /* Works, but is experimental. -fnf */
1323 if (AUTO_DEMANGLING
)
1325 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1332 /* The N_SO starting this symtab is the first symbol, so we
1333 better not check the symbol before it. I'm not this can
1334 happen, but it doesn't hurt to check for it. */
1335 bfd_seek (symfile_bfd
, sym_offset
, L_INCR
);
1336 processing_gcc_compilation
= 0;
1339 if (symbuf_idx
== symbuf_end
)
1341 bufp
= &symbuf
[symbuf_idx
];
1342 if (bufp
->n_type
!= (unsigned char)N_SO
)
1343 error("First symbol in segment of executable not a source symbol");
1345 max_symnum
= sym_size
/ symbol_size
;
1348 symnum
< max_symnum
;
1351 QUIT
; /* Allow this to be interruptable */
1352 if (symbuf_idx
== symbuf_end
)
1354 bufp
= &symbuf
[symbuf_idx
++];
1355 SWAP_SYMBOL (bufp
, abfd
);
1357 type
= bufp
->n_type
;
1361 if (type
& N_STAB
) {
1362 process_one_symbol (type
, bufp
->n_desc
, bufp
->n_value
,
1363 namestring
, section_offsets
, objfile
);
1365 /* We skip checking for a new .o or -l file; that should never
1366 happen in this routine. */
1367 else if (type
== N_TEXT
)
1369 /* I don't think this code will ever be executed, because
1370 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1371 the N_SO symbol which starts this source file.
1372 However, there is no reason not to accept
1373 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1375 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1376 processing_gcc_compilation
= 1;
1377 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1378 processing_gcc_compilation
= 2;
1380 #if 1 /* Works, but is experimental. -fnf */
1381 if (AUTO_DEMANGLING
)
1383 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1387 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
1388 || type
== (unsigned char)N_NBTEXT
1390 /* Global symbol: see if we came across a dbx defintion for
1391 a corresponding symbol. If so, store the value. Remove
1392 syms from the chain when their values are stored, but
1393 search the whole chain, as there may be several syms from
1394 different files with the same name. */
1395 /* This is probably not true. Since the files will be read
1396 in one at a time, each reference to a global symbol will
1397 be satisfied in each file as it appears. So we skip this
1403 current_objfile
= NULL
;
1405 /* In a Solaris elf file, this variable, which comes from the
1406 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1407 which comes from pst->textlow is correct. */
1408 if (last_source_start_addr
== 0)
1409 last_source_start_addr
= text_offset
;
1411 rtn
= end_symtab (text_offset
+ text_size
, 0, 0, objfile
);
1416 /* This handles a single symbol from the symbol-file, building symbols
1417 into a GDB symtab. It takes these arguments and an implicit argument.
1419 TYPE is the type field of the ".stab" symbol entry.
1420 DESC is the desc field of the ".stab" entry.
1421 VALU is the value field of the ".stab" entry.
1422 NAME is the symbol name, in our address space.
1423 SECTION_OFFSETS is a set of amounts by which the sections of this object
1424 file were relocated when it was loaded into memory.
1425 All symbols that refer
1426 to memory locations need to be offset by these amounts.
1427 OBJFILE is the object file from which we are reading symbols.
1428 It is used in end_symtab. */
1431 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1435 struct section_offsets
*section_offsets
;
1436 struct objfile
*objfile
;
1438 #ifndef SUN_FIXED_LBRAC_BUG
1439 /* This records the last pc address we've seen. We depend on there being
1440 an SLINE or FUN or SO before the first LBRAC, since the variable does
1441 not get reset in between reads of different symbol files. */
1442 static CORE_ADDR last_pc_address
;
1444 register struct context_stack
*new;
1445 /* This remembers the address of the start of a function. It is used
1446 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1447 relative to the current function's start address. On systems
1448 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1449 used to relocate these symbol types rather than SECTION_OFFSETS. */
1450 static CORE_ADDR function_start_offset
;
1453 #ifndef BLOCK_ADDRESS_FUNCTION_RELATIVE
1454 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1455 function start address, so just use the text offset. */
1456 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1459 /* Something is wrong if we see real data before
1460 seeing a source file name. */
1462 if (last_source_file
== NULL
&& type
!= (unsigned char)N_SO
)
1464 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
1465 where that code is defined. */
1466 if (IGNORE_SYMBOL (type
))
1469 /* FIXME, this should not be an error, since it precludes extending
1470 the symbol table information in this way... */
1471 error ("Invalid symbol data: does not start by identifying a source file.");
1479 /* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
1480 N_STSYM with a type code of f or F. Can't enable this until we get some
1481 stuff straightened out with psymtabs. FIXME. */
1487 /* Relocate for dynamic loading */
1488 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1490 /* Either of these types of symbols indicates the start of
1491 a new function. We must process its "name" normally for dbx,
1492 but also record the start of a new lexical context, and possibly
1493 also the end of the lexical context for the previous function. */
1494 /* This is not always true. This type of symbol may indicate a
1495 text segment variable. */
1497 colon_pos
= strchr (name
, ':');
1499 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
1501 define_symbol (valu
, name
, desc
, type
, objfile
);
1505 #ifndef SUN_FIXED_LBRAC_BUG
1506 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1509 #ifdef BLOCK_ADDRESS_FUNCTION_RELATIVE
1510 /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1511 are relative to the start of the function. On normal systems,
1512 and when using gcc on Solaris 2.0, these addresses are just
1513 absolute, or relative to the N_SO, depending on
1514 BLOCK_ADDRESS_ABSOLUTE. */
1515 function_start_offset
= valu
;
1518 within_function
= 1;
1519 if (context_stack_depth
> 0)
1521 new = pop_context ();
1522 /* Make a block for the local symbols within. */
1523 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1524 new->start_addr
, valu
, objfile
);
1526 /* Stack must be empty now. */
1527 if (context_stack_depth
!= 0)
1528 complain (&lbrac_unmatched_complaint
, symnum
);
1530 new = push_context (0, valu
);
1531 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
1535 /* This "symbol" just indicates the start of an inner lexical
1536 context within a function. */
1538 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1539 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1540 valu
+= function_start_offset
;
1542 /* On most machines, the block addresses are relative to the
1543 N_SO, the linker did not relocate them (sigh). */
1544 valu
+= last_source_start_addr
;
1547 #ifndef SUN_FIXED_LBRAC_BUG
1548 if (valu
< last_pc_address
) {
1549 /* Patch current LBRAC pc value to match last handy pc value */
1550 complain (&lbrac_complaint
);
1551 valu
= last_pc_address
;
1554 new = push_context (desc
, valu
);
1558 /* This "symbol" just indicates the end of an inner lexical
1559 context that was started with N_LBRAC. */
1561 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1562 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1563 valu
+= function_start_offset
;
1565 /* On most machines, the block addresses are relative to the
1566 N_SO, the linker did not relocate them (sigh). */
1567 valu
+= last_source_start_addr
;
1570 new = pop_context();
1571 if (desc
!= new->depth
)
1572 complain (&lbrac_mismatch_complaint
, symnum
);
1574 /* Some compilers put the variable decls inside of an
1575 LBRAC/RBRAC block. This macro should be nonzero if this
1576 is true. DESC is N_DESC from the N_RBRAC symbol.
1577 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1578 or the GCC2_COMPILED_SYMBOL. */
1579 #if !defined (VARIABLES_INSIDE_BLOCK)
1580 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1583 /* Can only use new->locals as local symbols here if we're in
1584 gcc or on a machine that puts them before the lbrack. */
1585 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1586 local_symbols
= new->locals
;
1588 /* If this is not the outermost LBRAC...RBRAC pair in the
1589 function, its local symbols preceded it, and are the ones
1590 just recovered from the context stack. Defined the block for them.
1592 If this is the outermost LBRAC...RBRAC pair, there is no
1593 need to do anything; leave the symbols that preceded it
1594 to be attached to the function's own block. However, if
1595 it is so, we need to indicate that we just moved outside
1598 && (context_stack_depth
1599 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
1601 /* FIXME Muzzle a compiler bug that makes end < start. */
1602 if (new->start_addr
> valu
)
1604 complain (&lbrac_rbrac_complaint
);
1605 new->start_addr
= valu
;
1607 /* Make a block for the local symbols within. */
1608 finish_block (0, &local_symbols
, new->old_blocks
,
1609 new->start_addr
, valu
, objfile
);
1613 within_function
= 0;
1615 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
1616 /* Now pop locals of block just finished. */
1617 local_symbols
= new->locals
;
1622 /* This kind of symbol indicates the start of an object file. */
1623 /* Relocate for dynamic loading */
1624 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1628 /* This type of symbol indicates the start of data
1629 for one source file.
1630 Finish the symbol table of the previous source file
1631 (if any) and start accumulating a new symbol table. */
1632 /* Relocate for dynamic loading */
1633 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1635 #ifndef SUN_FIXED_LBRAC_BUG
1636 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1639 #ifdef PCC_SOL_BROKEN
1640 /* pcc bug, occasionally puts out SO for SOL. */
1641 if (context_stack_depth
> 0)
1643 start_subfile (name
, NULL
);
1647 if (last_source_file
)
1649 /* Check if previous symbol was also an N_SO (with some
1650 sanity checks). If so, that one was actually the directory
1651 name, and the current one is the real file name.
1653 if (previous_stab_code
== (int) N_SO
)
1655 patch_subfile_names (current_subfile
, name
);
1656 break; /* Ignore repeated SOs */
1658 end_symtab (valu
, 0, 0, objfile
);
1662 start_symtab (name
, NULL
, valu
);
1667 /* This type of symbol indicates the start of data for
1668 a sub-source-file, one whose contents were copied or
1669 included in the compilation of the main source file
1670 (whose name was given in the N_SO symbol.) */
1671 /* Relocate for dynamic loading */
1672 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1673 start_subfile (name
, current_subfile
->dirname
);
1678 add_new_header_file (name
, valu
);
1679 start_subfile (name
, current_subfile
->dirname
);
1683 start_subfile (pop_subfile (), current_subfile
->dirname
);
1687 add_old_header_file (name
, valu
);
1691 /* This type of "symbol" really just records
1692 one line-number -- core-address correspondence.
1693 Enter it in the line list for this symbol table. */
1694 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1695 valu
+= function_start_offset
;
1696 #ifndef SUN_FIXED_LBRAC_BUG
1697 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
1699 record_line (current_subfile
, desc
, valu
);
1704 error ("Invalid symbol data: common within common at symtab pos %d",
1706 common_block
= local_symbols
;
1707 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
1711 /* Symbols declared since the BCOMM are to have the common block
1712 start address added in when we know it. common_block points to
1713 the first symbol after the BCOMM in the local_symbols list;
1714 copy the list and hang it off the symbol for the common block name
1718 struct symbol
*sym
=
1719 (struct symbol
*) xmmalloc (objfile
-> md
, sizeof (struct symbol
));
1720 memset (sym
, 0, sizeof *sym
);
1721 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
1722 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1723 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
1724 copy_pending (local_symbols
, common_block_i
, common_block
));
1725 i
= hashname (SYMBOL_NAME (sym
));
1726 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1727 global_sym_chain
[i
] = sym
;
1732 /* The following symbol types need to have the appropriate offset added
1733 to their value; then we process symbol definitions in the name. */
1735 case N_STSYM
: /* Static symbol in data seg */
1736 case N_LCSYM
: /* Static symbol in BSS seg */
1737 case N_ROSYM
: /* Static symbol in Read-only data seg */
1738 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
1739 Solaris2's stabs-in-coff makes *most* symbols relative
1740 but leaves a few absolute. N_STSYM and friends sit on the fence.
1741 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1742 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1743 This leaves us no choice but to search for the 'S' or 'V'...
1744 (or pass the whole section_offsets stuff down ONE MORE function
1745 call level, which we really don't want to do). */
1748 p
= strchr (name
, ':');
1749 if (p
!= 0 && p
[1] == 'S')
1751 /* FIXME! We relocate it by the TEXT offset, in case the
1752 whole module moved in memory. But this is wrong, since
1753 the sections can side around independently. */
1754 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1755 goto define_a_symbol
;
1757 /* Since it's not the kludge case, re-dispatch to the right handler. */
1759 case N_STSYM
: goto case_N_STSYM
;
1760 case N_LCSYM
: goto case_N_LCSYM
;
1761 case N_ROSYM
: goto case_N_ROSYM
;
1766 case_N_STSYM
: /* Static symbol in data seg */
1767 case N_DSLINE
: /* Source line number, data seg */
1768 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1769 goto define_a_symbol
;
1771 case_N_LCSYM
: /* Static symbol in BSS seg */
1772 case N_BSLINE
: /* Source line number, bss seg */
1773 /* N_BROWS: overlaps with N_BSLINE */
1774 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1775 goto define_a_symbol
;
1777 case_N_ROSYM
: /* Static symbol in Read-only data seg */
1778 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
1779 goto define_a_symbol
;
1781 case N_ENTRY
: /* Alternate entry point */
1782 /* Relocate for dynamic loading */
1783 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1784 goto define_a_symbol
;
1786 /* The following symbol types don't need the address field relocated,
1787 since it is either unused, or is absolute. */
1789 case N_GSYM
: /* Global variable */
1790 case N_NSYMS
: /* Number of symbols (ultrix) */
1791 case N_NOMAP
: /* No map? (ultrix) */
1792 case N_RSYM
: /* Register variable */
1793 case N_DEFD
: /* Modula-2 GNU module dependency */
1794 case N_SSYM
: /* Struct or union element */
1795 case N_LSYM
: /* Local symbol in stack */
1796 case N_PSYM
: /* Parameter variable */
1797 case N_LENG
: /* Length of preceding symbol type */
1799 define_symbol (valu
, name
, desc
, type
, objfile
);
1802 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1803 for a bunch of other flags, too. Someday we may parse their
1804 flags; for now we ignore theirs and hope they'll ignore ours. */
1805 case N_OPT
: /* Solaris 2: Compiler options */
1808 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
1810 processing_gcc_compilation
= 2;
1811 #if 1 /* Works, but is experimental. -fnf */
1812 if (AUTO_DEMANGLING
)
1814 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1821 /* The following symbol types can be ignored. */
1822 case N_OBJ
: /* Solaris 2: Object file dir and name */
1823 /* N_UNDF: Solaris 2: file separator mark */
1824 /* N_UNDF: -- we will never encounter it, since we only process one
1825 file's symbols at once. */
1826 case N_ENDM
: /* Solaris 2: End of module */
1827 case N_MAIN
: /* Name of main routine. */
1830 /* The following symbol types we don't know how to process. Handle
1831 them in a "default" way, but complain to people who care. */
1833 case N_CATCH
: /* Exception handler catcher */
1834 case N_EHDECL
: /* Exception handler name */
1835 case N_PC
: /* Global symbol in Pascal */
1836 case N_M2C
: /* Modula-2 compilation unit */
1837 /* N_MOD2: overlaps with N_EHDECL */
1838 case N_SCOPE
: /* Modula-2 scope information */
1839 case N_ECOML
: /* End common (local name) */
1840 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
1845 complain (&unknown_symtype_complaint
, local_hex_string(type
));
1847 define_symbol (valu
, name
, desc
, type
, objfile
);
1850 previous_stab_code
= type
;
1853 /* Copy a pending list, used to record the contents of a common
1854 block for later fixup. */
1855 static struct pending
*
1856 copy_pending (beg
, begi
, end
)
1857 struct pending
*beg
;
1859 struct pending
*end
;
1861 struct pending
*new = 0;
1862 struct pending
*next
;
1864 for (next
= beg
; next
!= 0 && (next
!= end
|| begi
< end
->nsyms
);
1865 next
= next
->next
, begi
= 0)
1868 for (j
= begi
; j
< next
->nsyms
; j
++)
1869 add_symbol_to_list (next
->symbol
[j
], &new);
1874 /* Scan and build partial symbols for an ELF symbol file.
1875 This ELF file has already been processed to get its minimal symbols,
1876 and any DWARF symbols that were in it.
1878 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
1881 OBJFILE is the object file we are reading symbols from.
1882 ADDR is the address relative to which the symbols are (e.g.
1883 the base address of the text segment).
1884 MAINLINE is true if we are reading the main symbol
1885 table (as opposed to a shared lib or dynamically loaded file).
1886 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
1888 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
1889 .stabstr section exists.
1891 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
1892 adjusted for elf details. */
1895 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
1896 staboffset
, stabsize
,
1897 stabstroffset
, stabstrsize
)
1898 struct objfile
*objfile
;
1899 struct section_offsets
*section_offsets
;
1901 file_ptr staboffset
;
1902 unsigned int stabsize
;
1903 file_ptr stabstroffset
;
1904 unsigned int stabstrsize
;
1907 bfd
*sym_bfd
= objfile
->obfd
;
1908 char *name
= bfd_get_filename (sym_bfd
);
1909 struct dbx_symfile_info
*info
;
1911 /* There is already a dbx_symfile_info allocated by our caller.
1912 It might even contain some info from the ELF symtab to help us. */
1913 info
= (struct dbx_symfile_info
*) objfile
->sym_private
;
1915 DBX_TEXT_SECT (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
1916 if (!DBX_TEXT_SECT (objfile
))
1917 error ("Can't find .text section in symbol file");
1919 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
1920 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
1921 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
1922 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
1923 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
1925 if (stabstrsize
< 0 /* FIXME: stabstrsize is unsigned; never true! */
1926 || stabstrsize
> bfd_get_size (sym_bfd
))
1927 error ("ridiculous string table size: %d bytes", stabstrsize
);
1928 DBX_STRINGTAB (objfile
) = (char *)
1929 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+1);
1931 /* Now read in the string table in one big gulp. */
1933 val
= bfd_seek (sym_bfd
, stabstroffset
, L_SET
);
1935 perror_with_name (name
);
1936 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
1937 if (val
!= stabstrsize
)
1938 perror_with_name (name
);
1940 stabsread_new_init ();
1941 buildsym_new_init ();
1942 free_header_files ();
1943 init_header_files ();
1944 install_minimal_symbols (objfile
);
1946 processing_acc_compilation
= 1;
1948 /* In an elf file, we've already installed the minimal symbols that came
1949 from the elf (non-stab) symbol table, so always act like an
1950 incremental load here. */
1951 dbx_symfile_read (objfile
, section_offsets
, 0);
1954 /* Scan and build partial symbols for a PA symbol file.
1955 This PA file has already been processed to get its minimal symbols.
1957 OBJFILE is the object file we are reading symbols from.
1958 ADDR is the address relative to which the symbols are (e.g.
1959 the base address of the text segment).
1960 MAINLINE is true if we are reading the main symbol
1961 table (as opposed to a shared lib or dynamically loaded file).
1966 pastab_build_psymtabs (objfile
, section_offsets
, mainline
)
1967 struct objfile
*objfile
;
1968 struct section_offsets
*section_offsets
;
1971 free_header_files ();
1972 init_header_files ();
1974 /* In a PA file, we've already installed the minimal symbols that came
1975 from the PA (non-stab) symbol table, so always act like an
1976 incremental load here. */
1978 dbx_symfile_read (objfile
, section_offsets
, mainline
);
1981 /* Parse the user's idea of an offset for dynamic linking, into our idea
1982 of how to represent it for fast symbol reading. */
1984 static struct section_offsets
*
1985 dbx_symfile_offsets (objfile
, addr
)
1986 struct objfile
*objfile
;
1989 struct section_offsets
*section_offsets
;
1992 section_offsets
= (struct section_offsets
*)
1993 obstack_alloc (&objfile
-> psymbol_obstack
,
1994 sizeof (struct section_offsets
) +
1995 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
1997 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
1998 ANOFFSET (section_offsets
, i
) = addr
;
2000 return section_offsets
;
2003 /* Register our willingness to decode symbols for SunOS and a.out and
2004 b.out files handled by BFD... */
2005 static struct sym_fns sunos_sym_fns
=
2007 "sunOs", /* sym_name: name or name prefix of BFD target type */
2008 6, /* sym_namelen: number of significant sym_name chars */
2009 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2010 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2011 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2012 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2013 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2014 NULL
/* next: pointer to next struct sym_fns */
2017 static struct sym_fns aout_sym_fns
=
2019 "a.out", /* sym_name: name or name prefix of BFD target type */
2020 5, /* sym_namelen: number of significant sym_name chars */
2021 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2022 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2023 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2024 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2025 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2026 NULL
/* next: pointer to next struct sym_fns */
2029 static struct sym_fns bout_sym_fns
=
2031 "b.out", /* sym_name: name or name prefix of BFD target type */
2032 5, /* sym_namelen: number of significant sym_name chars */
2033 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2034 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2035 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2036 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2037 dbx_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2038 NULL
/* next: pointer to next struct sym_fns */
2042 _initialize_dbxread ()
2044 add_symtab_fns(&sunos_sym_fns
);
2045 add_symtab_fns(&aout_sym_fns
);
2046 add_symtab_fns(&bout_sym_fns
);