/* Read dbx symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 Free Software Foundation, Inc.
This file is part of GDB.
static int symfile_relocatable = 0;
-/* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are
- relative to the function start address. */
-
-static int block_address_function_relative = 0;
\f
/* 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
struct header_file_location
{
- char *name; /* Name of header file */
+ 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. */
static void dbx_psymtab_to_symtab_1 (struct objfile *, struct partial_symtab *);
-static void read_dbx_dynamic_symtab (struct objfile *objfile);
-
-static void read_dbx_symtab (struct objfile *);
+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 struct partial_symtab *find_corresponding_bincl_psymtab (const char *,
+ int);
-static void add_bincl_to_list (struct partial_symtab *, char *, int);
+static void add_bincl_to_list (struct partial_symtab *, const char *, int);
static void init_bincl_list (int, struct objfile *);
-static char *dbx_next_symbol_text (struct objfile *);
+static const char *dbx_next_symbol_text (struct objfile *);
static void fill_symbuf (bfd *);
static void dbx_new_init (struct objfile *);
-static void dbx_symfile_read (struct objfile *, int);
+static void dbx_symfile_read (struct objfile *, symfile_add_flags);
static void dbx_symfile_finish (struct objfile *);
-static void record_minimal_symbol (const char *, CORE_ADDR, int,
+static void record_minimal_symbol (minimal_symbol_reader &,
+ 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 *,
+static struct partial_symtab *start_psymtab (struct objfile *, const char *,
CORE_ADDR, int,
struct partial_symbol **,
struct partial_symbol **);
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
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;
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);
}
#endif
\f
static void
-record_minimal_symbol (const char *name, CORE_ADDR address, int type,
+record_minimal_symbol (minimal_symbol_reader &reader,
+ const char *name, CORE_ADDR address, int type,
struct objfile *objfile)
{
enum minimal_symbol_type ms_type;
&& address < lowest_text_address)
lowest_text_address = address;
- prim_record_minimal_symbol_and_info
- (name, address, ms_type, section, objfile);
+ reader.record_with_info (name, address, ms_type, section);
}
\f
/* Scan and build partial symbols for a symbol file.
hung off the objfile structure. */
static void
-dbx_symfile_read (struct objfile *objfile, int symfile_flags)
+dbx_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
{
bfd *sym_bfd;
int val;
symfile_relocatable = bfd_get_file_flags (sym_bfd) & HAS_RELOC;
- /* This is true for Solaris (and all other systems which put stabs
- in sections, hopefully, since it would be silly to do things
- differently from Solaris), and false for SunOS4 and other a.out
- file formats. */
- block_address_function_relative =
- ((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 (objfile));
free_pending_blocks ();
back_to = make_cleanup (really_free_pendings, 0);
- init_minimal_symbol_collection ();
- make_cleanup_discard_minimal_symbols ();
+ minimal_symbol_reader reader (objfile);
/* Read stabs data from executable file and define symbols. */
- read_dbx_symtab (objfile);
-
- /* Add the dynamic symbols. */
-
- read_dbx_dynamic_symtab (objfile);
+ read_dbx_symtab (reader, objfile);
/* Install any minimal symbols that have been collected as the current
minimal symbols for this objfile. */
- install_minimal_symbols (objfile);
+ reader.install ();
do_cleanups (back_to);
}
static void
dbx_free_symfile_info (struct objfile *objfile, void *arg)
{
- struct dbx_symfile_info *dbx = arg;
+ struct dbx_symfile_info *dbx = (struct dbx_symfile_info *) arg;
if (dbx->header_files != NULL)
{
/* 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
(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;
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
-add_bincl_to_list (struct partial_symtab *pst, char *name, int instance)
+add_bincl_to_list (struct partial_symtab *pst, const char *name, int instance)
{
if (next_bincl >= bincl_list + bincls_allocated)
{
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;
static void
do_free_bincl_list_cleanup (void *objfile)
{
- free_bincl_list (objfile);
+ free_bincl_list ((struct objfile *) objfile);
}
static struct cleanup *
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)
return namestring;
}
-/* Scan a SunOs dynamic symbol table for symbols of interest and
- add them to the minimal symbol table. */
-
-static void
-read_dbx_dynamic_symtab (struct objfile *objfile)
-{
- bfd *abfd = objfile->obfd;
- struct cleanup *back_to;
- int counter;
- long dynsym_size;
- long dynsym_count;
- asymbol **dynsyms;
- asymbol **symptr;
- arelent **relptr;
- long dynrel_size;
- long dynrel_count;
- arelent **dynrels;
- CORE_ADDR sym_value;
- 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
- on a sun4 host (and vice versa) and bfd is not configured
- --with-target=all. This would trigger an assertion in bfd/sunos.c,
- so we ignore the dynamic symbols in this case. */
- if (bfd_get_flavour (abfd) != bfd_target_aout_flavour
- || (bfd_get_file_flags (abfd) & DYNAMIC) == 0
- || bfd_get_arch (abfd) == bfd_arch_unknown)
- return;
-
- dynsym_size = bfd_get_dynamic_symtab_upper_bound (abfd);
- if (dynsym_size < 0)
- return;
-
- dynsyms = (asymbol **) xmalloc (dynsym_size);
- back_to = make_cleanup (xfree, dynsyms);
-
- dynsym_count = bfd_canonicalize_dynamic_symtab (abfd, dynsyms);
- if (dynsym_count < 0)
- {
- do_cleanups (back_to);
- return;
- }
-
- /* Enter dynamic symbols into the minimal symbol table
- if this is a stripped executable. */
- if (bfd_get_symcount (abfd) <= 0)
- {
- symptr = dynsyms;
- for (counter = 0; counter < dynsym_count; counter++, symptr++)
- {
- asymbol *sym = *symptr;
- asection *sec;
- int type;
-
- sec = bfd_get_section (sym);
-
- /* BFD symbols are section relative. */
- sym_value = sym->value + sec->vma;
-
- if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
- {
- type = N_TEXT;
- }
- else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
- {
- type = N_DATA;
- }
- else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
- {
- type = N_BSS;
- }
- else
- continue;
-
- if (sym->flags & BSF_GLOBAL)
- type |= N_EXT;
-
- record_minimal_symbol (bfd_asymbol_name (sym), sym_value,
- type, objfile);
- }
- }
-
- /* Symbols from shared libraries have a dynamic relocation entry
- that points to the associated slot in the procedure linkage table.
- We make a mininal symbol table entry with type mst_solib_trampoline
- at the address in the procedure linkage table. */
- dynrel_size = bfd_get_dynamic_reloc_upper_bound (abfd);
- if (dynrel_size < 0)
- {
- do_cleanups (back_to);
- return;
- }
-
- dynrels = (arelent **) xmalloc (dynrel_size);
- make_cleanup (xfree, dynrels);
-
- dynrel_count = bfd_canonicalize_dynamic_reloc (abfd, dynrels, dynsyms);
- if (dynrel_count < 0)
- {
- do_cleanups (back_to);
- return;
- }
-
- for (counter = 0, relptr = dynrels;
- counter < dynrel_count;
- counter++, relptr++)
- {
- arelent *rel = *relptr;
- CORE_ADDR address = rel->address;
-
- switch (bfd_get_arch (abfd))
- {
- case bfd_arch_sparc:
- if (rel->howto->type != RELOC_JMP_SLOT)
- continue;
- break;
- case bfd_arch_m68k:
- /* `16' is the type BFD produces for a jump table relocation. */
- if (rel->howto->type != 16)
- continue;
-
- /* Adjust address in the jump table to point to
- the start of the bsr instruction. */
- address -= 2;
- break;
- default:
- continue;
- }
-
- name = bfd_asymbol_name (*rel->sym_ptr_ptr);
- prim_record_minimal_symbol (name, address, mst_solib_trampoline,
- objfile);
- }
-
- do_cleanups (back_to);
-}
-
static CORE_ADDR
-find_stab_function_addr (char *namestring, const char *filename,
+find_stab_function_addr (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 = 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;
debugging information is available. */
static void
-read_dbx_symtab (struct objfile *objfile)
+read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct external_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch. */
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;
record_it:
namestring = set_namestring (objfile, &nlist);
- record_minimal_symbol (namestring, nlist.n_value,
+ record_minimal_symbol (reader, namestring, nlist.n_value,
nlist.n_type, objfile); /* Always */
continue;
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,
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);
sym_name = NULL; /* pacify "gcc -Werror" */
if (psymtab_language == language_cplus)
{
- char *new_name, *name = xmalloc (p - namestring + 1);
- memcpy (name, namestring, p - namestring);
-
- name[p - namestring] = '\0';
- new_name = cp_canonicalize_string (name);
- if (new_name != NULL)
- {
- sym_len = strlen (new_name);
- sym_name = obstack_copy0 (&objfile->objfile_obstack,
- new_name, sym_len);
- xfree (new_name);
- }
- xfree (name);
- }
+ std::string name (namestring, p - namestring);
+ std::string new_name = cp_canonicalize_string (name.c_str ());
+ if (!new_name.empty ())
+ {
+ sym_len = new_name.length ();
+ sym_name = (char *) obstack_copy0 (&objfile->objfile_obstack,
+ new_name.c_str (),
+ sym_len);
+ }
+ }
if (sym_len == 0)
{
Accept either. */
while (*p && *p != ';' && *p != ',')
{
- char *q;
+ const char *q;
/* Check for and handle cretinous dbx symbol name
continuation! */
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';
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';
(normal). */
static struct partial_symtab *
-start_psymtab (struct objfile *objfile, char *filename, CORE_ADDR textlow,
+start_psymtab (struct objfile *objfile, const char *filename, CORE_ADDR textlow,
int ldsymoff, struct partial_symbol **global_syms,
struct partial_symbol **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_read_symtab;
SYMBOL_SIZE (result) = symbol_size;
if (pst->texthigh == 0 && 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 = 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;
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 *));
}
allocate_psymtab (include_list[i], objfile);
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;
discard_psymtab (objfile, pst);
/* Indicate that psymtab was thrown away. */
- pst = (struct partial_symtab *) NULL;
+ pst = NULL;
}
return pst;
}
static void
dbx_read_symtab (struct partial_symtab *self, struct objfile *objfile)
{
- bfd *sym_bfd;
-
if (self->readin)
{
fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. "
gdb_flush (gdb_stdout);
}
- sym_bfd = objfile->obfd;
-
next_symbol_text_func = dbx_next_symbol_text;
back_to = make_cleanup (null_cleanup, NULL);
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;
unsigned int prefix_len = cp_entire_prefix_len (name);
block_set_scope (block,
- obstack_copy0 (obstack, name, prefix_len),
+ (const char *) obstack_copy0 (obstack, name, prefix_len),
obstack);
}
}
is used in end_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)
{
source file. Used to detect the SunPRO solaris compiler. */
static int n_opt_found;
- /* The stab type used for the definition of the last function.
- N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
- static int function_stab_type = 0;
-
- if (!block_address_function_relative)
- {
- /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
- function start address, so just use the text offset. */
- function_start_offset =
- ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
- }
-
/* Something is wrong if we see real data before seeing a source
file name. */
/* Make a block for the local symbols within. */
block = finish_block (newobj->name, &local_symbols,
- newobj->old_blocks,
+ newobj->old_blocks, NULL,
newobj->start_addr, newobj->start_addr + valu);
/* For C++, set the block's scope. */
/* May be switching to an assembler file which may not be using
block relative stabs, so reset the offset. */
- if (block_address_function_relative)
- function_start_offset = 0;
+ function_start_offset = 0;
break;
}
if (n_opt_found && desc == 1)
break;
- if (block_address_function_relative)
- /* Relocate for Sun ELF acc fn-relative syms. */
- valu += function_start_offset;
- else
- /* On most machines, the block addresses are relative to the
- N_SO, the linker did not relocate them (sigh). */
- valu += last_source_start_addr;
+ valu += function_start_offset;
push_context (desc, valu);
break;
if (n_opt_found && desc == 1)
break;
- if (block_address_function_relative)
- /* Relocate for Sun ELF acc fn-relative syms. */
- valu += function_start_offset;
- else
- /* On most machines, the block addresses are relative to the
- N_SO, the linker did not relocate them (sigh). */
- valu += last_source_start_addr;
+ valu += function_start_offset;
if (context_stack_depth <= 0)
{
newobj->start_addr = valu;
}
/* Make a block for the local symbols within. */
- finish_block (0, &local_symbols, newobj->old_blocks,
+ finish_block (0, &local_symbols, newobj->old_blocks, NULL,
newobj->start_addr, valu);
}
}
if (*name == '\000')
break;
- if (block_address_function_relative)
- function_start_offset = 0;
+ function_start_offset = 0;
start_stabs ();
start_symtab (objfile, name, NULL, valu);
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.
if (name)
{
int deftype;
- char *colon_pos = strchr (name, ':');
+ const char *colon_pos = strchr (name, ':');
if (colon_pos == NULL)
deftype = '\0';
{
case 'f':
case 'F':
- function_stab_type = type;
-
/* Deal with the SunPRO 3.0 compiler which omits the
address from N_FUN symbols. */
if (type == N_FUN
valu = minsym_valu;
}
- if (block_address_function_relative)
- /* For Solaris 2 compilers, the block addresses and
- N_SLINE's are relative to the start of the
- function. On normal systems, and when using GCC on
- Solaris 2, these addresses are just absolute, or
- relative to the N_SO, depending on
- BLOCK_ADDRESS_ABSOLUTE. */
- function_start_offset = valu;
+ /* These addresses are absolute. */
+ function_start_offset = valu;
within_function = 1;
newobj = pop_context ();
/* Make a block for the local symbols within. */
block = finish_block (newobj->name, &local_symbols,
- newobj->old_blocks, newobj->start_addr,
- valu);
+ newobj->old_blocks, NULL,
+ newobj->start_addr, valu);
/* For C++, set the block's scope. */
if (SYMBOL_LANGUAGE (newobj->name) == language_cplus)
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
int val;
bfd *sym_bfd = objfile->obfd;
char *name = bfd_get_filename (sym_bfd);
- struct dbx_symfile_info *info;
unsigned int stabsize;
- /* 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 = DBX_SYMFILE_INFO (objfile);
-
DBX_TEXT_ADDR (objfile) = textaddr;
DBX_TEXT_SIZE (objfile) = textsize;
int val;
bfd *sym_bfd = objfile->obfd;
char *name = bfd_get_filename (sym_bfd);
- struct dbx_symfile_info *info;
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 = DBX_SYMFILE_INFO (objfile);
-
/* Find the first and last text address. dbx_symfile_read seems to
want this. */
find_text_range (sym_bfd, objfile);