#include "symfile.h"
#include "objfiles.h"
#include "buildsym.h"
+#include "stabsread.h"
+#include "gdb-stabs.h"
+#include "demangle.h"
#include "aout/aout64.h"
#include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
-/* Information is passed among various dbxread routines for accessing
- symbol files. A pointer to this structure is kept in the sym_private
- field of the objfile struct. */
-
-#ifdef hp9000s800
-struct dbx_symfile_info {
- asection *text_sect; /* Text section accessor */
- int symcount; /* How many symbols are there in the file */
- char *stringtab; /* The actual string table */
- int stringtab_size; /* Its size */
- off_t symtab_offset; /* Offset in file to symbol table */
- int hp_symcount;
- char *hp_stringtab;
- int hp_stringtab_size;
- off_t hp_symtab_offset;
-};
-#else
-struct dbx_symfile_info {
- asection *text_sect; /* Text section accessor */
- int symcount; /* How many symbols are there in the file */
- char *stringtab; /* The actual string table */
- int stringtab_size; /* Its size */
- off_t symtab_offset; /* Offset in file to symbol table */
- int symbol_size; /* Bytes in a single symbol */
-};
-#endif
-
-#define DBX_SYMFILE_INFO(o) ((struct dbx_symfile_info *)((o)->sym_private))
-#define DBX_TEXT_SECT(o) (DBX_SYMFILE_INFO(o)->text_sect)
-#define DBX_SYMCOUNT(o) (DBX_SYMFILE_INFO(o)->symcount)
-#define DBX_STRINGTAB(o) (DBX_SYMFILE_INFO(o)->stringtab)
-#define DBX_STRINGTAB_SIZE(o) (DBX_SYMFILE_INFO(o)->stringtab_size)
-#define DBX_SYMTAB_OFFSET(o) (DBX_SYMFILE_INFO(o)->symtab_offset)
-#define DBX_SYMBOL_SIZE(o) (DBX_SYMFILE_INFO(o)->symbol_size)
-#ifdef hp9000s800
-#define HP_SYMCOUNT(o) (DBX_SYMFILE_INFO(o)->hp_symcount)
-#define HP_STRINGTAB(o) (DBX_SYMFILE_INFO(o)->hp_stringtab)
-#define HP_STRINGTAB_SIZE(o) (DBX_SYMFILE_INFO(o)->hp_stringtab_size)
-#define HP_SYMTAB_OFFSET(o) (DBX_SYMFILE_INFO(o)->hp_symtab_offset)
-#endif
-
/* Each partial symbol table entry contains a pointer to private data for the
read_symtab() function to use when expanding a partial symbol table entry
to a full symbol table entry.
copy_pending PARAMS ((struct pending *, int, struct pending *));
static struct symtab *
-read_ofile_symtab PARAMS ((struct objfile *, int, int, CORE_ADDR, int, int));
+read_ofile_symtab PARAMS ((struct objfile *, int, int, CORE_ADDR, int,
+ struct section_offsets *));
static void
dbx_psymtab_to_symtab PARAMS ((struct partial_symtab *));
dbx_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
static void
-read_dbx_symtab PARAMS ((CORE_ADDR, struct objfile *, CORE_ADDR, int));
+read_dbx_symtab PARAMS ((struct section_offsets *, struct objfile *,
+ CORE_ADDR, int));
static void
free_bincl_list PARAMS ((struct objfile *));
dbx_new_init PARAMS ((struct objfile *));
static void
-dbx_symfile_read PARAMS ((struct objfile *, CORE_ADDR, int));
+dbx_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
static void
dbx_symfile_finish PARAMS ((struct objfile *));
header_files[i].length = 10;
header_files[i].vector
= (struct type **) xmalloc (10 * sizeof (struct type *));
- bzero (header_files[i].vector, 10 * sizeof (struct type *));
+ memset (header_files[i].vector, 0, 10 * sizeof (struct type *));
add_this_object_header_file (i);
}
put all the relevant info into a "struct dbx_symfile_info",
hung off the objfile structure.
- ADDR is the address relative to which the symbols in it are (e.g.
- the base address of the text segment).
+ SECTION_OFFSETS contains offsets relative to which the symbols in the
+ various sections are (depending where the sections were actually loaded).
MAINLINE is true if we are reading the main symbol
table (as opposed to a shared lib or dynamically loaded file). */
static void
-dbx_symfile_read (objfile, addr, mainline)
+dbx_symfile_read (objfile, section_offsets, mainline)
struct objfile *objfile;
- CORE_ADDR addr;
+ struct section_offsets *section_offsets;
int mainline; /* FIXME comments above */
{
bfd *sym_bfd;
/* Now that the symbol table data of the executable file are all in core,
process them and define symbols accordingly. */
- addr -= bfd_section_vma (sym_bfd, DBX_TEXT_SECT (objfile)); /*offset*/
- read_dbx_symtab (addr, objfile,
+ read_dbx_symtab (section_offsets, objfile,
bfd_section_vma (sym_bfd, DBX_TEXT_SECT (objfile)),
bfd_section_size (sym_bfd, DBX_TEXT_SECT (objfile)));
dbx_new_init (ignore)
struct objfile *ignore;
{
+ stabsread_new_init ();
buildsym_new_init ();
init_header_files ();
}
#endif
/* FIXME POKING INSIDE BFD DATA STRUCTURES */
+ DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
if (!DBX_TEXT_SECT (objfile))
error ("Can't find .text section in symbol file");
- DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
#ifdef hp9000s800
HP_SYMCOUNT (objfile) = obj_hp_sym_count (sym_bfd);
DBX_SYMCOUNT (objfile) = obj_dbx_sym_count (sym_bfd);
#else
+ DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
#endif
DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
style data, setup partial_symtab's describing each source file for
which debugging information is available.
SYMFILE_NAME is the name of the file we are reading from
- and ADDR is its relocated address (if incremental) or 0 (if not). */
+ and SECTION_OFFSETS is the set of offsets for the various sections
+ of the file (a set of zeros if the mainline program). */
static void
-read_dbx_symtab (addr, objfile, text_addr, text_size)
- CORE_ADDR addr;
+read_dbx_symtab (section_offsets, objfile, text_addr, text_size)
+ struct section_offsets *section_offsets;
struct objfile *objfile;
CORE_ADDR text_addr;
int text_size;
init_bincl_list (20, objfile);
make_cleanup (free_bincl_list, objfile);
- last_source_file = 0;
+ last_source_file = NULL;
#ifdef END_OF_TEXT_DEFAULT
end_of_text_addr = END_OF_TEXT_DEFAULT;
#else
- end_of_text_addr = text_addr + addr + text_size; /* Relocate */
+ end_of_text_addr = text_addr + section_offsets->offsets[SECT_OFF_TEXT]
+ + text_size; /* Relocate */
#endif
symfile_bfd = objfile->obfd; /* For next_text_symbol */
#define CUR_SYMBOL_TYPE bufp->n_type
#define CUR_SYMBOL_VALUE bufp->n_value
#define DBXREAD_ONLY
-#define START_PSYMTAB(ofile,addr,fname,low,symoff,global_syms,static_syms)\
- start_psymtab(ofile, addr, fname, low, symoff, global_syms, static_syms)
+#define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
+ start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
#define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
struct partial_symtab *
-start_psymtab (objfile, addr,
+start_psymtab (objfile, section_offsets,
filename, textlow, ldsymoff, global_syms, static_syms)
struct objfile *objfile;
- CORE_ADDR addr;
+ struct section_offsets *section_offsets;
char *filename;
CORE_ADDR textlow;
int ldsymoff;
struct partial_symbol *static_syms;
{
struct partial_symtab *result =
- start_psymtab_common(objfile, addr,
+ start_psymtab_common(objfile, section_offsets,
filename, textlow, global_syms, static_syms);
result->read_symtab_private = (char *)
STRING_OFFSET(result) = string_table_offset;
FILE_STRING_OFFSET(result) = file_string_table_offset;
+ /* If we're handling an ELF file, drag some section-relocation info
+ for this source file out of the ELF symbol table, to compensate for
+ Sun brain death. This replaces the section_offsets in this psymtab,
+ if successful. */
+ elfstab_offset_sections (objfile, result);
+
return result;
}
struct partial_symtab *subpst =
allocate_psymtab (include_list[i], objfile);
- subpst->addr = pst->addr;
+ subpst->section_offsets = pst->section_offsets;
subpst->read_symtab_private =
(char *) obstack_alloc (&objfile->psymbol_obstack,
sizeof (struct symloc));
if (LDSYMLEN(pst)) /* Otherwise it's a dummy */
{
/* Init stuff necessary for reading in symbols */
+ stabsread_init ();
buildsym_init ();
old_chain = make_cleanup (really_free_pendings, 0);
file_string_table_offset = FILE_STRING_OFFSET (pst);
pst->symtab =
read_ofile_symtab (pst->objfile, LDSYMOFF(pst), LDSYMLEN(pst),
pst->textlow, pst->texthigh - pst->textlow,
- pst->addr);
+ pst->section_offsets);
sort_symtab_syms (pst->symtab);
do_cleanups (old_chain);
SYM_SIZE is the size of the symbol info to read in.
TEXT_OFFSET is the beginning of the text segment we are reading symbols for
TEXT_SIZE is the size of the text segment read in.
- OFFSET is a relocation offset which gets added to each symbol. */
+ SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
static struct symtab *
read_ofile_symtab (objfile, sym_offset, sym_size, text_offset, text_size,
- offset)
+ section_offsets)
struct objfile *objfile;
int sym_offset;
int sym_size;
CORE_ADDR text_offset;
int text_size;
- int offset;
+ struct section_offsets *section_offsets;
{
register char *namestring;
register struct internal_nlist *bufp;
unsigned char type;
unsigned max_symnum;
register bfd *abfd;
+ struct symtab *rtn;
current_objfile = objfile;
- subfile_stack = 0;
+ subfile_stack = NULL;
#ifdef hp9000s800
stringtab_global = HP_STRINGTAB (objfile);
#else
stringtab_global = DBX_STRINGTAB (objfile);
#endif
- last_source_file = 0;
+ last_source_file = NULL;
abfd = objfile->obfd;
symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */
(bufp->n_type == N_TEXT
&& (strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL) == 0
|| strcmp(namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0));
+
+ /* Try to select a C++ demangling based on the compilation unit
+ producer. */
+
+ if (processing_gcc_compilation)
+ {
+#if 1 /* Works, but is experimental. -fnf */
+ if (current_demangling_style == auto_demangling)
+ {
+ set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
+ }
+#endif
+ }
}
else
{
if (type & N_STAB) {
process_one_symbol (type, bufp->n_desc, bufp->n_value,
- namestring, offset, objfile);
+ namestring, section_offsets, objfile);
}
/* We skip checking for a new .o or -l file; that should never
happen in this routine. */
else if (type == N_TEXT
&& (strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL) == 0
|| strcmp (namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0))
- /* I don't think this code will ever be executed, because
- the GCC_COMPILED_FLAG_SYMBOL usually is right before
- the N_SO symbol which starts this source file.
- However, there is no reason not to accept
- the GCC_COMPILED_FLAG_SYMBOL anywhere. */
- processing_gcc_compilation = 1;
+ {
+ /* I don't think this code will ever be executed, because
+ the GCC_COMPILED_FLAG_SYMBOL usually is right before
+ the N_SO symbol which starts this source file.
+ However, there is no reason not to accept
+ the GCC_COMPILED_FLAG_SYMBOL anywhere. */
+ processing_gcc_compilation = 1;
+#if 1 /* Works, but is experimental. -fnf */
+ if (current_demangling_style == auto_demangling)
+ {
+ set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
+ }
+#endif
+ }
else if (type & N_EXT || type == (unsigned char)N_TEXT
|| type == (unsigned char)N_NBTEXT
) {
if (last_source_start_addr == 0)
last_source_start_addr = text_offset;
- return end_symtab (text_offset + text_size, 0, 0, objfile);
+ rtn = end_symtab (text_offset + text_size, 0, 0, objfile);
+ end_stabs ();
+ return (rtn);
}
\f
/* This handles a single symbol from the symbol-file, building symbols
DESC is the desc field of the ".stab" entry.
VALU is the value field of the ".stab" entry.
NAME is the symbol name, in our address space.
- OFFSET is the amount by which this object file was relocated
- when it was loaded into memory. All symbols that refer
- to memory locations need to be offset by this amount.
+ SECTION_OFFSETS is a set of amounts by which the sections of this object
+ file were relocated when it was loaded into memory.
+ All symbols that refer
+ to memory locations need to be offset by these amounts.
OBJFILE is the object file from which we are reading symbols.
It is used in end_symtab. */
void
-process_one_symbol (type, desc, valu, name, offset, objfile)
+process_one_symbol (type, desc, valu, name, section_offsets, objfile)
int type, desc;
CORE_ADDR valu;
char *name;
- int offset;
+ struct section_offsets *section_offsets;
struct objfile *objfile;
{
#ifndef SUN_FIXED_LBRAC_BUG
/* This remembers the address of the start of a function. It is used
because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
relative to the current function's start address. On systems
- other than Solaris 2, this just holds the offset value, and is
- used to relocate these symbol types rather than OFFSET. */
+ other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
+ used to relocate these symbol types rather than SECTION_OFFSETS. */
static CORE_ADDR function_start_offset;
char *colon_pos;
/* Something is wrong if we see real data before
seeing a source file name. */
- if (last_source_file == 0 && type != (unsigned char)N_SO)
+ if (last_source_file == NULL && type != (unsigned char)N_SO)
{
/* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
where that code is defined. */
#if 0
/* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
N_STSYM with a type code of f or F. Can't enable this until we get some
- stuff straightened out with psymtabs. */
+ stuff straightened out with psymtabs. FIXME. */
case N_GSYM:
case N_STSYM:
#endif /* 0 */
- valu += offset; /* Relocate for dynamic loading */
+ /* Relocate for dynamic loading */
+ valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
/* Either of these types of symbols indicates the start of
a new function. We must process its "name" normally for dbx,
BLOCK_ADDRESS_ABSOLUTE. */
function_start_offset = valu;
#else
- function_start_offset = offset; /* Default on ordinary systems */
+ /* Default on ordinary systems */
+ function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
#endif
within_function = 1;
case N_FN:
case N_FN_SEQ:
/* This kind of symbol indicates the start of an object file. */
- valu += offset; /* Relocate for dynamic loading */
+ /* Relocate for dynamic loading */
+ valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
break;
case N_SO:
for one source file.
Finish the symbol table of the previous source file
(if any) and start accumulating a new symbol table. */
- valu += offset; /* Relocate for dynamic loading */
+ /* Relocate for dynamic loading */
+ valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
#ifndef SUN_FIXED_LBRAC_BUG
last_pc_address = valu; /* Save for SunOS bug circumcision */
Patch things up. */
if (previous_stab_code == N_SO)
{
- if (current_subfile && current_subfile->dirname == NULL
- && current_subfile->name != NULL
- && current_subfile->name[strlen(current_subfile->name)-1] == '/')
- {
- current_subfile->dirname = current_subfile->name;
- current_subfile->name =
- obsavestring (name, strlen (name),
- &objfile -> symbol_obstack);
- }
+ patch_subfile_names (current_subfile, name);
break; /* Ignore repeated SOs */
}
- (void) end_symtab (valu, 0, 0, objfile);
+ end_symtab (valu, 0, 0, objfile);
+ end_stabs ();
}
+ start_stabs ();
start_symtab (name, NULL, valu);
break;
a sub-source-file, one whose contents were copied or
included in the compilation of the main source file
(whose name was given in the N_SO symbol.) */
- valu += offset; /* Relocate for dynamic loading */
- start_subfile (name, NULL);
+ /* Relocate for dynamic loading */
+ valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ start_subfile (name, current_subfile->dirname);
break;
case N_BINCL:
push_subfile ();
add_new_header_file (name, valu);
- start_subfile (name, NULL);
+ start_subfile (name, current_subfile->dirname);
break;
case N_EINCL:
- start_subfile (pop_subfile (), NULL);
+ start_subfile (pop_subfile (), current_subfile->dirname);
break;
case N_EXCL:
int i;
struct symbol *sym =
(struct symbol *) xmmalloc (objfile -> md, sizeof (struct symbol));
- bzero (sym, sizeof *sym);
+ memset (sym, 0, sizeof *sym);
SYMBOL_NAME (sym) = savestring (name, strlen (name));
SYMBOL_CLASS (sym) = LOC_BLOCK;
SYMBOL_NAMESPACE (sym) = (enum namespace)((long)
break;
}
- /* The following symbol types need to have the offset added to their
- value; then we process symbol definitions in the name. */
- case N_STSYM: /* Global symbol */
- case N_LCSYM: /* Local symbol */
+ /* The following symbol types need to have the appropriate offset added
+ to their value; then we process symbol definitions in the name. */
+
+ case N_STSYM: /* Static symbol in data seg */
+ case N_LCSYM: /* Static symbol in BSS seg */
+ case N_ROSYM: /* Static symbol in Read-only data seg */
+ /* HORRID HACK DEPT. However, it's Sun's furgin' fault. FIXME.
+ Solaris2's stabs-in-coff makes *most* symbols relative
+ but leaves a few absolute. N_STSYM and friends sit on the fence.
+ .stab "foo:S...",N_STSYM is absolute (ld relocates it)
+ .stab "foo:V...",N_STSYM is relative (section base subtracted).
+ This leaves us no choice but to search for the 'S' or 'V'...
+ (or pass the whole section_offsets stuff down ONE MORE function
+ call level, which we really don't want to do). */
+ {
+ char *p;
+ p = strchr (name, ':');
+ if (p != 0 && p[1] == 'S')
+ {
+ /* FIXME! We relocate it by the TEXT offset, in case the
+ whole module moved in memory. But this is wrong, since
+ the sections can side around independently. */
+ 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) {
+ case N_STSYM: goto case_N_STSYM;
+ case N_LCSYM: goto case_N_LCSYM;
+ case N_ROSYM: goto case_N_ROSYM;
+ default: abort();
+ }
+ }
+
+ case_N_STSYM: /* Static symbol in data seg */
case N_DSLINE: /* Source line number, data seg */
+ valu += ANOFFSET (section_offsets, SECT_OFF_DATA);
+ goto define_a_symbol;
+
+ case_N_LCSYM: /* Static symbol in BSS seg */
case N_BSLINE: /* Source line number, bss seg */
/* N_BROWS: overlaps with N_BSLINE */
+ valu += ANOFFSET (section_offsets, SECT_OFF_BSS);
+ goto define_a_symbol;
+
+ case_N_ROSYM: /* Static symbol in Read-only data seg */
+ valu += ANOFFSET (section_offsets, SECT_OFF_RODATA);
+ goto define_a_symbol;
+
case N_ENTRY: /* Alternate entry point */
- valu += offset; /* Relocate for dynamic loading */
- /* FALL THROUGH */
+ /* Relocate for dynamic loading */
+ valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ goto define_a_symbol;
/* The following symbol types don't need the address field relocated,
since it is either unused, or is absolute. */
+ define_a_symbol:
case N_GSYM: /* Global variable */
case N_NSYMS: /* Number of symbols (ultrix) */
case N_NOMAP: /* No map? (ultrix) */
define_symbol (valu, name, desc, type, objfile);
break;
+ /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
+ for a bunch of other flags, too. Someday we may parse their
+ flags; for now we ignore theirs and hope they'll ignore ours. */
+ case N_OPT: /* Solaris 2: Compiler options */
+ if (name)
+ {
+ if (!strcmp (name, GCC2_COMPILED_FLAG_SYMBOL))
+ {
+ processing_gcc_compilation = 1;
+#if 1 /* Works, but is experimental. -fnf */
+ if (current_demangling_style == auto_demangling)
+ {
+ set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
+ }
+#endif
+ }
+ }
+ break;
+
/* The following symbol types can be ignored. */
case N_OBJ: /* Solaris 2: Object file dir and name */
- case N_OPT: /* Solaris 2: Optimization level? */
/* N_UNDF: Solaris 2: file separator mark */
/* N_UNDF: -- we will never encounter it, since we only process one
file's symbols at once. */
+ case N_ENDM: /* Solaris 2: End of module */
+ case N_MAIN: /* Name of main routine. */
break;
/* The following symbol types we don't know how to process. Handle
them in a "default" way, but complain to people who care. */
default:
+ case N_CATCH: /* Exception handler catcher */
case N_EHDECL: /* Exception handler name */
- case N_MAIN: /* Name of main routine (not used in C) */
case N_PC: /* Global symbol in Pascal */
case N_M2C: /* Modula-2 compilation unit */
/* N_MOD2: overlaps with N_EHDECL */
case N_NBBSS:
case N_NBSTS:
case N_NBLCS:
- case N_CATCH:
complain (&unknown_symtype_complaint, local_hex_string(type));
if (name)
define_symbol (valu, name, desc, type, objfile);
adjusted for elf details. */
void
-DEFUN(elfstab_build_psymtabs, (objfile, addr, mainline,
+DEFUN(elfstab_build_psymtabs, (objfile, section_offsets, mainline,
staboffset, stabsize,
stabstroffset, stabstrsize),
struct objfile *objfile AND
- CORE_ADDR addr AND
+ struct section_offsets *section_offsets AND
int mainline AND
unsigned int staboffset AND
unsigned int stabsize AND
char *name = bfd_get_filename (sym_bfd);
struct dbx_symfile_info *info;
- /* Allocate struct to keep track of the symfile */
- objfile->sym_private = (PTR) xmmalloc (objfile->md, sizeof (*info));
- info = (struct dbx_symfile_info *)objfile->sym_private;
+ /* There is already a dbx_symfile_info allocated by our caller.
+ It might even contain some info from the ELF symtab to help us. */
+ info = (struct dbx_symfile_info *) objfile->sym_private;
DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
if (!DBX_TEXT_SECT (objfile))
DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
DBX_SYMTAB_OFFSET (objfile) = staboffset;
- if (stabstrsize < 0)
+ if (stabstrsize < 0) /* FIXME: stabstrsize is unsigned; never true! */
error ("ridiculous string table size: %d bytes", stabstrsize);
DBX_STRINGTAB (objfile) = (char *)
obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
if (val != stabstrsize)
perror_with_name (name);
+ stabsread_new_init ();
buildsym_new_init ();
free_header_files ();
init_header_files ();
/* In an elf file, we've already installed the minimal symbols that came
from the elf (non-stab) symbol table, so always act like an
incremental load here. */
- dbx_symfile_read (objfile, addr, 0);
+ dbx_symfile_read (objfile, section_offsets, 0);
+}
+\f
+/* Parse the user's idea of an offset for dynamic linking, into our idea
+ of how to represent it for fast symbol reading. */
+
+struct section_offsets *
+dbx_symfile_offsets (objfile, addr)
+ struct objfile *objfile;
+ CORE_ADDR addr;
+{
+ struct section_offsets *section_offsets;
+ int i;
+
+ section_offsets = (struct section_offsets *)
+ obstack_alloc (&objfile -> psymbol_obstack,
+ sizeof (struct section_offsets) +
+ sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
+
+ for (i = 0; i < SECT_OFF_MAX; i++)
+ ANOFFSET (section_offsets, i) = addr;
+
+ return section_offsets;
}
\f
/* Register our willingness to decode symbols for SunOS and a.out and
dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
dbx_symfile_read, /* sym_read: read a symbol file into symtab */
dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
+ dbx_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */
NULL /* next: pointer to next struct sym_fns */
};
dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
dbx_symfile_read, /* sym_read: read a symbol file into symtab */
dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
+ dbx_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */
NULL /* next: pointer to next struct sym_fns */
};
dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
dbx_symfile_read, /* sym_read: read a symbol file into symtab */
dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
+ dbx_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */
NULL /* next: pointer to next struct sym_fns */
};
+/* This is probably a mistake. FIXME. Why can't the HP's use an ordinary
+ file format name with an -hppa suffix? */
static struct sym_fns hppa_sym_fns =
{
"hppa", /* sym_name: name or name prefix of BFD target type */
dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
dbx_symfile_read, /* sym_read: read a symbol file into symtab */
dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
+ dbx_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */
NULL /* next: pointer to next struct sym_fns */
};
projects / binutils.git / blobdiff