/* Read dbx symbol tables and convert to internal format, for GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
Free Software Foundation, Inc.
This file is part of GDB.
#include "command.h"
#include "target.h"
#include "gdbcore.h" /* for bfd stuff */
-#include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
#include "symfile.h"
#include "objfiles.h"
offset for the current and next .o files. */
static unsigned int file_string_table_offset;
static unsigned int next_file_string_table_offset;
+
+/* .o and NLM files contain unrelocated addresses which are based at 0. When
+ non-zero, this flag disables some of the special cases for Solaris elf+stab
+ text addresses at location 0. */
+
+static int symfile_relocatable = 0;
+
+ /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
+ to the function start address. */
+
+static int block_address_function_relative = 0;
\f
/* This is the lowest text address we have yet encountered. */
static CORE_ADDR lowest_text_address;
{"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
struct complaint repeated_header_complaint =
- {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
-
-struct complaint repeated_header_name_complaint =
- {"\"repeated\" header file not previously seen, named %s", 0, 0};
+ {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
\f
/* During initial symbol readin, we need to have a structure to keep
track of which psymtabs have which bincls in them. This structure
static void
dbx_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
+static void
+read_dbx_dynamic_symtab PARAMS ((struct section_offsets *,
+ struct objfile *objfile));
+
static void
read_dbx_symtab PARAMS ((struct section_offsets *, struct objfile *,
CORE_ADDR, int));
add_this_object_header_file (i);
return;
}
- complain (&repeated_header_complaint, symnum);
- complain (&repeated_header_name_complaint, name);
+ complain (&repeated_header_complaint, name, symnum);
}
/* Add to this file a "new" header file: definitions for its types follow.
struct objfile *objfile;
{
enum minimal_symbol_type ms_type;
+ int section;
switch (type)
{
- case N_TEXT | N_EXT: ms_type = mst_text; break;
- case N_DATA | N_EXT: ms_type = mst_data; break;
- case N_BSS | N_EXT: ms_type = mst_bss; break;
- case N_ABS | N_EXT: ms_type = mst_abs; break;
+ case N_TEXT | N_EXT:
+ ms_type = mst_text;
+ section = SECT_OFF_TEXT;
+ break;
+ case N_DATA | N_EXT:
+ ms_type = mst_data;
+ section = SECT_OFF_DATA;
+ break;
+ case N_BSS | N_EXT:
+ ms_type = mst_bss;
+ section = SECT_OFF_BSS;
+ break;
+ case N_ABS | N_EXT:
+ ms_type = mst_abs;
+ section = -1;
+ break;
#ifdef N_SETV
- case N_SETV | N_EXT: ms_type = mst_data; break;
+ case N_SETV | N_EXT:
+ ms_type = mst_data;
+ section = SECT_OFF_DATA;
+ break;
case N_SETV:
/* I don't think this type actually exists; since a N_SETV is the result
of going over many .o files, it doesn't make sense to have one
file local. */
ms_type = mst_file_data;
+ section = SECT_OFF_DATA;
break;
#endif
case N_TEXT:
case N_FN:
case N_FN_SEQ:
ms_type = mst_file_text;
+ section = SECT_OFF_TEXT;
break;
-
case N_DATA:
ms_type = mst_file_data;
if (VTBL_PREFIX_P ((tempstring)))
ms_type = mst_data;
}
+ section = SECT_OFF_DATA;
break;
-
case N_BSS:
ms_type = mst_file_bss;
+ section = SECT_OFF_BSS;
+ break;
+ default:
+ ms_type = mst_unknown;
+ section = -1;
break;
-
- default: ms_type = mst_unknown; break;
}
- if (ms_type == mst_file_text || ms_type == mst_text
+ if ((ms_type == mst_file_text || ms_type == mst_text)
&& address < lowest_text_address)
lowest_text_address = address;
- prim_record_minimal_symbol
+ prim_record_minimal_symbol_and_info
(obsavestring (name, strlen (name), &objfile -> symbol_obstack),
address,
ms_type,
+ NULL,
+ section,
objfile);
}
\f
int val;
struct cleanup *back_to;
+ val = strlen (objfile->name);
+
+ /* .o and .nlm files are relocatables with text, data and bss segs based at
+ 0. This flag disables special (Solaris stabs-in-elf only) fixups for
+ symbols with a value of 0. XXX - This is a Krock. Solaris stabs-in-elf
+ should be fixed to determine pst->textlow without using this text seg of
+ 0 fixup crap. */
+
+ if (strcmp (&objfile->name[val-2], ".o") == 0
+ || strcmp (&objfile->name[val-4], ".nlm") == 0)
+ symfile_relocatable = 1;
+
+ /* This is true for Solaris (and all other systems which put stabs
+ in sections, hopefully, since it would be silly to do things
+ differently from Solaris), and false for SunOS4 and other a.out
+ file formats. */
+ block_address_function_relative =
+ ((0 == strncmp (bfd_get_target (objfile->obfd), "elf", 3))
+ || (0 == strncmp (bfd_get_target (objfile->obfd), "som", 3))
+ || (0 == strncmp (bfd_get_target (objfile->obfd), "coff", 4))
+ || (0 == strncmp (bfd_get_target (objfile->obfd), "nlm", 3)));
+
sym_bfd = objfile->obfd;
val = bfd_seek (objfile->obfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
if (val < 0)
bfd_section_vma (sym_bfd, DBX_TEXT_SECT (objfile)),
bfd_section_size (sym_bfd, DBX_TEXT_SECT (objfile)));
+ /* Add the dynamic symbols. */
+
+ read_dbx_dynamic_symtab (section_offsets, objfile);
+
/* Install any minimal symbols that have been collected as the current
minimal symbols for this objfile. */
install_minimal_symbols (objfile);
- if (!have_partial_symbols ()) {
- wrap_here ("");
- printf_filtered ("(no debugging symbols found)...");
- wrap_here ("");
- }
-
do_cleanups (back_to);
}
&& STREQ (name, bincl->name))
return bincl->pst;
+ complain (&repeated_header_complaint, name, symnum);
return (struct partial_symtab *) 0;
}
bincls_allocated = 0;
}
+/* Scan a SunOs dynamic symbol table for symbols of interest and
+ add them to the minimal symbol table. */
+
+static void
+read_dbx_dynamic_symtab (section_offsets, objfile)
+ struct section_offsets *section_offsets;
+ struct objfile *objfile;
+{
+ bfd *abfd = objfile->obfd;
+ struct cleanup *back_to;
+ int counter;
+ long dynsym_size;
+ long dynsym_count;
+ asymbol **dynsyms;
+ asymbol **symptr;
+ arelent **relptr;
+ long dynrel_size;
+ long dynrel_count;
+ arelent **dynrels;
+ CORE_ADDR sym_value;
+ char *name;
+
+ /* Check that the symbol file has dynamic symbols that we know about.
+ bfd_arch_unknown can happen if we are reading a sun3 symbol file
+ on a sun4 host (and vice versa) and bfd is not configured
+ --with-target=all. This would trigger an assertion in bfd/sunos.c,
+ so we ignore the dynamic symbols in this case. */
+ if (bfd_get_flavour (abfd) != bfd_target_aout_flavour
+ || (bfd_get_file_flags (abfd) & DYNAMIC) == 0
+ || bfd_get_arch (abfd) == bfd_arch_unknown)
+ return;
+
+ dynsym_size = bfd_get_dynamic_symtab_upper_bound (abfd);
+ if (dynsym_size < 0)
+ return;
+
+ dynsyms = (asymbol **) xmalloc (dynsym_size);
+ back_to = make_cleanup (free, dynsyms);
+
+ dynsym_count = bfd_canonicalize_dynamic_symtab (abfd, dynsyms);
+ if (dynsym_count < 0)
+ {
+ do_cleanups (back_to);
+ return;
+ }
+
+ /* Enter dynamic symbols into the minimal symbol table
+ if this is a stripped executable. */
+ if (bfd_get_symcount (abfd) <= 0)
+ {
+ symptr = dynsyms;
+ for (counter = 0; counter < dynsym_count; counter++, symptr++)
+ {
+ asymbol *sym = *symptr;
+ asection *sec;
+ int type;
+
+ sec = bfd_get_section (sym);
+
+ /* BFD symbols are section relative. */
+ sym_value = sym->value + sec->vma;
+
+ if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
+ {
+ sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ type = N_TEXT;
+ }
+ else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
+ {
+ sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA);
+ type = N_DATA;
+ }
+ else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
+ {
+ sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS);
+ type = N_BSS;
+ }
+ else
+ continue;
+
+ if (sym->flags & BSF_GLOBAL)
+ type |= N_EXT;
+
+ name = (char *) bfd_asymbol_name (sym);
+ record_minimal_symbol
+ (obsavestring (name, strlen (name), &objfile -> symbol_obstack),
+ sym_value,
+ type,
+ objfile);
+ }
+ }
+
+ /* Symbols from shared libraries have a dynamic relocation entry
+ that points to the associated slot in the procedure linkage table.
+ We make a mininal symbol table entry with type mst_solib_trampoline
+ at the address in the procedure linkage table. */
+ dynrel_size = bfd_get_dynamic_reloc_upper_bound (abfd);
+ if (dynrel_size < 0)
+ {
+ do_cleanups (back_to);
+ return;
+ }
+
+ dynrels = (arelent **) xmalloc (dynrel_size);
+ make_cleanup (free, dynrels);
+
+ dynrel_count = bfd_canonicalize_dynamic_reloc (abfd, dynrels, dynsyms);
+ if (dynrel_count < 0)
+ {
+ do_cleanups (back_to);
+ return;
+ }
+
+ for (counter = 0, relptr = dynrels;
+ counter < dynrel_count;
+ counter++, relptr++)
+ {
+ arelent *rel = *relptr;
+ CORE_ADDR address =
+ rel->address + ANOFFSET (section_offsets, SECT_OFF_DATA);
+
+ switch (bfd_get_arch (abfd))
+ {
+ case bfd_arch_sparc:
+ if (rel->howto->type != RELOC_JMP_SLOT)
+ continue;
+ break;
+ case bfd_arch_m68k:
+ /* `16' is the type BFD produces for a jump table relocation. */
+ if (rel->howto->type != 16)
+ continue;
+
+ /* Adjust address in the jump table to point to
+ the start of the bsr instruction. */
+ address -= 2;
+ break;
+ default:
+ continue;
+ }
+
+ name = bfd_asymbol_name (*rel->sym_ptr_ptr);
+ prim_record_minimal_symbol
+ (obsavestring (name, strlen (name), &objfile -> symbol_obstack),
+ address,
+ mst_solib_trampoline,
+ objfile);
+ }
+
+ do_cleanups (back_to);
+}
+
/* Given pointers to an a.out symbol table in core containing dbx
style data, setup partial_symtab's describing each source file for
which debugging information is available.
struct cleanup *back_to;
bfd *abfd;
- /* End of the text segment of the executable file. */
- CORE_ADDR end_of_text_addr;
-
/* Current partial symtab */
struct partial_symtab *pst;
if (((unsigned)bufp->n_strx + file_string_table_offset) >= \
DBX_STRINGTAB_SIZE (objfile)) { \
complain (&string_table_offset_complaint, symnum); \
- namestring = "foo"; \
+ namestring = "<bad string table offset>"; \
} else \
namestring = bufp->n_strx + file_string_table_offset + \
DBX_STRINGTAB (objfile)
end_psymtab (pst, psymtab_include_list, includes_used,
symnum * symbol_size,
(lowest_text_address == (CORE_ADDR)-1
- ? text_addr : lowest_text_address)
+ ? (text_addr + section_offsets->offsets[SECT_OFF_TEXT])
+ : lowest_text_address)
+ text_size,
dependency_list, dependencies_used);
}
int number_dependencies;
{
int i;
- struct partial_symtab *p1;
struct objfile *objfile = pst -> objfile;
if (capping_symbol_offset != -1)
own ending address to our starting address, nor to set addresses on
`dependency' files that have both textlow and texthigh zero. */
if (pst->textlow) {
+ struct partial_symtab *p1;
+
ALL_OBJFILE_PSYMTABS (objfile, p1) {
if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst) {
p1->texthigh = pst->textlow;
free_named_symtabs (pst->filename);
if (num_includes == 0
- && number_dependencies == 0
- && pst->n_global_syms == 0
- && pst->n_static_syms == 0) {
- /* Throw away this psymtab, it's empty. We can't deallocate it, since
- it is on the obstack, but we can forget to chain it on the list. */
- struct partial_symtab *prev_pst;
-
- /* First, snip it out of the psymtab chain */
-
- if (pst->objfile->psymtabs == pst)
- pst->objfile->psymtabs = pst->next;
- else
- for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
- if (prev_pst->next == pst)
- prev_pst->next = pst->next;
+ && number_dependencies == 0
+ && pst->n_global_syms == 0
+ && pst->n_static_syms == 0)
+ {
+ /* Throw away this psymtab, it's empty. We can't deallocate it, since
+ it is on the obstack, but we can forget to chain it on the list. */
+ /* Empty psymtabs happen as a result of header files which don't have
+ any symbols in them. There can be a lot of them. But this check
+ is wrong, in that a psymtab with N_SLINE entries but nothing else
+ is not empty, but we don't realize that. Fixing that without slowing
+ things down might be tricky. */
+ struct partial_symtab *prev_pst;
+
+ /* First, snip it out of the psymtab chain */
+
+ if (pst->objfile->psymtabs == pst)
+ pst->objfile->psymtabs = pst->next;
+ else
+ for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
+ if (prev_pst->next == pst)
+ prev_pst->next = pst->next;
- /* Next, put it on a free list for recycling */
+ /* Next, put it on a free list for recycling */
- pst->next = pst->objfile->free_psymtabs;
- pst->objfile->free_psymtabs = pst;
+ pst->next = pst->objfile->free_psymtabs;
+ pst->objfile->free_psymtabs = pst;
- /* Indicate that psymtab was thrown away. */
- pst = (struct partial_symtab *)NULL;
- }
+ /* Indicate that psymtab was thrown away. */
+ pst = (struct partial_symtab *)NULL;
+ }
return pst;
}
\f
processing_gcc_compilation = 0;
if (bufp->n_type == N_TEXT)
{
+ const char *tempstring = namestring;
+
if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
processing_gcc_compilation = 1;
else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
processing_gcc_compilation = 2;
+ if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
+ ++tempstring;
+ if (STREQN (tempstring, "__gnu_compiled", 14))
+ processing_gcc_compilation = 2;
}
/* Try to select a C++ demangling based on the compilation unit
used to relocate these symbol types rather than SECTION_OFFSETS. */
static CORE_ADDR function_start_offset;
- /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are relative
- to the function start address. */
- int block_address_function_relative;
-
/* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
file. Used to detect the SunPRO solaris compiler. */
static int n_opt_found;
N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
static int function_stab_type = 0;
- /* This is true for Solaris (and all other systems which put stabs
- in sections, hopefully, since it would be silly to do things
- differently from Solaris), and false for SunOS4 and other a.out
- file formats. */
- block_address_function_relative =
- ((0 == strncmp (bfd_get_target (objfile->obfd), "elf", 3))
- || (0 == strncmp (bfd_get_target (objfile->obfd), "som", 3))
- || (0 == strncmp (bfd_get_target (objfile->obfd), "coff", 4)));
-
if (!block_address_function_relative)
/* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
function start address, so just use the text offset. */
end_symtab (valu, 0, 0, objfile, SECT_OFF_TEXT);
end_stabs ();
}
+
+ /* Null name means this just marks the end of text for this .o file.
+ Don't start a new symtab in this case. */
+ if (*name == '\000')
+ break;
+
start_stabs ();
start_symtab (name, NULL, valu);
break;
-
case N_SOL:
/* This type of symbol indicates the start of data for
a sub-source-file, one whose contents were copied or
call level, which we really don't want to do). */
{
char *p;
- p = strchr (name, ':');
- if (p != 0 && p[1] == 'S')
+
+ /* .o files and NLMs have non-zero text seg offsets, but don't need
+ their static syms offset in this fashion. XXX - This is really a
+ crock that should be fixed in the solib handling code so that I
+ don't have to work around it here. */
+
+ if (!symfile_relocatable)
{
- /* The linker relocated it. We don't want to add an
- elfstab_offset_sections-type offset, but we *do* want
- to add whatever solib.c passed to symbol_file_add as
- addr (this is known to affect SunOS4, and I suspect ELF
- too). Since elfstab_offset_sections currently does not
- muck with the text offset (there is no Ttext.text
- symbol), we can get addr from the text offset. If
- elfstab_offset_sections ever starts dealing with the
- text offset, and we still need to do this, we need to
- invent a SECT_OFF_ADDR_KLUDGE or something. */
- valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
- goto define_a_symbol;
+ p = strchr (name, ':');
+ if (p != 0 && p[1] == 'S')
+ {
+ /* The linker relocated it. We don't want to add an
+ elfstab_offset_sections-type offset, but we *do* want
+ to add whatever solib.c passed to symbol_file_add as
+ addr (this is known to affect SunOS4, and I suspect ELF
+ too). Since elfstab_offset_sections currently does not
+ muck with the text offset (there is no Ttext.text
+ symbol), we can get addr from the text offset. If
+ elfstab_offset_sections ever starts dealing with the
+ text offset, and we still need to do this, we need to
+ invent a SECT_OFF_ADDR_KLUDGE or something. */
+ valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ goto define_a_symbol;
+ }
}
/* Since it's not the kludge case, re-dispatch to the right handler. */
switch (type) {
dbx_symfile_read (objfile, section_offsets, 0);
}
\f
-/* Scan and build partial symbols for a PA symbol file.
- This PA file has already been processed to get its minimal symbols.
+/* Scan and build partial symbols for a file with special sections for stabs
+ and stabstrings. The file has already been processed to get its minimal
+ symbols, and any other symbols that might be necessary to resolve GSYMs.
+
+ This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
+ rolled into one.
OBJFILE is the object file we are reading symbols from.
- ADDR is the address relative to which the symbols are (e.g.
- the base address of the text segment).
- MAINLINE is true if we are reading the main symbol
- table (as opposed to a shared lib or dynamically loaded file).
+ ADDR is the address relative to which the symbols are (e.g. the base address
+ of the text segment).
+ MAINLINE is true if we are reading the main symbol table (as opposed to a
+ shared lib or dynamically loaded file).
+ STAB_NAME is the name of the section that contains the stabs.
+ STABSTR_NAME is the name of the section that contains the stab strings.
- */
+ This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
void
-pastab_build_psymtabs (objfile, section_offsets, mainline)
+stabsect_build_psymtabs (objfile, section_offsets, mainline, stab_name,
+ stabstr_name, text_name)
struct objfile *objfile;
struct section_offsets *section_offsets;
int mainline;
+ char *stab_name;
+ char *stabstr_name;
+ char *text_name;
{
+ int val;
+ bfd *sym_bfd = objfile->obfd;
+ char *name = bfd_get_filename (sym_bfd);
+ asection *stabsect;
+ asection *stabstrsect;
+
+ stabsect = bfd_get_section_by_name (sym_bfd, stab_name);
+ stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name);
+
+ if (!stabsect)
+ return;
+
+ if (!stabstrsect)
+ error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
+ stab_name, stabstr_name);
+
+ objfile->sym_stab_info = (PTR) xmalloc (sizeof (struct dbx_symfile_info));
+ memset (DBX_SYMFILE_INFO (objfile), 0, sizeof (struct dbx_symfile_info));
+
+ DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, text_name);
+ if (!DBX_TEXT_SECT (objfile))
+ error ("Can't find %s section in symbol file", text_name);
+
+ DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist);
+ DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
+ / DBX_SYMBOL_SIZE (objfile);
+ DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect);
+ DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
+
+ if (DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
+ error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile));
+ DBX_STRINGTAB (objfile) = (char *)
+ obstack_alloc (&objfile->psymbol_obstack, DBX_STRINGTAB_SIZE (objfile) + 1);
+
+ /* Now read in the string table in one big gulp. */
+
+ val = bfd_get_section_contents (sym_bfd, /* bfd */
+ stabstrsect, /* bfd section */
+ DBX_STRINGTAB (objfile), /* input buffer */
+ 0, /* offset into section */
+ DBX_STRINGTAB_SIZE (objfile)); /* amount to read */
+
+ if (!val)
+ perror_with_name (name);
+
+ stabsread_new_init ();
+ buildsym_new_init ();
free_header_files ();
init_header_files ();
+ install_minimal_symbols (objfile);
- /* This is needed to debug objects assembled with gas2. */
- processing_acc_compilation = 1;
-
- /* In a PA file, we've already installed the minimal symbols that came
- from the PA (non-stab) symbol table, so always act like an
- incremental load here. */
+ /* Now, do an incremental load */
- dbx_symfile_read (objfile, section_offsets, mainline);
+ processing_acc_compilation = 1;
+ dbx_symfile_read (objfile, section_offsets, 0);
}
\f
/* Parse the user's idea of an offset for dynamic linking, into our idea