/* Read dbx symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2023 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"
-#if defined(__CYGNUSCLIB__)
-#include <sys/types.h>
-#include <fcntl.h>
-#endif
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.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 "gdbcore.h"
+#include "libaout.h"
#include "filenames.h"
#include "objfiles.h"
#include "buildsym-legacy.h"
#include "complaints.h"
#include "cp-abi.h"
#include "cp-support.h"
-#include "psympriv.h"
+#include "c-lang.h"
+#include "psymtab.h"
#include "block.h"
#include "aout/aout64.h"
-#include "aout/stab_gnu.h" /* We always use GNU stabs, not
- native, now. */
+#include "aout/stab_gnu.h"
\f
/* Key for dbx-associated data. */
-objfile_key<dbx_symfile_info> dbx_objfile_data_key;
+const registry<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. */
need to make guesses based on the symbols (which *are* relocated to
reflect the address it will be loaded at). */
-static CORE_ADDR lowest_text_address;
+static unrelocated_addr lowest_text_address;
/* Non-zero if there is any line number info in the objfile. Prevents
dbx_end_psymtab from discarding an otherwise empty psymtab. */
static void dbx_read_symtab (legacy_psymtab *self,
struct objfile *objfile);
-static void dbx_psymtab_to_symtab_1 (legacy_psymtab *, struct objfile *);
+static void dbx_expand_psymtab (legacy_psymtab *, struct objfile *);
-static void read_dbx_symtab (minimal_symbol_reader &, struct objfile *);
+static void read_dbx_symtab (minimal_symbol_reader &, psymtab_storage *,
+ struct objfile *);
static legacy_psymtab *find_corresponding_bincl_psymtab (const char *,
int);
static void dbx_symfile_finish (struct objfile *);
static void record_minimal_symbol (minimal_symbol_reader &,
- const char *, CORE_ADDR, int,
+ const char *, unrelocated_addr, int,
struct objfile *);
static void add_new_header_file (const char *, int);
static void add_this_object_header_file (int);
-static legacy_psymtab *start_psymtab (struct objfile *, const char *,
- CORE_ADDR, int);
+static legacy_psymtab *start_psymtab (psymtab_storage *, struct objfile *,
+ const char *, unrelocated_addr, int);
/* Free up old header file tables. */
\f
static void
record_minimal_symbol (minimal_symbol_reader &reader,
- const char *name, CORE_ADDR address, int type,
+ const char *name, unrelocated_addr address, int type,
struct objfile *objfile)
{
enum minimal_symbol_type ms_type;
break;
case N_SETV:
/* I don't think this type actually exists; since a N_SETV is the result
- of going over many .o files, it doesn't make sense to have one
- file local. */
+ of going over many .o files, it doesn't make sense to have one
+ file local. */
ms_type = mst_file_data;
section = SECT_OFF_DATA (objfile);
break;
ms_type = mst_file_data;
/* Check for __DYNAMIC, which is used by Sun shared libraries.
- Record it as global even if it's local, not global, so
- lookup_minimal_symbol can find it. We don't check symbol_leading_char
- because for SunOS4 it always is '_'. */
- if (name[8] == 'C' && strcmp ("__DYNAMIC", name) == 0)
+ Record it as global even if it's local, not global, so
+ lookup_minimal_symbol can find it. We don't check symbol_leading_char
+ because for SunOS4 it always is '_'. */
+ if (strcmp ("__DYNAMIC", name) == 0)
ms_type = mst_data;
/* Same with virtual function tables, both global and static. */
{
const char *tempstring = name;
- if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
+ if (*tempstring != '\0'
+ && *tempstring == bfd_get_symbol_leading_char (objfile->obfd.get ()))
++tempstring;
if (is_vtable_name (tempstring))
ms_type = mst_data;
bfd *sym_bfd;
int val;
- sym_bfd = objfile->obfd;
+ sym_bfd = objfile->obfd.get ();
/* .o and .nlm files are relocatables with text, data and bss segs based at
0. This flag disables special (Solaris stabs-in-elf only) fixups for
if (val < 0)
perror_with_name (objfile_name (objfile));
- /* Size the symbol table. */
- init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
-
symbol_size = DBX_SYMBOL_SIZE (objfile);
symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
/* Read stabs data from executable file and define symbols. */
- read_dbx_symtab (reader, objfile);
+ psymbol_functions *psf = new psymbol_functions ();
+ psymtab_storage *partial_symtabs = psf->get_partial_symtabs ().get ();
+ objfile->qf.emplace_front (psf);
+ read_dbx_symtab (reader, partial_symtabs, objfile);
/* Install any minimal symbols that have been collected as the current
minimal symbols for this objfile. */
dbx_symfile_init (struct objfile *objfile)
{
int val;
- bfd *sym_bfd = objfile->obfd;
+ bfd *sym_bfd = objfile->obfd.get ();
const char *name = bfd_get_filename (sym_bfd);
asection *text_sect;
unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
if (STRING_TABLE_OFFSET == 0)
{
/* It appears that with the existing bfd code, STRING_TABLE_OFFSET
- will never be zero, even when there is no string table. This
- would appear to be a bug in bfd. */
+ will never be zero, even when there is no string table. This
+ would appear to be a bug in bfd. */
DBX_STRINGTAB_SIZE (objfile) = 0;
DBX_STRINGTAB (objfile) = NULL;
}
perror_with_name (name);
memset (size_temp, 0, sizeof (size_temp));
- val = bfd_bread (size_temp, sizeof (size_temp), sym_bfd);
+ val = bfd_read (size_temp, sizeof (size_temp), sym_bfd);
if (val < 0)
{
perror_with_name (name);
val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
if (val < 0)
perror_with_name (name);
- val = bfd_bread (DBX_STRINGTAB (objfile),
- DBX_STRINGTAB_SIZE (objfile),
- sym_bfd);
+ val = bfd_read (DBX_STRINGTAB (objfile),
+ DBX_STRINGTAB_SIZE (objfile),
+ sym_bfd);
if (val != DBX_STRINGTAB_SIZE (objfile))
perror_with_name (name);
}
{
nbytes = sizeof (symbuf);
if (nbytes > symbuf_left)
- nbytes = symbuf_left;
+ nbytes = symbuf_left;
memcpy (symbuf, stabs_data + symbuf_read, nbytes);
}
else if (symbuf_sections == NULL)
{
count = sizeof (symbuf);
- nbytes = bfd_bread (symbuf, count, sym_bfd);
+ nbytes = bfd_read (symbuf, count, sym_bfd);
}
else
{
count = symbuf_left;
if (count > sizeof (symbuf))
count = sizeof (symbuf);
- nbytes = bfd_bread (symbuf, count, sym_bfd);
+ nbytes = bfd_read (symbuf, count, sym_bfd);
}
if (nbytes < 0)
symbuf_left -= sym_offset;
}
else
- bfd_seek (symfile_bfd, sym_offset, SEEK_CUR);
+ if (bfd_seek (symfile_bfd, sym_offset, SEEK_CUR) != 0)
+ perror_with_name (bfd_get_filename (symfile_bfd));
}
#define INTERNALIZE_SYMBOL(intern, extern, abfd) \
if (msym.minsym == NULL)
{
/* Sun Fortran appends an underscore to the minimal symbol name,
- try again with an appended underscore if the minimal symbol
- was not found. */
+ try again with an appended underscore if the minimal symbol
+ was not found. */
p[n] = '_';
p[n + 1] = 0;
msym = lookup_minimal_symbol (p, filename, objfile);
debugging information is available. */
static void
-read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile)
+read_dbx_symtab (minimal_symbol_reader &reader,
+ psymtab_storage *partial_symtabs,
+ struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
struct external_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch. */
struct internal_nlist nlist;
CORE_ADDR text_addr;
set_last_source_file (NULL);
- lowest_text_address = (CORE_ADDR) -1;
+ lowest_text_address = (unrelocated_addr) -1;
- symfile_bfd = objfile->obfd; /* For next_text_symbol. */
- abfd = objfile->obfd;
+ symfile_bfd = objfile->obfd.get (); /* For next_text_symbol. */
+ abfd = objfile->obfd.get ();
symbuf_end = symbuf_idx = 0;
next_symbol_text_func = dbx_next_symbol_text;
textlow_not_set = 1;
OBJSTAT (objfile, n_stabs++);
/* Ok. There is a lot of code duplicated in the rest of this
- switch statement (for efficiency reasons). Since I don't
- like duplicating code, I will do my penance here, and
- describe the code which is duplicated:
+ switch statement (for efficiency reasons). Since I don't
+ like duplicating code, I will do my penance here, and
+ describe the code which is duplicated:
- *) The assignment to namestring.
- *) The call to strchr.
- *) The addition of a partial symbol the two partial
- symbol lists. This last is a large section of code, so
- I've imbedded it in the following macro. */
+ *) The assignment to namestring.
+ *) The call to strchr.
+ *) The addition of a partial symbol the two partial
+ symbol lists. This last is a large section of code, so
+ I've embedded it in the following macro. */
switch (nlist.n_type)
{
record_it:
namestring = set_namestring (objfile, &nlist);
- record_minimal_symbol (reader, namestring, nlist.n_value,
+ record_minimal_symbol (reader, namestring,
+ unrelocated_addr (nlist.n_value),
nlist.n_type, objfile); /* Always */
continue;
|| (namestring[(nsl = strlen (namestring)) - 1] == 'o'
&& namestring[nsl - 2] == '.'))
{
+ unrelocated_addr unrel_val = unrelocated_addr (nlist.n_value);
+
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->raw_text_low ())
+ && unrel_val >= pst->unrelocated_text_low ())
{
- dbx_end_psymtab (objfile, pst, psymtab_include_list,
+ dbx_end_psymtab (objfile, partial_symtabs,
+ pst, psymtab_include_list,
includes_used, symnum * symbol_size,
- nlist.n_value > pst->raw_text_high ()
- ? nlist.n_value : pst->raw_text_high (),
+ unrel_val > pst->unrelocated_text_high ()
+ ? unrel_val : pst->unrelocated_text_high (),
dependency_list, dependencies_used,
textlow_not_set);
pst = (legacy_psymtab *) 0;
if (pst)
{
- dbx_end_psymtab (objfile, pst, psymtab_include_list,
+ unrelocated_addr unrel_value = unrelocated_addr (valu);
+ dbx_end_psymtab (objfile, partial_symtabs,
+ pst, psymtab_include_list,
includes_used, symnum * symbol_size,
- (valu > pst->raw_text_high ()
- ? valu : pst->raw_text_high ()),
+ unrel_value > pst->unrelocated_text_high ()
+ ? unrel_value
+ : pst->unrelocated_text_high (),
dependency_list, dependencies_used,
prev_textlow_not_set);
pst = (legacy_psymtab *) 0;
{
/* Save the directory name SOs locally, then save it into
the psymtab when it's created below. */
- dirname_nso = namestring;
- continue;
+ dirname_nso = namestring;
+ continue;
}
/* Some other compilers (C++ ones in particular) emit useless
if (!pst)
{
- pst = start_psymtab (objfile,
- namestring, valu,
+ pst = start_psymtab (partial_symtabs, objfile,
+ namestring,
+ unrelocated_addr (valu),
first_so_symnum * symbol_size);
pst->dirname = dirname_nso;
dirname_nso = NULL;
/* See if this is an end of function stab. */
if (pst && nlist.n_type == N_FUN && *namestring == '\000')
{
- CORE_ADDR valu;
+ unrelocated_addr valu;
/* It's value is the size (in bytes) of the function for
function relative stabs, or the address of the function's
end for old style stabs. */
- valu = nlist.n_value + last_function_start;
- if (pst->raw_text_high () == 0 || valu > pst->raw_text_high ())
+ valu = unrelocated_addr (nlist.n_value + last_function_start);
+ if (pst->unrelocated_text_high () == unrelocated_addr (0)
+ || valu > pst->unrelocated_text_high ())
pst->set_text_high (valu);
break;
}
if (!p)
continue; /* Not a debugging symbol. */
- sym_len = 0;
+ sym_len = 0;
sym_name = NULL; /* pacify "gcc -Werror" */
- if (psymtab_language == language_cplus)
- {
+ if (psymtab_language == language_cplus)
+ {
std::string name (namestring, p - namestring);
- std::string new_name = cp_canonicalize_string (name.c_str ());
- if (!new_name.empty ())
+ gdb::unique_xmalloc_ptr<char> new_name
+ = cp_canonicalize_string (name.c_str ());
+ if (new_name != nullptr)
{
- sym_len = new_name.length ();
+ sym_len = strlen (new_name.get ());
sym_name = obstack_strdup (&objfile->objfile_obstack,
- new_name);
+ new_name.get ());
+ }
+ }
+ else if (psymtab_language == language_c)
+ {
+ std::string name (namestring, p - namestring);
+ gdb::unique_xmalloc_ptr<char> new_name
+ = c_canonicalize_name (name.c_str ());
+ if (new_name != nullptr)
+ {
+ sym_len = strlen (new_name.get ());
+ sym_name = obstack_strdup (&objfile->objfile_obstack,
+ new_name.get ());
}
}
- if (sym_len == 0)
- {
- sym_name = namestring;
- sym_len = p - namestring;
- }
+ if (sym_len == 0)
+ {
+ sym_name = namestring;
+ sym_len = p - namestring;
+ }
/* Main processing section for debugging symbols which
the initial read through the symbol tables needs to worry
switch (p[1])
{
case 'S':
- if (gdbarch_static_transform_name_p (gdbarch))
- gdbarch_static_transform_name (gdbarch, namestring);
-
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_STATIC,
- data_sect_index,
- psymbol_placement::STATIC,
- nlist.n_value, psymtab_language, objfile);
+ if (pst != nullptr)
+ pst->add_psymbol (std::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_STATIC,
+ data_sect_index,
+ psymbol_placement::STATIC,
+ unrelocated_addr (nlist.n_value),
+ psymtab_language,
+ partial_symtabs, objfile);
+ else
+ complaint (_("static `%*s' appears to be defined "
+ "outside of all compilation units"),
+ sym_len, sym_name);
continue;
case 'G':
/* The addresses in these entries are reported to be
wrong. See the code that reads 'G's for symtabs. */
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_STATIC,
- data_sect_index,
- psymbol_placement::GLOBAL,
- nlist.n_value, psymtab_language, objfile);
+ if (pst != nullptr)
+ pst->add_psymbol (std::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_STATIC,
+ data_sect_index,
+ psymbol_placement::GLOBAL,
+ unrelocated_addr (nlist.n_value),
+ psymtab_language,
+ partial_symtabs, objfile);
+ else
+ complaint (_("global `%*s' appears to be defined "
+ "outside of all compilation units"),
+ sym_len, sym_name);
continue;
case 'T':
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- 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 (pst != nullptr)
+ pst->add_psymbol (std::string_view (sym_name, sym_len),
+ true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ unrelocated_addr (0),
+ psymtab_language,
+ partial_symtabs, objfile);
+ else
+ complaint (_("enum, struct, or union `%*s' appears "
+ "to be defined outside of all "
+ "compilation units"),
+ sym_len, sym_name);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len),
- true, VAR_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ if (pst != nullptr)
+ pst->add_psymbol (std::string_view (sym_name, sym_len),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ unrelocated_addr (0),
+ psymtab_language,
+ partial_symtabs, objfile);
+ else
+ complaint (_("typedef `%*s' appears to be defined "
+ "outside of all compilation units"),
+ sym_len, sym_name);
p += 1;
}
}
case 't':
if (p != namestring) /* a name is there, not just :T... */
{
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len),
- true, VAR_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ if (pst != nullptr)
+ pst->add_psymbol (std::string_view (sym_name, sym_len),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ unrelocated_addr (0),
+ psymtab_language,
+ partial_symtabs, objfile);
+ else
+ complaint (_("typename `%*s' appears to be defined "
+ "outside of all compilation units"),
+ sym_len, sym_name);
}
check_enum:
/* If this is an enumerated type, we need to
;
/* Note that the value doesn't matter for
enum constants in psymtabs, just in symtabs. */
- add_psymbol_to_list (gdb::string_view (p, q - p), true,
- VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC, 0,
- psymtab_language, objfile);
+ if (pst != nullptr)
+ pst->add_psymbol (std::string_view (p, q - p), true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ unrelocated_addr (0),
+ psymtab_language,
+ partial_symtabs, objfile);
+ else
+ complaint (_("enum constant `%*s' appears to be defined "
+ "outside of all compilation units"),
+ ((int) (q - p)), p);
/* Point past the name. */
p = q;
/* Skip over the value. */
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC, 0,
- psymtab_language, objfile);
+ if (pst != nullptr)
+ pst->add_psymbol (std::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ unrelocated_addr (0),
+ psymtab_language,
+ partial_symtabs, objfile);
+ else
+ complaint (_("constant `%*s' appears to be defined "
+ "outside of all compilation units"),
+ sym_len, sym_name);
+
continue;
case 'f':
if (! pst)
{
- int name_len = p - namestring;
- char *name = (char *) xmalloc (name_len + 1);
-
- memcpy (name, namestring, name_len);
- name[name_len] = '\0';
- function_outside_compilation_unit_complaint (name);
- xfree (name);
+ std::string name (namestring, (p - namestring));
+ function_outside_compilation_unit_complaint (name.c_str ());
}
/* Kludges for ELF/STABS with Sun ACC. */
last_function_name = namestring;
pst ? pst->filename : NULL,
objfile);
if (minsym.minsym != NULL)
- nlist.n_value = MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym);
+ nlist.n_value
+ = CORE_ADDR (minsym.minsym->unrelocated_address ());
}
if (pst && textlow_not_set
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- pst->set_text_low (nlist.n_value);
+ pst->set_text_low (unrelocated_addr (nlist.n_value));
textlow_not_set = 0;
}
/* End kludge. */
the partial symbol table. */
if (pst
&& (textlow_not_set
- || (nlist.n_value < pst->raw_text_low ()
+ || (unrelocated_addr (nlist.n_value)
+ < pst->unrelocated_text_low ()
&& (nlist.n_value != 0))))
{
- pst->set_text_low (nlist.n_value);
+ pst->set_text_low (unrelocated_addr (nlist.n_value));
textlow_not_set = 0;
}
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::STATIC,
- nlist.n_value, psymtab_language, objfile);
+ if (pst != nullptr)
+ pst->add_psymbol (std::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::STATIC,
+ unrelocated_addr (nlist.n_value),
+ psymtab_language,
+ partial_symtabs, objfile);
continue;
/* Global functions were ignored here, but now they
case 'F':
if (! pst)
{
- int name_len = p - namestring;
- char *name = (char *) xmalloc (name_len + 1);
-
- memcpy (name, namestring, name_len);
- name[name_len] = '\0';
- function_outside_compilation_unit_complaint (name);
- xfree (name);
+ std::string name (namestring, (p - namestring));
+ function_outside_compilation_unit_complaint (name.c_str ());
}
/* Kludges for ELF/STABS with Sun ACC. */
last_function_name = namestring;
pst ? pst->filename : NULL,
objfile);
if (minsym.minsym != NULL)
- nlist.n_value = MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym);
+ nlist.n_value
+ = CORE_ADDR (minsym.minsym->unrelocated_address ());
}
if (pst && textlow_not_set
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- pst->set_text_low (nlist.n_value);
+ pst->set_text_low (unrelocated_addr (nlist.n_value));
textlow_not_set = 0;
}
/* End kludge. */
the partial symbol table. */
if (pst
&& (textlow_not_set
- || (nlist.n_value < pst->raw_text_low ()
+ || (unrelocated_addr (nlist.n_value)
+ < pst->unrelocated_text_low ()
&& (nlist.n_value != 0))))
{
- pst->set_text_low (nlist.n_value);
+ pst->set_text_low (unrelocated_addr (nlist.n_value));
textlow_not_set = 0;
}
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::GLOBAL,
- nlist.n_value, psymtab_language, objfile);
+ if (pst != nullptr)
+ pst->add_psymbol (std::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::GLOBAL,
+ unrelocated_addr (nlist.n_value),
+ psymtab_language,
+ partial_symtabs, objfile);
continue;
/* Two things show up here (hopefully); static symbols of
(dependencies_used
* sizeof (legacy_psymtab *)));
#ifdef DEBUG_INFO
- fprintf_unfiltered (gdb_stderr,
- "Had to reallocate "
- "dependency list.\n");
- fprintf_unfiltered (gdb_stderr,
- "New dependencies allocated: %d\n",
- dependencies_allocated);
+ gdb_printf (gdb_stderr,
+ "Had to reallocate "
+ "dependency list.\n");
+ gdb_printf (gdb_stderr,
+ "New dependencies allocated: %d\n",
+ dependencies_allocated);
#endif
}
}
compiled without debugging info follows this module. */
if (pst && gdbarch_sofun_address_maybe_missing (gdbarch))
{
- dbx_end_psymtab (objfile, pst,
+ dbx_end_psymtab (objfile, partial_symtabs, pst,
psymtab_include_list, includes_used,
symnum * symbol_size,
- (CORE_ADDR) 0, dependency_list,
+ (unrelocated_addr) 0, dependency_list,
dependencies_used, textlow_not_set);
pst = (legacy_psymtab *) 0;
includes_used = 0;
{
/* 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
- : lowest_text_address)
- + text_size;
-
- dbx_end_psymtab (objfile, pst, psymtab_include_list, includes_used,
+ unrelocated_addr text_end
+ = (unrelocated_addr
+ ((lowest_text_address == (unrelocated_addr) -1
+ ? text_addr
+ : CORE_ADDR (lowest_text_address))
+ + text_size));
+
+ dbx_end_psymtab (objfile, partial_symtabs,
+ pst, psymtab_include_list, includes_used,
symnum * symbol_size,
- (text_end > pst->raw_text_high ()
- ? text_end : pst->raw_text_high ()),
+ (text_end > pst->unrelocated_text_high ()
+ ? text_end : pst->unrelocated_text_high ()),
dependency_list, dependencies_used, textlow_not_set);
}
}
(normal). */
static legacy_psymtab *
-start_psymtab (struct objfile *objfile, const char *filename, CORE_ADDR textlow,
- int ldsymoff)
+start_psymtab (psymtab_storage *partial_symtabs, struct objfile *objfile,
+ const char *filename, unrelocated_addr textlow, int ldsymoff)
{
- legacy_psymtab *result = new legacy_psymtab (filename, objfile, textlow);
+ legacy_psymtab *result = new legacy_psymtab (filename, partial_symtabs,
+ objfile->per_bfd, textlow);
result->read_symtab_private =
XOBNEW (&objfile->objfile_obstack, struct symloc);
LDSYMOFF (result) = ldsymoff;
result->legacy_read_symtab = dbx_read_symtab;
- result->legacy_expand_psymtab = dbx_psymtab_to_symtab_1;
+ result->legacy_expand_psymtab = dbx_expand_psymtab;
SYMBOL_SIZE (result) = symbol_size;
SYMBOL_OFFSET (result) = symbol_table_offset;
STRING_OFFSET (result) = string_table_offset;
FIXME: List variables and peculiarities of same. */
legacy_psymtab *
-dbx_end_psymtab (struct objfile *objfile, legacy_psymtab *pst,
+dbx_end_psymtab (struct objfile *objfile, psymtab_storage *partial_symtabs,
+ legacy_psymtab *pst,
const char **include_list, int num_includes,
- int capping_symbol_offset, CORE_ADDR capping_text,
+ int capping_symbol_offset, unrelocated_addr capping_text,
legacy_psymtab **dependency_list,
int number_dependencies,
int textlow_not_set)
{
int i;
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
if (capping_symbol_offset != -1)
LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst);
}
if (minsym.minsym)
- pst->set_text_high (MSYMBOL_VALUE_RAW_ADDRESS (minsym.minsym)
- + MSYMBOL_SIZE (minsym.minsym));
+ pst->set_text_high
+ (unrelocated_addr (CORE_ADDR (minsym.minsym->unrelocated_address ())
+ + minsym.minsym->size ()));
last_function_name = NULL;
}
;
/* This test will be true if the last .o file is only data. */
else if (textlow_not_set)
- pst->set_text_low (pst->raw_text_high ());
+ pst->set_text_low (pst->unrelocated_text_high ());
else
{
/* 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. */
+ 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. */
- for (partial_symtab *p1 : objfile->psymtabs ())
+ for (partial_symtab *p1 : partial_symtabs->range ())
if (!p1->text_high_valid && p1->text_low_valid && p1 != pst)
- p1->set_text_high (pst->raw_text_low ());
+ p1->set_text_high (pst->unrelocated_text_low ());
}
/* End of kludge for patching Solaris textlow and texthigh. */
- end_psymtab_common (objfile, pst);
+ pst->end ();
pst->number_of_dependencies = number_dependencies;
if (number_dependencies)
{
pst->dependencies
- = objfile->partial_symtabs->allocate_dependencies (number_dependencies);
+ = partial_symtabs->allocate_dependencies (number_dependencies);
memcpy (pst->dependencies, dependency_list,
number_dependencies * sizeof (legacy_psymtab *));
}
for (i = 0; i < num_includes; i++)
{
legacy_psymtab *subpst =
- new legacy_psymtab (include_list[i], objfile);
+ new legacy_psymtab (include_list[i], partial_symtabs, objfile->per_bfd);
subpst->read_symtab_private =
XOBNEW (&objfile->objfile_obstack, struct symloc);
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. */
+ shared by the entire set of include files. FIXME-someday. */
subpst->dependencies =
- objfile->partial_symtabs->allocate_dependencies (1);
+ partial_symtabs->allocate_dependencies (1);
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;
if (num_includes == 0
&& number_dependencies == 0
- && pst->n_global_syms == 0
- && pst->n_static_syms == 0
+ && pst->empty ()
&& has_line_numbers == 0)
{
- /* Throw away this psymtab, it's empty. We can't deallocate it, since
- it is on the obstack, but we can forget to chain it on the list. */
+ /* Throw away this psymtab, it's empty. */
/* Empty psymtabs happen as a result of header files which don't have
- any symbols in them. There can be a lot of them. But this check
- is wrong, in that a psymtab with N_SLINE entries but nothing else
- is not empty, but we don't realize that. Fixing that without slowing
- things down might be tricky. */
+ any symbols in them. There can be a lot of them. But this check
+ is wrong, in that a psymtab with N_SLINE entries but nothing else
+ is not empty, but we don't realize that. Fixing that without slowing
+ things down might be tricky. */
- objfile->partial_symtabs->discard_psymtab (pst);
+ partial_symtabs->discard_psymtab (pst);
/* Indicate that psymtab was thrown away. */
pst = NULL;
}
\f
static void
-dbx_psymtab_to_symtab_1 (legacy_psymtab *pst, struct objfile *objfile)
+dbx_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile)
{
gdb_assert (!pst->readin);
/* Read in all partial symtabs on which this one is dependent. */
- pst->read_dependencies (objfile);
+ pst->expand_dependencies (objfile);
if (LDSYMLEN (pst)) /* Otherwise it's a dummy. */
{
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);
+ if (bfd_seek (objfile->obfd.get (), SYMBOL_OFFSET (pst), SEEK_SET) == 0)
+ read_ofile_symtab (objfile, pst);
}
pst->readin = true;
}
/* Match with global symbols. This only needs to be done once,
- after all of the symtabs and dependencies have been read in. */
+ after all of the symtabs and dependencies have been read in. */
scan_file_globals (objfile);
}
}
stringtab_global = DBX_STRINGTAB (objfile);
set_last_source_file (NULL);
- abfd = objfile->obfd;
- symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol. */
+ abfd = objfile->obfd.get ();
+ symfile_bfd = objfile->obfd.get (); /* Implicit param to next_text_symbol. */
symbuf_end = symbuf_idx = 0;
symbuf_read = 0;
symbuf_left = sym_offset + sym_size;
processing_gcc_compilation = 1;
else if (strcmp (namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0)
processing_gcc_compilation = 2;
- if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
+ if (*tempstring != '\0'
+ && *tempstring == bfd_get_symbol_leading_char (symfile_bfd))
++tempstring;
if (startswith (tempstring, "__gnu_compiled"))
processing_gcc_compilation = 2;
else
{
/* The N_SO starting this symtab is the first symbol, so we
- better not check the symbol before it. I'm not this can
- happen, but it doesn't hurt to check for it. */
+ better not check the symbol before it. I'm not this can
+ happen, but it doesn't hurt to check for it. */
stabs_seek (sym_offset);
processing_gcc_compilation = 0;
}
PST_LANGUAGE (pst));
}
/* We skip checking for a new .o or -l file; that should never
- happen in this routine. */
+ happen in this routine. */
else if (type == N_TEXT)
{
/* I don't think this code will ever be executed, because
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));
+ pst->compunit_symtab = end_compunit_symtab (text_offset + text_size);
end_stabs ();
const char *name = symbol->demangled_name ();
unsigned int prefix_len = cp_entire_prefix_len (name);
- block_set_scope (block, obstack_strndup (obstack, name, prefix_len),
- obstack);
+ block->set_scope (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_compunit_symtab.
LANGUAGE is the language of the symtab.
*/
const section_offsets §ion_offsets,
struct objfile *objfile, enum language language)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
struct context_stack *newobj;
struct context_stack cstk;
/* This remembers the address of the start of a function. It is
source file. Used to detect the SunPRO solaris compiler. */
static int n_opt_found;
+ /* The section index for this symbol. */
+ int section_index = -1;
+
/* Something is wrong if we see real data before seeing a source
file name. */
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
- gracefully with the case. A complain()t might be in order,
- but this should not be an error (). */
+ Currently no one puts symbols there, but we should deal
+ gracefully with the case. A complain()t might be in order,
+ but this should not be an error (). */
return;
}
struct block *block;
if (outermost_context_p ())
- {
+ {
lbrac_mismatch_complaint (symnum);
- break;
- }
+ break;
+ }
/* The following check is added before recording line 0 at
end of function so as to handle hand-generated stabs
{
CORE_ADDR addr = last_function_start + valu;
- record_line (get_current_subfile (), 0,
- gdbarch_addr_bits_remove (gdbarch, addr));
+ record_line
+ (get_current_subfile (), 0,
+ unrelocated_addr (gdbarch_addr_bits_remove (gdbarch, addr)
+ - objfile->text_section_offset ()));
}
within_function = 0;
sline_found_in_function = 0;
/* Relocate for dynamic loading. */
+ section_index = SECT_OFF_TEXT (objfile);
valu += section_offsets[SECT_OFF_TEXT (objfile)];
valu = gdbarch_addr_bits_remove (gdbarch, valu);
last_function_start = valu;
case N_LBRAC:
/* This "symbol" just indicates the start of an inner lexical
- context within a function. */
+ context within a function. */
/* Ignore extra outermost context from SunPRO cc and acc. */
if (n_opt_found && desc == 1)
case N_RBRAC:
/* This "symbol" just indicates the end of an inner lexical
- context that was started with N_LBRAC. */
+ context that was started with N_LBRAC. */
/* Ignore extra outermost context from SunPRO cc and acc. */
if (n_opt_found && desc == 1)
case N_FN:
case N_FN_SEQ:
/* This kind of symbol indicates the start of an object file.
- Relocate for dynamic loading. */
+ Relocate for dynamic loading. */
+ section_index = SECT_OFF_TEXT (objfile);
valu += section_offsets[SECT_OFF_TEXT (objfile)];
break;
case N_SO:
/* This type of symbol indicates the start of data for one
- source file. Finish the symbol table of the previous source
- file (if any) and start accumulating a new symbol table.
- Relocate for dynamic loading. */
+ source file. Finish the symbol table of the previous source
+ file (if any) and start accumulating a new symbol table.
+ Relocate for dynamic loading. */
+ section_index = SECT_OFF_TEXT (objfile);
valu += section_offsets[SECT_OFF_TEXT (objfile)];
n_opt_found = 0;
patch_subfile_names (get_current_subfile (), name);
break; /* Ignore repeated SOs. */
}
- end_symtab (valu, SECT_OFF_TEXT (objfile));
+ end_compunit_symtab (valu);
end_stabs ();
}
/* Null name means this just marks the end of text for this .o
- file. Don't start a new symtab in this case. */
+ file. Don't start a new symtab in this case. */
if (*name == '\000')
break;
function_start_offset = 0;
start_stabs ();
- start_symtab (objfile, name, NULL, valu, language);
+ start_compunit_symtab (objfile, name, NULL, valu, language);
record_debugformat ("stabs");
break;
case N_SOL:
/* This type of symbol indicates the start of data for 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). Relocate for dynamic loading. */
+ 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). Relocate for dynamic loading. */
+ section_index = SECT_OFF_TEXT (objfile);
valu += section_offsets[SECT_OFF_TEXT (objfile)];
start_subfile (name);
break;
case N_SLINE:
/* This type of "symbol" really just records one line-number --
- core-address correspondence. Enter it in the line list for
- this symbol table. */
+ core-address correspondence. Enter it in the line list for
+ this symbol table. */
/* Relocate for dynamic loading and for ELF acc
- function-relative symbols. */
+ function-relative symbols. */
valu += function_start_offset;
/* GCC 2.95.3 emits the first N_SLINE stab somewhere in the
CORE_ADDR addr = processing_gcc_compilation == 2 ?
last_function_start : valu;
- record_line (get_current_subfile (), desc,
- gdbarch_addr_bits_remove (gdbarch, addr));
+ record_line
+ (get_current_subfile (), desc,
+ unrelocated_addr (gdbarch_addr_bits_remove (gdbarch, addr)
+ - objfile->text_section_offset ()));
sline_found_in_function = 1;
}
else
- record_line (get_current_subfile (), desc,
- gdbarch_addr_bits_remove (gdbarch, valu));
+ record_line
+ (get_current_subfile (), desc,
+ unrelocated_addr (gdbarch_addr_bits_remove (gdbarch, valu)
+ - objfile->text_section_offset ()));
break;
case N_BCOMM:
break;
/* The following symbol types need to have the appropriate
- offset added to their value; then we process symbol
- definitions in the name. */
+ offset added to their value; then we process symbol
+ definitions in the name. */
case N_STSYM: /* Static symbol in data segment. */
case N_LCSYM: /* Static symbol in BSS segment. */
case N_ROSYM: /* Static symbol in read-only data segment. */
/* HORRID HACK DEPT. However, it's Sun's furgin' fault.
- Solaris 2's stabs-in-elf makes *most* symbols relative but
- leaves a few absolute (at least for Solaris 2.1 and version
- 2.0.1 of the SunPRO compiler). 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). */
+ Solaris 2's stabs-in-elf makes *most* symbols relative but
+ leaves a few absolute (at least for Solaris 2.1 and version
+ 2.0.1 of the SunPRO compiler). 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). */
{
const char *p;
symbol_file_add as addr (this is known to affect
SunOS 4, and I suspect ELF too). Since there is no
Ttext.text symbol, we can get addr from the text offset. */
+ section_index = SECT_OFF_TEXT (objfile);
valu += section_offsets[SECT_OFF_TEXT (objfile)];
goto define_a_symbol;
}
}
/* Since it's not the kludge case, re-dispatch to the right
- handler. */
+ handler. */
switch (type)
{
case N_STSYM:
case N_ROSYM:
goto case_N_ROSYM;
default:
- internal_error (__FILE__, __LINE__,
- _("failed internal consistency check"));
+ internal_error (_("failed internal consistency check"));
}
}
case_N_STSYM: /* Static symbol in data segment. */
case N_DSLINE: /* Source line number, data segment. */
+ section_index = SECT_OFF_DATA (objfile);
valu += section_offsets[SECT_OFF_DATA (objfile)];
goto define_a_symbol;
case_N_LCSYM: /* Static symbol in BSS segment. */
case N_BSLINE: /* Source line number, BSS segment. */
/* N_BROWS: overlaps with N_BSLINE. */
+ section_index = SECT_OFF_BSS (objfile);
valu += section_offsets[SECT_OFF_BSS (objfile)];
goto define_a_symbol;
case_N_ROSYM: /* Static symbol in read-only data segment. */
+ section_index = SECT_OFF_RODATA (objfile);
valu += section_offsets[SECT_OFF_RODATA (objfile)];
goto define_a_symbol;
case N_ENTRY: /* Alternate entry point. */
/* Relocate for dynamic loading. */
+ section_index = SECT_OFF_TEXT (objfile);
valu += section_offsets[SECT_OFF_TEXT (objfile)];
goto define_a_symbol;
/* The following symbol types we don't know how to process.
- Handle them in a "default" way, but complain to people who
- care. */
+ 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_NBSTS:
case N_NBLCS:
unknown_symtype_complaint (hex_string (type));
- /* FALLTHROUGH */
define_a_symbol:
+ [[fallthrough]];
/* These symbol types don't need the address field relocated,
- since it is either unused, or is absolute. */
+ 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). */
case 'f':
case 'F':
/* Deal with the SunPRO 3.0 compiler which omits the
- address from N_FUN symbols. */
+ address from N_FUN symbols. */
if (type == N_FUN
&& valu == section_offsets[SECT_OFF_TEXT (objfile)]
&& gdbarch_sofun_address_maybe_missing (gdbarch))
= find_stab_function (name, get_last_source_file (),
objfile);
if (minsym.minsym != NULL)
- valu = BMSYMBOL_VALUE_ADDRESS (minsym);
+ valu = minsym.value_address ();
}
/* These addresses are absolute. */
newobj = push_context (0, valu);
newobj->name = define_symbol (valu, name, desc, type, objfile);
+ if (newobj->name != nullptr)
+ newobj->name->set_section_index (section_index);
break;
default:
- define_symbol (valu, name, desc, type, objfile);
+ {
+ struct symbol *sym = define_symbol (valu, name, desc, type,
+ objfile);
+ if (sym != nullptr)
+ sym->set_section_index (section_index);
+ }
break;
}
}
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. */
+ 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)
{
case N_PATCH: /* Solaris 2: Patch Run Time Checker. */
/* N_UNDF: Solaris 2: File separator mark. */
/* N_UNDF: -- we will never encounter it, since we only process
- one file's symbols at once. */
+ one file's symbols at once. */
case N_ENDM: /* Solaris 2: End of module. */
case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
break;
if (name[0] == '#')
{
/* Initialize symbol reference names and determine if this is a
- definition. If a symbol reference is being defined, go ahead
- and add it. Otherwise, just return. */
+ definition. If a symbol reference is being defined, go ahead
+ and add it. Otherwise, just return. */
const char *s = name;
int refnum;
/* If this stab defines a new reference ID that is not on the
- reference list, then put it on the reference list.
+ reference list, then put it on the reference list.
- We go ahead and advance NAME past the reference, even though
- it is not strictly necessary at this time. */
+ We go ahead and advance NAME past the reference, even though
+ it is not strictly necessary at this time. */
refnum = symbol_reference_defined (&s);
if (refnum >= 0)
if (!ref_search (refnum))
file_ptr stabstroffset, unsigned int stabstrsize)
{
int val;
- bfd *sym_bfd = objfile->obfd;
+ bfd *sym_bfd = objfile->obfd.get ();
const char *name = bfd_get_filename (sym_bfd);
unsigned int stabsize;
val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
if (val < 0)
perror_with_name (name);
- val = bfd_bread (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd);
+ val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd);
if (val != stabstrsize)
perror_with_name (name);
file_ptr stabstroffset, unsigned int stabstrsize)
{
int val;
- bfd *sym_bfd = objfile->obfd;
+ bfd *sym_bfd = objfile->obfd.get ();
const char *name = bfd_get_filename (sym_bfd);
stabsread_new_init ();
val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
if (val < 0)
perror_with_name (name);
- val = bfd_bread (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd);
+ val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd);
if (val != stabstrsize)
perror_with_name (name);
char *stabstr_name, char *text_name)
{
int val;
- bfd *sym_bfd = objfile->obfd;
+ bfd *sym_bfd = objfile->obfd.get ();
const char *name = bfd_get_filename (sym_bfd);
asection *stabsect;
asection *stabstrsect;
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 */
- NULL, /* sym_read_psymbols */
dbx_symfile_finish, /* finished with file, cleanup */
default_symfile_offsets, /* parse user's offsets to internal form */
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 ();