/* Read dbx symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986-2017 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
#include "filenames.h"
#include "objfiles.h"
-#include "buildsym.h"
+#include "buildsym-legacy.h"
#include "stabsread.h"
#include "gdb-stabs.h"
#include "demangle.h"
#include "cp-support.h"
#include "psympriv.h"
#include "block.h"
-
#include "aout/aout64.h"
#include "aout/stab_gnu.h" /* We always use GNU stabs, not
native, now. */
/* Key for dbx-associated data. */
-const struct objfile_data *dbx_objfile_data_key;
+objfile_key<dbx_symfile_info> dbx_objfile_data_key;
/* We put a pointer to this structure in the read_symtab_private field
of the psymtab. */
int symbol_offset;
int string_offset;
int file_string_offset;
+ enum language pst_language;
};
#define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
#define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
#define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
#define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
+#define PST_LANGUAGE(p) (SYMLOC(p)->pst_language)
\f
/* The objfile we are currently reading. */
static int symfile_relocatable = 0;
+/* When set, we are processing a .o file compiled by sun acc. This is
+ misnamed; it refers to all stabs-in-elf implementations which use
+ N_UNDF the way Sun does, including Solaris gcc. Hopefully all
+ stabs-in-elf implementations ever invented will choose to be
+ compatible. */
+
+static unsigned char processing_acc_compilation;
+
\f
/* The lowest text address we have yet encountered. This is needed
because in an a.out file, there is no header field which tells us
static void
unknown_symtype_complaint (const char *arg1)
{
- complaint (&symfile_complaints, _("unknown symbol type %s"), arg1);
+ complaint (_("unknown symbol type %s"), arg1);
}
static void
lbrac_mismatch_complaint (int arg1)
{
- complaint (&symfile_complaints,
- _("N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d"), arg1);
+ complaint (_("N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d"), arg1);
}
static void
repeated_header_complaint (const char *arg1, int arg2)
{
- complaint (&symfile_complaints,
- _("\"repeated\" header file %s not "
+ complaint (_("\"repeated\" header file %s not "
"previously seen, at symtab pos %d"),
arg1, arg2);
}
CORE_ADDR end = 0;
for (sec = sym_bfd->sections; sec; sec = sec->next)
- if (bfd_get_section_flags (sym_bfd, sec) & SEC_CODE)
+ if (bfd_section_flags (sec) & SEC_CODE)
{
- CORE_ADDR sec_start = bfd_section_vma (sym_bfd, sec);
- CORE_ADDR sec_end = sec_start + bfd_section_size (sym_bfd, sec);
+ CORE_ADDR sec_start = bfd_section_vma (sec);
+ CORE_ADDR sec_end = sec_start + bfd_section_size (sec);
if (found_any)
{
struct header_file_location
{
- char *name; /* Name of header file */
+ header_file_location (const char *name_, int instance_,
+ struct partial_symtab *pst_)
+ : name (name_),
+ instance (instance_),
+ pst (pst_)
+ {
+ }
+
+ const char *name; /* Name of header file */
int instance; /* See above */
struct partial_symtab *pst; /* Partial symtab that has the
BINCL/EINCL defs for this file. */
};
-/* The actual list and controling variables. */
-static struct header_file_location *bincl_list, *next_bincl;
-static int bincls_allocated;
+/* The list of bincls. */
+static std::vector<struct header_file_location> *bincl_list;
/* Local function prototypes. */
-extern void _initialize_dbxread (void);
-
static void read_ofile_symtab (struct objfile *, struct partial_symtab *);
static void dbx_read_symtab (struct partial_symtab *self,
static void read_dbx_symtab (minimal_symbol_reader &, struct objfile *);
-static void free_bincl_list (struct objfile *);
-
-static struct partial_symtab *find_corresponding_bincl_psymtab (char *, int);
-
-static void add_bincl_to_list (struct partial_symtab *, char *, int);
-
-static void init_bincl_list (int, struct objfile *);
+static struct partial_symtab *find_corresponding_bincl_psymtab (const char *,
+ int);
-static char *dbx_next_symbol_text (struct objfile *);
+static const char *dbx_next_symbol_text (struct objfile *);
static void fill_symbuf (bfd *);
const char *, CORE_ADDR, int,
struct objfile *);
-static void add_new_header_file (char *, int);
+static void add_new_header_file (const char *, int);
-static void add_old_header_file (char *, int);
+static void add_old_header_file (const char *, int);
static void add_this_object_header_file (int);
-static struct partial_symtab *start_psymtab (struct objfile *, char *,
- CORE_ADDR, int,
- struct partial_symbol **,
- struct partial_symbol **);
+static struct partial_symtab *start_psymtab (struct objfile *, const char *,
+ CORE_ADDR, int);
/* Free up old header file tables. */
symbol tables for the same header file. */
static void
-add_old_header_file (char *name, int instance)
+add_old_header_file (const char *name, int instance)
{
struct header_file *p = HEADER_FILES (dbxread_objfile);
int i;
so we record the file when its "begin" is seen and ignore the "end". */
static void
-add_new_header_file (char *name, int instance)
+add_new_header_file (const char *name, int instance)
{
int i;
struct header_file *hfile;
{
bfd *sym_bfd;
int val;
- struct cleanup *back_to;
sym_bfd = objfile->obfd;
perror_with_name (objfile_name (objfile));
/* Size the symbol table. */
- if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
- init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
+ init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
symbol_size = DBX_SYMBOL_SIZE (objfile);
symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
- free_pending_blocks ();
- back_to = make_cleanup (really_free_pendings, 0);
+ scoped_free_pendings free_pending;
minimal_symbol_reader reader (objfile);
minimal symbols for this objfile. */
reader.install ();
-
- do_cleanups (back_to);
}
/* Initialize anything that needs initializing when a completely new
dbx_new_init (struct objfile *ignore)
{
stabsread_new_init ();
- buildsym_new_init ();
init_header_files ();
}
{
int val;
bfd *sym_bfd = objfile->obfd;
- char *name = bfd_get_filename (sym_bfd);
+ const 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. */
- dbx = XCNEW (struct dbx_symfile_info);
- set_objfile_data (objfile, dbx_objfile_data_key, dbx);
+ dbx_objfile_data_key.emplace (objfile);
DBX_TEXT_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
DBX_DATA_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".data");
text_sect = bfd_get_section_by_name (sym_bfd, ".text");
if (!text_sect)
error (_("Can't find .text section in symbol file"));
- DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
- DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
+ DBX_TEXT_ADDR (objfile) = bfd_section_vma (text_sect);
+ DBX_TEXT_SIZE (objfile) = bfd_section_size (text_sect);
DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
free_header_files ();
}
-static void
-dbx_free_symfile_info (struct objfile *objfile, void *arg)
+dbx_symfile_info::~dbx_symfile_info ()
{
- struct dbx_symfile_info *dbx = (struct dbx_symfile_info *) arg;
-
- if (dbx->header_files != NULL)
+ if (header_files != NULL)
{
- int i = dbx->n_header_files;
- struct header_file *hfiles = dbx->header_files;
+ int i = n_header_files;
+ struct header_file *hfiles = header_files;
while (--i >= 0)
{
}
xfree (hfiles);
}
-
- xfree (dbx);
}
\f
/* Name of last function encountered. Used in Solaris to approximate
object file boundaries. */
-static char *last_function_name;
+static const char *last_function_name;
/* The address in memory of the string table of the object file we are
reading (which might not be the "main" object file, but might be a
/* These variables are used to control fill_symbuf when the stabs
symbols are not contiguous (as may be the case when a COFF file is
linked using --split-by-reloc). */
-static struct stab_section_list *symbuf_sections;
+static const std::vector<asection *> *symbuf_sections;
+static size_t sect_idx;
static unsigned int symbuf_left;
static unsigned int symbuf_read;
{
if (symbuf_left <= 0)
{
- file_ptr filepos = symbuf_sections->section->filepos;
+ file_ptr filepos = (*symbuf_sections)[sect_idx]->filepos;
if (bfd_seek (sym_bfd, filepos, SEEK_SET) != 0)
perror_with_name (bfd_get_filename (sym_bfd));
- symbuf_left = bfd_section_size (sym_bfd, symbuf_sections->section);
+ symbuf_left = bfd_section_size ((*symbuf_sections)[sect_idx]);
symbol_table_offset = filepos - symbuf_read;
- symbuf_sections = symbuf_sections->next;
+ ++sect_idx;
}
count = symbuf_left;
(a \ at the end of the text of a name)
call this function to get the continuation. */
-static char *
+static const char *
dbx_next_symbol_text (struct objfile *objfile)
{
struct internal_nlist nlist;
return nlist.n_strx + stringtab_global + file_string_table_offset;
}
\f
-/* Initialize the list of bincls to contain none and have some
- allocated. */
-
-static void
-init_bincl_list (int number, struct objfile *objfile)
-{
- bincls_allocated = number;
- next_bincl = bincl_list = XNEWVEC (struct header_file_location,
- bincls_allocated);
-}
-
-/* Add a bincl to the list. */
-
-static void
-add_bincl_to_list (struct partial_symtab *pst, char *name, int instance)
-{
- if (next_bincl >= bincl_list + bincls_allocated)
- {
- int offset = next_bincl - bincl_list;
-
- bincls_allocated *= 2;
- bincl_list = (struct header_file_location *)
- xrealloc ((char *) bincl_list,
- bincls_allocated * sizeof (struct header_file_location));
- next_bincl = bincl_list + offset;
- }
- next_bincl->pst = pst;
- next_bincl->instance = instance;
- next_bincl++->name = name;
-}
/* Given a name, value pair, find the corresponding
bincl in the list. Return the partial symtab associated
with that header_file_location. */
static struct partial_symtab *
-find_corresponding_bincl_psymtab (char *name, int instance)
+find_corresponding_bincl_psymtab (const char *name, int instance)
{
- struct header_file_location *bincl;
-
- for (bincl = bincl_list; bincl < next_bincl; bincl++)
- if (bincl->instance == instance
- && strcmp (name, bincl->name) == 0)
- return bincl->pst;
+ for (const header_file_location &bincl : *bincl_list)
+ if (bincl.instance == instance
+ && strcmp (name, bincl.name) == 0)
+ return bincl.pst;
repeated_header_complaint (name, symnum);
return (struct partial_symtab *) 0;
}
-/* Free the storage allocated for the bincl list. */
-
-static void
-free_bincl_list (struct objfile *objfile)
-{
- xfree (bincl_list);
- bincls_allocated = 0;
-}
-
-static void
-do_free_bincl_list_cleanup (void *objfile)
-{
- free_bincl_list ((struct objfile *) objfile);
-}
-
-static struct cleanup *
-make_cleanup_free_bincl_list (struct objfile *objfile)
-{
- return make_cleanup (do_free_bincl_list_cleanup, objfile);
-}
-
/* Set namestring based on nlist. If the string table index is invalid,
give a fake name, and print a single error message per symbol file read,
rather than abort the symbol reading or flood the user with messages. */
-static char *
+static const char *
set_namestring (struct objfile *objfile, const struct internal_nlist *nlist)
{
- char *namestring;
+ const char *namestring;
if (nlist->n_strx + file_string_table_offset
>= DBX_STRINGTAB_SIZE (objfile)
|| nlist->n_strx + file_string_table_offset < nlist->n_strx)
{
- complaint (&symfile_complaints,
- _("bad string table offset in symbol %d"),
+ complaint (_("bad string table offset in symbol %d"),
symnum);
namestring = "<bad string table offset>";
}
return namestring;
}
-static CORE_ADDR
-find_stab_function_addr (char *namestring, const char *filename,
- struct objfile *objfile)
+static struct bound_minimal_symbol
+find_stab_function (const char *namestring, const char *filename,
+ struct objfile *objfile)
{
struct bound_minimal_symbol msym;
- char *p;
int n;
- p = strchr (namestring, ':');
- if (p == NULL)
- p = namestring;
- n = p - namestring;
- p = (char *) alloca (n + 2);
+ const char *colon = strchr (namestring, ':');
+ if (colon == NULL)
+ n = 0;
+ else
+ n = colon - namestring;
+
+ char *p = (char *) alloca (n + 2);
strncpy (p, namestring, n);
p[n] = 0;
msym = lookup_minimal_symbol (p, NULL, objfile);
}
- return msym.minsym == NULL ? 0 : BMSYMBOL_VALUE_ADDRESS (msym);
+ return msym;
}
static void
function_outside_compilation_unit_complaint (const char *arg1)
{
- complaint (&symfile_complaints,
- _("function `%s' appears to be defined "
+ complaint (_("function `%s' appears to be defined "
"outside of all compilation units"),
arg1);
}
struct internal_nlist nlist;
CORE_ADDR text_addr;
int text_size;
- char *sym_name;
+ const char *sym_name;
int sym_len;
- char *namestring;
+ const char *namestring;
int nsl;
int past_first_source_file = 0;
CORE_ADDR last_function_start = 0;
- struct cleanup *back_to;
bfd *abfd;
int textlow_not_set;
int data_sect_index;
sizeof (struct partial_symtab *));
/* Init bincl list */
- init_bincl_list (20, objfile);
- back_to = make_cleanup_free_bincl_list (objfile);
+ std::vector<struct header_file_location> bincl_storage;
+ scoped_restore restore_bincl_global
+ = make_scoped_restore (&bincl_list, &bincl_storage);
set_last_source_file (NULL);
|| (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)
+ && nlist.n_value >= pst->raw_text_low ())
{
dbx_end_psymtab (objfile, pst, psymtab_include_list,
includes_used, symnum * symbol_size,
- nlist.n_value > pst->texthigh
- ? nlist.n_value : pst->texthigh,
+ nlist.n_value > pst->raw_text_high ()
+ ? nlist.n_value : pst->raw_text_high (),
dependency_list, dependencies_used,
textlow_not_set);
pst = (struct partial_symtab *) 0;
static int prev_so_symnum = -10;
static int first_so_symnum;
const char *p;
- static char *dirname_nso;
+ static const char *dirname_nso;
int prev_textlow_not_set;
- valu = nlist.n_value + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ valu = nlist.n_value;
prev_textlow_not_set = textlow_not_set;
{
dbx_end_psymtab (objfile, pst, psymtab_include_list,
includes_used, symnum * symbol_size,
- valu > pst->texthigh
- ? valu : pst->texthigh,
+ (valu > pst->raw_text_high ()
+ ? valu : pst->raw_text_high ()),
dependency_list, dependencies_used,
prev_textlow_not_set);
pst = (struct partial_symtab *) 0;
{
pst = start_psymtab (objfile,
namestring, valu,
- first_so_symnum * symbol_size,
- objfile->global_psymbols.next,
- objfile->static_psymbols.next);
+ first_so_symnum * symbol_size);
pst->dirname = dirname_nso;
dirname_nso = NULL;
}
{
/* FIXME: we should not get here without a PST to work on.
Attempt to recover. */
- complaint (&symfile_complaints,
- _("N_BINCL %s not in entries for "
+ complaint (_("N_BINCL %s not in entries for "
"any file, at symtab pos %d"),
namestring, symnum);
continue;
}
- add_bincl_to_list (pst, namestring, nlist.n_value);
+ bincl_list->emplace_back (namestring, nlist.n_value, pst);
/* Mark down an include file in the current psymtab. */
case N_M2C: /* I suspect that I can ignore this here. */
case N_SCOPE: /* Same. */
{
- char *p;
+ const char *p;
namestring = set_namestring (objfile, &nlist);
function relative stabs, or the address of the function's
end for old style stabs. */
valu = nlist.n_value + last_function_start;
- if (pst->texthigh == 0 || valu > pst->texthigh)
- pst->texthigh = valu;
+ if (pst->raw_text_high () == 0 || valu > pst->raw_text_high ())
+ pst->set_text_high (valu);
break;
}
if (!new_name.empty ())
{
sym_len = new_name.length ();
- sym_name = (char *) obstack_copy0 (&objfile->objfile_obstack,
- new_name.c_str (),
- sym_len);
+ sym_name = obstack_strdup (&objfile->objfile_obstack,
+ new_name);
}
}
switch (p[1])
{
case 'S':
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- data_sect_index);
-
if (gdbarch_static_transform_name_p (gdbarch))
gdbarch_static_transform_name (gdbarch, namestring);
- add_psymbol_to_list (sym_name, sym_len, 1,
+ add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
VAR_DOMAIN, LOC_STATIC,
- &objfile->static_psymbols,
+ data_sect_index,
+ psymbol_placement::STATIC,
nlist.n_value, psymtab_language, objfile);
continue;
case 'G':
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- data_sect_index);
/* The addresses in these entries are reported to be
wrong. See the code that reads 'G's for symtabs. */
- add_psymbol_to_list (sym_name, sym_len, 1,
+ add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
VAR_DOMAIN, LOC_STATIC,
- &objfile->global_psymbols,
+ data_sect_index,
+ psymbol_placement::GLOBAL,
nlist.n_value, psymtab_language, objfile);
continue;
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list (sym_name, sym_len, 1,
- STRUCT_DOMAIN, LOC_TYPEDEF,
- &objfile->static_psymbols,
+ add_psymbol_to_list (gdb::string_view (sym_name, sym_len),
+ true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
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,
+ add_psymbol_to_list (gdb::string_view (sym_name, sym_len),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
0, psymtab_language, objfile);
p += 1;
}
case 't':
if (p != namestring) /* a name is there, not just :T... */
{
- add_psymbol_to_list (sym_name, sym_len, 1,
- VAR_DOMAIN, LOC_TYPEDEF,
- &objfile->static_psymbols,
+ add_psymbol_to_list (gdb::string_view (sym_name, sym_len),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
0, psymtab_language, objfile);
}
check_enum:
Accept either. */
while (*p && *p != ';' && *p != ',')
{
- char *q;
+ const char *q;
/* Check for and handle cretinous dbx symbol name
continuation! */
;
/* Note that the value doesn't matter for
enum constants in psymtabs, just in symtabs. */
- add_psymbol_to_list (p, q - p, 1,
- VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, 0,
+ add_psymbol_to_list (gdb::string_view (p, q - p), true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC, 0,
psymtab_language, objfile);
/* Point past the name. */
p = q;
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (sym_name, sym_len, 1,
- VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, 0,
+ add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC, 0,
psymtab_language, objfile);
continue;
function_outside_compilation_unit_complaint (name);
xfree (name);
}
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
/* Kludges for ELF/STABS with Sun ACC. */
last_function_name = namestring;
/* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
value for the bottom of the text seg in those cases. */
- if (nlist.n_value == ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile))
+ if (nlist.n_value == 0
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- CORE_ADDR minsym_valu =
- find_stab_function_addr (namestring,
- pst ? pst->filename : NULL,
- objfile);
-
- /* find_stab_function_addr will return 0 if the minimal
- symbol wasn't found. (Unfortunately, this might also
- be a valid address.) Anyway, if it *does* return 0,
- it is likely that the value was set correctly to begin
- with... */
- if (minsym_valu != 0)
- nlist.n_value = minsym_valu;
+ struct bound_minimal_symbol minsym
+ = find_stab_function (namestring,
+ pst ? pst->filename : NULL,
+ objfile);
+ if (minsym.minsym != NULL)
+ nlist.n_value = MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym);
}
if (pst && textlow_not_set
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- pst->textlow = nlist.n_value;
+ pst->set_text_low (nlist.n_value);
textlow_not_set = 0;
}
/* End kludge. */
the partial symbol table. */
if (pst
&& (textlow_not_set
- || (nlist.n_value < pst->textlow
- && (nlist.n_value
- != ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile))))))
+ || (nlist.n_value < pst->raw_text_low ()
+ && (nlist.n_value != 0))))
{
- pst->textlow = nlist.n_value;
+ pst->set_text_low (nlist.n_value);
textlow_not_set = 0;
}
- add_psymbol_to_list (sym_name, sym_len, 1,
+ add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
VAR_DOMAIN, LOC_BLOCK,
- &objfile->static_psymbols,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::STATIC,
nlist.n_value, psymtab_language, objfile);
continue;
function_outside_compilation_unit_complaint (name);
xfree (name);
}
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
/* Kludges for ELF/STABS with Sun ACC. */
last_function_name = namestring;
/* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
value for the bottom of the text seg in those cases. */
- if (nlist.n_value == ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile))
+ if (nlist.n_value == 0
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- CORE_ADDR minsym_valu =
- find_stab_function_addr (namestring,
- pst ? pst->filename : NULL,
- objfile);
-
- /* find_stab_function_addr will return 0 if the minimal
- symbol wasn't found. (Unfortunately, this might also
- be a valid address.) Anyway, if it *does* return 0,
- it is likely that the value was set correctly to begin
- with... */
- if (minsym_valu != 0)
- nlist.n_value = minsym_valu;
+ struct bound_minimal_symbol minsym
+ = find_stab_function (namestring,
+ pst ? pst->filename : NULL,
+ objfile);
+ if (minsym.minsym != NULL)
+ nlist.n_value = MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym);
}
if (pst && textlow_not_set
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- pst->textlow = nlist.n_value;
+ pst->set_text_low (nlist.n_value);
textlow_not_set = 0;
}
/* End kludge. */
the partial symbol table. */
if (pst
&& (textlow_not_set
- || (nlist.n_value < pst->textlow
- && (nlist.n_value
- != ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile))))))
+ || (nlist.n_value < pst->raw_text_low ()
+ && (nlist.n_value != 0))))
{
- pst->textlow = nlist.n_value;
+ pst->set_text_low (nlist.n_value);
textlow_not_set = 0;
}
- add_psymbol_to_list (sym_name, sym_len, 1,
+ add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
VAR_DOMAIN, LOC_BLOCK,
- &objfile->global_psymbols,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::GLOBAL,
nlist.n_value, psymtab_language, objfile);
continue;
time searching to the end of every string looking for
a backslash. */
- complaint (&symfile_complaints,
- _("unknown symbol descriptor `%c'"),
+ complaint (_("unknown symbol descriptor `%c'"),
p[1]);
/* Ignore it; perhaps it is an extension that we don't
continue;
case N_ENDM:
- /* Solaris 2 end of module, finish current partial symbol table.
- dbx_end_psymtab will set pst->texthigh to the proper value, which
- is necessary if a module compiled without debugging info
- follows this module. */
+ /* Solaris 2 end of module, finish current partial symbol
+ table. dbx_end_psymtab will set the high text address of
+ PST 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))
{
dbx_end_psymtab (objfile, pst,
/* If there's stuff to be cleaned up, clean it up. */
if (pst)
{
- /* Don't set pst->texthigh lower than it already is. */
+ /* Don't set high text address of PST lower than it already
+ is. */
CORE_ADDR text_end =
(lowest_text_address == (CORE_ADDR) -1
- ? (text_addr + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile)))
+ ? text_addr
: lowest_text_address)
+ text_size;
dbx_end_psymtab (objfile, pst, psymtab_include_list, includes_used,
symnum * symbol_size,
- text_end > pst->texthigh ? text_end : pst->texthigh,
+ (text_end > pst->raw_text_high ()
+ ? text_end : pst->raw_text_high ()),
dependency_list, dependencies_used, textlow_not_set);
}
-
- do_cleanups (back_to);
}
/* Allocate and partially fill a partial symtab. It will be
(normal). */
static struct partial_symtab *
-start_psymtab (struct objfile *objfile, char *filename, CORE_ADDR textlow,
- int ldsymoff, struct partial_symbol **global_syms,
- struct partial_symbol **static_syms)
+start_psymtab (struct objfile *objfile, const char *filename, CORE_ADDR textlow,
+ int ldsymoff)
{
struct partial_symtab *result =
- start_psymtab_common (objfile, filename, textlow,
- global_syms, static_syms);
+ start_psymtab_common (objfile, filename, textlow);
result->read_symtab_private =
XOBNEW (&objfile->objfile_obstack, struct symloc);
/* Deduce the source language from the filename for this psymtab. */
psymtab_language = deduce_language_from_filename (filename);
+ PST_LANGUAGE (result) = psymtab_language;
return result;
}
if (capping_symbol_offset != -1)
LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst);
- pst->texthigh = capping_text;
+ pst->set_text_high (capping_text);
/* Under Solaris, the N_SO symbols always have a value of 0,
instead of the usual address of the .o file. Therefore,
a reliable texthigh by taking the address plus size of the
last function in the file. */
- if (pst->texthigh == 0 && last_function_name
+ if (!pst->text_high_valid && last_function_name
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- char *p;
int n;
struct bound_minimal_symbol minsym;
- p = strchr (last_function_name, ':');
- if (p == NULL)
- p = last_function_name;
- n = p - last_function_name;
- p = (char *) alloca (n + 2);
+ const char *colon = strchr (last_function_name, ':');
+ if (colon == NULL)
+ n = 0;
+ else
+ n = colon - last_function_name;
+ char *p = (char *) alloca (n + 2);
strncpy (p, last_function_name, n);
p[n] = 0;
}
if (minsym.minsym)
- pst->texthigh = (BMSYMBOL_VALUE_ADDRESS (minsym)
- + MSYMBOL_SIZE (minsym.minsym));
+ pst->set_text_high (MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym)
+ + MSYMBOL_SIZE (minsym.minsym));
last_function_name = NULL;
}
;
/* This test will be true if the last .o file is only data. */
else if (textlow_not_set)
- pst->textlow = pst->texthigh;
+ pst->set_text_low (pst->raw_text_high ());
else
{
- struct partial_symtab *p1;
-
/* If we know our own starting text address, then walk through all other
psymtabs for this objfile, and if any didn't know their ending text
address, set it to our starting address. Take care to not set our
- own ending address to our starting address, nor to set addresses on
- `dependency' files that have both textlow and texthigh zero. */
+ own ending address to our starting address. */
- ALL_OBJFILE_PSYMTABS (objfile, p1)
- {
- if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst)
- {
- p1->texthigh = pst->textlow;
- /* If this file has only data, then make textlow match
- texthigh. */
- if (p1->textlow == 0)
- p1->textlow = p1->texthigh;
- }
- }
+ for (partial_symtab *p1 : objfile->psymtabs ())
+ if (!p1->text_high_valid && p1->text_low_valid && p1 != pst)
+ p1->set_text_high (pst->raw_text_low ());
}
/* End of kludge for patching Solaris textlow and texthigh. */
pst->number_of_dependencies = number_dependencies;
if (number_dependencies)
{
- pst->dependencies = XOBNEWVEC (&objfile->objfile_obstack,
- struct partial_symtab *,
- number_dependencies);
+ pst->dependencies
+ = objfile->partial_symtabs->allocate_dependencies (number_dependencies);
memcpy (pst->dependencies, dependency_list,
number_dependencies * sizeof (struct partial_symtab *));
}
subpst->read_symtab_private =
XOBNEW (&objfile->objfile_obstack, struct symloc);
LDSYMOFF (subpst) =
- LDSYMLEN (subpst) =
- subpst->textlow =
- subpst->texthigh = 0;
+ LDSYMLEN (subpst) = 0;
/* 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 =
- XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
+ objfile->partial_symtabs->allocate_dependencies (1);
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;
- subpst->globals_offset =
- subpst->n_global_syms =
- subpst->statics_offset =
- subpst->n_static_syms = 0;
-
- subpst->readin = 0;
- subpst->compunit_symtab = 0;
subpst->read_symtab = pst->read_symtab;
}
static void
dbx_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst)
{
- struct cleanup *old_chain;
int i;
if (pst->readin)
{
/* Init stuff necessary for reading in symbols */
stabsread_init ();
- buildsym_init ();
- old_chain = make_cleanup (really_free_pendings, 0);
+ scoped_free_pendings free_pending;
file_string_table_offset = FILE_STRING_OFFSET (pst);
symbol_size = SYMBOL_SIZE (pst);
/* Read in this file's symbols. */
bfd_seek (objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
read_ofile_symtab (objfile, pst);
-
- do_cleanups (old_chain);
}
pst->readin = 1;
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)
next_symbol_text_func = dbx_next_symbol_text;
- back_to = make_cleanup (null_cleanup, NULL);
-
- if (DBX_STAB_SECTION (objfile))
- {
- stabs_data
- = symfile_relocate_debug_section (objfile,
- DBX_STAB_SECTION (objfile),
- NULL);
-
- if (stabs_data)
- make_cleanup (free_current_contents, (void *) &stabs_data);
- }
-
- dbx_psymtab_to_symtab_1 (objfile, self);
+ {
+ scoped_restore restore_stabs_data = make_scoped_restore (&stabs_data);
+ gdb::unique_xmalloc_ptr<gdb_byte> data_holder;
+ if (DBX_STAB_SECTION (objfile))
+ {
+ stabs_data
+ = symfile_relocate_debug_section (objfile,
+ DBX_STAB_SECTION (objfile),
+ NULL);
+ data_holder.reset (stabs_data);
+ }
- do_cleanups (back_to);
+ dbx_psymtab_to_symtab_1 (objfile, self);
+ }
/* Match with global symbols. This only needs to be done once,
after all of the symtabs and dependencies have been read in. */
static void
read_ofile_symtab (struct objfile *objfile, struct partial_symtab *pst)
{
- char *namestring;
+ const char *namestring;
struct external_nlist *bufp;
struct internal_nlist nlist;
unsigned char type;
sym_offset = LDSYMOFF (pst);
sym_size = LDSYMLEN (pst);
- text_offset = pst->textlow;
- text_size = pst->texthigh - pst->textlow;
+ text_offset = pst->text_low (objfile);
+ text_size = pst->text_high (objfile) - pst->text_low (objfile);
section_offsets = objfile->section_offsets;
dbxread_objfile = objfile;
positive offsets. */
nlist.n_value = (nlist.n_value ^ 0x80000000) - 0x80000000;
process_one_symbol (type, nlist.n_desc, nlist.n_value,
- namestring, section_offsets, objfile);
+ namestring, section_offsets, objfile,
+ PST_LANGUAGE (pst));
}
/* We skip checking for a new .o or -l file; that should never
happen in this routine. */
else if (type & N_EXT || type == (unsigned char) N_TEXT
|| type == (unsigned char) N_NBTEXT)
{
- /* Global symbol: see if we came across a dbx defintion for
+ /* Global symbol: see if we came across a dbx definition for
a corresponding symbol. If so, store the value. Remove
syms from the chain when their values are stored, but
search the whole chain, as there may be several syms from
}
}
- /* In a Solaris elf file, this variable, which comes from the
- value of the N_SO symbol, will still be 0. Luckily, text_offset,
- which comes from pst->textlow is correct. */
- if (last_source_start_addr == 0)
- last_source_start_addr = text_offset;
+ /* In a Solaris elf file, this variable, which comes from the value
+ of the N_SO symbol, will still be 0. Luckily, text_offset, which
+ comes from low text address of PST, is correct. */
+ if (get_last_source_start_addr () == 0)
+ set_last_source_start_addr (text_offset);
/* In reordered executables last_source_start_addr may not be the
lower bound for this symtab, instead use text_offset which comes
- from pst->textlow which is correct. */
- if (last_source_start_addr > text_offset)
- last_source_start_addr = text_offset;
+ from the low text address of PST, which is correct. */
+ if (get_last_source_start_addr () > text_offset)
+ set_last_source_start_addr (text_offset);
pst->compunit_symtab = end_symtab (text_offset + text_size,
SECT_OFF_TEXT (objfile));
struct block *block,
struct obstack *obstack)
{
- if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
+ if (symbol->demangled_name () != NULL)
{
/* Try to figure out the appropriate namespace from the
demangled name. */
name of the class as well. This should be harmless, but
is a little unfortunate. */
- const char *name = SYMBOL_DEMANGLED_NAME (symbol);
+ const char *name = symbol->demangled_name ();
unsigned int prefix_len = cp_entire_prefix_len (name);
- block_set_scope (block,
- (const char *) obstack_copy0 (obstack, name, prefix_len),
+ block_set_scope (block, obstack_strndup (obstack, name, prefix_len),
obstack);
}
}
the pst->section_offsets. 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. */
+ is used in end_symtab.
+ LANGUAGE is the language of the symtab.
+*/
void
-process_one_symbol (int type, int desc, CORE_ADDR valu, char *name,
+process_one_symbol (int type, int desc, CORE_ADDR valu, const char *name,
const struct section_offsets *section_offsets,
- struct objfile *objfile)
+ struct objfile *objfile, enum language language)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct context_stack *newobj;
+ struct context_stack cstk;
/* 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
the current block. */
struct block *block;
- if (context_stack_depth <= 0)
+ if (outermost_context_p ())
{
lbrac_mismatch_complaint (symnum);
break;
{
CORE_ADDR addr = last_function_start + valu;
- record_line (current_subfile, 0,
+ record_line (get_current_subfile (), 0,
gdbarch_addr_bits_remove (gdbarch, addr));
}
within_function = 0;
- newobj = pop_context ();
+ cstk = pop_context ();
/* Make a block for the local symbols within. */
- block = finish_block (newobj->name, &local_symbols,
- newobj->old_blocks, NULL,
- newobj->start_addr, newobj->start_addr + valu);
+ block = finish_block (cstk.name,
+ cstk.old_blocks, NULL,
+ cstk.start_addr, cstk.start_addr + valu);
/* For C++, set the block's scope. */
- if (SYMBOL_LANGUAGE (newobj->name) == language_cplus)
- cp_set_block_scope (newobj->name, block, &objfile->objfile_obstack);
+ if (cstk.name->language () == language_cplus)
+ cp_set_block_scope (cstk.name, block, &objfile->objfile_obstack);
/* May be switching to an assembler file which may not be using
block relative stabs, so reset the offset. */
valu += function_start_offset;
- if (context_stack_depth <= 0)
+ if (outermost_context_p ())
{
lbrac_mismatch_complaint (symnum);
break;
}
- newobj = pop_context ();
- if (desc != newobj->depth)
+ cstk = pop_context ();
+ if (desc != cstk.depth)
lbrac_mismatch_complaint (symnum);
- if (local_symbols != NULL)
+ if (*get_local_symbols () != NULL)
{
/* GCC development snapshots from March to December of
2000 would output N_LSYM entries after N_LBRAC
entries. As a consequence, these symbols are simply
discarded. Complain if this is the case. */
- complaint (&symfile_complaints,
- _("misplaced N_LBRAC entry; discarding local "
+ complaint (_("misplaced N_LBRAC entry; discarding local "
"symbols which have no enclosing block"));
}
- local_symbols = newobj->locals;
+ *get_local_symbols () = cstk.locals;
- if (context_stack_depth > 1)
+ if (get_context_stack_depth () > 1)
{
/* This is not the outermost LBRAC...RBRAC pair in the
function, its local symbols preceded it, and are the ones
for them (but don't bother if the block contains no
symbols. Should we complain on blocks without symbols?
I can't think of any useful purpose for them). */
- if (local_symbols != NULL)
+ if (*get_local_symbols () != NULL)
{
/* Muzzle a compiler bug that makes end < start.
??? Which compilers? Is this ever harmful?. */
- if (newobj->start_addr > valu)
+ if (cstk.start_addr > valu)
{
- complaint (&symfile_complaints,
- _("block start larger than block end"));
- newobj->start_addr = valu;
+ complaint (_("block start larger than block end"));
+ cstk.start_addr = valu;
}
/* Make a block for the local symbols within. */
- finish_block (0, &local_symbols, newobj->old_blocks, NULL,
- newobj->start_addr, valu);
+ finish_block (0, cstk.old_blocks, NULL,
+ cstk.start_addr, valu);
}
}
else
name. Patch things up. */
if (previous_stab_code == (unsigned char) N_SO)
{
- patch_subfile_names (current_subfile, name);
+ patch_subfile_names (get_current_subfile (), name);
break; /* Ignore repeated SOs. */
}
end_symtab (valu, SECT_OFF_TEXT (objfile));
function_start_offset = 0;
start_stabs ();
- start_symtab (objfile, name, NULL, valu);
+ start_symtab (objfile, name, NULL, valu, language);
record_debugformat ("stabs");
break;
function-relative symbols. */
valu += function_start_offset;
- /* GCC 2.95.3 emits the first N_SLINE stab somwehere in the
+ /* GCC 2.95.3 emits the first N_SLINE stab somewhere in the
middle of the prologue instead of right at the start of the
function. To deal with this we record the address for the
first N_SLINE stab to be the start of the function instead of
CORE_ADDR addr = processing_gcc_compilation == 2 ?
last_function_start : valu;
- record_line (current_subfile, desc,
+ record_line (get_current_subfile (), desc,
gdbarch_addr_bits_remove (gdbarch, addr));
sline_found_in_function = 1;
}
else
- record_line (current_subfile, desc,
+ record_line (get_current_subfile (), desc,
gdbarch_addr_bits_remove (gdbarch, valu));
break;
down ONE MORE function call level, which we really don't want
to do). */
{
- char *p;
+ const char *p;
/* Normal object file and NLMs have non-zero text seg offsets,
but don't need their static syms offset in this fashion.
unknown_symtype_complaint (hex_string (type));
/* FALLTHROUGH */
- /* The following symbol types don't need the address field
- relocated, since it is either unused, or is absolute. */
define_a_symbol:
+ /* These symbol types don't need the address field relocated,
+ since it is either unused, or is absolute. */
case N_GSYM: /* Global variable. */
case N_NSYMS: /* Number of symbols (Ultrix). */
case N_NOMAP: /* No map? (Ultrix). */
if (name)
{
int deftype;
- char *colon_pos = strchr (name, ':');
+ const char *colon_pos = strchr (name, ':');
if (colon_pos == NULL)
deftype = '\0';
SECT_OFF_TEXT (objfile))
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- CORE_ADDR minsym_valu =
- 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.
- (Unfortunately, this might also be a valid
- address.) Anyway, if it *does* return 0, it is
- likely that the value was set correctly to begin
- with... */
- if (minsym_valu != 0)
- valu = minsym_valu;
+ struct bound_minimal_symbol minsym
+ = find_stab_function (name, get_last_source_file (),
+ objfile);
+ if (minsym.minsym != NULL)
+ valu = BMSYMBOL_VALUE_ADDRESS (minsym);
}
/* These addresses are absolute. */
within_function = 1;
- if (context_stack_depth > 1)
+ if (get_context_stack_depth () > 1)
{
- complaint (&symfile_complaints,
- _("unmatched N_LBRAC before symtab pos %d"),
+ complaint (_("unmatched N_LBRAC before symtab pos %d"),
symnum);
break;
}
- if (context_stack_depth > 0)
+ if (!outermost_context_p ())
{
struct block *block;
- newobj = pop_context ();
+ cstk = pop_context ();
/* Make a block for the local symbols within. */
- block = finish_block (newobj->name, &local_symbols,
- newobj->old_blocks, NULL,
- newobj->start_addr, valu);
+ block = finish_block (cstk.name,
+ cstk.old_blocks, NULL,
+ cstk.start_addr, valu);
/* For C++, set the block's scope. */
- if (SYMBOL_LANGUAGE (newobj->name) == language_cplus)
- cp_set_block_scope (newobj->name, block,
+ if (cstk.name->language () == language_cplus)
+ cp_set_block_scope (cstk.name, block,
&objfile->objfile_obstack);
}
definition. If a symbol reference is being defined, go ahead
and add it. Otherwise, just return. */
- char *s = name;
+ const char *s = name;
int refnum;
/* If this stab defines a new reference ID that is not on the
void
coffstab_build_psymtabs (struct objfile *objfile,
CORE_ADDR textaddr, unsigned int textsize,
- struct stab_section_list *stabsects,
+ const std::vector<asection *> &stabsects,
file_ptr stabstroffset, unsigned int stabstrsize)
{
int val;
bfd *sym_bfd = objfile->obfd;
- char *name = bfd_get_filename (sym_bfd);
+ const char *name = bfd_get_filename (sym_bfd);
unsigned int stabsize;
+ /* Allocate struct to keep track of stab reading. */
+ dbx_objfile_data_key.emplace (objfile);
+
DBX_TEXT_ADDR (objfile) = textaddr;
DBX_TEXT_SIZE (objfile) = textsize;
perror_with_name (name);
stabsread_new_init ();
- buildsym_new_init ();
free_header_files ();
init_header_files ();
/* In a coff file, we've already installed the minimal symbols that came
from the coff (non-stab) symbol table, so always act like an
incremental load here. */
- if (stabsects->next == NULL)
+ scoped_restore save_symbuf_sections
+ = make_scoped_restore (&symbuf_sections);
+ if (stabsects.size () == 1)
{
- stabsize = bfd_section_size (sym_bfd, stabsects->section);
+ stabsize = bfd_section_size (stabsects[0]);
DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
- DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
+ DBX_SYMTAB_OFFSET (objfile) = stabsects[0]->filepos;
}
else
{
- struct stab_section_list *stabsect;
-
DBX_SYMCOUNT (objfile) = 0;
- for (stabsect = stabsects; stabsect != NULL; stabsect = stabsect->next)
+ for (asection *section : stabsects)
{
- stabsize = bfd_section_size (sym_bfd, stabsect->section);
+ stabsize = bfd_section_size (section);
DBX_SYMCOUNT (objfile) += stabsize / DBX_SYMBOL_SIZE (objfile);
}
- DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
+ DBX_SYMTAB_OFFSET (objfile) = stabsects[0]->filepos;
- symbuf_sections = stabsects->next;
- symbuf_left = bfd_section_size (sym_bfd, stabsects->section);
+ sect_idx = 1;
+ symbuf_sections = &stabsects;
+ symbuf_left = bfd_section_size (stabsects[0]);
symbuf_read = 0;
}
{
int val;
bfd *sym_bfd = objfile->obfd;
- char *name = bfd_get_filename (sym_bfd);
- struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
+ const char *name = bfd_get_filename (sym_bfd);
+
+ stabsread_new_init ();
+
+ /* Allocate struct to keep track of stab reading. */
+ dbx_objfile_data_key.emplace (objfile);
/* Find the first and last text address. dbx_symfile_read seems to
want this. */
#define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
DBX_SYMCOUNT (objfile)
- = bfd_section_size (objfile->obfd, stabsect) / DBX_SYMBOL_SIZE (objfile);
+ = bfd_section_size (stabsect) / DBX_SYMBOL_SIZE (objfile);
DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos;
DBX_STAB_SECTION (objfile) = stabsect;
perror_with_name (name);
stabsread_new_init ();
- buildsym_new_init ();
free_header_files ();
init_header_files ();
processing_acc_compilation = 1;
symbuf_read = 0;
- symbuf_left = bfd_section_size (objfile->obfd, stabsect);
+ symbuf_left = bfd_section_size (stabsect);
+
+ scoped_restore restore_stabs_data = make_scoped_restore (&stabs_data);
+ gdb::unique_xmalloc_ptr<gdb_byte> data_holder;
+
stabs_data = symfile_relocate_debug_section (objfile, stabsect, NULL);
if (stabs_data)
- make_cleanup (free_current_contents, (void *) &stabs_data);
+ data_holder.reset (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
table and normal symbol entries won't be in the ".stab" section; but in
case it does, it will install them itself. */
dbx_symfile_read (objfile, 0);
-
- do_cleanups (back_to);
}
\f
/* Scan and build partial symbols for a file with special sections for stabs
{
int val;
bfd *sym_bfd = objfile->obfd;
- char *name = bfd_get_filename (sym_bfd);
+ const char *name = bfd_get_filename (sym_bfd);
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);
- dbx = XCNEW (struct dbx_symfile_info);
- set_objfile_data (objfile, dbx_objfile_data_key, dbx);
+ dbx_objfile_data_key.emplace (objfile);
text_sect = bfd_get_section_by_name (sym_bfd, text_name);
if (!text_sect)
error (_("Can't find %s section in symbol file"), text_name);
- DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
- DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
+ DBX_TEXT_ADDR (objfile) = bfd_section_vma (text_sect);
+ DBX_TEXT_SIZE (objfile) = bfd_section_size (text_sect);
DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist);
- DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
+ DBX_SYMCOUNT (objfile) = bfd_section_size (stabsect)
/ DBX_SYMBOL_SIZE (objfile);
- DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect);
+ DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (stabstrsect);
DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; /* XXX - FIXME: POKING
INSIDE BFD DATA
STRUCTURES */
perror_with_name (name);
stabsread_new_init ();
- buildsym_new_init ();
free_header_files ();
init_header_files ();
_initialize_dbxread (void)
{
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