/* Read dbx symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2008, 2009, 2010.
- Free Software Foundation, Inc.
+ Copyright (C) 1986-2015 Free Software Foundation, Inc.
This file is part of GDB.
for real. dbx_psymtab_to_symtab() is the function that does this */
#include "defs.h"
-#include "gdb_string.h"
-
#if defined(__CYGNUSCLIB__)
#include <sys/types.h>
#include <fcntl.h>
#endif
#include "gdb_obstack.h"
-#include "gdb_stat.h"
+#include <sys/stat.h>
#include "symtab.h"
#include "breakpoint.h"
#include "target.h"
#include "gdbcore.h" /* for bfd stuff */
#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
+#include "filenames.h"
#include "objfiles.h"
#include "buildsym.h"
#include "stabsread.h"
#include "cp-abi.h"
#include "cp-support.h"
#include "psympriv.h"
-
-#include "gdb_assert.h"
-#include "gdb_string.h"
+#include "block.h"
#include "aout/aout64.h"
#include "aout/stab_gnu.h" /* We always use GNU stabs, not
native, now. */
\f
+/* Key for dbx-associated data. */
+
+const struct objfile_data *dbx_objfile_data_key;
+
/* We put a pointer to this structure in the read_symtab_private field
of the psymtab. */
#define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
\f
+/* The objfile we are currently reading. */
+
+static struct objfile *dbxread_objfile;
+
/* Remember what we deduced to be the source language of this psymtab. */
static enum language psymtab_language = language_unknown;
static CORE_ADDR lowest_text_address;
/* Non-zero if there is any line number info in the objfile. Prevents
- end_psymtab from discarding an otherwise empty psymtab. */
+ dbx_end_psymtab from discarding an otherwise empty psymtab. */
static int has_line_numbers;
extern void _initialize_dbxread (void);
-static void read_ofile_symtab (struct partial_symtab *);
+static void read_ofile_symtab (struct objfile *, struct partial_symtab *);
-static void dbx_psymtab_to_symtab (struct partial_symtab *);
+static void dbx_read_symtab (struct partial_symtab *self,
+ struct objfile *objfile);
-static void dbx_psymtab_to_symtab_1 (struct partial_symtab *);
+static void dbx_psymtab_to_symtab_1 (struct objfile *, struct partial_symtab *);
static void read_dbx_dynamic_symtab (struct objfile *objfile);
static void dbx_symfile_finish (struct objfile *);
-static void record_minimal_symbol (char *, CORE_ADDR, int, struct objfile *);
+static void record_minimal_symbol (const char *, CORE_ADDR, int,
+ struct objfile *);
static void add_new_header_file (char *, int);
init_header_files (void)
{
n_allocated_this_object_header_files = 10;
- this_object_header_files = (int *) xmalloc (10 * sizeof (int));
+ this_object_header_files = XNEWVEC (int, 10);
}
/* Add header file number I for this object file
static void
add_old_header_file (char *name, int instance)
{
- struct header_file *p = HEADER_FILES (current_objfile);
+ struct header_file *p = HEADER_FILES (dbxread_objfile);
int i;
- for (i = 0; i < N_HEADER_FILES (current_objfile); i++)
- if (strcmp (p[i].name, name) == 0 && instance == p[i].instance)
+ for (i = 0; i < N_HEADER_FILES (dbxread_objfile); i++)
+ if (filename_cmp (p[i].name, name) == 0 && instance == p[i].instance)
{
add_this_object_header_file (i);
return;
/* Make sure there is room for one more header file. */
- i = N_ALLOCATED_HEADER_FILES (current_objfile);
+ i = N_ALLOCATED_HEADER_FILES (dbxread_objfile);
- if (N_HEADER_FILES (current_objfile) == i)
+ if (N_HEADER_FILES (dbxread_objfile) == i)
{
if (i == 0)
{
- N_ALLOCATED_HEADER_FILES (current_objfile) = 10;
- HEADER_FILES (current_objfile) = (struct header_file *)
+ N_ALLOCATED_HEADER_FILES (dbxread_objfile) = 10;
+ HEADER_FILES (dbxread_objfile) = (struct header_file *)
xmalloc (10 * sizeof (struct header_file));
}
else
{
i *= 2;
- N_ALLOCATED_HEADER_FILES (current_objfile) = i;
- HEADER_FILES (current_objfile) = (struct header_file *)
- xrealloc ((char *) HEADER_FILES (current_objfile),
+ N_ALLOCATED_HEADER_FILES (dbxread_objfile) = i;
+ HEADER_FILES (dbxread_objfile) = (struct header_file *)
+ xrealloc ((char *) HEADER_FILES (dbxread_objfile),
(i * sizeof (struct header_file)));
}
}
/* Create an entry for this header file. */
- i = N_HEADER_FILES (current_objfile)++;
- hfile = HEADER_FILES (current_objfile) + i;
+ i = N_HEADER_FILES (dbxread_objfile)++;
+ hfile = HEADER_FILES (dbxread_objfile) + i;
hfile->name = xstrdup (name);
hfile->instance = instance;
hfile->length = 10;
- hfile->vector
- = (struct type **) xmalloc (10 * sizeof (struct type *));
- memset (hfile->vector, 0, 10 * sizeof (struct type *));
+ hfile->vector = XCNEWVEC (struct type *, 10);
add_this_object_header_file (i);
}
static struct type **
explicit_lookup_type (int real_filenum, int index)
{
- struct header_file *f = &HEADER_FILES (current_objfile)[real_filenum];
+ struct header_file *f = &HEADER_FILES (dbxread_objfile)[real_filenum];
if (index >= f->length)
{
#endif
\f
static void
-record_minimal_symbol (char *name, CORE_ADDR address, int type,
+record_minimal_symbol (const char *name, CORE_ADDR address, int type,
struct objfile *objfile)
{
enum minimal_symbol_type ms_type;
int section;
- asection *bfd_section;
switch (type)
{
case N_TEXT | N_EXT:
ms_type = mst_text;
section = SECT_OFF_TEXT (objfile);
- bfd_section = DBX_TEXT_SECTION (objfile);
break;
case N_DATA | N_EXT:
ms_type = mst_data;
section = SECT_OFF_DATA (objfile);
- bfd_section = DBX_DATA_SECTION (objfile);
break;
case N_BSS | N_EXT:
ms_type = mst_bss;
section = SECT_OFF_BSS (objfile);
- bfd_section = DBX_BSS_SECTION (objfile);
break;
case N_ABS | N_EXT:
ms_type = mst_abs;
section = -1;
- bfd_section = NULL;
break;
#ifdef N_SETV
case N_SETV | N_EXT:
ms_type = mst_data;
section = SECT_OFF_DATA (objfile);
- bfd_section = DBX_DATA_SECTION (objfile);
break;
case N_SETV:
/* I don't think this type actually exists; since a N_SETV is the result
file local. */
ms_type = mst_file_data;
section = SECT_OFF_DATA (objfile);
- bfd_section = DBX_DATA_SECTION (objfile);
break;
#endif
case N_TEXT:
case N_FN_SEQ:
ms_type = mst_file_text;
section = SECT_OFF_TEXT (objfile);
- bfd_section = DBX_TEXT_SECTION (objfile);
break;
case N_DATA:
ms_type = mst_file_data;
/* Same with virtual function tables, both global and static. */
{
- char *tempstring = name;
+ const char *tempstring = name;
if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
++tempstring;
ms_type = mst_data;
}
section = SECT_OFF_DATA (objfile);
- bfd_section = DBX_DATA_SECTION (objfile);
break;
case N_BSS:
ms_type = mst_file_bss;
section = SECT_OFF_BSS (objfile);
- bfd_section = DBX_BSS_SECTION (objfile);
break;
default:
ms_type = mst_unknown;
section = -1;
- bfd_section = NULL;
break;
}
lowest_text_address = address;
prim_record_minimal_symbol_and_info
- (name, address, ms_type, section, bfd_section, objfile);
+ (name, address, ms_type, section, objfile);
}
\f
/* Scan and build partial symbols for a symbol file.
differently from Solaris), and false for SunOS4 and other a.out
file formats. */
block_address_function_relative =
- ((0 == strncmp (bfd_get_target (sym_bfd), "elf", 3))
- || (0 == strncmp (bfd_get_target (sym_bfd), "som", 3))
- || (0 == strncmp (bfd_get_target (sym_bfd), "coff", 4))
- || (0 == strncmp (bfd_get_target (sym_bfd), "pe", 2))
- || (0 == strncmp (bfd_get_target (sym_bfd), "epoc-pe", 7))
- || (0 == strncmp (bfd_get_target (sym_bfd), "nlm", 3)));
+ ((startswith (bfd_get_target (sym_bfd), "elf"))
+ || (startswith (bfd_get_target (sym_bfd), "som"))
+ || (startswith (bfd_get_target (sym_bfd), "coff"))
+ || (startswith (bfd_get_target (sym_bfd), "pe"))
+ || (startswith (bfd_get_target (sym_bfd), "epoc-pe"))
+ || (startswith (bfd_get_target (sym_bfd), "nlm")));
val = bfd_seek (sym_bfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
if (val < 0)
- perror_with_name (objfile->name);
+ perror_with_name (objfile_name (objfile));
/* Size the symbol table. */
if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
char *name = bfd_get_filename (sym_bfd);
asection *text_sect;
unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
+ struct dbx_symfile_info *dbx;
/* Allocate struct to keep track of the symfile. */
- objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
- xmalloc (sizeof (struct dbx_symfile_info));
- memset (objfile->deprecated_sym_stab_info, 0,
- sizeof (struct dbx_symfile_info));
+ dbx = XCNEW (struct dbx_symfile_info);
+ set_objfile_data (objfile, dbx_objfile_data_key, dbx);
DBX_TEXT_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
DBX_DATA_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".data");
/* FIXME POKING INSIDE BFD DATA STRUCTURES. */
- DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
-
text_sect = bfd_get_section_by_name (sym_bfd, ".text");
if (!text_sect)
error (_("Can't find .text section in symbol file"));
static void
dbx_symfile_finish (struct objfile *objfile)
{
- if (objfile->deprecated_sym_stab_info != NULL)
+ free_header_files ();
+}
+
+static void
+dbx_free_symfile_info (struct objfile *objfile, void *arg)
+{
+ struct dbx_symfile_info *dbx = (struct dbx_symfile_info *) arg;
+
+ if (dbx->header_files != NULL)
{
- if (HEADER_FILES (objfile) != NULL)
- {
- int i = N_HEADER_FILES (objfile);
- struct header_file *hfiles = HEADER_FILES (objfile);
+ int i = dbx->n_header_files;
+ struct header_file *hfiles = dbx->header_files;
- while (--i >= 0)
- {
- xfree (hfiles[i].name);
- xfree (hfiles[i].vector);
- }
- xfree (hfiles);
+ while (--i >= 0)
+ {
+ xfree (hfiles[i].name);
+ xfree (hfiles[i].vector);
}
- xfree (objfile->deprecated_sym_stab_info);
+ xfree (hfiles);
}
- free_header_files ();
+
+ xfree (dbx);
}
+
\f
/* Buffer for reading the symbol table entries. */
init_bincl_list (int number, struct objfile *objfile)
{
bincls_allocated = number;
- next_bincl = bincl_list = (struct header_file_location *)
- xmalloc (bincls_allocated * sizeof (struct header_file_location));
+ next_bincl = bincl_list = XNEWVEC (struct header_file_location,
+ bincls_allocated);
}
/* Add a bincl to the list. */
static void
do_free_bincl_list_cleanup (void *objfile)
{
- free_bincl_list (objfile);
+ free_bincl_list ((struct objfile *) objfile);
}
static struct cleanup *
long dynrel_count;
arelent **dynrels;
CORE_ADDR sym_value;
- char *name;
+ const 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
if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
{
- sym_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
type = N_TEXT;
}
else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
{
- sym_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
type = N_DATA;
}
else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
{
- sym_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
type = N_BSS;
}
else
if (sym->flags & BSF_GLOBAL)
type |= N_EXT;
- record_minimal_symbol ((char *) bfd_asymbol_name (sym), sym_value,
+ record_minimal_symbol (bfd_asymbol_name (sym), sym_value,
type, objfile);
}
}
counter++, relptr++)
{
arelent *rel = *relptr;
- CORE_ADDR address =
- rel->address + ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
+ CORE_ADDR address = rel->address;
switch (bfd_get_arch (abfd))
{
continue;
}
- name = (char *) bfd_asymbol_name (*rel->sym_ptr_ptr);
+ name = bfd_asymbol_name (*rel->sym_ptr_ptr);
prim_record_minimal_symbol (name, address, mst_solib_trampoline,
objfile);
}
find_stab_function_addr (char *namestring, const char *filename,
struct objfile *objfile)
{
- struct minimal_symbol *msym;
+ struct bound_minimal_symbol msym;
char *p;
int n;
if (p == NULL)
p = namestring;
n = p - namestring;
- p = alloca (n + 2);
+ p = (char *) alloca (n + 2);
strncpy (p, namestring, n);
p[n] = 0;
msym = lookup_minimal_symbol (p, filename, objfile);
- if (msym == NULL)
+ if (msym.minsym == NULL)
{
/* Sun Fortran appends an underscore to the minimal symbol name,
try again with an appended underscore if the minimal symbol
msym = lookup_minimal_symbol (p, filename, objfile);
}
- if (msym == NULL && filename != NULL)
+ if (msym.minsym == NULL && filename != NULL)
{
/* Try again without the filename. */
p[n] = 0;
msym = lookup_minimal_symbol (p, NULL, objfile);
}
- if (msym == NULL && filename != NULL)
+ if (msym.minsym == NULL && filename != NULL)
{
/* And try again for Sun Fortran, but without the filename. */
p[n] = '_';
msym = lookup_minimal_symbol (p, NULL, objfile);
}
- return msym == NULL ? 0 : SYMBOL_VALUE_ADDRESS (msym);
+ return msym.minsym == NULL ? 0 : BMSYMBOL_VALUE_ADDRESS (msym);
}
static void
char *namestring;
int nsl;
int past_first_source_file = 0;
- CORE_ADDR last_o_file_start = 0;
CORE_ADDR last_function_start = 0;
struct cleanup *back_to;
bfd *abfd;
struct partial_symtab *pst;
/* List of current psymtab's include files. */
- char **psymtab_include_list;
+ const char **psymtab_include_list;
int includes_allocated;
int includes_used;
includes_allocated = 30;
includes_used = 0;
- psymtab_include_list = (char **) alloca (includes_allocated *
- sizeof (char *));
+ psymtab_include_list = (const char **) alloca (includes_allocated *
+ sizeof (const char *));
dependencies_allocated = 30;
dependencies_used = 0;
init_bincl_list (20, objfile);
back_to = make_cleanup_free_bincl_list (objfile);
- last_source_file = NULL;
+ set_last_source_file (NULL);
lowest_text_address = (CORE_ADDR) -1;
case N_TEXT | N_EXT:
case N_NBTEXT | N_EXT:
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
goto record_it;
case N_DATA | N_EXT:
case N_NBDATA | N_EXT:
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
goto record_it;
case N_BSS:
case N_BSS | N_EXT:
case N_NBBSS | N_EXT:
case N_SETV | N_EXT: /* FIXME, is this in BSS? */
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
goto record_it;
case N_ABS | N_EXT:
record_it:
namestring = set_namestring (objfile, &nlist);
- bss_ext_symbol:
record_minimal_symbol (namestring, nlist.n_value,
nlist.n_type, objfile); /* Always */
continue;
case N_FN:
case N_FN_SEQ:
case N_TEXT:
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
namestring = set_namestring (objfile, &nlist);
if ((namestring[0] == '-' && namestring[1] == 'l')
|| (namestring[(nsl = strlen (namestring)) - 1] == 'o'
&& namestring[nsl - 2] == '.'))
{
+ nlist.n_value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
+
if (past_first_source_file && pst
/* The gould NP1 uses low values for .o and -l symbols
which are not the address. */
&& nlist.n_value >= pst->textlow)
{
- end_psymtab (pst, psymtab_include_list, includes_used,
- symnum * symbol_size,
- nlist.n_value > pst->texthigh
- ? nlist.n_value : pst->texthigh,
- dependency_list, dependencies_used,
- textlow_not_set);
+ dbx_end_psymtab (objfile, pst, psymtab_include_list,
+ includes_used, symnum * symbol_size,
+ nlist.n_value > pst->texthigh
+ ? nlist.n_value : pst->texthigh,
+ dependency_list, dependencies_used,
+ textlow_not_set);
pst = (struct partial_symtab *) 0;
includes_used = 0;
dependencies_used = 0;
}
else
past_first_source_file = 1;
- last_o_file_start = nlist.n_value;
}
else
goto record_it;
continue;
case N_DATA:
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
goto record_it;
case N_UNDF | N_EXT:
- if (nlist.n_value != 0)
- {
- /* This is a "Fortran COMMON" symbol. See if the target
- environment knows where it has been relocated to. */
-
- CORE_ADDR reladdr;
-
- namestring = set_namestring (objfile, &nlist);
- if (target_lookup_symbol (namestring, &reladdr))
- {
- continue; /* Error in lookup; ignore symbol for now. */
- }
- nlist.n_type ^= (N_BSS ^ N_UNDF); /* Define it as a
- bss-symbol. */
- nlist.n_value = reladdr;
- goto bss_ext_symbol;
- }
- continue; /* Just undefined, not COMMON. */
+ /* The case (nlist.n_value != 0) is a "Fortran COMMON" symbol.
+ We used to rely on the target to tell us whether it knows
+ where the symbol has been relocated to, but none of the
+ target implementations actually provided that operation.
+ So we just ignore the symbol, the same way we would do if
+ we had a target-side symbol lookup which returned no match.
+
+ All other symbols (with nlist.n_value == 0), are really
+ undefined, and so we ignore them too. */
+ continue;
case N_UNDF:
if (processing_acc_compilation && nlist.n_strx == 1)
CORE_ADDR valu;
static int prev_so_symnum = -10;
static int first_so_symnum;
- char *p;
+ const char *p;
static char *dirname_nso;
int prev_textlow_not_set;
prev_textlow_not_set = textlow_not_set;
/* A zero value is probably an indication for the SunPRO 3.0
- compiler. end_psymtab explicitly tests for zero, so
+ compiler. dbx_end_psymtab explicitly tests for zero, so
don't relocate it. */
if (nlist.n_value == 0
if (pst)
{
- end_psymtab (pst, psymtab_include_list, includes_used,
- symnum * symbol_size,
- valu > pst->texthigh ? valu : pst->texthigh,
- dependency_list, dependencies_used,
- prev_textlow_not_set);
+ dbx_end_psymtab (objfile, pst, psymtab_include_list,
+ includes_used, symnum * symbol_size,
+ valu > pst->texthigh
+ ? valu : pst->texthigh,
+ dependency_list, dependencies_used,
+ prev_textlow_not_set);
pst = (struct partial_symtab *) 0;
includes_used = 0;
dependencies_used = 0;
If pst exists, is empty, and has a filename ending in '/',
we assume the previous N_SO was a directory name. */
- p = strrchr (namestring, '/');
- if (p && *(p + 1) == '\000')
+ p = lbasename (namestring);
+ if (p != namestring && *p == '\000')
{
/* Save the directory name SOs locally, then save it into
the psymtab when it's created below. */
things like "break c-exp.y:435" need to work (I
suppose the psymtab_include_list could be hashed or put
in a binary tree, if profiling shows this is a major hog). */
- if (pst && strcmp (namestring, pst->filename) == 0)
+ if (pst && filename_cmp (namestring, pst->filename) == 0)
continue;
{
int i;
for (i = 0; i < includes_used; i++)
- if (strcmp (namestring, psymtab_include_list[i]) == 0)
+ if (filename_cmp (namestring, psymtab_include_list[i]) == 0)
{
i = -1;
break;
psymtab_include_list[includes_used++] = namestring;
if (includes_used >= includes_allocated)
{
- char **orig = psymtab_include_list;
+ const char **orig = psymtab_include_list;
- psymtab_include_list = (char **)
- alloca ((includes_allocated *= 2) * sizeof (char *));
+ psymtab_include_list = (const char **)
+ alloca ((includes_allocated *= 2) * sizeof (const char *));
memcpy (psymtab_include_list, orig,
- includes_used * sizeof (char *));
+ includes_used * sizeof (const char *));
}
continue;
}
sym_name = NULL; /* pacify "gcc -Werror" */
if (psymtab_language == language_cplus)
{
- char *new_name, *name = xmalloc (p - namestring + 1);
+ char *new_name, *name = (char *) xmalloc (p - namestring + 1);
memcpy (name, namestring, p - namestring);
name[p - namestring] = '\0';
if (new_name != NULL)
{
sym_len = strlen (new_name);
- sym_name = obsavestring (new_name, sym_len,
- &objfile->objfile_obstack);
+ sym_name = (char *) obstack_copy0 (&objfile->objfile_obstack,
+ new_name, sym_len);
xfree (new_name);
}
xfree (name);
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
- 0, nlist.n_value,
- psymtab_language, objfile);
+ nlist.n_value, psymtab_language, objfile);
continue;
case 'G':
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
- 0, nlist.n_value,
- psymtab_language, objfile);
+ nlist.n_value, psymtab_language, objfile);
continue;
case 'T':
add_psymbol_to_list (sym_name, sym_len, 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- nlist.n_value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- nlist.n_value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
p += 1;
}
}
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- nlist.n_value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
}
check_enum:
/* If this is an enumerated type, we need to
add_psymbol_to_list (p, q - p, 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols, 0,
- 0, psymtab_language, objfile);
+ psymtab_language, objfile);
/* Point past the name. */
p = q;
/* Skip over the value. */
/* Constant, e.g. from "const" in Pascal. */
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, nlist.n_value,
- 0, psymtab_language, objfile);
+ &objfile->static_psymbols, 0,
+ psymtab_language, objfile);
continue;
case 'f':
if (! pst)
{
int name_len = p - namestring;
- char *name = xmalloc (name_len + 1);
+ char *name = (char *) xmalloc (name_len + 1);
memcpy (name, namestring, name_len);
name[name_len] = '\0';
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, nlist.n_value,
- psymtab_language, objfile);
+ nlist.n_value, psymtab_language, objfile);
continue;
/* Global functions were ignored here, but now they
if (! pst)
{
int name_len = p - namestring;
- char *name = xmalloc (name_len + 1);
+ char *name = (char *) xmalloc (name_len + 1);
memcpy (name, namestring, name_len);
name[name_len] = '\0';
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, nlist.n_value,
- psymtab_language, objfile);
+ nlist.n_value, psymtab_language, objfile);
continue;
/* Two things show up here (hopefully); static symbols of
case N_ENDM:
/* Solaris 2 end of module, finish current partial symbol table.
- end_psymtab will set pst->texthigh to the proper value, which
+ dbx_end_psymtab will set pst->texthigh to the proper value, which
is necessary if a module compiled without debugging info
follows this module. */
if (pst && gdbarch_sofun_address_maybe_missing (gdbarch))
{
- end_psymtab (pst, psymtab_include_list, includes_used,
- symnum * symbol_size,
- (CORE_ADDR) 0, dependency_list,
- dependencies_used, textlow_not_set);
+ dbx_end_psymtab (objfile, pst,
+ psymtab_include_list, includes_used,
+ symnum * symbol_size,
+ (CORE_ADDR) 0, dependency_list,
+ dependencies_used, textlow_not_set);
pst = (struct partial_symtab *) 0;
includes_used = 0;
dependencies_used = 0;
case N_SLINE:
case N_RSYM:
case N_PSYM:
+ case N_BNSYM:
+ case N_ENSYM:
case N_LBRAC:
case N_NSYMS: /* Ultrix 4.0: symbol count */
case N_DEFD: /* GNU Modula-2 */
: lowest_text_address)
+ text_size;
- end_psymtab (pst, psymtab_include_list, includes_used,
- symnum * symbol_size,
- text_end > pst->texthigh ? text_end : pst->texthigh,
- dependency_list, dependencies_used, textlow_not_set);
+ dbx_end_psymtab (objfile, pst, psymtab_include_list, includes_used,
+ symnum * symbol_size,
+ text_end > pst->texthigh ? text_end : pst->texthigh,
+ dependency_list, dependencies_used, textlow_not_set);
}
do_cleanups (back_to);
struct partial_symbol **static_syms)
{
struct partial_symtab *result =
- start_psymtab_common (objfile, objfile->section_offsets,
- filename, textlow, global_syms, static_syms);
+ start_psymtab_common (objfile, filename, textlow,
+ global_syms, static_syms);
- result->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc));
+ result->read_symtab_private =
+ XOBNEW (&objfile->objfile_obstack, struct symloc);
LDSYMOFF (result) = ldsymoff;
- result->read_symtab = dbx_psymtab_to_symtab;
+ result->read_symtab = dbx_read_symtab;
SYMBOL_SIZE (result) = symbol_size;
SYMBOL_OFFSET (result) = symbol_table_offset;
STRING_OFFSET (result) = string_table_offset;
FILE_STRING_OFFSET (result) = file_string_table_offset;
-#ifdef HAVE_ELF
- /* 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);
-#endif
-
/* Deduce the source language from the filename for this psymtab. */
psymtab_language = deduce_language_from_filename (filename);
FIXME: List variables and peculiarities of same. */
struct partial_symtab *
-end_psymtab (struct partial_symtab *pst, char **include_list, int num_includes,
- int capping_symbol_offset, CORE_ADDR capping_text,
- struct partial_symtab **dependency_list, int number_dependencies,
- int textlow_not_set)
+dbx_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
+ const char **include_list, int num_includes,
+ int capping_symbol_offset, CORE_ADDR capping_text,
+ struct partial_symtab **dependency_list,
+ int number_dependencies,
+ int textlow_not_set)
{
int i;
- struct objfile *objfile = pst->objfile;
struct gdbarch *gdbarch = get_objfile_arch (objfile);
if (capping_symbol_offset != -1)
{
char *p;
int n;
- struct minimal_symbol *minsym;
+ struct bound_minimal_symbol minsym;
p = strchr (last_function_name, ':');
if (p == NULL)
p = last_function_name;
n = p - last_function_name;
- p = alloca (n + 2);
+ p = (char *) alloca (n + 2);
strncpy (p, last_function_name, n);
p[n] = 0;
minsym = lookup_minimal_symbol (p, pst->filename, objfile);
- if (minsym == NULL)
+ if (minsym.minsym == NULL)
{
/* Sun Fortran appends an underscore to the minimal symbol name,
try again with an appended underscore if the minimal symbol
minsym = lookup_minimal_symbol (p, pst->filename, objfile);
}
- if (minsym)
- pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym);
+ if (minsym.minsym)
+ pst->texthigh = (BMSYMBOL_VALUE_ADDRESS (minsym)
+ + MSYMBOL_SIZE (minsym.minsym));
last_function_name = NULL;
}
/* End of kludge for patching Solaris textlow and texthigh. */
- pst->n_global_syms =
- objfile->global_psymbols.next - (objfile->global_psymbols.list
- + pst->globals_offset);
- pst->n_static_syms =
- objfile->static_psymbols.next - (objfile->static_psymbols.list
- + pst->statics_offset);
+ end_psymtab_common (objfile, pst);
pst->number_of_dependencies = number_dependencies;
if (number_dependencies)
{
- pst->dependencies = (struct partial_symtab **)
- obstack_alloc (&objfile->objfile_obstack,
- number_dependencies * sizeof (struct partial_symtab *));
+ pst->dependencies = XOBNEWVEC (&objfile->objfile_obstack,
+ struct partial_symtab *,
+ number_dependencies);
memcpy (pst->dependencies, dependency_list,
number_dependencies * sizeof (struct partial_symtab *));
}
struct partial_symtab *subpst =
allocate_psymtab (include_list[i], objfile);
- /* Copy the sesction_offsets array from the main psymtab. */
- subpst->section_offsets = pst->section_offsets;
subpst->read_symtab_private =
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symloc));
+ XOBNEW (&objfile->objfile_obstack, struct symloc);
LDSYMOFF (subpst) =
LDSYMLEN (subpst) =
subpst->textlow =
/* We could save slight bits of space by only making one of these,
shared by the entire set of include files. FIXME-someday. */
- subpst->dependencies = (struct partial_symtab **)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct partial_symtab *));
+ subpst->dependencies =
+ XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;
subpst->n_static_syms = 0;
subpst->readin = 0;
- subpst->symtab = 0;
+ subpst->compunit_symtab = 0;
subpst->read_symtab = pst->read_symtab;
}
- sort_pst_symbols (pst);
-
if (num_includes == 0
&& number_dependencies == 0
&& pst->n_global_syms == 0
is not empty, but we don't realize that. Fixing that without slowing
things down might be tricky. */
- discard_psymtab (pst);
+ discard_psymtab (objfile, pst);
/* Indicate that psymtab was thrown away. */
- pst = (struct partial_symtab *) NULL;
+ pst = NULL;
}
return pst;
}
\f
static void
-dbx_psymtab_to_symtab_1 (struct partial_symtab *pst)
+dbx_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst)
{
struct cleanup *old_chain;
int i;
- if (!pst)
- return;
-
if (pst->readin)
{
fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. "
wrap_here (""); /* Flush output. */
gdb_flush (gdb_stdout);
}
- dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
+ dbx_psymtab_to_symtab_1 (objfile, pst->dependencies[i]);
}
if (LDSYMLEN (pst)) /* Otherwise it's a dummy. */
symbol_size = SYMBOL_SIZE (pst);
/* Read in this file's symbols. */
- bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
- read_ofile_symtab (pst);
+ bfd_seek (objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
+ read_ofile_symtab (objfile, pst);
do_cleanups (old_chain);
}
}
/* Read in all of the symbols for a given psymtab for real.
- Be verbose about it if the user wants that. */
+ Be verbose about it if the user wants that. SELF is not NULL. */
static void
-dbx_psymtab_to_symtab (struct partial_symtab *pst)
+dbx_read_symtab (struct partial_symtab *self, struct objfile *objfile)
{
bfd *sym_bfd;
- struct cleanup *back_to = NULL;
- if (!pst)
- return;
-
- if (pst->readin)
+ if (self->readin)
{
fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. "
"Shouldn't happen.\n",
- pst->filename);
+ self->filename);
return;
}
- if (LDSYMLEN (pst) || pst->number_of_dependencies)
+ if (LDSYMLEN (self) || self->number_of_dependencies)
{
+ struct cleanup *back_to;
+
/* Print the message now, before reading the string table,
to avoid disconcerting pauses. */
if (info_verbose)
{
- printf_filtered ("Reading in symbols for %s...", pst->filename);
+ printf_filtered ("Reading in symbols for %s...", self->filename);
gdb_flush (gdb_stdout);
}
- sym_bfd = pst->objfile->obfd;
+ sym_bfd = objfile->obfd;
next_symbol_text_func = dbx_next_symbol_text;
- if (DBX_STAB_SECTION (pst->objfile))
+ back_to = make_cleanup (null_cleanup, NULL);
+
+ if (DBX_STAB_SECTION (objfile))
{
stabs_data
- = symfile_relocate_debug_section (pst->objfile,
- DBX_STAB_SECTION (pst->objfile),
+ = symfile_relocate_debug_section (objfile,
+ DBX_STAB_SECTION (objfile),
NULL);
if (stabs_data)
- back_to = make_cleanup (free_current_contents,
- (void *) &stabs_data);
+ make_cleanup (free_current_contents, (void *) &stabs_data);
}
- dbx_psymtab_to_symtab_1 (pst);
+ dbx_psymtab_to_symtab_1 (objfile, self);
- if (back_to)
- do_cleanups (back_to);
+ do_cleanups (back_to);
/* Match with global symbols. This only needs to be done once,
after all of the symtabs and dependencies have been read in. */
- scan_file_globals (pst->objfile);
+ scan_file_globals (objfile);
/* Finish up the debug error message. */
if (info_verbose)
/* Read in a defined section of a specific object file's symbols. */
static void
-read_ofile_symtab (struct partial_symtab *pst)
+read_ofile_symtab (struct objfile *objfile, struct partial_symtab *pst)
{
char *namestring;
struct external_nlist *bufp;
unsigned char type;
unsigned max_symnum;
bfd *abfd;
- struct objfile *objfile;
int sym_offset; /* Offset to start of symbols to read */
int sym_size; /* Size of symbols to read */
CORE_ADDR text_offset; /* Start of text segment for symbols */
int text_size; /* Size of text segment for symbols */
struct section_offsets *section_offsets;
- objfile = pst->objfile;
sym_offset = LDSYMOFF (pst);
sym_size = LDSYMLEN (pst);
text_offset = pst->textlow;
text_size = pst->texthigh - pst->textlow;
- /* This cannot be simply objfile->section_offsets because of
- elfstab_offset_sections() which initializes the psymtab section
- offsets information in a special way, and that is different from
- objfile->section_offsets. */
- section_offsets = pst->section_offsets;
+ section_offsets = objfile->section_offsets;
- current_objfile = objfile;
- subfile_stack = NULL;
+ dbxread_objfile = objfile;
stringtab_global = DBX_STRINGTAB (objfile);
- last_source_file = NULL;
+ set_last_source_file (NULL);
abfd = objfile->obfd;
symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol. */
processing_gcc_compilation = 2;
if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
++tempstring;
- if (strncmp (tempstring, "__gnu_compiled", 14) == 0)
+ if (startswith (tempstring, "__gnu_compiled"))
processing_gcc_compilation = 2;
}
-
- /* Try to select a C++ demangling based on the compilation unit
- producer. */
-
-#if 0
- /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
- know whether it will use the old style or v3 mangling. */
- if (processing_gcc_compilation)
- {
- if (AUTO_DEMANGLING)
- {
- set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
- }
- }
-#endif
}
else
{
processing_gcc_compilation = 1;
else if (strcmp (namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0)
processing_gcc_compilation = 2;
-
-#if 0
- /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
- know whether it will use the old style or v3 mangling. */
- if (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 > text_offset)
last_source_start_addr = text_offset;
- pst->symtab = end_symtab (text_offset + text_size, objfile,
- SECT_OFF_TEXT (objfile));
+ pst->compunit_symtab = end_symtab (text_offset + text_size,
+ SECT_OFF_TEXT (objfile));
end_stabs ();
- current_objfile = NULL;
+ dbxread_objfile = NULL;
}
\f
+/* Record the namespace that the function defined by SYMBOL was
+ defined in, if necessary. BLOCK is the associated block; use
+ OBSTACK for allocation. */
+
+static void
+cp_set_block_scope (const struct symbol *symbol,
+ struct block *block,
+ struct obstack *obstack)
+{
+ if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
+ {
+ /* Try to figure out the appropriate namespace from the
+ demangled name. */
+
+ /* FIXME: carlton/2003-04-15: If the function in question is
+ a method of a class, the name will actually include the
+ name of the class as well. This should be harmless, but
+ is a little unfortunate. */
+
+ const char *name = SYMBOL_DEMANGLED_NAME (symbol);
+ unsigned int prefix_len = cp_entire_prefix_len (name);
+
+ block_set_scope (block,
+ (const char *) obstack_copy0 (obstack, name, prefix_len),
+ obstack);
+ }
+}
+
/* This handles a single symbol from the symbol-file, building symbols
into a GDB symtab. It takes these arguments and an implicit argument.
void
process_one_symbol (int type, int desc, CORE_ADDR valu, char *name,
- struct section_offsets *section_offsets,
+ const struct section_offsets *section_offsets,
struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- struct context_stack *new;
+ struct context_stack *newobj;
/* 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
/* Something is wrong if we see real data before seeing a source
file name. */
- if (last_source_file == NULL && type != (unsigned char) N_SO)
+ if (get_last_source_file () == NULL && type != (unsigned char) N_SO)
{
/* Ignore any symbols which appear before an N_SO symbol.
Currently no one puts symbols there, but we should deal
}
within_function = 0;
- new = pop_context ();
+ newobj = pop_context ();
/* Make a block for the local symbols within. */
- block = finish_block (new->name, &local_symbols, new->old_blocks,
- new->start_addr, new->start_addr + valu,
- objfile);
+ block = finish_block (newobj->name, &local_symbols,
+ newobj->old_blocks, NULL,
+ newobj->start_addr, newobj->start_addr + valu);
/* For C++, set the block's scope. */
- if (SYMBOL_LANGUAGE (new->name) == language_cplus)
- cp_set_block_scope (new->name, block, &objfile->objfile_obstack,
- "", 0);
+ if (SYMBOL_LANGUAGE (newobj->name) == language_cplus)
+ cp_set_block_scope (newobj->name, block, &objfile->objfile_obstack);
/* May be switching to an assembler file which may not be using
block relative stabs, so reset the offset. */
/* Relocate for dynamic loading. */
valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
- valu = gdbarch_smash_text_address (gdbarch, valu);
+ valu = gdbarch_addr_bits_remove (gdbarch, valu);
last_function_start = valu;
goto define_a_symbol;
break;
}
- new = pop_context ();
- if (desc != new->depth)
+ newobj = pop_context ();
+ if (desc != newobj->depth)
lbrac_mismatch_complaint (symnum);
if (local_symbols != NULL)
_("misplaced N_LBRAC entry; discarding local "
"symbols which have no enclosing block"));
}
- local_symbols = new->locals;
+ local_symbols = newobj->locals;
if (context_stack_depth > 1)
{
/* Muzzle a compiler bug that makes end < start.
??? Which compilers? Is this ever harmful?. */
- if (new->start_addr > valu)
+ if (newobj->start_addr > valu)
{
complaint (&symfile_complaints,
_("block start larger than block end"));
- new->start_addr = valu;
+ newobj->start_addr = valu;
}
/* Make a block for the local symbols within. */
- finish_block (0, &local_symbols, new->old_blocks,
- new->start_addr, valu, objfile);
+ finish_block (0, &local_symbols, newobj->old_blocks, NULL,
+ newobj->start_addr, valu);
}
}
else
n_opt_found = 0;
- if (last_source_file)
+ if (get_last_source_file ())
{
/* Check if previous symbol was also an N_SO (with some
sanity checks). If so, that one was actually the
patch_subfile_names (current_subfile, name);
break; /* Ignore repeated SOs. */
}
- end_symtab (valu, objfile, SECT_OFF_TEXT (objfile));
+ end_symtab (valu, SECT_OFF_TEXT (objfile));
end_stabs ();
}
function_start_offset = 0;
start_stabs ();
- start_symtab (name, NULL, valu);
+ start_symtab (objfile, name, NULL, valu);
record_debugformat ("stabs");
break;
in the compilation of the main source file (whose name was
given in the N_SO symbol). Relocate for dynamic loading. */
valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
- start_subfile (name, current_subfile->dirname);
+ start_subfile (name);
break;
case N_BINCL:
push_subfile ();
add_new_header_file (name, valu);
- start_subfile (name, current_subfile->dirname);
+ start_subfile (name);
break;
case N_EINCL:
- start_subfile (pop_subfile (), current_subfile->dirname);
+ start_subfile (pop_subfile ());
break;
case N_EXCL:
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*
+ /* The linker relocated it. We don't want to add a
+ Sun-stabs Tfoo.foo-like offset, but we *do*
want to add whatever solib.c passed to
symbol_file_add as addr (this is known to affect
- SunOS 4, 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. */
+ SunOS 4, and I suspect ELF too). Since there is no
+ Ttext.text symbol, we can get addr from the text offset. */
valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
goto define_a_symbol;
}
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
CORE_ADDR minsym_valu =
- find_stab_function_addr (name, last_source_file, objfile);
+ find_stab_function_addr (name, get_last_source_file (),
+ objfile);
/* The function find_stab_function_addr will return
0 if the minimal symbol wasn't found.
{
struct block *block;
- new = pop_context ();
+ newobj = pop_context ();
/* Make a block for the local symbols within. */
- block = finish_block (new->name, &local_symbols,
- new->old_blocks, new->start_addr,
- valu, objfile);
+ block = finish_block (newobj->name, &local_symbols,
+ newobj->old_blocks, NULL,
+ newobj->start_addr, valu);
/* For C++, set the block's scope. */
- if (SYMBOL_LANGUAGE (new->name) == language_cplus)
- cp_set_block_scope (new->name, block,
- &objfile->objfile_obstack,
- "", 0);
+ if (SYMBOL_LANGUAGE (newobj->name) == language_cplus)
+ cp_set_block_scope (newobj->name, block,
+ &objfile->objfile_obstack);
}
- new = push_context (0, valu);
- new->name = define_symbol (valu, name, desc, type, objfile);
+ newobj = push_context (0, valu);
+ newobj->name = define_symbol (valu, name, desc, type, objfile);
break;
default:
if (strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0)
{
processing_gcc_compilation = 2;
-#if 0 /* Works, but is experimental. -fnf */
- /* For now, stay with AUTO_DEMANGLING for g++ output, as
- we don't know whether it will use the old style or v3
- mangling. */
- if (AUTO_DEMANGLING)
- {
- set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
- }
-#endif
}
else
n_opt_found = 1;
N_MAIN within a given objfile, complain() and choose
arbitrarily. (kingdon) */
if (name != NULL)
- set_main_name (name);
+ set_objfile_main_name (objfile, name, language_unknown);
break;
/* The following symbol types can be ignored. */
Generally this is used so that an alias can refer to its main
symbol. */
+ gdb_assert (name);
if (name[0] == '#')
{
/* Initialize symbol reference names and determine if this is a
/* There is already a dbx_symfile_info allocated by our caller.
It might even contain some info from the coff symtab to help us. */
- info = objfile->deprecated_sym_stab_info;
+ info = DBX_SYMFILE_INFO (objfile);
DBX_TEXT_ADDR (objfile) = textaddr;
DBX_TEXT_SIZE (objfile) = textsize;
bfd *sym_bfd = objfile->obfd;
char *name = bfd_get_filename (sym_bfd);
struct dbx_symfile_info *info;
- struct cleanup *back_to = NULL;
+ struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
/* 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 = objfile->deprecated_sym_stab_info;
+ info = DBX_SYMFILE_INFO (objfile);
/* Find the first and last text address. dbx_symfile_read seems to
want this. */
symbuf_left = bfd_section_size (objfile->obfd, stabsect);
stabs_data = symfile_relocate_debug_section (objfile, stabsect, NULL);
if (stabs_data)
- back_to = make_cleanup (free_current_contents, (void *) &stabs_data);
+ make_cleanup (free_current_contents, (void *) &stabs_data);
/* 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
case it does, it will install them itself. */
dbx_symfile_read (objfile, 0);
- if (back_to)
- do_cleanups (back_to);
+ do_cleanups (back_to);
}
\f
/* Scan and build partial symbols for a file with special sections for stabs
asection *stabsect;
asection *stabstrsect;
asection *text_sect;
+ struct dbx_symfile_info *dbx;
stabsect = bfd_get_section_by_name (sym_bfd, stab_name);
stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name);
"but not string section (%s)"),
stab_name, stabstr_name);
- objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
- xmalloc (sizeof (struct dbx_symfile_info));
- memset (objfile->deprecated_sym_stab_info, 0,
- sizeof (struct dbx_symfile_info));
+ dbx = XCNEW (struct dbx_symfile_info);
+ set_objfile_data (objfile, dbx_objfile_data_key, dbx);
text_sect = bfd_get_section_by_name (sym_bfd, text_name);
if (!text_sect)
\f
static const struct sym_fns aout_sym_fns =
{
- bfd_target_aout_flavour,
dbx_new_init, /* init anything gbl to entire symtab */
dbx_symfile_init, /* read initial info, setup for sym_read() */
dbx_symfile_read, /* read a symbol file into symtab */
default_symfile_segments, /* Get segment information from a file. */
NULL,
default_symfile_relocate, /* Relocate a debug section. */
+ NULL, /* sym_probe_fns */
&psym_functions
};
void
_initialize_dbxread (void)
{
- add_symtab_fns (&aout_sym_fns);
+ add_symtab_fns (bfd_target_aout_flavour, &aout_sym_fns);
+
+ dbx_objfile_data_key
+ = register_objfile_data_with_cleanup (NULL, dbx_free_symfile_info);
}
projects / deliverable / binutils-gdb.git / blobdiff