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 /* We don't want to use HP-UX's nlists. */
46 #define _NLIST_INCLUDED
50 #include <sys/param.h>
57 #include "breakpoint.h"
60 #include "gdbcore.h" /* for bfd stuff */
61 #include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
66 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
72 #include "aout/aout64.h"
73 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
75 /* Information is passed among various dbxread routines for accessing
76 symbol files. A pointer to this structure is kept in the sym_private
77 field of the objfile struct. */
80 struct dbx_symfile_info {
81 asection *text_sect; /* Text section accessor */
82 int symcount; /* How many symbols are there in the file */
83 char *stringtab; /* The actual string table */
84 int stringtab_size; /* Its size */
85 off_t symtab_offset; /* Offset in file to symbol table */
88 int hp_stringtab_size;
89 off_t hp_symtab_offset;
92 struct dbx_symfile_info {
93 asection *text_sect; /* Text section accessor */
94 int symcount; /* How many symbols are there in the file */
95 char *stringtab; /* The actual string table */
96 int stringtab_size; /* Its size */
97 off_t symtab_offset; /* Offset in file to symbol table */
98 int symbol_size; /* Bytes in a single symbol */
102 #define DBX_SYMFILE_INFO(o) ((struct dbx_symfile_info *)((o)->sym_private))
103 #define DBX_TEXT_SECT(o) (DBX_SYMFILE_INFO(o)->text_sect)
104 #define DBX_SYMCOUNT(o) (DBX_SYMFILE_INFO(o)->symcount)
105 #define DBX_STRINGTAB(o) (DBX_SYMFILE_INFO(o)->stringtab)
106 #define DBX_STRINGTAB_SIZE(o) (DBX_SYMFILE_INFO(o)->stringtab_size)
107 #define DBX_SYMTAB_OFFSET(o) (DBX_SYMFILE_INFO(o)->symtab_offset)
108 #define DBX_SYMBOL_SIZE(o) (DBX_SYMFILE_INFO(o)->symbol_size)
110 #define HP_SYMCOUNT(o) (DBX_SYMFILE_INFO(o)->hp_symcount)
111 #define HP_STRINGTAB(o) (DBX_SYMFILE_INFO(o)->hp_stringtab)
112 #define HP_STRINGTAB_SIZE(o) (DBX_SYMFILE_INFO(o)->hp_stringtab_size)
113 #define HP_SYMTAB_OFFSET(o) (DBX_SYMFILE_INFO(o)->hp_symtab_offset)
116 /* Each partial symbol table entry contains a pointer to private data for the
117 read_symtab() function to use when expanding a partial symbol table entry
118 to a full symbol table entry.
120 For dbxread this structure contains the offset within the file symbol table
121 of first local symbol for this file, and length (in bytes) of the section
122 of the symbol table devoted to this file's symbols (actually, the section
123 bracketed may contain more than just this file's symbols). It also contains
124 further information needed to locate the symbols if they are in an ELF file.
126 If ldsymlen is 0, the only reason for this thing's existence is the
127 dependency list. Nothing else will happen when it is read in. */
129 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
130 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
131 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
132 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
133 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
134 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
135 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
143 int file_string_offset;
146 /* Macro to determine which symbols to ignore when reading the first symbol
147 of a file. Some machines override this definition. */
148 #ifndef IGNORE_SYMBOL
149 /* This code is used on Ultrix systems. Ignore it */
150 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
153 /* Macro for name of symbol to indicate a file compiled with gcc. */
154 #ifndef GCC_COMPILED_FLAG_SYMBOL
155 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
158 /* Macro for name of symbol to indicate a file compiled with gcc2. */
159 #ifndef GCC2_COMPILED_FLAG_SYMBOL
160 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
163 /* Define this as 1 if a pcc declaration of a char or short argument
164 gives the correct address. Otherwise assume pcc gives the
165 address of the corresponding int, which is not the same on a
166 big-endian machine. */
168 #ifndef BELIEVE_PCC_PROMOTION
169 #define BELIEVE_PCC_PROMOTION 0
172 /* Nonzero means give verbose info on gdb action. From main.c. */
173 extern int info_verbose;
175 /* The BFD for this file -- implicit parameter to next_symbol_text. */
177 static bfd *symfile_bfd;
179 /* The size of each symbol in the symbol file (in external form).
180 This is set by dbx_symfile_read when building psymtabs, and by
181 dbx_psymtab_to_symtab when building symtabs. */
183 static unsigned symbol_size;
185 /* This is the offset of the symbol table in the executable file */
186 static unsigned symbol_table_offset;
188 /* This is the offset of the string table in the executable file */
189 static unsigned string_table_offset;
191 /* For elf+stab executables, the n_strx field is not a simple index
192 into the string table. Instead, each .o file has a base offset
193 in the string table, and the associated symbols contain offsets
194 from this base. The following two variables contain the base
195 offset for the current and next .o files. */
196 static unsigned int file_string_table_offset;
197 static unsigned int next_file_string_table_offset;
199 /* Complaints about the symbols we have encountered. */
201 struct complaint lbrac_complaint =
202 {"bad block start address patched", 0, 0};
204 struct complaint string_table_offset_complaint =
205 {"bad string table offset in symbol %d", 0, 0};
207 struct complaint unknown_symtype_complaint =
208 {"unknown symbol type %s", 0, 0};
210 struct complaint lbrac_rbrac_complaint =
211 {"block start larger than block end", 0, 0};
213 struct complaint lbrac_unmatched_complaint =
214 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
216 struct complaint lbrac_mismatch_complaint =
217 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
219 struct complaint repeated_header_complaint =
220 {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
222 struct complaint repeated_header_name_complaint =
223 {"\"repeated\" header file not previously seen, named %s", 0, 0};
225 /* During initial symbol readin, we need to have a structure to keep
226 track of which psymtabs have which bincls in them. This structure
227 is used during readin to setup the list of dependencies within each
228 partial symbol table. */
230 struct header_file_location
232 char *name; /* Name of header file */
233 int instance; /* See above */
234 struct partial_symtab *pst; /* Partial symtab that has the
235 BINCL/EINCL defs for this file */
238 /* The actual list and controling variables */
239 static struct header_file_location *bincl_list, *next_bincl;
240 static int bincls_allocated;
242 /* Local function prototypes */
245 free_header_files PARAMS ((void));
248 init_header_files PARAMS ((void));
250 static struct pending *
251 copy_pending PARAMS ((struct pending *, int, struct pending *));
253 static struct symtab *
254 read_ofile_symtab PARAMS ((struct objfile *, int, int, CORE_ADDR, int, int));
257 dbx_psymtab_to_symtab PARAMS ((struct partial_symtab *));
260 dbx_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
263 read_dbx_symtab PARAMS ((CORE_ADDR, struct objfile *, CORE_ADDR, int));
266 free_bincl_list PARAMS ((struct objfile *));
268 static struct partial_symtab *
269 find_corresponding_bincl_psymtab PARAMS ((char *, int));
272 add_bincl_to_list PARAMS ((struct partial_symtab *, char *, int));
275 init_bincl_list PARAMS ((int, struct objfile *));
278 init_psymbol_list PARAMS ((struct objfile *));
281 dbx_next_symbol_text PARAMS ((void));
284 fill_symbuf PARAMS ((bfd *));
287 dbx_symfile_init PARAMS ((struct objfile *));
290 dbx_new_init PARAMS ((struct objfile *));
293 dbx_symfile_read PARAMS ((struct objfile *, CORE_ADDR, int));
296 dbx_symfile_finish PARAMS ((struct objfile *));
299 record_minimal_symbol PARAMS ((char *, CORE_ADDR, int, struct objfile *));
302 add_new_header_file PARAMS ((char *, int));
305 add_old_header_file PARAMS ((char *, int));
308 add_this_object_header_file PARAMS ((int));
310 /* Free up old header file tables */
317 if (header_files != NULL)
319 for (i = 0; i < n_header_files; i++)
321 free (header_files[i].name);
323 free ((PTR)header_files);
327 if (this_object_header_files)
329 free ((PTR)this_object_header_files);
330 this_object_header_files = NULL;
332 n_allocated_header_files = 0;
333 n_allocated_this_object_header_files = 0;
336 /* Allocate new header file tables */
342 n_allocated_header_files = 10;
343 header_files = (struct header_file *)
344 xmalloc (10 * sizeof (struct header_file));
346 n_allocated_this_object_header_files = 10;
347 this_object_header_files = (int *) xmalloc (10 * sizeof (int));
350 /* Add header file number I for this object file
351 at the next successive FILENUM. */
354 add_this_object_header_file (i)
357 if (n_this_object_header_files == n_allocated_this_object_header_files)
359 n_allocated_this_object_header_files *= 2;
360 this_object_header_files
361 = (int *) xrealloc ((char *) this_object_header_files,
362 n_allocated_this_object_header_files * sizeof (int));
365 this_object_header_files[n_this_object_header_files++] = i;
368 /* Add to this file an "old" header file, one already seen in
369 a previous object file. NAME is the header file's name.
370 INSTANCE is its instance code, to select among multiple
371 symbol tables for the same header file. */
374 add_old_header_file (name, instance)
378 register struct header_file *p = header_files;
381 for (i = 0; i < n_header_files; i++)
382 if (!strcmp (p[i].name, name) && instance == p[i].instance)
384 add_this_object_header_file (i);
387 complain (&repeated_header_complaint, (char *)symnum);
388 complain (&repeated_header_name_complaint, name);
391 /* Add to this file a "new" header file: definitions for its types follow.
392 NAME is the header file's name.
393 Most often this happens only once for each distinct header file,
394 but not necessarily. If it happens more than once, INSTANCE has
395 a different value each time, and references to the header file
396 use INSTANCE values to select among them.
398 dbx output contains "begin" and "end" markers for each new header file,
399 but at this level we just need to know which files there have been;
400 so we record the file when its "begin" is seen and ignore the "end". */
403 add_new_header_file (name, instance)
409 /* Make sure there is room for one more header file. */
411 if (n_header_files == n_allocated_header_files)
413 n_allocated_header_files *= 2;
414 header_files = (struct header_file *)
415 xrealloc ((char *) header_files,
416 (n_allocated_header_files * sizeof (struct header_file)));
419 /* Create an entry for this header file. */
421 i = n_header_files++;
422 header_files[i].name = savestring (name, strlen(name));
423 header_files[i].instance = instance;
424 header_files[i].length = 10;
425 header_files[i].vector
426 = (struct type **) xmalloc (10 * sizeof (struct type *));
427 bzero (header_files[i].vector, 10 * sizeof (struct type *));
429 add_this_object_header_file (i);
433 static struct type **
434 explicit_lookup_type (real_filenum, index)
435 int real_filenum, index;
437 register struct header_file *f = &header_files[real_filenum];
439 if (index >= f->length)
442 f->vector = (struct type **)
443 xrealloc (f->vector, f->length * sizeof (struct type *));
444 bzero (&f->vector[f->length / 2],
445 f->length * sizeof (struct type *) / 2);
447 return &f->vector[index];
452 record_minimal_symbol (name, address, type, objfile)
456 struct objfile *objfile;
458 enum minimal_symbol_type ms_type;
460 switch (type &~ N_EXT) {
461 case N_TEXT: ms_type = mst_text; break;
462 case N_DATA: ms_type = mst_data; break;
463 case N_BSS: ms_type = mst_bss; break;
464 case N_ABS: ms_type = mst_abs; break;
466 case N_SETV: ms_type = mst_data; break;
468 default: ms_type = mst_unknown; break;
471 prim_record_minimal_symbol (obsavestring (name, strlen (name), &objfile -> symbol_obstack),
475 /* Scan and build partial symbols for a symbol file.
476 We have been initialized by a call to dbx_symfile_init, which
477 put all the relevant info into a "struct dbx_symfile_info",
478 hung off the objfile structure.
480 ADDR is the address relative to which the symbols in it are (e.g.
481 the base address of the text segment).
482 MAINLINE is true if we are reading the main symbol
483 table (as opposed to a shared lib or dynamically loaded file). */
486 dbx_symfile_read (objfile, addr, mainline)
487 struct objfile *objfile;
489 int mainline; /* FIXME comments above */
494 sym_bfd = objfile->obfd;
495 val = bfd_seek (objfile->obfd, DBX_SYMTAB_OFFSET (objfile), L_SET);
497 perror_with_name (objfile->name);
499 /* If we are reinitializing, or if we have never loaded syms yet, init */
500 if (mainline || objfile->global_psymbols.size == 0 || objfile->static_psymbols.size == 0)
501 init_psymbol_list (objfile);
504 symbol_size = obj_dbx_symbol_entry_size (sym_bfd);
506 symbol_size = DBX_SYMBOL_SIZE (objfile);
508 symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
511 make_cleanup (really_free_pendings, 0);
513 init_minimal_symbol_collection ();
514 make_cleanup (discard_minimal_symbols, 0);
516 /* Now that the symbol table data of the executable file are all in core,
517 process them and define symbols accordingly. */
519 addr -= bfd_section_vma (sym_bfd, DBX_TEXT_SECT (objfile)); /*offset*/
520 read_dbx_symtab (addr, objfile,
521 bfd_section_vma (sym_bfd, DBX_TEXT_SECT (objfile)),
522 bfd_section_size (sym_bfd, DBX_TEXT_SECT (objfile)));
524 /* Install any minimal symbols that have been collected as the current
525 minimal symbols for this objfile. */
527 install_minimal_symbols (objfile);
529 if (!have_partial_symbols ()) {
531 printf_filtered ("(no debugging symbols found)...");
536 /* Initialize anything that needs initializing when a completely new
537 symbol file is specified (not just adding some symbols from another
538 file, e.g. a shared library). */
541 dbx_new_init (ignore)
542 struct objfile *ignore;
544 buildsym_new_init ();
545 init_header_files ();
549 /* dbx_symfile_init ()
550 is the dbx-specific initialization routine for reading symbols.
551 It is passed a struct objfile which contains, among other things,
552 the BFD for the file whose symbols are being read, and a slot for a pointer
553 to "private data" which we fill with goodies.
555 We read the string table into malloc'd space and stash a pointer to it.
557 Since BFD doesn't know how to read debug symbols in a format-independent
558 way (and may never do so...), we have to do it ourselves. We will never
559 be called unless this is an a.out (or very similar) file.
560 FIXME, there should be a cleaner peephole into the BFD environment here. */
563 dbx_symfile_init (objfile)
564 struct objfile *objfile;
567 bfd *sym_bfd = objfile->obfd;
568 char *name = bfd_get_filename (sym_bfd);
569 unsigned char size_temp[4];
571 /* Allocate struct to keep track of the symfile */
572 objfile->sym_private = (PTR)
573 xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
575 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
577 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_dbx_str_filepos (sym_bfd))
578 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_dbx_sym_filepos (sym_bfd))
579 #define HP_STRING_TABLE_OFFSET (sym_bfd->origin + obj_hp_str_filepos (sym_bfd))
580 #define HP_SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_hp_sym_filepos (sym_bfd))
582 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
583 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
585 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
587 DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
588 if (!DBX_TEXT_SECT (objfile))
589 error ("Can't find .text section in symbol file");
591 DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
593 HP_SYMCOUNT (objfile) = obj_hp_sym_count (sym_bfd);
594 DBX_SYMCOUNT (objfile) = obj_dbx_sym_count (sym_bfd);
596 DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
598 DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
600 /* Read the string table and stash it away in the psymbol_obstack. It is
601 only needed as long as we need to expand psymbols into full symbols,
602 so when we blow away the psymbol the string table goes away as well.
603 Note that gdb used to use the results of attempting to malloc the
604 string table, based on the size it read, as a form of sanity check
605 for botched byte swapping, on the theory that a byte swapped string
606 table size would be so totally bogus that the malloc would fail. Now
607 that we put in on the psymbol_obstack, we can't do this since gdb gets
608 a fatal error (out of virtual memory) if the size is bogus. We can
609 however at least check to see if the size is zero or some negative
613 DBX_STRINGTAB_SIZE (objfile) = obj_dbx_stringtab_size (sym_bfd);
614 HP_STRINGTAB_SIZE (objfile) = obj_hp_stringtab_size (sym_bfd);
616 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, L_SET);
618 perror_with_name (name);
620 val = bfd_read ((PTR)size_temp, sizeof (long), 1, sym_bfd);
622 perror_with_name (name);
624 DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
627 if (DBX_STRINGTAB_SIZE (objfile) <= 0)
628 error ("ridiculous string table size (%d bytes).",
629 DBX_STRINGTAB_SIZE (objfile));
631 DBX_STRINGTAB (objfile) =
632 (char *) obstack_alloc (&objfile -> psymbol_obstack,
633 DBX_STRINGTAB_SIZE (objfile));
635 if (HP_STRINGTAB_SIZE (objfile) <= 0)
636 error ("ridiculous string table size (%d bytes).",
637 HP_STRINGTAB_SIZE (objfile));
639 HP_STRINGTAB (objfile) =
640 (char *) obstack_alloc (&objfile -> psymbol_obstack,
641 HP_STRINGTAB_SIZE (objfile));
644 /* Now read in the string table in one big gulp. */
646 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, L_SET);
648 perror_with_name (name);
649 val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
651 if (val != DBX_STRINGTAB_SIZE (objfile))
652 perror_with_name (name);
654 val = bfd_seek (sym_bfd, HP_STRING_TABLE_OFFSET, L_SET);
656 perror_with_name (name);
657 val = bfd_read (HP_STRINGTAB (objfile), HP_STRINGTAB_SIZE (objfile), 1,
659 if (val != HP_STRINGTAB_SIZE (objfile))
660 perror_with_name (name);
663 HP_SYMTAB_OFFSET (objfile) = HP_SYMBOL_TABLE_OFFSET;
667 /* Perform any local cleanups required when we are done with a particular
668 objfile. I.E, we are in the process of discarding all symbol information
669 for an objfile, freeing up all memory held for it, and unlinking the
670 objfile struct from the global list of known objfiles. */
673 dbx_symfile_finish (objfile)
674 struct objfile *objfile;
676 if (objfile->sym_private != NULL)
678 mfree (objfile -> md, objfile->sym_private);
680 free_header_files ();
684 /* Buffer for reading the symbol table entries. */
685 static struct internal_nlist symbuf[4096];
686 static int symbuf_idx;
687 static int symbuf_end;
689 /* Name of last function encountered. Used in Solaris to approximate
690 object file boundaries. */
691 static char *last_function_name;
693 /* The address in memory of the string table of the object file we are
694 reading (which might not be the "main" object file, but might be a
695 shared library or some other dynamically loaded thing). This is set
696 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
697 when building symtabs, and is used only by next_symbol_text. */
698 static char *stringtab_global;
700 /* Refill the symbol table input buffer
701 and set the variables that control fetching entries from it.
702 Reports an error if no data available.
703 This function can read past the end of the symbol table
704 (into the string table) but this does no harm. */
707 fill_symbuf (sym_bfd)
710 int nbytes = bfd_read ((PTR)symbuf, sizeof (symbuf), 1, sym_bfd);
712 perror_with_name (bfd_get_filename (sym_bfd));
713 else if (nbytes == 0)
714 error ("Premature end of file reading symbol table");
715 symbuf_end = nbytes / symbol_size;
719 /* same as above for the HP symbol table */
721 static struct symbol_dictionary_record hp_symbuf[4096];
722 static int hp_symbuf_idx;
723 static int hp_symbuf_end;
726 fill_hp_symbuf (sym_bfd)
729 int nbytes = bfd_read ((PTR)hp_symbuf, sizeof (hp_symbuf), 1, sym_bfd);
731 error ("error or end of file reading symbol table");
732 hp_symbuf_end = nbytes / sizeof (struct symbol_dictionary_record);
738 #define SWAP_SYMBOL(symp, abfd) \
740 (symp)->n_strx = bfd_h_get_32(abfd, \
741 (unsigned char *)&(symp)->n_strx); \
742 (symp)->n_desc = bfd_h_get_16 (abfd, \
743 (unsigned char *)&(symp)->n_desc); \
744 (symp)->n_value = bfd_h_get_32 (abfd, \
745 (unsigned char *)&(symp)->n_value); \
748 /* Invariant: The symbol pointed to by symbuf_idx is the first one
749 that hasn't been swapped. Swap the symbol at the same time
750 that symbuf_idx is incremented. */
752 /* dbx allows the text of a symbol name to be continued into the
753 next symbol name! When such a continuation is encountered
754 (a \ at the end of the text of a name)
755 call this function to get the continuation. */
758 dbx_next_symbol_text ()
760 if (symbuf_idx == symbuf_end)
761 fill_symbuf (symfile_bfd);
763 SWAP_SYMBOL(&symbuf[symbuf_idx], symfile_bfd);
764 return symbuf[symbuf_idx++].n_strx + stringtab_global
765 + file_string_table_offset;
768 /* Initializes storage for all of the partial symbols that will be
769 created by read_dbx_symtab and subsidiaries. */
772 init_psymbol_list (objfile)
773 struct objfile *objfile;
775 /* Free any previously allocated psymbol lists. */
776 if (objfile -> global_psymbols.list)
777 mfree (objfile -> md, (PTR)objfile -> global_psymbols.list);
778 if (objfile -> static_psymbols.list)
779 mfree (objfile -> md, (PTR)objfile -> static_psymbols.list);
781 /* Current best guess is that there are approximately a twentieth
782 of the total symbols (in a debugging file) are global or static
785 objfile -> global_psymbols.size = (DBX_SYMCOUNT (objfile) +
786 HP_SYMCOUNT (objfile)) / 10;
787 objfile -> static_psymbols.size = (DBX_SYMCOUNT (objfile) +
788 HP_SYMCOUNT (objfile)) / 10;
790 objfile -> global_psymbols.size = DBX_SYMCOUNT (objfile) / 10;
791 objfile -> static_psymbols.size = DBX_SYMCOUNT (objfile) / 10;
793 objfile -> global_psymbols.next = objfile -> global_psymbols.list = (struct partial_symbol *)
794 xmmalloc (objfile -> md, objfile -> global_psymbols.size * sizeof (struct partial_symbol));
795 objfile -> static_psymbols.next = objfile -> static_psymbols.list = (struct partial_symbol *)
796 xmmalloc (objfile -> md, objfile -> static_psymbols.size * sizeof (struct partial_symbol));
799 /* Initialize the list of bincls to contain none and have some
803 init_bincl_list (number, objfile)
805 struct objfile *objfile;
807 bincls_allocated = number;
808 next_bincl = bincl_list = (struct header_file_location *)
809 xmmalloc (objfile -> md, bincls_allocated * sizeof(struct header_file_location));
812 /* Add a bincl to the list. */
815 add_bincl_to_list (pst, name, instance)
816 struct partial_symtab *pst;
820 if (next_bincl >= bincl_list + bincls_allocated)
822 int offset = next_bincl - bincl_list;
823 bincls_allocated *= 2;
824 bincl_list = (struct header_file_location *)
825 xmrealloc (pst->objfile->md, (char *)bincl_list,
826 bincls_allocated * sizeof (struct header_file_location));
827 next_bincl = bincl_list + offset;
829 next_bincl->pst = pst;
830 next_bincl->instance = instance;
831 next_bincl++->name = name;
834 /* Given a name, value pair, find the corresponding
835 bincl in the list. Return the partial symtab associated
836 with that header_file_location. */
838 static struct partial_symtab *
839 find_corresponding_bincl_psymtab (name, instance)
843 struct header_file_location *bincl;
845 for (bincl = bincl_list; bincl < next_bincl; bincl++)
846 if (bincl->instance == instance
847 && !strcmp (name, bincl->name))
850 return (struct partial_symtab *) 0;
853 /* Free the storage allocated for the bincl list. */
856 free_bincl_list (objfile)
857 struct objfile *objfile;
859 mfree (objfile -> md, (PTR)bincl_list);
860 bincls_allocated = 0;
863 /* Given pointers to an a.out symbol table in core containing dbx
864 style data, setup partial_symtab's describing each source file for
865 which debugging information is available.
866 SYMFILE_NAME is the name of the file we are reading from
867 and ADDR is its relocated address (if incremental) or 0 (if not). */
870 read_dbx_symtab (addr, objfile, text_addr, text_size)
872 struct objfile *objfile;
876 register struct internal_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch */
877 register char *namestring;
879 int past_first_source_file = 0;
880 CORE_ADDR last_o_file_start = 0;
881 struct cleanup *old_chain;
885 struct symbol_dictionary_record *hp_bufp;
887 /* A hack: the first text symbol in the debugging library */
892 /* End of the text segment of the executable file. */
893 CORE_ADDR end_of_text_addr;
895 /* Current partial symtab */
896 struct partial_symtab *pst;
898 /* List of current psymtab's include files */
899 char **psymtab_include_list;
900 int includes_allocated;
903 /* Index within current psymtab dependency list */
904 struct partial_symtab **dependency_list;
905 int dependencies_used, dependencies_allocated;
907 /* FIXME. We probably want to change stringtab_global rather than add this
908 while processing every symbol entry. FIXME. */
909 file_string_table_offset = 0;
910 next_file_string_table_offset = 0;
913 stringtab_global = HP_STRINGTAB (objfile);
915 stringtab_global = DBX_STRINGTAB (objfile);
918 pst = (struct partial_symtab *) 0;
920 includes_allocated = 30;
922 psymtab_include_list = (char **) alloca (includes_allocated *
925 dependencies_allocated = 30;
926 dependencies_used = 0;
928 (struct partial_symtab **) alloca (dependencies_allocated *
929 sizeof (struct partial_symtab *));
931 old_chain = make_cleanup (free_objfile, objfile);
933 /* Init bincl list */
934 init_bincl_list (20, objfile);
935 make_cleanup (free_bincl_list, objfile);
937 last_source_file = 0;
939 #ifdef END_OF_TEXT_DEFAULT
940 end_of_text_addr = END_OF_TEXT_DEFAULT;
942 end_of_text_addr = text_addr + addr + text_size; /* Relocate */
945 symfile_bfd = objfile->obfd; /* For next_text_symbol */
946 abfd = objfile->obfd;
947 symbuf_end = symbuf_idx = 0;
948 next_symbol_text_func = dbx_next_symbol_text;
951 /* On pa machines, the global symbols are all in the regular HP-UX
952 symbol table. Read them in first. */
954 hp_symbuf_end = hp_symbuf_idx = 0;
955 bfd_seek (abfd, HP_SYMTAB_OFFSET (objfile), 0);
957 for (hp_symnum = 0; hp_symnum < HP_SYMCOUNT (objfile); hp_symnum++)
962 if (hp_symbuf_idx == hp_symbuf_end)
963 fill_hp_symbuf (abfd);
964 hp_bufp = &hp_symbuf[hp_symbuf_idx++];
965 switch (hp_bufp->symbol_type)
976 hp_bufp->symbol_value &= ~3; /* clear out permission bits */
984 extern int kernel_debugging;
985 if (!kernel_debugging)
994 /* Use the address of dbsubc to finish the last psymtab. */
995 if (hp_bufp->symbol_type == ST_CODE &&
996 HP_STRINGTAB (objfile)[hp_bufp->name.n_strx] == '_' &&
997 !strcmp (HP_STRINGTAB (objfile) + hp_bufp->name.n_strx, "_dbsubc"))
998 dbsubc_addr = hp_bufp->symbol_value;
999 if (hp_bufp->symbol_scope == SS_UNIVERSAL)
1001 if (hp_bufp->name.n_strx > HP_STRINGTAB_SIZE (objfile))
1002 error ("Invalid symbol data; bad HP string table offset: %d",
1003 hp_bufp->name.n_strx);
1004 /* A hack, but gets the job done. */
1005 if (!strcmp (hp_bufp->name.n_strx + HP_STRINGTAB (objfile),
1007 objfile -> ei.entry_file_lowpc = hp_bufp->symbol_value;
1008 if (!strcmp (hp_bufp->name.n_strx + HP_STRINGTAB (objfile),
1010 objfile -> ei.entry_file_highpc = hp_bufp->symbol_value;
1011 record_minimal_symbol (hp_bufp->name.n_strx + HP_STRINGTAB (objfile),
1012 hp_bufp->symbol_value, dbx_type | N_EXT,
1016 bfd_seek (abfd, DBX_SYMTAB_OFFSET (objfile), 0);
1019 for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
1021 /* Get the symbol for this run and pull out some info */
1022 QUIT; /* allow this to be interruptable */
1023 if (symbuf_idx == symbuf_end)
1025 bufp = &symbuf[symbuf_idx++];
1028 * Special case to speed up readin.
1030 if (bufp->n_type == (unsigned char)N_SLINE) continue;
1032 SWAP_SYMBOL (bufp, abfd);
1034 /* Ok. There is a lot of code duplicated in the rest of this
1035 switch statement (for efficiency reasons). Since I don't
1036 like duplicating code, I will do my penance here, and
1037 describe the code which is duplicated:
1039 *) The assignment to namestring.
1040 *) The call to strchr.
1041 *) The addition of a partial symbol the the two partial
1042 symbol lists. This last is a large section of code, so
1043 I've imbedded it in the following macro.
1046 /* Set namestring based on bufp. If the string table index is invalid,
1047 give a fake name, and print a single error message per symbol file read,
1048 rather than abort the symbol reading or flood the user with messages. */
1050 /*FIXME: Too many adds and indirections in here for the inner loop. */
1051 #define SET_NAMESTRING()\
1052 if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
1053 DBX_STRINGTAB_SIZE (objfile)) { \
1054 complain (&string_table_offset_complaint, (char *) symnum); \
1055 namestring = "foo"; \
1057 namestring = bufp->n_strx + file_string_table_offset + \
1058 DBX_STRINGTAB (objfile)
1060 #define CUR_SYMBOL_TYPE bufp->n_type
1061 #define CUR_SYMBOL_VALUE bufp->n_value
1062 #define DBXREAD_ONLY
1063 #define START_PSYMTAB(ofile,addr,fname,low,symoff,global_syms,static_syms)\
1064 start_psymtab(ofile, addr, fname, low, symoff, global_syms, static_syms)
1065 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1066 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1068 #include "partial-stab.h"
1071 /* If there's stuff to be cleaned up, clean it up. */
1073 if (DBX_SYMCOUNT (objfile) > 0 /* We have some syms */
1074 /*FIXME, does this have a bug at start address 0? */
1075 && last_o_file_start
1076 && objfile -> ei.entry_point < bufp->n_value
1077 && objfile -> ei.entry_point >= last_o_file_start)
1079 objfile -> ei.entry_file_lowpc = last_o_file_start;
1080 objfile -> ei.entry_file_highpc = bufp->n_value;
1087 end_psymtab (pst, psymtab_include_list, includes_used,
1088 symnum * symbol_size, dbsubc_addr,
1089 dependency_list, dependencies_used);
1091 end_psymtab (pst, psymtab_include_list, includes_used,
1092 symnum * symbol_size, end_of_text_addr,
1093 dependency_list, dependencies_used);
1097 free_bincl_list (objfile);
1098 discard_cleanups (old_chain);
1101 /* Allocate and partially fill a partial symtab. It will be
1102 completely filled at the end of the symbol list.
1104 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1105 is the address relative to which its symbols are (incremental) or 0
1109 struct partial_symtab *
1110 start_psymtab (objfile, addr,
1111 filename, textlow, ldsymoff, global_syms, static_syms)
1112 struct objfile *objfile;
1117 struct partial_symbol *global_syms;
1118 struct partial_symbol *static_syms;
1120 struct partial_symtab *result =
1121 start_psymtab_common(objfile, addr,
1122 filename, textlow, global_syms, static_syms);
1124 result->read_symtab_private = (char *)
1125 obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
1126 LDSYMOFF(result) = ldsymoff;
1127 result->read_symtab = dbx_psymtab_to_symtab;
1128 SYMBOL_SIZE(result) = symbol_size;
1129 SYMBOL_OFFSET(result) = symbol_table_offset;
1130 STRING_OFFSET(result) = string_table_offset;
1131 FILE_STRING_OFFSET(result) = file_string_table_offset;
1136 /* Close off the current usage of a partial_symbol table entry. This
1137 involves setting the correct number of includes (with a realloc),
1138 setting the high text mark, setting the symbol length in the
1139 executable, and setting the length of the global and static lists
1142 The global symbols and static symbols are then seperately sorted.
1144 Then the partial symtab is put on the global list.
1145 *** List variables and peculiarities of same. ***
1149 end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
1150 capping_text, dependency_list, number_dependencies)
1151 struct partial_symtab *pst;
1152 char **include_list;
1154 int capping_symbol_offset;
1155 CORE_ADDR capping_text;
1156 struct partial_symtab **dependency_list;
1157 int number_dependencies;
1158 /* struct partial_symbol *capping_global, *capping_static;*/
1161 struct partial_symtab *p1;
1162 struct objfile *objfile = pst -> objfile;
1164 if (capping_symbol_offset != -1)
1165 LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
1166 pst->texthigh = capping_text;
1168 /* Under Solaris, the N_SO symbols always have a value of 0,
1169 instead of the usual address of the .o file. Therefore,
1170 we have to do some tricks to fill in texthigh and textlow.
1171 The first trick is in partial-stab.h: if we see a static
1172 or global function, and the textlow for the current pst
1173 is still 0, then we use that function's address for
1174 the textlow of the pst.
1176 Now, to fill in texthigh, we remember the last function seen
1177 in the .o file (also in partial-stab.h). Also, there's a hack in
1178 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1179 to here via the misc_info field. Therefore, we can fill in
1180 a reliable texthigh by taking the address plus size of the
1181 last function in the file.
1183 Unfortunately, that does not cover the case where the last function
1184 in the file is static. See the paragraph below for more comments
1187 Finally, if we have a valid textlow for the current file, we run
1188 down the partial_symtab_list filling in previous texthighs that
1189 are still unknown. */
1191 if (pst->texthigh == 0 && last_function_name) {
1194 struct minimal_symbol *minsym;
1196 p = strchr (last_function_name, ':');
1198 p = last_function_name;
1199 n = p - last_function_name;
1201 strncpy (p, last_function_name, n);
1204 minsym = lookup_minimal_symbol (p, objfile);
1207 pst->texthigh = minsym->address + (int)minsym->info;
1209 /* This file ends with a static function, and it's
1210 difficult to imagine how hard it would be to track down
1211 the elf symbol. Luckily, most of the time no one will notice,
1212 since the next file will likely be compiled with -g, so
1213 the code below will copy the first fuction's start address
1214 back to our texthigh variable. (Also, if this file is the
1215 last one in a dynamically linked program, texthigh already
1216 has the right value.) If the next file isn't compiled
1217 with -g, then the last function in this file winds up owning
1218 all of the text space up to the next -g file, or the end (minus
1219 shared libraries). This only matters for single stepping,
1220 and even then it will still work, except that it will single
1221 step through all of the covered functions, instead of setting
1222 breakpoints around them as it usualy does. This makes it
1223 pretty slow, but at least it doesn't fail.
1225 We can fix this with a fairly big change to bfd, but we need
1226 to coordinate better with Cygnus if we want to do that. FIXME. */
1228 last_function_name = NULL;
1231 /* this test will be true if the last .o file is only data */
1232 if (pst->textlow == 0)
1233 pst->textlow = pst->texthigh;
1235 /* If we know our own starting text address, then walk through all other
1236 psymtabs for this objfile, and if any didn't know their ending text
1237 address, set it to our starting address. Take care to not set our
1238 own ending address to our starting address, nor to set addresses on
1239 `dependency' files that have both textlow and texthigh zero. */
1241 ALL_OBJFILE_PSYMTABS (objfile, p1) {
1242 if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst) {
1243 p1->texthigh = pst->textlow;
1244 /* if this file has only data, then make textlow match texthigh */
1245 if (p1->textlow == 0)
1246 p1->textlow = p1->texthigh;
1251 /* End of kludge for patching Solaris textlow and texthigh. */
1254 pst->n_global_syms =
1255 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
1256 pst->n_static_syms =
1257 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
1259 pst->number_of_dependencies = number_dependencies;
1260 if (number_dependencies)
1262 pst->dependencies = (struct partial_symtab **)
1263 obstack_alloc (&objfile->psymbol_obstack,
1264 number_dependencies * sizeof (struct partial_symtab *));
1265 memcpy (pst->dependencies, dependency_list,
1266 number_dependencies * sizeof (struct partial_symtab *));
1269 pst->dependencies = 0;
1271 for (i = 0; i < num_includes; i++)
1273 struct partial_symtab *subpst =
1274 allocate_psymtab (include_list[i], objfile);
1276 subpst->addr = pst->addr;
1277 subpst->read_symtab_private =
1278 (char *) obstack_alloc (&objfile->psymbol_obstack,
1279 sizeof (struct symloc));
1283 subpst->texthigh = 0;
1285 /* We could save slight bits of space by only making one of these,
1286 shared by the entire set of include files. FIXME-someday. */
1287 subpst->dependencies = (struct partial_symtab **)
1288 obstack_alloc (&objfile->psymbol_obstack,
1289 sizeof (struct partial_symtab *));
1290 subpst->dependencies[0] = pst;
1291 subpst->number_of_dependencies = 1;
1293 subpst->globals_offset =
1294 subpst->n_global_syms =
1295 subpst->statics_offset =
1296 subpst->n_static_syms = 0;
1300 subpst->read_symtab = dbx_psymtab_to_symtab;
1303 sort_pst_symbols (pst);
1305 /* If there is already a psymtab or symtab for a file of this name, remove it.
1306 (If there is a symtab, more drastic things also happen.)
1307 This happens in VxWorks. */
1308 free_named_symtabs (pst->filename);
1310 if (num_includes == 0
1311 && number_dependencies == 0
1312 && pst->n_global_syms == 0
1313 && pst->n_static_syms == 0) {
1314 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1315 it is on the obstack, but we can forget to chain it on the list. */
1316 struct partial_symtab *prev_pst;
1318 /* First, snip it out of the psymtab chain */
1320 if (pst->objfile->psymtabs == pst)
1321 pst->objfile->psymtabs = pst->next;
1323 for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
1324 if (prev_pst->next == pst)
1325 prev_pst->next = pst->next;
1327 /* Next, put it on a free list for recycling */
1329 pst->next = pst->objfile->free_psymtabs;
1330 pst->objfile->free_psymtabs = pst;
1335 dbx_psymtab_to_symtab_1 (pst)
1336 struct partial_symtab *pst;
1338 struct cleanup *old_chain;
1346 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1351 /* Read in all partial symtabs on which this one is dependent */
1352 for (i = 0; i < pst->number_of_dependencies; i++)
1353 if (!pst->dependencies[i]->readin)
1355 /* Inform about additional files that need to be read in. */
1358 fputs_filtered (" ", stdout);
1360 fputs_filtered ("and ", stdout);
1362 printf_filtered ("%s...", pst->dependencies[i]->filename);
1363 wrap_here (""); /* Flush output */
1366 dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
1369 if (LDSYMLEN(pst)) /* Otherwise it's a dummy */
1371 /* Init stuff necessary for reading in symbols */
1373 old_chain = make_cleanup (really_free_pendings, 0);
1374 file_string_table_offset = FILE_STRING_OFFSET (pst);
1376 symbol_size = obj_dbx_symbol_entry_size (sym_bfd);
1378 symbol_size = SYMBOL_SIZE (pst);
1381 /* Read in this file's symbols */
1382 bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), L_SET);
1384 read_ofile_symtab (pst->objfile, LDSYMOFF(pst), LDSYMLEN(pst),
1385 pst->textlow, pst->texthigh - pst->textlow,
1387 sort_symtab_syms (pst->symtab);
1389 do_cleanups (old_chain);
1395 /* Read in all of the symbols for a given psymtab for real.
1396 Be verbose about it if the user wants that. */
1399 dbx_psymtab_to_symtab (pst)
1400 struct partial_symtab *pst;
1409 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1414 if (LDSYMLEN(pst) || pst->number_of_dependencies)
1416 /* Print the message now, before reading the string table,
1417 to avoid disconcerting pauses. */
1420 printf_filtered ("Reading in symbols for %s...", pst->filename);
1424 sym_bfd = pst->objfile->obfd;
1426 next_symbol_text_func = dbx_next_symbol_text;
1428 dbx_psymtab_to_symtab_1 (pst);
1430 /* Match with global symbols. This only needs to be done once,
1431 after all of the symtabs and dependencies have been read in. */
1432 scan_file_globals (pst->objfile);
1434 /* Finish up the debug error message. */
1436 printf_filtered ("done.\n");
1440 /* Read in a defined section of a specific object file's symbols.
1442 DESC is the file descriptor for the file, positioned at the
1443 beginning of the symtab
1444 SYM_OFFSET is the offset within the file of
1445 the beginning of the symbols we want to read
1446 SYM_SIZE is the size of the symbol info to read in.
1447 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
1448 TEXT_SIZE is the size of the text segment read in.
1449 OFFSET is a relocation offset which gets added to each symbol. */
1451 static struct symtab *
1452 read_ofile_symtab (objfile, sym_offset, sym_size, text_offset, text_size,
1454 struct objfile *objfile;
1457 CORE_ADDR text_offset;
1461 register char *namestring;
1462 register struct internal_nlist *bufp;
1464 unsigned max_symnum;
1467 current_objfile = objfile;
1471 stringtab_global = HP_STRINGTAB (objfile);
1473 stringtab_global = DBX_STRINGTAB (objfile);
1475 last_source_file = 0;
1477 abfd = objfile->obfd;
1478 symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */
1479 symbuf_end = symbuf_idx = 0;
1481 /* It is necessary to actually read one symbol *before* the start
1482 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1483 occurs before the N_SO symbol.
1485 Detecting this in read_dbx_symtab
1486 would slow down initial readin, so we look for it here instead. */
1487 if (!processing_acc_compilation && sym_offset >= (int)symbol_size)
1489 bfd_seek (symfile_bfd, sym_offset - symbol_size, L_INCR);
1491 bufp = &symbuf[symbuf_idx++];
1492 SWAP_SYMBOL (bufp, abfd);
1496 processing_gcc_compilation =
1497 (bufp->n_type == N_TEXT
1498 && (strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL) == 0
1499 || strcmp(namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0));
1503 /* The N_SO starting this symtab is the first symbol, so we
1504 better not check the symbol before it. I'm not this can
1505 happen, but it doesn't hurt to check for it. */
1506 bfd_seek (symfile_bfd, sym_offset, L_INCR);
1507 processing_gcc_compilation = 0;
1510 if (symbuf_idx == symbuf_end)
1512 bufp = &symbuf[symbuf_idx];
1513 if (bufp->n_type != (unsigned char)N_SO)
1514 error("First symbol in segment of executable not a source symbol");
1516 max_symnum = sym_size / symbol_size;
1519 symnum < max_symnum;
1522 QUIT; /* Allow this to be interruptable */
1523 if (symbuf_idx == symbuf_end)
1525 bufp = &symbuf[symbuf_idx++];
1526 SWAP_SYMBOL (bufp, abfd);
1528 type = bufp->n_type;
1529 if (type == (unsigned char)N_CATCH)
1531 /* N_CATCH is not fixed up by the linker, and unfortunately,
1532 there's no other place to put it in the .stab map. */
1533 bufp->n_value += text_offset - offset;
1538 if (type & N_STAB) {
1539 process_one_symbol (type, bufp->n_desc, bufp->n_value,
1540 namestring, offset, objfile);
1542 /* We skip checking for a new .o or -l file; that should never
1543 happen in this routine. */
1544 else if (type == N_TEXT
1545 && (strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL) == 0
1546 || strcmp (namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0))
1547 /* I don't think this code will ever be executed, because
1548 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1549 the N_SO symbol which starts this source file.
1550 However, there is no reason not to accept
1551 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1552 processing_gcc_compilation = 1;
1553 else if (type & N_EXT || type == (unsigned char)N_TEXT
1554 || type == (unsigned char)N_NBTEXT
1556 /* Global symbol: see if we came across a dbx defintion for
1557 a corresponding symbol. If so, store the value. Remove
1558 syms from the chain when their values are stored, but
1559 search the whole chain, as there may be several syms from
1560 different files with the same name. */
1561 /* This is probably not true. Since the files will be read
1562 in one at a time, each reference to a global symbol will
1563 be satisfied in each file as it appears. So we skip this
1569 current_objfile = NULL;
1571 /* In a Solaris elf file, this variable, which comes from the
1572 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1573 which comes from pst->textlow is correct. */
1574 if (last_source_start_addr == 0)
1575 last_source_start_addr = text_offset;
1577 return end_symtab (text_offset + text_size, 0, 0, objfile);
1580 /* This handles a single symbol from the symbol-file, building symbols
1581 into a GDB symtab. It takes these arguments and an implicit argument.
1583 TYPE is the type field of the ".stab" symbol entry.
1584 DESC is the desc field of the ".stab" entry.
1585 VALU is the value field of the ".stab" entry.
1586 NAME is the symbol name, in our address space.
1587 OFFSET is the amount by which this object file was relocated
1588 when it was loaded into memory. All symbols that refer
1589 to memory locations need to be offset by this amount.
1590 OBJFILE is the object file from which we are reading symbols.
1591 It is used in end_symtab. */
1594 process_one_symbol (type, desc, valu, name, offset, objfile)
1599 struct objfile *objfile;
1601 #ifndef SUN_FIXED_LBRAC_BUG
1602 /* This records the last pc address we've seen. We depend on there being
1603 an SLINE or FUN or SO before the first LBRAC, since the variable does
1604 not get reset in between reads of different symbol files. */
1605 static CORE_ADDR last_pc_address;
1607 register struct context_stack *new;
1608 /* This remembers the address of the start of a function. It is used
1609 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1610 relative to the current function's start address. On systems
1611 other than Solaris 2, this just holds the offset value, and is
1612 used to relocate these symbol types rather than OFFSET. */
1613 static CORE_ADDR function_start_offset;
1616 /* Something is wrong if we see real data before
1617 seeing a source file name. */
1619 if (last_source_file == 0 && type != (unsigned char)N_SO)
1621 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
1622 where that code is defined. */
1623 if (IGNORE_SYMBOL (type))
1626 /* FIXME, this should not be an error, since it precludes extending
1627 the symbol table information in this way... */
1628 error ("Invalid symbol data: does not start by identifying a source file.");
1636 /* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
1637 N_STSYM with a type code of f or F. Can't enable this until we get some
1638 stuff straightened out with psymtabs. */
1644 valu += offset; /* Relocate for dynamic loading */
1646 /* Either of these types of symbols indicates the start of
1647 a new function. We must process its "name" normally for dbx,
1648 but also record the start of a new lexical context, and possibly
1649 also the end of the lexical context for the previous function. */
1650 /* This is not always true. This type of symbol may indicate a
1651 text segment variable. */
1653 colon_pos = strchr (name, ':');
1655 || (*colon_pos != 'f' && *colon_pos != 'F'))
1657 define_symbol (valu, name, desc, type, objfile);
1661 #ifndef SUN_FIXED_LBRAC_BUG
1662 last_pc_address = valu; /* Save for SunOS bug circumcision */
1665 #ifdef BLOCK_ADDRESS_FUNCTION_RELATIVE
1666 /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1667 are relative to the start of the function. On normal systems,
1668 and when using gcc on Solaris 2.0, these addresses are just
1669 absolute, or relative to the N_SO, depending on
1670 BLOCK_ADDRESS_ABSOLUTE. */
1671 function_start_offset = valu;
1673 function_start_offset = offset; /* Default on ordinary systems */
1676 within_function = 1;
1677 if (context_stack_depth > 0)
1679 new = pop_context ();
1680 /* Make a block for the local symbols within. */
1681 finish_block (new->name, &local_symbols, new->old_blocks,
1682 new->start_addr, valu, objfile);
1684 /* Stack must be empty now. */
1685 if (context_stack_depth != 0)
1686 complain (&lbrac_unmatched_complaint, (char *) symnum);
1688 new = push_context (0, valu);
1689 new->name = define_symbol (valu, name, desc, type, objfile);
1693 /* Record the address at which this catch takes place. */
1694 define_symbol (valu+offset, name, desc, type, objfile);
1698 /* This "symbol" just indicates the start of an inner lexical
1699 context within a function. */
1701 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1702 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1703 valu += function_start_offset;
1705 /* On most machines, the block addresses are relative to the
1706 N_SO, the linker did not relocate them (sigh). */
1707 valu += last_source_start_addr;
1710 #ifndef SUN_FIXED_LBRAC_BUG
1711 if (valu < last_pc_address) {
1712 /* Patch current LBRAC pc value to match last handy pc value */
1713 complain (&lbrac_complaint, 0);
1714 valu = last_pc_address;
1717 new = push_context (desc, valu);
1721 /* This "symbol" just indicates the end of an inner lexical
1722 context that was started with N_LBRAC. */
1724 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1725 /* Relocate for dynamic loading and Sun ELF acc fn-relative syms. */
1726 valu += function_start_offset;
1728 /* On most machines, the block addresses are relative to the
1729 N_SO, the linker did not relocate them (sigh). */
1730 valu += last_source_start_addr;
1733 new = pop_context();
1734 if (desc != new->depth)
1735 complain (&lbrac_mismatch_complaint, (char *) symnum);
1737 /* Some compilers put the variable decls inside of an
1738 LBRAC/RBRAC block. This macro should be nonzero if this
1739 is true. DESC is N_DESC from the N_RBRAC symbol.
1740 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1741 or the GCC2_COMPILED_SYMBOL. */
1742 #if !defined (VARIABLES_INSIDE_BLOCK)
1743 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1746 /* Can only use new->locals as local symbols here if we're in
1747 gcc or on a machine that puts them before the lbrack. */
1748 if (!VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1749 local_symbols = new->locals;
1751 /* If this is not the outermost LBRAC...RBRAC pair in the
1752 function, its local symbols preceded it, and are the ones
1753 just recovered from the context stack. Defined the block for them.
1755 If this is the outermost LBRAC...RBRAC pair, there is no
1756 need to do anything; leave the symbols that preceded it
1757 to be attached to the function's own block. However, if
1758 it is so, we need to indicate that we just moved outside
1761 && (context_stack_depth
1762 > !VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation)))
1764 /* FIXME Muzzle a compiler bug that makes end < start. */
1765 if (new->start_addr > valu)
1767 complain(&lbrac_rbrac_complaint, 0);
1768 new->start_addr = valu;
1770 /* Make a block for the local symbols within. */
1771 finish_block (0, &local_symbols, new->old_blocks,
1772 new->start_addr, valu, objfile);
1776 within_function = 0;
1778 if (VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1779 /* Now pop locals of block just finished. */
1780 local_symbols = new->locals;
1785 /* This kind of symbol indicates the start of an object file. */
1786 valu += offset; /* Relocate for dynamic loading */
1790 /* This type of symbol indicates the start of data
1791 for one source file.
1792 Finish the symbol table of the previous source file
1793 (if any) and start accumulating a new symbol table. */
1794 valu += offset; /* Relocate for dynamic loading */
1796 #ifndef SUN_FIXED_LBRAC_BUG
1797 last_pc_address = valu; /* Save for SunOS bug circumcision */
1800 #ifdef PCC_SOL_BROKEN
1801 /* pcc bug, occasionally puts out SO for SOL. */
1802 if (context_stack_depth > 0)
1804 start_subfile (name, NULL);
1808 if (last_source_file)
1810 /* Check if previous symbol was also an N_SO (with some
1811 sanity checks). If so, that one was actually the directory
1812 name, and the current one is the real file name.
1814 if (previous_stab_code == N_SO)
1816 if (current_subfile && current_subfile->dirname == NULL
1817 && current_subfile->name != NULL
1818 && current_subfile->name[strlen(current_subfile->name)-1] == '/')
1820 current_subfile->dirname = current_subfile->name;
1821 current_subfile->name =
1822 obsavestring (name, strlen (name),
1823 &objfile -> symbol_obstack);
1825 break; /* Ignore repeated SOs */
1827 (void) end_symtab (valu, 0, 0, objfile);
1829 start_symtab (name, NULL, valu);
1834 /* This type of symbol indicates the start of data for
1835 a sub-source-file, one whose contents were copied or
1836 included in the compilation of the main source file
1837 (whose name was given in the N_SO symbol.) */
1838 valu += offset; /* Relocate for dynamic loading */
1839 start_subfile (name, NULL);
1844 add_new_header_file (name, valu);
1845 start_subfile (name, NULL);
1849 start_subfile (pop_subfile (), NULL);
1853 add_old_header_file (name, valu);
1857 /* This type of "symbol" really just records
1858 one line-number -- core-address correspondence.
1859 Enter it in the line list for this symbol table. */
1860 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
1861 valu += function_start_offset;
1862 #ifndef SUN_FIXED_LBRAC_BUG
1863 last_pc_address = valu; /* Save for SunOS bug circumcision */
1865 record_line (current_subfile, desc, valu);
1870 error ("Invalid symbol data: common within common at symtab pos %d",
1872 common_block = local_symbols;
1873 common_block_i = local_symbols ? local_symbols->nsyms : 0;
1877 /* Symbols declared since the BCOMM are to have the common block
1878 start address added in when we know it. common_block points to
1879 the first symbol after the BCOMM in the local_symbols list;
1880 copy the list and hang it off the symbol for the common block name
1884 struct symbol *sym =
1885 (struct symbol *) xmmalloc (objfile -> md, sizeof (struct symbol));
1886 bzero (sym, sizeof *sym);
1887 SYMBOL_NAME (sym) = savestring (name, strlen (name));
1888 SYMBOL_CLASS (sym) = LOC_BLOCK;
1889 SYMBOL_NAMESPACE (sym) = (enum namespace)((long)
1890 copy_pending (local_symbols, common_block_i, common_block));
1891 i = hashname (SYMBOL_NAME (sym));
1892 SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
1893 global_sym_chain[i] = sym;
1898 /* The following symbol types need to have the offset added to their
1899 value; then we process symbol definitions in the name. */
1900 case N_STSYM: /* Global symbol */
1901 case N_LCSYM: /* Local symbol */
1902 case N_DSLINE: /* Source line number, data seg */
1903 case N_BSLINE: /* Source line number, bss seg */
1904 /* N_BROWS: overlaps with N_BSLINE */
1905 case N_ENTRY: /* Alternate entry point */
1906 valu += offset; /* Relocate for dynamic loading */
1909 /* The following symbol types don't need the address field relocated,
1910 since it is either unused, or is absolute. */
1911 case N_GSYM: /* Global variable */
1912 case N_NSYMS: /* Number of symbols (ultrix) */
1913 case N_NOMAP: /* No map? (ultrix) */
1914 case N_RSYM: /* Register variable */
1915 case N_DEFD: /* Modula-2 GNU module dependency */
1916 case N_SSYM: /* Struct or union element */
1917 case N_LSYM: /* Local symbol in stack */
1918 case N_PSYM: /* Parameter variable */
1919 case N_LENG: /* Length of preceding symbol type */
1921 define_symbol (valu, name, desc, type, objfile);
1924 /* The following symbol types can be ignored. */
1925 case N_OBJ: /* Solaris 2: Object file dir and name */
1926 case N_OPT: /* Solaris 2: Optimization level? */
1927 /* N_UNDF: Solaris 2: file separator mark */
1928 /* N_UNDF: -- we will never encounter it, since we only process one
1929 file's symbols at once. */
1932 /* The following symbol types we don't know how to process. Handle
1933 them in a "default" way, but complain to people who care. */
1935 case N_EHDECL: /* Exception handler name */
1936 case N_MAIN: /* Name of main routine (not used in C) */
1937 case N_PC: /* Global symbol in Pascal */
1938 case N_M2C: /* Modula-2 compilation unit */
1939 /* N_MOD2: overlaps with N_EHDECL */
1940 case N_SCOPE: /* Modula-2 scope information */
1941 case N_ECOML: /* End common (local name) */
1942 case N_NBTEXT: /* Gould Non-Base-Register symbols??? */
1947 complain (&unknown_symtype_complaint, local_hex_string(type));
1949 define_symbol (valu, name, desc, type, objfile);
1952 previous_stab_code = type;
1955 /* Copy a pending list, used to record the contents of a common
1956 block for later fixup. */
1957 static struct pending *
1958 copy_pending (beg, begi, end)
1959 struct pending *beg;
1961 struct pending *end;
1963 struct pending *new = 0;
1964 struct pending *next;
1966 for (next = beg; next != 0 && (next != end || begi < end->nsyms);
1967 next = next->next, begi = 0)
1970 for (j = begi; j < next->nsyms; j++)
1971 add_symbol_to_list (next->symbol[j], &new);
1976 /* Scan and build partial symbols for an ELF symbol file.
1977 This ELF file has already been processed to get its minimal symbols,
1978 and any DWARF symbols that were in it.
1980 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
1983 OBJFILE is the object file we are reading symbols from.
1984 ADDR is the address relative to which the symbols are (e.g.
1985 the base address of the text segment).
1986 MAINLINE is true if we are reading the main symbol
1987 table (as opposed to a shared lib or dynamically loaded file).
1988 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
1990 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
1991 .stabstr section exists.
1993 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
1994 adjusted for elf details. */
1997 DEFUN(elfstab_build_psymtabs, (objfile, addr, mainline,
1998 staboffset, stabsize,
1999 stabstroffset, stabstrsize),
2000 struct objfile *objfile AND
2003 unsigned int staboffset AND
2004 unsigned int stabsize AND
2005 unsigned int stabstroffset AND
2006 unsigned int stabstrsize)
2009 bfd *sym_bfd = objfile->obfd;
2010 char *name = bfd_get_filename (sym_bfd);
2011 struct dbx_symfile_info *info;
2013 /* Allocate struct to keep track of the symfile */
2014 objfile->sym_private = (PTR) xmmalloc (objfile->md, sizeof (*info));
2015 info = (struct dbx_symfile_info *)objfile->sym_private;
2017 DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
2018 if (!DBX_TEXT_SECT (objfile))
2019 error ("Can't find .text section in symbol file");
2021 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2022 DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
2023 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2024 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2025 DBX_SYMTAB_OFFSET (objfile) = staboffset;
2027 if (stabstrsize < 0)
2028 error ("ridiculous string table size: %d bytes", stabstrsize);
2029 DBX_STRINGTAB (objfile) = (char *)
2030 obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
2032 /* Now read in the string table in one big gulp. */
2034 val = bfd_seek (sym_bfd, stabstroffset, L_SET);
2036 perror_with_name (name);
2037 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2038 if (val != stabstrsize)
2039 perror_with_name (name);
2041 buildsym_new_init ();
2042 free_header_files ();
2043 init_header_files ();
2044 install_minimal_symbols (objfile);
2046 processing_acc_compilation = 1;
2048 /* In an elf file, we've already installed the minimal symbols that came
2049 from the elf (non-stab) symbol table, so always act like an
2050 incremental load here. */
2051 dbx_symfile_read (objfile, addr, 0);
2054 /* Register our willingness to decode symbols for SunOS and a.out and
2055 b.out files handled by BFD... */
2056 static struct sym_fns sunos_sym_fns =
2058 "sunOs", /* sym_name: name or name prefix of BFD target type */
2059 6, /* sym_namelen: number of significant sym_name chars */
2060 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2061 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2062 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2063 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2064 NULL /* next: pointer to next struct sym_fns */
2067 static struct sym_fns aout_sym_fns =
2069 "a.out", /* sym_name: name or name prefix of BFD target type */
2070 5, /* sym_namelen: number of significant sym_name chars */
2071 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2072 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2073 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2074 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2075 NULL /* next: pointer to next struct sym_fns */
2078 static struct sym_fns bout_sym_fns =
2080 "b.out", /* sym_name: name or name prefix of BFD target type */
2081 5, /* sym_namelen: number of significant sym_name chars */
2082 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2083 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2084 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2085 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2086 NULL /* next: pointer to next struct sym_fns */
2089 static struct sym_fns hppa_sym_fns =
2091 "hppa", /* sym_name: name or name prefix of BFD target type */
2092 4, /* sym_namelen: number of significant sym_name chars */
2093 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2094 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2095 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2096 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2097 NULL /* next: pointer to next struct sym_fns */
2101 _initialize_dbxread ()
2103 add_symtab_fns(&sunos_sym_fns);
2104 add_symtab_fns(&aout_sym_fns);
2105 add_symtab_fns(&bout_sym_fns);
2106 add_symtab_fns(&hppa_sym_fns);