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>
46 #include <sys/param.h>
53 #include "breakpoint.h"
56 #include "gdbcore.h" /* for bfd stuff */
57 #include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
58 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
62 #include "stabsread.h"
63 #include "gdb-stabs.h"
65 #include "language.h" /* Needed inside partial-stab.h */
66 #include "complaints.h"
68 #include "aout/aout64.h"
69 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
71 /* Each partial symbol table entry contains a pointer to private data for the
72 read_symtab() function to use when expanding a partial symbol table entry
73 to a full symbol table entry.
75 For dbxread this structure contains the offset within the file symbol table
76 of first local symbol for this file, and length (in bytes) of the section
77 of the symbol table devoted to this file's symbols (actually, the section
78 bracketed may contain more than just this file's symbols). It also contains
79 further information needed to locate the symbols if they are in an ELF file.
81 If ldsymlen is 0, the only reason for this thing's existence is the
82 dependency list. Nothing else will happen when it is read in. */
84 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
85 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
86 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
87 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
88 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
89 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
90 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
98 int file_string_offset;
101 /* Macro to determine which symbols to ignore when reading the first symbol
102 of a file. Some machines override this definition. */
103 #ifndef IGNORE_SYMBOL
104 /* This code is used on Ultrix systems. Ignore it */
105 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
108 /* Macro for name of symbol to indicate a file compiled with gcc. */
109 #ifndef GCC_COMPILED_FLAG_SYMBOL
110 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
113 /* Macro for name of symbol to indicate a file compiled with gcc2. */
114 #ifndef GCC2_COMPILED_FLAG_SYMBOL
115 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
118 /* Define this as 1 if a pcc declaration of a char or short argument
119 gives the correct address. Otherwise assume pcc gives the
120 address of the corresponding int, which is not the same on a
121 big-endian machine. */
123 #ifndef BELIEVE_PCC_PROMOTION
124 #define BELIEVE_PCC_PROMOTION 0
127 /* Remember what we deduced to be the source language of this psymtab. */
129 static enum language psymtab_language = language_unknown;
131 /* Nonzero means give verbose info on gdb action. From main.c. */
132 extern int info_verbose;
134 /* The BFD for this file -- implicit parameter to next_symbol_text. */
136 static bfd *symfile_bfd;
138 /* The size of each symbol in the symbol file (in external form).
139 This is set by dbx_symfile_read when building psymtabs, and by
140 dbx_psymtab_to_symtab when building symtabs. */
142 static unsigned symbol_size;
144 /* This is the offset of the symbol table in the executable file */
145 static unsigned symbol_table_offset;
147 /* This is the offset of the string table in the executable file */
148 static unsigned string_table_offset;
150 /* For elf+stab executables, the n_strx field is not a simple index
151 into the string table. Instead, each .o file has a base offset
152 in the string table, and the associated symbols contain offsets
153 from this base. The following two variables contain the base
154 offset for the current and next .o files. */
155 static unsigned int file_string_table_offset;
156 static unsigned int next_file_string_table_offset;
158 /* Complaints about the symbols we have encountered. */
160 struct complaint lbrac_complaint =
161 {"bad block start address patched", 0, 0};
163 struct complaint string_table_offset_complaint =
164 {"bad string table offset in symbol %d", 0, 0};
166 struct complaint unknown_symtype_complaint =
167 {"unknown symbol type %s", 0, 0};
169 struct complaint unknown_symchar_complaint =
170 {"unknown symbol type character `%c'", 0, 0};
172 struct complaint lbrac_rbrac_complaint =
173 {"block start larger than block end", 0, 0};
175 struct complaint lbrac_unmatched_complaint =
176 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
178 struct complaint lbrac_mismatch_complaint =
179 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
181 struct complaint repeated_header_complaint =
182 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
184 struct complaint repeated_header_name_complaint =
185 {"\"repeated\" header file not previously seen, named %s", 0, 0};
187 /* During initial symbol readin, we need to have a structure to keep
188 track of which psymtabs have which bincls in them. This structure
189 is used during readin to setup the list of dependencies within each
190 partial symbol table. */
192 struct header_file_location
194 char *name; /* Name of header file */
195 int instance; /* See above */
196 struct partial_symtab *pst; /* Partial symtab that has the
197 BINCL/EINCL defs for this file */
200 /* The actual list and controling variables */
201 static struct header_file_location *bincl_list, *next_bincl;
202 static int bincls_allocated;
204 /* Local function prototypes */
207 free_header_files PARAMS ((void));
210 init_header_files PARAMS ((void));
212 static struct pending *
213 copy_pending PARAMS ((struct pending *, int, struct pending *));
216 read_ofile_symtab PARAMS ((struct partial_symtab *));
219 dbx_psymtab_to_symtab PARAMS ((struct partial_symtab *));
222 dbx_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
225 read_dbx_symtab PARAMS ((struct section_offsets *, struct objfile *,
229 free_bincl_list PARAMS ((struct objfile *));
231 static struct partial_symtab *
232 find_corresponding_bincl_psymtab PARAMS ((char *, int));
235 add_bincl_to_list PARAMS ((struct partial_symtab *, char *, int));
238 init_bincl_list PARAMS ((int, struct objfile *));
241 init_psymbol_list PARAMS ((struct objfile *));
244 dbx_next_symbol_text PARAMS ((void));
247 fill_symbuf PARAMS ((bfd *));
250 dbx_symfile_init PARAMS ((struct objfile *));
253 dbx_new_init PARAMS ((struct objfile *));
256 dbx_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
259 dbx_symfile_finish PARAMS ((struct objfile *));
262 record_minimal_symbol PARAMS ((char *, CORE_ADDR, int, struct objfile *));
265 add_new_header_file PARAMS ((char *, int));
268 add_old_header_file PARAMS ((char *, int));
271 add_this_object_header_file PARAMS ((int));
273 /* Free up old header file tables */
280 if (header_files != NULL)
282 for (i = 0; i < n_header_files; i++)
284 free (header_files[i].name);
286 free ((PTR)header_files);
290 if (this_object_header_files)
292 free ((PTR)this_object_header_files);
293 this_object_header_files = NULL;
295 n_allocated_header_files = 0;
296 n_allocated_this_object_header_files = 0;
299 /* Allocate new header file tables */
305 n_allocated_header_files = 10;
306 header_files = (struct header_file *)
307 xmalloc (10 * sizeof (struct header_file));
309 n_allocated_this_object_header_files = 10;
310 this_object_header_files = (int *) xmalloc (10 * sizeof (int));
313 /* Add header file number I for this object file
314 at the next successive FILENUM. */
317 add_this_object_header_file (i)
320 if (n_this_object_header_files == n_allocated_this_object_header_files)
322 n_allocated_this_object_header_files *= 2;
323 this_object_header_files
324 = (int *) xrealloc ((char *) this_object_header_files,
325 n_allocated_this_object_header_files * sizeof (int));
328 this_object_header_files[n_this_object_header_files++] = i;
331 /* Add to this file an "old" header file, one already seen in
332 a previous object file. NAME is the header file's name.
333 INSTANCE is its instance code, to select among multiple
334 symbol tables for the same header file. */
337 add_old_header_file (name, instance)
341 register struct header_file *p = header_files;
344 for (i = 0; i < n_header_files; i++)
345 if (STREQ (p[i].name, name) && instance == p[i].instance)
347 add_this_object_header_file (i);
350 complain (&repeated_header_complaint, symnum);
351 complain (&repeated_header_name_complaint, name);
354 /* Add to this file a "new" header file: definitions for its types follow.
355 NAME is the header file's name.
356 Most often this happens only once for each distinct header file,
357 but not necessarily. If it happens more than once, INSTANCE has
358 a different value each time, and references to the header file
359 use INSTANCE values to select among them.
361 dbx output contains "begin" and "end" markers for each new header file,
362 but at this level we just need to know which files there have been;
363 so we record the file when its "begin" is seen and ignore the "end". */
366 add_new_header_file (name, instance)
372 /* Make sure there is room for one more header file. */
374 if (n_header_files == n_allocated_header_files)
376 n_allocated_header_files *= 2;
377 header_files = (struct header_file *)
378 xrealloc ((char *) header_files,
379 (n_allocated_header_files * sizeof (struct header_file)));
382 /* Create an entry for this header file. */
384 i = n_header_files++;
385 header_files[i].name = savestring (name, strlen(name));
386 header_files[i].instance = instance;
387 header_files[i].length = 10;
388 header_files[i].vector
389 = (struct type **) xmalloc (10 * sizeof (struct type *));
390 memset (header_files[i].vector, 0, 10 * sizeof (struct type *));
392 add_this_object_header_file (i);
396 static struct type **
397 explicit_lookup_type (real_filenum, index)
398 int real_filenum, index;
400 register struct header_file *f = &header_files[real_filenum];
402 if (index >= f->length)
405 f->vector = (struct type **)
406 xrealloc (f->vector, f->length * sizeof (struct type *));
407 bzero (&f->vector[f->length / 2],
408 f->length * sizeof (struct type *) / 2);
410 return &f->vector[index];
415 record_minimal_symbol (name, address, type, objfile)
419 struct objfile *objfile;
421 enum minimal_symbol_type ms_type;
423 switch (type &~ N_EXT) {
424 case N_TEXT: ms_type = mst_text; break;
425 case N_DATA: ms_type = mst_data; break;
426 case N_BSS: ms_type = mst_bss; break;
427 case N_ABS: ms_type = mst_abs; break;
429 case N_SETV: ms_type = mst_data; break;
431 default: ms_type = mst_unknown; break;
434 prim_record_minimal_symbol (obsavestring (name, strlen (name), &objfile -> symbol_obstack),
438 /* Scan and build partial symbols for a symbol file.
439 We have been initialized by a call to dbx_symfile_init, which
440 put all the relevant info into a "struct dbx_symfile_info",
441 hung off the objfile structure.
443 SECTION_OFFSETS contains offsets relative to which the symbols in the
444 various sections are (depending where the sections were actually loaded).
445 MAINLINE is true if we are reading the main symbol
446 table (as opposed to a shared lib or dynamically loaded file). */
449 dbx_symfile_read (objfile, section_offsets, mainline)
450 struct objfile *objfile;
451 struct section_offsets *section_offsets;
452 int mainline; /* FIXME comments above */
457 sym_bfd = objfile->obfd;
458 val = bfd_seek (objfile->obfd, DBX_SYMTAB_OFFSET (objfile), L_SET);
460 perror_with_name (objfile->name);
462 /* If we are reinitializing, or if we have never loaded syms yet, init */
463 if (mainline || objfile->global_psymbols.size == 0 || objfile->static_psymbols.size == 0)
464 init_psymbol_list (objfile);
466 symbol_size = DBX_SYMBOL_SIZE (objfile);
467 symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
470 make_cleanup (really_free_pendings, 0);
472 init_minimal_symbol_collection ();
473 make_cleanup (discard_minimal_symbols, 0);
475 /* Now that the symbol table data of the executable file are all in core,
476 process them and define symbols accordingly. */
478 read_dbx_symtab (section_offsets, objfile,
479 bfd_section_vma (sym_bfd, DBX_TEXT_SECT (objfile)),
480 bfd_section_size (sym_bfd, DBX_TEXT_SECT (objfile)));
482 /* Install any minimal symbols that have been collected as the current
483 minimal symbols for this objfile. */
485 install_minimal_symbols (objfile);
487 if (!have_partial_symbols ()) {
489 printf_filtered ("(no debugging symbols found)...");
494 /* Initialize anything that needs initializing when a completely new
495 symbol file is specified (not just adding some symbols from another
496 file, e.g. a shared library). */
499 dbx_new_init (ignore)
500 struct objfile *ignore;
502 stabsread_new_init ();
503 buildsym_new_init ();
504 init_header_files ();
508 /* dbx_symfile_init ()
509 is the dbx-specific initialization routine for reading symbols.
510 It is passed a struct objfile which contains, among other things,
511 the BFD for the file whose symbols are being read, and a slot for a pointer
512 to "private data" which we fill with goodies.
514 We read the string table into malloc'd space and stash a pointer to it.
516 Since BFD doesn't know how to read debug symbols in a format-independent
517 way (and may never do so...), we have to do it ourselves. We will never
518 be called unless this is an a.out (or very similar) file.
519 FIXME, there should be a cleaner peephole into the BFD environment here. */
521 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
524 dbx_symfile_init (objfile)
525 struct objfile *objfile;
528 bfd *sym_bfd = objfile->obfd;
529 char *name = bfd_get_filename (sym_bfd);
530 unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
532 /* Allocate struct to keep track of the symfile */
533 objfile->sym_private = (PTR)
534 xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
536 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
537 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
538 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
540 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
542 DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
543 DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
544 if (!DBX_TEXT_SECT (objfile))
545 error ("Can't find .text section in symbol file");
547 DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
548 DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
549 DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
551 /* Read the string table and stash it away in the psymbol_obstack. It is
552 only needed as long as we need to expand psymbols into full symbols,
553 so when we blow away the psymbol the string table goes away as well.
554 Note that gdb used to use the results of attempting to malloc the
555 string table, based on the size it read, as a form of sanity check
556 for botched byte swapping, on the theory that a byte swapped string
557 table size would be so totally bogus that the malloc would fail. Now
558 that we put in on the psymbol_obstack, we can't do this since gdb gets
559 a fatal error (out of virtual memory) if the size is bogus. We can
560 however at least check to see if the size is less than the size of
561 the size field itself, or larger than the size of the entire file.
562 Note that all valid string tables have a size greater than zero, since
563 the bytes used to hold the size are included in the count. */
565 if (STRING_TABLE_OFFSET == 0)
567 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
568 will never be zero, even when there is no string table. This
569 would appear to be a bug in bfd. */
570 DBX_STRINGTAB_SIZE (objfile) = 0;
571 DBX_STRINGTAB (objfile) = NULL;
575 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, L_SET);
577 perror_with_name (name);
579 memset ((PTR) size_temp, 0, sizeof (size_temp));
580 val = bfd_read ((PTR) size_temp, sizeof (size_temp), 1, sym_bfd);
583 perror_with_name (name);
587 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
588 EOF if there is no string table, and attempting to read the size
589 from EOF will read zero bytes. */
590 DBX_STRINGTAB_SIZE (objfile) = 0;
591 DBX_STRINGTAB (objfile) = NULL;
595 /* Read some data that would appear to be the string table size.
596 If there really is a string table, then it is probably the right
597 size. Byteswap if necessary and validate the size. Note that
598 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
599 random data that happened to be at STRING_TABLE_OFFSET, because
600 bfd can't tell us there is no string table, the sanity checks may
601 or may not catch this. */
602 DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
604 if (DBX_STRINGTAB_SIZE (objfile) < sizeof (size_temp)
605 || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
606 error ("ridiculous string table size (%d bytes).",
607 DBX_STRINGTAB_SIZE (objfile));
609 DBX_STRINGTAB (objfile) =
610 (char *) obstack_alloc (&objfile -> psymbol_obstack,
611 DBX_STRINGTAB_SIZE (objfile));
613 /* Now read in the string table in one big gulp. */
615 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, L_SET);
617 perror_with_name (name);
618 val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
620 if (val != DBX_STRINGTAB_SIZE (objfile))
621 perror_with_name (name);
626 /* Perform any local cleanups required when we are done with a particular
627 objfile. I.E, we are in the process of discarding all symbol information
628 for an objfile, freeing up all memory held for it, and unlinking the
629 objfile struct from the global list of known objfiles. */
632 dbx_symfile_finish (objfile)
633 struct objfile *objfile;
635 if (objfile->sym_private != NULL)
637 mfree (objfile -> md, objfile->sym_private);
639 free_header_files ();
643 /* Buffer for reading the symbol table entries. */
644 static struct internal_nlist symbuf[4096];
645 static int symbuf_idx;
646 static int symbuf_end;
648 /* Name of last function encountered. Used in Solaris to approximate
649 object file boundaries. */
650 static char *last_function_name;
652 /* The address in memory of the string table of the object file we are
653 reading (which might not be the "main" object file, but might be a
654 shared library or some other dynamically loaded thing). This is set
655 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
656 when building symtabs, and is used only by next_symbol_text. */
657 static char *stringtab_global;
659 /* Refill the symbol table input buffer
660 and set the variables that control fetching entries from it.
661 Reports an error if no data available.
662 This function can read past the end of the symbol table
663 (into the string table) but this does no harm. */
666 fill_symbuf (sym_bfd)
669 int nbytes = bfd_read ((PTR)symbuf, sizeof (symbuf), 1, sym_bfd);
671 perror_with_name (bfd_get_filename (sym_bfd));
672 else if (nbytes == 0)
673 error ("Premature end of file reading symbol table");
674 symbuf_end = nbytes / symbol_size;
678 #define SWAP_SYMBOL(symp, abfd) \
680 (symp)->n_strx = bfd_h_get_32(abfd, \
681 (unsigned char *)&(symp)->n_strx); \
682 (symp)->n_desc = bfd_h_get_16 (abfd, \
683 (unsigned char *)&(symp)->n_desc); \
684 (symp)->n_value = bfd_h_get_32 (abfd, \
685 (unsigned char *)&(symp)->n_value); \
688 /* Invariant: The symbol pointed to by symbuf_idx is the first one
689 that hasn't been swapped. Swap the symbol at the same time
690 that symbuf_idx is incremented. */
692 /* dbx allows the text of a symbol name to be continued into the
693 next symbol name! When such a continuation is encountered
694 (a \ at the end of the text of a name)
695 call this function to get the continuation. */
698 dbx_next_symbol_text ()
700 if (symbuf_idx == symbuf_end)
701 fill_symbuf (symfile_bfd);
703 SWAP_SYMBOL(&symbuf[symbuf_idx], symfile_bfd);
704 return symbuf[symbuf_idx++].n_strx + stringtab_global
705 + file_string_table_offset;
708 /* Initializes storage for all of the partial symbols that will be
709 created by read_dbx_symtab and subsidiaries. */
712 init_psymbol_list (objfile)
713 struct objfile *objfile;
715 /* Free any previously allocated psymbol lists. */
716 if (objfile -> global_psymbols.list)
717 mfree (objfile -> md, (PTR)objfile -> global_psymbols.list);
718 if (objfile -> static_psymbols.list)
719 mfree (objfile -> md, (PTR)objfile -> static_psymbols.list);
721 /* Current best guess is that there are approximately a twentieth
722 of the total symbols (in a debugging file) are global or static
724 objfile -> global_psymbols.size = DBX_SYMCOUNT (objfile) / 10;
725 objfile -> static_psymbols.size = DBX_SYMCOUNT (objfile) / 10;
726 objfile -> global_psymbols.next = objfile -> global_psymbols.list = (struct partial_symbol *)
727 xmmalloc (objfile -> md, objfile -> global_psymbols.size * sizeof (struct partial_symbol));
728 objfile -> static_psymbols.next = objfile -> static_psymbols.list = (struct partial_symbol *)
729 xmmalloc (objfile -> md, objfile -> static_psymbols.size * sizeof (struct partial_symbol));
732 /* Initialize the list of bincls to contain none and have some
736 init_bincl_list (number, objfile)
738 struct objfile *objfile;
740 bincls_allocated = number;
741 next_bincl = bincl_list = (struct header_file_location *)
742 xmmalloc (objfile -> md, bincls_allocated * sizeof(struct header_file_location));
745 /* Add a bincl to the list. */
748 add_bincl_to_list (pst, name, instance)
749 struct partial_symtab *pst;
753 if (next_bincl >= bincl_list + bincls_allocated)
755 int offset = next_bincl - bincl_list;
756 bincls_allocated *= 2;
757 bincl_list = (struct header_file_location *)
758 xmrealloc (pst->objfile->md, (char *)bincl_list,
759 bincls_allocated * sizeof (struct header_file_location));
760 next_bincl = bincl_list + offset;
762 next_bincl->pst = pst;
763 next_bincl->instance = instance;
764 next_bincl++->name = name;
767 /* Given a name, value pair, find the corresponding
768 bincl in the list. Return the partial symtab associated
769 with that header_file_location. */
771 static struct partial_symtab *
772 find_corresponding_bincl_psymtab (name, instance)
776 struct header_file_location *bincl;
778 for (bincl = bincl_list; bincl < next_bincl; bincl++)
779 if (bincl->instance == instance
780 && STREQ (name, bincl->name))
783 return (struct partial_symtab *) 0;
786 /* Free the storage allocated for the bincl list. */
789 free_bincl_list (objfile)
790 struct objfile *objfile;
792 mfree (objfile -> md, (PTR)bincl_list);
793 bincls_allocated = 0;
796 /* Given pointers to an a.out symbol table in core containing dbx
797 style data, setup partial_symtab's describing each source file for
798 which debugging information is available.
799 SYMFILE_NAME is the name of the file we are reading from
800 and SECTION_OFFSETS is the set of offsets for the various sections
801 of the file (a set of zeros if the mainline program). */
804 read_dbx_symtab (section_offsets, objfile, text_addr, text_size)
805 struct section_offsets *section_offsets;
806 struct objfile *objfile;
810 register struct internal_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch */
811 register char *namestring;
813 int past_first_source_file = 0;
814 CORE_ADDR last_o_file_start = 0;
815 struct cleanup *old_chain;
818 /* End of the text segment of the executable file. */
819 CORE_ADDR end_of_text_addr;
821 /* Current partial symtab */
822 struct partial_symtab *pst;
824 /* List of current psymtab's include files */
825 char **psymtab_include_list;
826 int includes_allocated;
829 /* Index within current psymtab dependency list */
830 struct partial_symtab **dependency_list;
831 int dependencies_used, dependencies_allocated;
833 /* FIXME. We probably want to change stringtab_global rather than add this
834 while processing every symbol entry. FIXME. */
835 file_string_table_offset = 0;
836 next_file_string_table_offset = 0;
838 stringtab_global = DBX_STRINGTAB (objfile);
840 pst = (struct partial_symtab *) 0;
842 includes_allocated = 30;
844 psymtab_include_list = (char **) alloca (includes_allocated *
847 dependencies_allocated = 30;
848 dependencies_used = 0;
850 (struct partial_symtab **) alloca (dependencies_allocated *
851 sizeof (struct partial_symtab *));
853 old_chain = make_cleanup (free_objfile, objfile);
855 /* Init bincl list */
856 init_bincl_list (20, objfile);
857 make_cleanup (free_bincl_list, objfile);
859 last_source_file = NULL;
861 #ifdef END_OF_TEXT_DEFAULT
862 end_of_text_addr = END_OF_TEXT_DEFAULT;
864 end_of_text_addr = text_addr + section_offsets->offsets[SECT_OFF_TEXT]
865 + text_size; /* Relocate */
868 symfile_bfd = objfile->obfd; /* For next_text_symbol */
869 abfd = objfile->obfd;
870 symbuf_end = symbuf_idx = 0;
871 next_symbol_text_func = dbx_next_symbol_text;
873 for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
875 /* Get the symbol for this run and pull out some info */
876 QUIT; /* allow this to be interruptable */
877 if (symbuf_idx == symbuf_end)
879 bufp = &symbuf[symbuf_idx++];
882 * Special case to speed up readin.
884 if (bufp->n_type == (unsigned char)N_SLINE) continue;
886 SWAP_SYMBOL (bufp, abfd);
888 /* Ok. There is a lot of code duplicated in the rest of this
889 switch statement (for efficiency reasons). Since I don't
890 like duplicating code, I will do my penance here, and
891 describe the code which is duplicated:
893 *) The assignment to namestring.
894 *) The call to strchr.
895 *) The addition of a partial symbol the the two partial
896 symbol lists. This last is a large section of code, so
897 I've imbedded it in the following macro.
900 /* Set namestring based on bufp. If the string table index is invalid,
901 give a fake name, and print a single error message per symbol file read,
902 rather than abort the symbol reading or flood the user with messages. */
904 /*FIXME: Too many adds and indirections in here for the inner loop. */
905 #define SET_NAMESTRING()\
906 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
907 DBX_STRINGTAB_SIZE (objfile)) { \
908 complain (&string_table_offset_complaint, symnum); \
909 namestring = "foo"; \
911 namestring = bufp->n_strx + file_string_table_offset + \
912 DBX_STRINGTAB (objfile)
914 #define CUR_SYMBOL_TYPE bufp->n_type
915 #define CUR_SYMBOL_VALUE bufp->n_value
917 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
918 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
919 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
920 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
922 #include "partial-stab.h"
925 /* If there's stuff to be cleaned up, clean it up. */
926 if (DBX_SYMCOUNT (objfile) > 0 /* We have some syms */
927 /*FIXME, does this have a bug at start address 0? */
929 && objfile -> ei.entry_point < bufp->n_value
930 && objfile -> ei.entry_point >= last_o_file_start)
932 objfile -> ei.entry_file_lowpc = last_o_file_start;
933 objfile -> ei.entry_file_highpc = bufp->n_value;
938 end_psymtab (pst, psymtab_include_list, includes_used,
939 symnum * symbol_size, end_of_text_addr,
940 dependency_list, dependencies_used);
943 free_bincl_list (objfile);
944 discard_cleanups (old_chain);
947 /* Allocate and partially fill a partial symtab. It will be
948 completely filled at the end of the symbol list.
950 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
951 is the address relative to which its symbols are (incremental) or 0
955 struct partial_symtab *
956 start_psymtab (objfile, section_offsets,
957 filename, textlow, ldsymoff, global_syms, static_syms)
958 struct objfile *objfile;
959 struct section_offsets *section_offsets;
963 struct partial_symbol *global_syms;
964 struct partial_symbol *static_syms;
966 struct partial_symtab *result =
967 start_psymtab_common(objfile, section_offsets,
968 filename, textlow, global_syms, static_syms);
970 result->read_symtab_private = (char *)
971 obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
972 LDSYMOFF(result) = ldsymoff;
973 result->read_symtab = dbx_psymtab_to_symtab;
974 SYMBOL_SIZE(result) = symbol_size;
975 SYMBOL_OFFSET(result) = symbol_table_offset;
976 STRING_OFFSET(result) = string_table_offset;
977 FILE_STRING_OFFSET(result) = file_string_table_offset;
979 /* If we're handling an ELF file, drag some section-relocation info
980 for this source file out of the ELF symbol table, to compensate for
981 Sun brain death. This replaces the section_offsets in this psymtab,
983 elfstab_offset_sections (objfile, result);
985 /* Deduce the source language from the filename for this psymtab. */
986 psymtab_language = deduce_language_from_filename (filename);
991 /* Close off the current usage of a partial_symbol table entry. This
992 involves setting the correct number of includes (with a realloc),
993 setting the high text mark, setting the symbol length in the
994 executable, and setting the length of the global and static lists
997 The global symbols and static symbols are then seperately sorted.
999 Then the partial symtab is put on the global list.
1000 *** List variables and peculiarities of same. ***
1004 end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
1005 capping_text, dependency_list, number_dependencies)
1006 struct partial_symtab *pst;
1007 char **include_list;
1009 int capping_symbol_offset;
1010 CORE_ADDR capping_text;
1011 struct partial_symtab **dependency_list;
1012 int number_dependencies;
1013 /* struct partial_symbol *capping_global, *capping_static;*/
1016 struct partial_symtab *p1;
1017 struct objfile *objfile = pst -> objfile;
1019 if (capping_symbol_offset != -1)
1020 LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
1021 pst->texthigh = capping_text;
1023 /* Under Solaris, the N_SO symbols always have a value of 0,
1024 instead of the usual address of the .o file. Therefore,
1025 we have to do some tricks to fill in texthigh and textlow.
1026 The first trick is in partial-stab.h: if we see a static
1027 or global function, and the textlow for the current pst
1028 is still 0, then we use that function's address for
1029 the textlow of the pst.
1031 Now, to fill in texthigh, we remember the last function seen
1032 in the .o file (also in partial-stab.h). Also, there's a hack in
1033 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1034 to here via the misc_info field. Therefore, we can fill in
1035 a reliable texthigh by taking the address plus size of the
1036 last function in the file.
1038 Unfortunately, that does not cover the case where the last function
1039 in the file is static. See the paragraph below for more comments
1042 Finally, if we have a valid textlow for the current file, we run
1043 down the partial_symtab_list filling in previous texthighs that
1044 are still unknown. */
1046 if (pst->texthigh == 0 && last_function_name) {
1049 struct minimal_symbol *minsym;
1051 p = strchr (last_function_name, ':');
1053 p = last_function_name;
1054 n = p - last_function_name;
1056 strncpy (p, last_function_name, n);
1059 minsym = lookup_minimal_symbol (p, objfile);
1062 pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) +
1063 (int) MSYMBOL_INFO (minsym);
1065 /* This file ends with a static function, and it's
1066 difficult to imagine how hard it would be to track down
1067 the elf symbol. Luckily, most of the time no one will notice,
1068 since the next file will likely be compiled with -g, so
1069 the code below will copy the first fuction's start address
1070 back to our texthigh variable. (Also, if this file is the
1071 last one in a dynamically linked program, texthigh already
1072 has the right value.) If the next file isn't compiled
1073 with -g, then the last function in this file winds up owning
1074 all of the text space up to the next -g file, or the end (minus
1075 shared libraries). This only matters for single stepping,
1076 and even then it will still work, except that it will single
1077 step through all of the covered functions, instead of setting
1078 breakpoints around them as it usualy does. This makes it
1079 pretty slow, but at least it doesn't fail.
1081 We can fix this with a fairly big change to bfd, but we need
1082 to coordinate better with Cygnus if we want to do that. FIXME. */
1084 last_function_name = NULL;
1087 /* this test will be true if the last .o file is only data */
1088 if (pst->textlow == 0)
1089 pst->textlow = pst->texthigh;
1091 /* If we know our own starting text address, then walk through all other
1092 psymtabs for this objfile, and if any didn't know their ending text
1093 address, set it to our starting address. Take care to not set our
1094 own ending address to our starting address, nor to set addresses on
1095 `dependency' files that have both textlow and texthigh zero. */
1097 ALL_OBJFILE_PSYMTABS (objfile, p1) {
1098 if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst) {
1099 p1->texthigh = pst->textlow;
1100 /* if this file has only data, then make textlow match texthigh */
1101 if (p1->textlow == 0)
1102 p1->textlow = p1->texthigh;
1107 /* End of kludge for patching Solaris textlow and texthigh. */
1110 pst->n_global_syms =
1111 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
1112 pst->n_static_syms =
1113 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
1115 pst->number_of_dependencies = number_dependencies;
1116 if (number_dependencies)
1118 pst->dependencies = (struct partial_symtab **)
1119 obstack_alloc (&objfile->psymbol_obstack,
1120 number_dependencies * sizeof (struct partial_symtab *));
1121 memcpy (pst->dependencies, dependency_list,
1122 number_dependencies * sizeof (struct partial_symtab *));
1125 pst->dependencies = 0;
1127 for (i = 0; i < num_includes; i++)
1129 struct partial_symtab *subpst =
1130 allocate_psymtab (include_list[i], objfile);
1132 subpst->section_offsets = pst->section_offsets;
1133 subpst->read_symtab_private =
1134 (char *) obstack_alloc (&objfile->psymbol_obstack,
1135 sizeof (struct symloc));
1139 subpst->texthigh = 0;
1141 /* We could save slight bits of space by only making one of these,
1142 shared by the entire set of include files. FIXME-someday. */
1143 subpst->dependencies = (struct partial_symtab **)
1144 obstack_alloc (&objfile->psymbol_obstack,
1145 sizeof (struct partial_symtab *));
1146 subpst->dependencies[0] = pst;
1147 subpst->number_of_dependencies = 1;
1149 subpst->globals_offset =
1150 subpst->n_global_syms =
1151 subpst->statics_offset =
1152 subpst->n_static_syms = 0;
1156 subpst->read_symtab = pst->read_symtab;
1159 sort_pst_symbols (pst);
1161 /* If there is already a psymtab or symtab for a file of this name, remove it.
1162 (If there is a symtab, more drastic things also happen.)
1163 This happens in VxWorks. */
1164 free_named_symtabs (pst->filename);
1166 if (num_includes == 0
1167 && number_dependencies == 0
1168 && pst->n_global_syms == 0
1169 && pst->n_static_syms == 0) {
1170 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1171 it is on the obstack, but we can forget to chain it on the list. */
1172 struct partial_symtab *prev_pst;
1174 /* First, snip it out of the psymtab chain */
1176 if (pst->objfile->psymtabs == pst)
1177 pst->objfile->psymtabs = pst->next;
1179 for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
1180 if (prev_pst->next == pst)
1181 prev_pst->next = pst->next;
1183 /* Next, put it on a free list for recycling */
1185 pst->next = pst->objfile->free_psymtabs;
1186 pst->objfile->free_psymtabs = pst;
1191 dbx_psymtab_to_symtab_1 (pst)
1192 struct partial_symtab *pst;
1194 struct cleanup *old_chain;
1202 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1207 /* Read in all partial symtabs on which this one is dependent */
1208 for (i = 0; i < pst->number_of_dependencies; i++)
1209 if (!pst->dependencies[i]->readin)
1211 /* Inform about additional files that need to be read in. */
1214 fputs_filtered (" ", stdout);
1216 fputs_filtered ("and ", stdout);
1218 printf_filtered ("%s...", pst->dependencies[i]->filename);
1219 wrap_here (""); /* Flush output */
1222 dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
1225 if (LDSYMLEN(pst)) /* Otherwise it's a dummy */
1227 /* Init stuff necessary for reading in symbols */
1230 old_chain = make_cleanup (really_free_pendings, 0);
1231 file_string_table_offset = FILE_STRING_OFFSET (pst);
1232 symbol_size = SYMBOL_SIZE (pst);
1234 /* Read in this file's symbols */
1235 bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), L_SET);
1236 read_ofile_symtab (pst);
1237 sort_symtab_syms (pst->symtab);
1239 do_cleanups (old_chain);
1245 /* Read in all of the symbols for a given psymtab for real.
1246 Be verbose about it if the user wants that. */
1249 dbx_psymtab_to_symtab (pst)
1250 struct partial_symtab *pst;
1259 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1264 if (LDSYMLEN(pst) || pst->number_of_dependencies)
1266 /* Print the message now, before reading the string table,
1267 to avoid disconcerting pauses. */
1270 printf_filtered ("Reading in symbols for %s...", pst->filename);
1274 sym_bfd = pst->objfile->obfd;
1276 next_symbol_text_func = dbx_next_symbol_text;
1278 dbx_psymtab_to_symtab_1 (pst);
1280 /* Match with global symbols. This only needs to be done once,
1281 after all of the symtabs and dependencies have been read in. */
1282 scan_file_globals (pst->objfile);
1284 /* Finish up the debug error message. */
1286 printf_filtered ("done.\n");
1290 /* Read in a defined section of a specific object file's symbols. */
1293 read_ofile_symtab (pst)
1294 struct partial_symtab *pst;
1296 register char *namestring;
1297 register struct internal_nlist *bufp;
1299 unsigned max_symnum;
1302 struct objfile *objfile;
1303 int sym_offset; /* Offset to start of symbols to read */
1304 int sym_size; /* Size of symbols to read */
1305 CORE_ADDR text_offset; /* Start of text segment for symbols */
1306 int text_size; /* Size of text segment for symbols */
1307 struct section_offsets *section_offsets;
1309 objfile = pst->objfile;
1310 sym_offset = LDSYMOFF(pst);
1311 sym_size = LDSYMLEN(pst);
1312 text_offset = pst->textlow;
1313 text_size = pst->texthigh - pst->textlow;
1314 section_offsets = pst->section_offsets;
1316 current_objfile = objfile;
1317 subfile_stack = NULL;
1319 stringtab_global = DBX_STRINGTAB (objfile);
1320 last_source_file = NULL;
1322 abfd = objfile->obfd;
1323 symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */
1324 symbuf_end = symbuf_idx = 0;
1326 /* It is necessary to actually read one symbol *before* the start
1327 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1328 occurs before the N_SO symbol.
1330 Detecting this in read_dbx_symtab
1331 would slow down initial readin, so we look for it here instead. */
1332 if (!processing_acc_compilation && sym_offset >= (int)symbol_size)
1334 bfd_seek (symfile_bfd, sym_offset - symbol_size, L_INCR);
1336 bufp = &symbuf[symbuf_idx++];
1337 SWAP_SYMBOL (bufp, abfd);
1341 processing_gcc_compilation = 0;
1342 if (bufp->n_type == N_TEXT)
1344 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1345 processing_gcc_compilation = 1;
1346 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1347 processing_gcc_compilation = 2;
1350 /* Try to select a C++ demangling based on the compilation unit
1353 if (processing_gcc_compilation)
1355 if (AUTO_DEMANGLING)
1357 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1363 /* The N_SO starting this symtab is the first symbol, so we
1364 better not check the symbol before it. I'm not this can
1365 happen, but it doesn't hurt to check for it. */
1366 bfd_seek (symfile_bfd, sym_offset, L_INCR);
1367 processing_gcc_compilation = 0;
1370 if (symbuf_idx == symbuf_end)
1372 bufp = &symbuf[symbuf_idx];
1373 if (bufp->n_type != (unsigned char)N_SO)
1374 error("First symbol in segment of executable not a source symbol");
1376 max_symnum = sym_size / symbol_size;
1379 symnum < max_symnum;
1382 QUIT; /* Allow this to be interruptable */
1383 if (symbuf_idx == symbuf_end)
1385 bufp = &symbuf[symbuf_idx++];
1386 SWAP_SYMBOL (bufp, abfd);
1388 type = bufp->n_type;
1392 if (type & N_STAB) {
1393 process_one_symbol (type, bufp->n_desc, bufp->n_value,
1394 namestring, section_offsets, objfile);
1396 /* We skip checking for a new .o or -l file; that should never
1397 happen in this routine. */
1398 else if (type == N_TEXT)
1400 /* I don't think this code will ever be executed, because
1401 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1402 the N_SO symbol which starts this source file.
1403 However, there is no reason not to accept
1404 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1406 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1407 processing_gcc_compilation = 1;
1408 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1409 processing_gcc_compilation = 2;
1411 if (AUTO_DEMANGLING)
1413 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1416 else if (type & N_EXT || type == (unsigned char)N_TEXT
1417 || type == (unsigned char)N_NBTEXT
1419 /* Global symbol: see if we came across a dbx defintion for
1420 a corresponding symbol. If so, store the value. Remove
1421 syms from the chain when their values are stored, but
1422 search the whole chain, as there may be several syms from
1423 different files with the same name. */
1424 /* This is probably not true. Since the files will be read
1425 in one at a time, each reference to a global symbol will
1426 be satisfied in each file as it appears. So we skip this
1432 current_objfile = NULL;
1434 /* In a Solaris elf file, this variable, which comes from the
1435 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1436 which comes from pst->textlow is correct. */
1437 if (last_source_start_addr == 0)
1438 last_source_start_addr = text_offset;
1440 pst->symtab = end_symtab (text_offset + text_size, 0, 0, objfile,
1446 /* This handles a single symbol from the symbol-file, building symbols
1447 into a GDB symtab. It takes these arguments and an implicit argument.
1449 TYPE is the type field of the ".stab" symbol entry.
1450 DESC is the desc field of the ".stab" entry.
1451 VALU is the value field of the ".stab" entry.
1452 NAME is the symbol name, in our address space.
1453 SECTION_OFFSETS is a set of amounts by which the sections of this object
1454 file were relocated when it was loaded into memory.
1455 All symbols that refer
1456 to memory locations need to be offset by these amounts.
1457 OBJFILE is the object file from which we are reading symbols.
1458 It is used in end_symtab. */
1461 process_one_symbol (type, desc, valu, name, section_offsets, objfile)
1465 struct section_offsets *section_offsets;
1466 struct objfile *objfile;
1468 #ifndef SUN_FIXED_LBRAC_BUG
1469 /* This records the last pc address we've seen. We depend on there being
1470 an SLINE or FUN or SO before the first LBRAC, since the variable does
1471 not get reset in between reads of different symbol files. */
1472 static CORE_ADDR last_pc_address;
1474 register struct context_stack *new;
1475 /* This remembers the address of the start of a function. It is used
1476 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1477 relative to the current function's start address. On systems
1478 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1479 used to relocate these symbol types rather than SECTION_OFFSETS. */
1480 static CORE_ADDR function_start_offset;
1483 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
1484 to the function start address. */
1485 int block_address_function_relative;
1487 /* This is true for Solaris (and all other stabs-in-elf systems, hopefully,
1488 since it would be silly to do things differently from Solaris), and
1489 false for SunOS4 and other a.out file formats. */
1490 block_address_function_relative =
1491 0 == strncmp (bfd_get_target (objfile->obfd), "elf", 3);
1493 if (!block_address_function_relative)
1494 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1495 function start address, so just use the text offset. */
1496 function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
1498 /* Something is wrong if we see real data before
1499 seeing a source file name. */
1501 if (last_source_file == NULL && type != (unsigned char)N_SO)
1503 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
1504 where that code is defined. */
1505 if (IGNORE_SYMBOL (type))
1508 /* FIXME, this should not be an error, since it precludes extending
1509 the symbol table information in this way... */
1510 error ("Invalid symbol data: does not start by identifying a source file.");
1518 /* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
1519 N_STSYM with a type code of f or F. Can't enable this until we get some
1520 stuff straightened out with psymtabs. FIXME. */
1526 /* Relocate for dynamic loading */
1527 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1529 /* Either of these types of symbols indicates the start of
1530 a new function. We must process its "name" normally for dbx,
1531 but also record the start of a new lexical context, and possibly
1532 also the end of the lexical context for the previous function. */
1533 /* This is not always true. This type of symbol may indicate a
1534 text segment variable. */
1536 colon_pos = strchr (name, ':');
1538 || (*colon_pos != 'f' && *colon_pos != 'F'))
1540 define_symbol (valu, name, desc, type, objfile);
1544 #ifndef SUN_FIXED_LBRAC_BUG
1545 last_pc_address = valu; /* Save for SunOS bug circumcision */
1548 if (block_address_function_relative)
1549 /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1550 are relative to the start of the function. On normal systems,
1551 and when using gcc on Solaris 2.0, these addresses are just
1552 absolute, or relative to the N_SO, depending on
1553 BLOCK_ADDRESS_ABSOLUTE. */
1554 function_start_offset = valu;
1556 within_function = 1;
1557 if (context_stack_depth > 0)
1559 new = pop_context ();
1560 /* Make a block for the local symbols within. */
1561 finish_block (new->name, &local_symbols, new->old_blocks,
1562 new->start_addr, valu, objfile);
1564 /* Stack must be empty now. */
1565 if (context_stack_depth != 0)
1566 complain (&lbrac_unmatched_complaint, symnum);
1568 new = push_context (0, valu);
1569 new->name = define_symbol (valu, name, desc, type, objfile);
1573 /* This "symbol" just indicates the start of an inner lexical
1574 context within a function. */
1576 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1577 /* Relocate for dynamic loading (?). */
1578 valu += function_start_offset;
1580 if (block_address_function_relative)
1581 /* Relocate for Sun ELF acc fn-relative syms. */
1582 valu += function_start_offset;
1584 /* On most machines, the block addresses are relative to the
1585 N_SO, the linker did not relocate them (sigh). */
1586 valu += last_source_start_addr;
1589 #ifndef SUN_FIXED_LBRAC_BUG
1590 if (valu < last_pc_address) {
1591 /* Patch current LBRAC pc value to match last handy pc value */
1592 complain (&lbrac_complaint);
1593 valu = last_pc_address;
1596 new = push_context (desc, valu);
1600 /* This "symbol" just indicates the end of an inner lexical
1601 context that was started with N_LBRAC. */
1603 #if defined(BLOCK_ADDRESS_ABSOLUTE)
1604 /* Relocate for dynamic loading (?). */
1605 valu += function_start_offset;
1607 if (block_address_function_relative)
1608 /* Relocate for Sun ELF acc fn-relative syms. */
1609 valu += function_start_offset;
1611 /* On most machines, the block addresses are relative to the
1612 N_SO, the linker did not relocate them (sigh). */
1613 valu += last_source_start_addr;
1616 new = pop_context();
1617 if (desc != new->depth)
1618 complain (&lbrac_mismatch_complaint, symnum);
1620 /* Some compilers put the variable decls inside of an
1621 LBRAC/RBRAC block. This macro should be nonzero if this
1622 is true. DESC is N_DESC from the N_RBRAC symbol.
1623 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1624 or the GCC2_COMPILED_SYMBOL. */
1625 #if !defined (VARIABLES_INSIDE_BLOCK)
1626 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1629 /* Can only use new->locals as local symbols here if we're in
1630 gcc or on a machine that puts them before the lbrack. */
1631 if (!VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1632 local_symbols = new->locals;
1634 /* If this is not the outermost LBRAC...RBRAC pair in the
1635 function, its local symbols preceded it, and are the ones
1636 just recovered from the context stack. Defined the block for them.
1638 If this is the outermost LBRAC...RBRAC pair, there is no
1639 need to do anything; leave the symbols that preceded it
1640 to be attached to the function's own block. However, if
1641 it is so, we need to indicate that we just moved outside
1644 && (context_stack_depth
1645 > !VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation)))
1647 /* FIXME Muzzle a compiler bug that makes end < start. */
1648 if (new->start_addr > valu)
1650 complain (&lbrac_rbrac_complaint);
1651 new->start_addr = valu;
1653 /* Make a block for the local symbols within. */
1654 finish_block (0, &local_symbols, new->old_blocks,
1655 new->start_addr, valu, objfile);
1659 within_function = 0;
1661 if (VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1662 /* Now pop locals of block just finished. */
1663 local_symbols = new->locals;
1668 /* This kind of symbol indicates the start of an object file. */
1669 /* Relocate for dynamic loading */
1670 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1674 /* This type of symbol indicates the start of data
1675 for one source file.
1676 Finish the symbol table of the previous source file
1677 (if any) and start accumulating a new symbol table. */
1678 /* Relocate for dynamic loading */
1679 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1681 #ifndef SUN_FIXED_LBRAC_BUG
1682 last_pc_address = valu; /* Save for SunOS bug circumcision */
1685 #ifdef PCC_SOL_BROKEN
1686 /* pcc bug, occasionally puts out SO for SOL. */
1687 if (context_stack_depth > 0)
1689 start_subfile (name, NULL);
1693 if (last_source_file)
1695 /* Check if previous symbol was also an N_SO (with some
1696 sanity checks). If so, that one was actually the directory
1697 name, and the current one is the real file name.
1699 if (previous_stab_code == (unsigned char) N_SO)
1701 patch_subfile_names (current_subfile, name);
1702 break; /* Ignore repeated SOs */
1704 end_symtab (valu, 0, 0, objfile, SECT_OFF_TEXT);
1708 start_symtab (name, NULL, valu);
1713 /* This type of symbol indicates the start of data for
1714 a sub-source-file, one whose contents were copied or
1715 included in the compilation of the main source file
1716 (whose name was given in the N_SO symbol.) */
1717 /* Relocate for dynamic loading */
1718 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1719 start_subfile (name, current_subfile->dirname);
1724 add_new_header_file (name, valu);
1725 start_subfile (name, current_subfile->dirname);
1729 start_subfile (pop_subfile (), current_subfile->dirname);
1733 add_old_header_file (name, valu);
1737 /* This type of "symbol" really just records
1738 one line-number -- core-address correspondence.
1739 Enter it in the line list for this symbol table. */
1740 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1741 valu += function_start_offset;
1742 #ifndef SUN_FIXED_LBRAC_BUG
1743 last_pc_address = valu; /* Save for SunOS bug circumcision */
1745 record_line (current_subfile, desc, valu);
1750 error ("Invalid symbol data: common within common at symtab pos %d",
1752 common_block = local_symbols;
1753 common_block_i = local_symbols ? local_symbols->nsyms : 0;
1757 /* Symbols declared since the BCOMM are to have the common block
1758 start address added in when we know it. common_block points to
1759 the first symbol after the BCOMM in the local_symbols list;
1760 copy the list and hang it off the symbol for the common block name
1764 struct symbol *sym =
1765 (struct symbol *) xmmalloc (objfile -> md, sizeof (struct symbol));
1766 memset (sym, 0, sizeof *sym);
1767 SYMBOL_NAME (sym) = savestring (name, strlen (name));
1768 SYMBOL_CLASS (sym) = LOC_BLOCK;
1769 SYMBOL_NAMESPACE (sym) = (enum namespace)((long)
1770 copy_pending (local_symbols, common_block_i, common_block));
1771 i = hashname (SYMBOL_NAME (sym));
1772 SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
1773 global_sym_chain[i] = sym;
1778 /* The following symbol types need to have the appropriate offset added
1779 to their value; then we process symbol definitions in the name. */
1781 case N_STSYM: /* Static symbol in data seg */
1782 case N_LCSYM: /* Static symbol in BSS seg */
1783 case N_ROSYM: /* Static symbol in Read-only data seg */
1784 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
1785 Solaris2's stabs-in-coff makes *most* symbols relative
1786 but leaves a few absolute. N_STSYM and friends sit on the fence.
1787 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
1788 .stab "foo:V...",N_STSYM is relative (section base subtracted).
1789 This leaves us no choice but to search for the 'S' or 'V'...
1790 (or pass the whole section_offsets stuff down ONE MORE function
1791 call level, which we really don't want to do). */
1794 p = strchr (name, ':');
1795 if (p != 0 && p[1] == 'S')
1797 /* FIXME! We relocate it by the TEXT offset, in case the
1798 whole module moved in memory. But this is wrong, since
1799 the sections can side around independently. */
1800 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1801 goto define_a_symbol;
1803 /* Since it's not the kludge case, re-dispatch to the right handler. */
1805 case N_STSYM: goto case_N_STSYM;
1806 case N_LCSYM: goto case_N_LCSYM;
1807 case N_ROSYM: goto case_N_ROSYM;
1812 case_N_STSYM: /* Static symbol in data seg */
1813 case N_DSLINE: /* Source line number, data seg */
1814 valu += ANOFFSET (section_offsets, SECT_OFF_DATA);
1815 goto define_a_symbol;
1817 case_N_LCSYM: /* Static symbol in BSS seg */
1818 case N_BSLINE: /* Source line number, bss seg */
1819 /* N_BROWS: overlaps with N_BSLINE */
1820 valu += ANOFFSET (section_offsets, SECT_OFF_BSS);
1821 goto define_a_symbol;
1823 case_N_ROSYM: /* Static symbol in Read-only data seg */
1824 valu += ANOFFSET (section_offsets, SECT_OFF_RODATA);
1825 goto define_a_symbol;
1827 case N_ENTRY: /* Alternate entry point */
1828 /* Relocate for dynamic loading */
1829 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1830 goto define_a_symbol;
1832 /* The following symbol types don't need the address field relocated,
1833 since it is either unused, or is absolute. */
1835 case N_GSYM: /* Global variable */
1836 case N_NSYMS: /* Number of symbols (ultrix) */
1837 case N_NOMAP: /* No map? (ultrix) */
1838 case N_RSYM: /* Register variable */
1839 case N_DEFD: /* Modula-2 GNU module dependency */
1840 case N_SSYM: /* Struct or union element */
1841 case N_LSYM: /* Local symbol in stack */
1842 case N_PSYM: /* Parameter variable */
1843 case N_LENG: /* Length of preceding symbol type */
1845 define_symbol (valu, name, desc, type, objfile);
1848 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
1849 for a bunch of other flags, too. Someday we may parse their
1850 flags; for now we ignore theirs and hope they'll ignore ours. */
1851 case N_OPT: /* Solaris 2: Compiler options */
1854 if (STREQ (name, GCC2_COMPILED_FLAG_SYMBOL))
1856 processing_gcc_compilation = 2;
1857 #if 1 /* Works, but is experimental. -fnf */
1858 if (AUTO_DEMANGLING)
1860 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1867 /* The following symbol types can be ignored. */
1868 case N_OBJ: /* Solaris 2: Object file dir and name */
1869 /* N_UNDF: Solaris 2: file separator mark */
1870 /* N_UNDF: -- we will never encounter it, since we only process one
1871 file's symbols at once. */
1872 case N_ENDM: /* Solaris 2: End of module */
1873 case N_MAIN: /* Name of main routine. */
1876 /* The following symbol types we don't know how to process. Handle
1877 them in a "default" way, but complain to people who care. */
1879 case N_CATCH: /* Exception handler catcher */
1880 case N_EHDECL: /* Exception handler name */
1881 case N_PC: /* Global symbol in Pascal */
1882 case N_M2C: /* Modula-2 compilation unit */
1883 /* N_MOD2: overlaps with N_EHDECL */
1884 case N_SCOPE: /* Modula-2 scope information */
1885 case N_ECOML: /* End common (local name) */
1886 case N_NBTEXT: /* Gould Non-Base-Register symbols??? */
1891 complain (&unknown_symtype_complaint, local_hex_string(type));
1893 define_symbol (valu, name, desc, type, objfile);
1896 previous_stab_code = type;
1899 /* Copy a pending list, used to record the contents of a common
1900 block for later fixup. */
1901 static struct pending *
1902 copy_pending (beg, begi, end)
1903 struct pending *beg;
1905 struct pending *end;
1907 struct pending *new = 0;
1908 struct pending *next;
1910 for (next = beg; next != 0 && (next != end || begi < end->nsyms);
1911 next = next->next, begi = 0)
1914 for (j = begi; j < next->nsyms; j++)
1915 add_symbol_to_list (next->symbol[j], &new);
1920 /* Scan and build partial symbols for an ELF symbol file.
1921 This ELF file has already been processed to get its minimal symbols,
1922 and any DWARF symbols that were in it.
1924 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
1927 OBJFILE is the object file we are reading symbols from.
1928 ADDR is the address relative to which the symbols are (e.g.
1929 the base address of the text segment).
1930 MAINLINE is true if we are reading the main symbol
1931 table (as opposed to a shared lib or dynamically loaded file).
1932 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
1934 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
1935 .stabstr section exists.
1937 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
1938 adjusted for elf details. */
1941 elfstab_build_psymtabs (objfile, section_offsets, mainline,
1942 staboffset, stabsize,
1943 stabstroffset, stabstrsize)
1944 struct objfile *objfile;
1945 struct section_offsets *section_offsets;
1947 file_ptr staboffset;
1948 unsigned int stabsize;
1949 file_ptr stabstroffset;
1950 unsigned int stabstrsize;
1953 bfd *sym_bfd = objfile->obfd;
1954 char *name = bfd_get_filename (sym_bfd);
1955 struct dbx_symfile_info *info;
1957 /* There is already a dbx_symfile_info allocated by our caller.
1958 It might even contain some info from the ELF symtab to help us. */
1959 info = (struct dbx_symfile_info *) objfile->sym_private;
1961 DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
1962 if (!DBX_TEXT_SECT (objfile))
1963 error ("Can't find .text section in symbol file");
1965 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
1966 DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
1967 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
1968 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
1969 DBX_SYMTAB_OFFSET (objfile) = staboffset;
1971 if (stabstrsize < 0 /* FIXME: stabstrsize is unsigned; never true! */
1972 || stabstrsize > bfd_get_size (sym_bfd))
1973 error ("ridiculous string table size: %d bytes", stabstrsize);
1974 DBX_STRINGTAB (objfile) = (char *)
1975 obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
1977 /* Now read in the string table in one big gulp. */
1979 val = bfd_seek (sym_bfd, stabstroffset, L_SET);
1981 perror_with_name (name);
1982 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
1983 if (val != stabstrsize)
1984 perror_with_name (name);
1986 stabsread_new_init ();
1987 buildsym_new_init ();
1988 free_header_files ();
1989 init_header_files ();
1990 install_minimal_symbols (objfile);
1992 processing_acc_compilation = 1;
1994 /* In an elf file, we've already installed the minimal symbols that came
1995 from the elf (non-stab) symbol table, so always act like an
1996 incremental load here. */
1997 dbx_symfile_read (objfile, section_offsets, 0);
2000 /* Scan and build partial symbols for a PA symbol file.
2001 This PA file has already been processed to get its minimal symbols.
2003 OBJFILE is the object file we are reading symbols from.
2004 ADDR is the address relative to which the symbols are (e.g.
2005 the base address of the text segment).
2006 MAINLINE is true if we are reading the main symbol
2007 table (as opposed to a shared lib or dynamically loaded file).
2012 pastab_build_psymtabs (objfile, section_offsets, mainline)
2013 struct objfile *objfile;
2014 struct section_offsets *section_offsets;
2017 free_header_files ();
2018 init_header_files ();
2020 /* In a PA file, we've already installed the minimal symbols that came
2021 from the PA (non-stab) symbol table, so always act like an
2022 incremental load here. */
2024 dbx_symfile_read (objfile, section_offsets, mainline);
2027 /* Parse the user's idea of an offset for dynamic linking, into our idea
2028 of how to represent it for fast symbol reading. */
2030 static struct section_offsets *
2031 dbx_symfile_offsets (objfile, addr)
2032 struct objfile *objfile;
2035 struct section_offsets *section_offsets;
2038 section_offsets = (struct section_offsets *)
2039 obstack_alloc (&objfile -> psymbol_obstack,
2040 sizeof (struct section_offsets) +
2041 sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
2043 for (i = 0; i < SECT_OFF_MAX; i++)
2044 ANOFFSET (section_offsets, i) = addr;
2046 return section_offsets;
2049 /* Register our willingness to decode symbols for SunOS and a.out and
2050 b.out files handled by BFD... */
2051 static struct sym_fns sunos_sym_fns =
2053 "sunOs", /* sym_name: name or name prefix of BFD target type */
2054 6, /* sym_namelen: number of significant sym_name chars */
2055 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2056 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2057 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2058 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2059 dbx_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */
2060 NULL /* next: pointer to next struct sym_fns */
2063 static struct sym_fns aout_sym_fns =
2065 "a.out", /* sym_name: name or name prefix of BFD target type */
2066 5, /* sym_namelen: number of significant sym_name chars */
2067 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2068 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2069 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2070 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2071 dbx_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */
2072 NULL /* next: pointer to next struct sym_fns */
2075 static struct sym_fns bout_sym_fns =
2077 "b.out", /* sym_name: name or name prefix of BFD target type */
2078 5, /* sym_namelen: number of significant sym_name chars */
2079 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2080 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2081 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2082 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2083 dbx_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */
2084 NULL /* next: pointer to next struct sym_fns */
2088 _initialize_dbxread ()
2090 add_symtab_fns(&sunos_sym_fns);
2091 add_symtab_fns(&aout_sym_fns);
2092 add_symtab_fns(&bout_sym_fns);