/* Read dbx symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986-2004, 2008-2012 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GDB.
for real. dbx_psymtab_to_symtab() is the function that does this */
#include "defs.h"
-#include "gdb_string.h"
-
#if defined(__CYGNUSCLIB__)
#include <sys/types.h>
#include <fcntl.h>
#endif
#include "gdb_obstack.h"
-#include "gdb_stat.h"
+#include <sys/stat.h>
#include "symtab.h"
#include "breakpoint.h"
#include "target.h"
#include "cp-abi.h"
#include "cp-support.h"
#include "psympriv.h"
-
-#include "gdb_assert.h"
-#include "gdb_string.h"
-
+#include "block.h"
#include "aout/aout64.h"
#include "aout/stab_gnu.h" /* We always use GNU stabs, not
native, now. */
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;
-/* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are
- relative to the function start address. */
+/* 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;
-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
static CORE_ADDR lowest_text_address;
/* Non-zero if there is any line number info in the objfile. Prevents
- end_psymtab from discarding an otherwise empty psymtab. */
+ dbx_end_psymtab from discarding an otherwise empty psymtab. */
static int has_line_numbers;
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);
}
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_psymtab_to_symtab (struct objfile *, struct partial_symtab *);
+static void dbx_read_symtab (struct partial_symtab *self,
+ struct objfile *objfile);
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 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 read_dbx_symtab (minimal_symbol_reader &, struct objfile *);
-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 *);
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 (char *, CORE_ADDR, int, struct objfile *);
+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 **);
+ std::vector<partial_symbol *> &,
+ std::vector<partial_symbol *> &);
/* Free up old header file tables. */
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 (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;
int section;
- asection *bfd_section;
switch (type)
{
case N_TEXT | N_EXT:
ms_type = mst_text;
section = SECT_OFF_TEXT (objfile);
- bfd_section = DBX_TEXT_SECTION (objfile);
break;
case N_DATA | N_EXT:
ms_type = mst_data;
section = SECT_OFF_DATA (objfile);
- bfd_section = DBX_DATA_SECTION (objfile);
break;
case N_BSS | N_EXT:
ms_type = mst_bss;
section = SECT_OFF_BSS (objfile);
- bfd_section = DBX_BSS_SECTION (objfile);
break;
case N_ABS | N_EXT:
ms_type = mst_abs;
section = -1;
- bfd_section = NULL;
break;
#ifdef N_SETV
case N_SETV | N_EXT:
ms_type = mst_data;
section = SECT_OFF_DATA (objfile);
- bfd_section = DBX_DATA_SECTION (objfile);
break;
case N_SETV:
/* I don't think this type actually exists; since a N_SETV is the result
file local. */
ms_type = mst_file_data;
section = SECT_OFF_DATA (objfile);
- bfd_section = DBX_DATA_SECTION (objfile);
break;
#endif
case N_TEXT:
case N_FN_SEQ:
ms_type = mst_file_text;
section = SECT_OFF_TEXT (objfile);
- bfd_section = DBX_TEXT_SECTION (objfile);
break;
case N_DATA:
ms_type = mst_file_data;
/* Same with virtual function tables, both global and static. */
{
- char *tempstring = name;
+ const char *tempstring = name;
if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
++tempstring;
ms_type = mst_data;
}
section = SECT_OFF_DATA (objfile);
- bfd_section = DBX_DATA_SECTION (objfile);
break;
case N_BSS:
ms_type = mst_file_bss;
section = SECT_OFF_BSS (objfile);
- bfd_section = DBX_BSS_SECTION (objfile);
break;
default:
ms_type = mst_unknown;
section = -1;
- bfd_section = NULL;
break;
}
&& address < lowest_text_address)
lowest_text_address = address;
- prim_record_minimal_symbol_and_info
- (name, address, ms_type, section, bfd_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;
- struct cleanup *back_to;
sym_bfd = objfile->obfd;
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 =
- ((0 == strncmp (bfd_get_target (sym_bfd), "elf", 3))
- || (0 == strncmp (bfd_get_target (sym_bfd), "som", 3))
- || (0 == strncmp (bfd_get_target (sym_bfd), "coff", 4))
- || (0 == strncmp (bfd_get_target (sym_bfd), "pe", 2))
- || (0 == strncmp (bfd_get_target (sym_bfd), "epoc-pe", 7))
- || (0 == strncmp (bfd_get_target (sym_bfd), "nlm", 3)));
-
val = bfd_seek (sym_bfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
if (val < 0)
- perror_with_name (objfile->name);
+ perror_with_name (objfile_name (objfile));
/* Size the symbol table. */
- if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
+ if (objfile->global_psymbols.capacity () == 0
+ && objfile->static_psymbols.capacity () == 0)
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;
- 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);
-
- do_cleanups (back_to);
+ reader.install ();
}
/* Initialize anything that needs initializing when a completely new
dbx_new_init (struct objfile *ignore)
{
stabsread_new_init ();
- buildsym_new_init ();
+ buildsym_init ();
init_header_files ();
}
/* FIXME POKING INSIDE BFD DATA STRUCTURES. */
- DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
-
text_sect = bfd_get_section_by_name (sym_bfd, ".text");
if (!text_sect)
error (_("Can't find .text section in symbol file"));
static void
dbx_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;
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 = (struct header_file_location *)
- xmalloc (bincls_allocated * sizeof (struct header_file_location));
-}
-
-/* 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 (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;
}
-/* 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;
- 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)
- {
- sym_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
- type = N_TEXT;
- }
- else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
- {
- sym_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
- type = N_DATA;
- }
- else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
- {
- sym_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
- type = N_BSS;
- }
- else
- continue;
-
- if (sym->flags & BSF_GLOBAL)
- type |= N_EXT;
-
- record_minimal_symbol ((char *) 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 + ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
-
- 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 = (char *) 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 minimal_symbol *msym;
- char *p;
+ struct bound_minimal_symbol msym;
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;
msym = lookup_minimal_symbol (p, filename, objfile);
- if (msym == NULL)
+ if (msym.minsym == NULL)
{
/* Sun Fortran appends an underscore to the minimal symbol name,
try again with an appended underscore if the minimal symbol
msym = lookup_minimal_symbol (p, filename, objfile);
}
- if (msym == NULL && filename != NULL)
+ if (msym.minsym == NULL && filename != NULL)
{
/* Try again without the filename. */
p[n] = 0;
msym = lookup_minimal_symbol (p, NULL, objfile);
}
- if (msym == NULL && filename != NULL)
+ if (msym.minsym == NULL && filename != NULL)
{
/* And try again for Sun Fortran, but without the filename. */
p[n] = '_';
msym = lookup_minimal_symbol (p, NULL, objfile);
}
- return msym == NULL ? 0 : SYMBOL_VALUE_ADDRESS (msym);
+ return msym.minsym == NULL ? 0 : BMSYMBOL_VALUE_ADDRESS (msym);
}
static void
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);
}
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_o_file_start = 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);
- last_source_file = NULL;
+ set_last_source_file (NULL);
lowest_text_address = (CORE_ADDR) -1;
case N_TEXT | N_EXT:
case N_NBTEXT | N_EXT:
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
goto record_it;
case N_DATA | N_EXT:
case N_NBDATA | N_EXT:
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
goto record_it;
case N_BSS:
case N_BSS | N_EXT:
case N_NBBSS | N_EXT:
case N_SETV | N_EXT: /* FIXME, is this in BSS? */
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
goto record_it;
case N_ABS | N_EXT:
record_it:
namestring = set_namestring (objfile, &nlist);
- bss_ext_symbol:
- record_minimal_symbol (namestring, nlist.n_value,
+ record_minimal_symbol (reader, namestring, nlist.n_value,
nlist.n_type, objfile); /* Always */
continue;
case N_FN:
case N_FN_SEQ:
case N_TEXT:
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
namestring = set_namestring (objfile, &nlist);
if ((namestring[0] == '-' && namestring[1] == 'l')
|| (namestring[(nsl = strlen (namestring)) - 1] == 'o'
&& namestring[nsl - 2] == '.'))
{
+ nlist.n_value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
+
if (past_first_source_file && pst
/* The gould NP1 uses low values for .o and -l symbols
which are not the address. */
&& nlist.n_value >= pst->textlow)
{
- end_psymtab (objfile, pst, psymtab_include_list,
- includes_used, symnum * symbol_size,
- nlist.n_value > pst->texthigh
- ? nlist.n_value : pst->texthigh,
- dependency_list, dependencies_used,
- textlow_not_set);
+ dbx_end_psymtab (objfile, pst, psymtab_include_list,
+ includes_used, symnum * symbol_size,
+ nlist.n_value > pst->texthigh
+ ? nlist.n_value : pst->texthigh,
+ dependency_list, dependencies_used,
+ textlow_not_set);
pst = (struct partial_symtab *) 0;
includes_used = 0;
dependencies_used = 0;
}
else
past_first_source_file = 1;
- last_o_file_start = nlist.n_value;
}
else
goto record_it;
continue;
case N_DATA:
- nlist.n_value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
goto record_it;
case N_UNDF | N_EXT:
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,
prev_textlow_not_set = textlow_not_set;
/* A zero value is probably an indication for the SunPRO 3.0
- compiler. end_psymtab explicitly tests for zero, so
+ compiler. dbx_end_psymtab explicitly tests for zero, so
don't relocate it. */
if (nlist.n_value == 0
if (pst)
{
- end_psymtab (objfile, pst, psymtab_include_list,
- includes_used, symnum * symbol_size,
- valu > pst->texthigh ? valu : pst->texthigh,
- dependency_list, dependencies_used,
- prev_textlow_not_set);
+ dbx_end_psymtab (objfile, pst, psymtab_include_list,
+ includes_used, symnum * symbol_size,
+ valu > pst->texthigh
+ ? valu : pst->texthigh,
+ dependency_list, dependencies_used,
+ prev_textlow_not_set);
pst = (struct partial_symtab *) 0;
includes_used = 0;
dependencies_used = 0;
pst = start_psymtab (objfile,
namestring, valu,
first_so_symnum * symbol_size,
- objfile->global_psymbols.next,
- objfile->static_psymbols.next);
+ objfile->global_psymbols,
+ objfile->static_psymbols);
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);
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 = obsavestring (new_name, sym_len,
- &objfile->objfile_obstack);
- 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)
{
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
- 0, nlist.n_value,
- psymtab_language, objfile);
+ nlist.n_value, psymtab_language, objfile);
continue;
case 'G':
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
- 0, nlist.n_value,
- psymtab_language, objfile);
+ nlist.n_value, psymtab_language, objfile);
continue;
case 'T':
add_psymbol_to_list (sym_name, sym_len, 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- nlist.n_value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- nlist.n_value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
p += 1;
}
}
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- nlist.n_value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
}
check_enum:
/* If this is an enumerated type, we need to
Accept either. */
while (*p && *p != ';' && *p != ',')
{
- char *q;
+ const char *q;
/* Check for and handle cretinous dbx symbol name
continuation! */
add_psymbol_to_list (p, q - p, 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols, 0,
- 0, psymtab_language, objfile);
+ psymtab_language, objfile);
/* Point past the name. */
p = q;
/* Skip over the value. */
/* Constant, e.g. from "const" in Pascal. */
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, nlist.n_value,
- 0, psymtab_language, objfile);
+ &objfile->static_psymbols, 0,
+ psymtab_language, objfile);
continue;
case 'f':
if (! pst)
{
int name_len = p - namestring;
- char *name = xmalloc (name_len + 1);
+ char *name = (char *) xmalloc (name_len + 1);
memcpy (name, namestring, name_len);
name[name_len] = '\0';
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, nlist.n_value,
- psymtab_language, objfile);
+ nlist.n_value, psymtab_language, objfile);
continue;
/* Global functions were ignored here, but now they
if (! pst)
{
int name_len = p - namestring;
- char *name = xmalloc (name_len + 1);
+ char *name = (char *) xmalloc (name_len + 1);
memcpy (name, namestring, name_len);
name[name_len] = '\0';
add_psymbol_to_list (sym_name, sym_len, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, nlist.n_value,
- psymtab_language, objfile);
+ nlist.n_value, psymtab_language, objfile);
continue;
/* Two things show up here (hopefully); static symbols of
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
case N_ENDM:
/* Solaris 2 end of module, finish current partial symbol table.
- end_psymtab will set pst->texthigh to the proper value, which
+ dbx_end_psymtab will set pst->texthigh to the proper value, which
is necessary if a module compiled without debugging info
follows this module. */
if (pst && gdbarch_sofun_address_maybe_missing (gdbarch))
{
- end_psymtab (objfile, pst, psymtab_include_list, includes_used,
- symnum * symbol_size,
- (CORE_ADDR) 0, dependency_list,
- dependencies_used, textlow_not_set);
+ dbx_end_psymtab (objfile, pst,
+ psymtab_include_list, includes_used,
+ symnum * symbol_size,
+ (CORE_ADDR) 0, dependency_list,
+ dependencies_used, textlow_not_set);
pst = (struct partial_symtab *) 0;
includes_used = 0;
dependencies_used = 0;
case N_SLINE:
case N_RSYM:
case N_PSYM:
+ case N_BNSYM:
+ case N_ENSYM:
case N_LBRAC:
case N_NSYMS: /* Ultrix 4.0: symbol count */
case N_DEFD: /* GNU Modula-2 */
: lowest_text_address)
+ text_size;
- end_psymtab (objfile, pst, psymtab_include_list, includes_used,
- symnum * symbol_size,
- text_end > pst->texthigh ? text_end : pst->texthigh,
- dependency_list, dependencies_used, textlow_not_set);
+ dbx_end_psymtab (objfile, pst, psymtab_include_list, includes_used,
+ symnum * symbol_size,
+ text_end > pst->texthigh ? text_end : pst->texthigh,
+ dependency_list, dependencies_used, textlow_not_set);
}
-
- do_cleanups (back_to);
}
/* 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, std::vector<partial_symbol *> &global_psymbols,
+ std::vector<partial_symbol *> &static_psymbols)
{
struct partial_symtab *result =
- start_psymtab_common (objfile, objfile->section_offsets,
- filename, textlow, global_syms, static_syms);
+ start_psymtab_common (objfile, filename, textlow,
+ global_psymbols, static_psymbols);
- result->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc));
+ result->read_symtab_private =
+ XOBNEW (&objfile->objfile_obstack, struct symloc);
LDSYMOFF (result) = ldsymoff;
- result->read_symtab = dbx_psymtab_to_symtab;
+ result->read_symtab = dbx_read_symtab;
SYMBOL_SIZE (result) = symbol_size;
SYMBOL_OFFSET (result) = symbol_table_offset;
STRING_OFFSET (result) = string_table_offset;
FILE_STRING_OFFSET (result) = file_string_table_offset;
-#ifdef HAVE_ELF
- /* If we're handling an ELF file, drag some section-relocation info
- for this source file out of the ELF symbol table, to compensate for
- Sun brain death. This replaces the section_offsets in this psymtab,
- if successful. */
- elfstab_offset_sections (objfile, result);
-#endif
-
/* Deduce the source language from the filename for this psymtab. */
psymtab_language = deduce_language_from_filename (filename);
+ PST_LANGUAGE (result) = psymtab_language;
return result;
}
FIXME: List variables and peculiarities of same. */
struct partial_symtab *
-end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
- const char **include_list, int num_includes,
- int capping_symbol_offset, CORE_ADDR capping_text,
- struct partial_symtab **dependency_list, int number_dependencies,
- int textlow_not_set)
+dbx_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
+ const char **include_list, int num_includes,
+ int capping_symbol_offset, CORE_ADDR capping_text,
+ struct partial_symtab **dependency_list,
+ int number_dependencies,
+ int textlow_not_set)
{
int i;
struct gdbarch *gdbarch = get_objfile_arch (objfile);
if (pst->texthigh == 0 && last_function_name
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- char *p;
int n;
- struct minimal_symbol *minsym;
+ struct bound_minimal_symbol minsym;
- p = strchr (last_function_name, ':');
- if (p == NULL)
- p = last_function_name;
- n = p - last_function_name;
- p = alloca (n + 2);
+ 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;
minsym = lookup_minimal_symbol (p, pst->filename, objfile);
- if (minsym == NULL)
+ if (minsym.minsym == NULL)
{
/* Sun Fortran appends an underscore to the minimal symbol name,
try again with an appended underscore if the minimal symbol
minsym = lookup_minimal_symbol (p, pst->filename, objfile);
}
- if (minsym)
- pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym);
+ if (minsym.minsym)
+ pst->texthigh = (BMSYMBOL_VALUE_ADDRESS (minsym)
+ + MSYMBOL_SIZE (minsym.minsym));
last_function_name = NULL;
}
/* End of kludge for patching Solaris textlow and texthigh. */
- pst->n_global_syms =
- objfile->global_psymbols.next - (objfile->global_psymbols.list
- + pst->globals_offset);
- pst->n_static_syms =
- objfile->static_psymbols.next - (objfile->static_psymbols.list
- + pst->statics_offset);
+ end_psymtab_common (objfile, pst);
pst->number_of_dependencies = number_dependencies;
if (number_dependencies)
{
- pst->dependencies = (struct partial_symtab **)
- obstack_alloc (&objfile->objfile_obstack,
- number_dependencies * sizeof (struct partial_symtab *));
+ pst->dependencies = XOBNEWVEC (&objfile->objfile_obstack,
+ struct partial_symtab *,
+ number_dependencies);
memcpy (pst->dependencies, dependency_list,
number_dependencies * sizeof (struct partial_symtab *));
}
struct partial_symtab *subpst =
allocate_psymtab (include_list[i], objfile);
- /* Copy the sesction_offsets array from the main psymtab. */
- subpst->section_offsets = pst->section_offsets;
subpst->read_symtab_private =
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symloc));
+ XOBNEW (&objfile->objfile_obstack, struct symloc);
LDSYMOFF (subpst) =
LDSYMLEN (subpst) =
subpst->textlow =
/* We could save slight bits of space by only making one of these,
shared by the entire set of include files. FIXME-someday. */
- subpst->dependencies = (struct partial_symtab **)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct partial_symtab *));
+ subpst->dependencies =
+ XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;
subpst->n_static_syms = 0;
subpst->readin = 0;
- subpst->symtab = 0;
+ subpst->compunit_symtab = 0;
subpst->read_symtab = pst->read_symtab;
}
- sort_pst_symbols (objfile, pst);
-
if (num_includes == 0
&& number_dependencies == 0
&& pst->n_global_syms == 0
discard_psymtab (objfile, pst);
/* Indicate that psymtab was thrown away. */
- pst = (struct partial_symtab *) NULL;
+ pst = NULL;
}
return pst;
}
static void
dbx_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst)
{
- struct cleanup *old_chain;
int i;
- if (!pst)
- return;
-
if (pst->readin)
{
fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. "
/* 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;
}
/* Read in all of the symbols for a given psymtab for real.
- Be verbose about it if the user wants that. */
+ Be verbose about it if the user wants that. SELF is not NULL. */
static void
-dbx_psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
+dbx_read_symtab (struct partial_symtab *self, struct objfile *objfile)
{
- bfd *sym_bfd;
- struct cleanup *back_to = NULL;
-
- if (!pst)
- return;
-
- if (pst->readin)
+ if (self->readin)
{
fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. "
"Shouldn't happen.\n",
- pst->filename);
+ self->filename);
return;
}
- if (LDSYMLEN (pst) || pst->number_of_dependencies)
+ if (LDSYMLEN (self) || self->number_of_dependencies)
{
/* Print the message now, before reading the string table,
to avoid disconcerting pauses. */
if (info_verbose)
{
- printf_filtered ("Reading in symbols for %s...", pst->filename);
+ printf_filtered ("Reading in symbols for %s...", self->filename);
gdb_flush (gdb_stdout);
}
- sym_bfd = objfile->obfd;
-
next_symbol_text_func = dbx_next_symbol_text;
- if (DBX_STAB_SECTION (objfile))
- {
- stabs_data
- = symfile_relocate_debug_section (objfile,
- DBX_STAB_SECTION (objfile),
- NULL);
-
- if (stabs_data)
- back_to = make_cleanup (free_current_contents,
- (void *) &stabs_data);
- }
-
- dbx_psymtab_to_symtab_1 (objfile, pst);
+ {
+ 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);
+ }
- if (back_to)
- 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_size = LDSYMLEN (pst);
text_offset = pst->textlow;
text_size = pst->texthigh - pst->textlow;
- /* This cannot be simply objfile->section_offsets because of
- elfstab_offset_sections() which initializes the psymtab section
- offsets information in a special way, and that is different from
- objfile->section_offsets. */
- section_offsets = pst->section_offsets;
+ section_offsets = objfile->section_offsets;
dbxread_objfile = objfile;
- subfile_stack = NULL;
stringtab_global = DBX_STRINGTAB (objfile);
- last_source_file = NULL;
+ set_last_source_file (NULL);
abfd = objfile->obfd;
symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol. */
processing_gcc_compilation = 2;
if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
++tempstring;
- if (strncmp (tempstring, "__gnu_compiled", 14) == 0)
+ if (startswith (tempstring, "__gnu_compiled"))
processing_gcc_compilation = 2;
}
-
- /* Try to select a C++ demangling based on the compilation unit
- producer. */
-
-#if 0
- /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
- know whether it will use the old style or v3 mangling. */
- if (processing_gcc_compilation)
- {
- if (AUTO_DEMANGLING)
- {
- set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
- }
- }
-#endif
}
else
{
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. */
processing_gcc_compilation = 1;
else if (strcmp (namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0)
processing_gcc_compilation = 2;
-
-#if 0
- /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
- know whether it will use the old style or v3 mangling. */
- if (AUTO_DEMANGLING)
- {
- set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
- }
-#endif
}
else if (type & N_EXT || type == (unsigned char) N_TEXT
|| type == (unsigned char) N_NBTEXT)
/* 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;
+ 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;
+ if (get_last_source_start_addr () > text_offset)
+ set_last_source_start_addr (text_offset);
- pst->symtab = end_symtab (text_offset + text_size, objfile,
- SECT_OFF_TEXT (objfile));
+ pst->compunit_symtab = end_symtab (text_offset + text_size,
+ SECT_OFF_TEXT (objfile));
end_stabs ();
}
\f
+/* Record the namespace that the function defined by SYMBOL was
+ defined in, if necessary. BLOCK is the associated block; use
+ OBSTACK for allocation. */
+
+static void
+cp_set_block_scope (const struct symbol *symbol,
+ struct block *block,
+ struct obstack *obstack)
+{
+ if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
+ {
+ /* Try to figure out the appropriate namespace from the
+ demangled name. */
+
+ /* FIXME: carlton/2003-04-15: If the function in question is
+ a method of a class, the name will actually include the
+ name of the class as well. This should be harmless, but
+ is a little unfortunate. */
+
+ const char *name = SYMBOL_DEMANGLED_NAME (symbol);
+ unsigned int prefix_len = cp_entire_prefix_len (name);
+
+ block_set_scope (block,
+ (const char *) obstack_copy0 (obstack, name, prefix_len),
+ obstack);
+ }
+}
+
/* This handles a single symbol from the symbol-file, building symbols
into a GDB symtab. It takes these arguments and an implicit argument.
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,
- struct section_offsets *section_offsets,
- struct objfile *objfile)
+process_one_symbol (int type, int desc, CORE_ADDR valu, const char *name,
+ const struct section_offsets *section_offsets,
+ struct objfile *objfile, enum language language)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- struct context_stack *new;
+ 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
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. */
- if (last_source_file == NULL && type != (unsigned char) N_SO)
+ if (get_last_source_file () == NULL && type != (unsigned char) N_SO)
{
/* Ignore any symbols which appear before an N_SO symbol.
Currently no one puts symbols there, but we should deal
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;
- new = pop_context ();
+ cstk = pop_context ();
/* Make a block for the local symbols within. */
- block = finish_block (new->name, &local_symbols, new->old_blocks,
- new->start_addr, new->start_addr + valu,
- objfile);
+ block = finish_block (cstk.name, &local_symbols,
+ cstk.old_blocks, NULL,
+ cstk.start_addr, cstk.start_addr + valu);
/* For C++, set the block's scope. */
- if (SYMBOL_LANGUAGE (new->name) == language_cplus)
- cp_set_block_scope (new->name, block, &objfile->objfile_obstack,
- "", 0);
+ if (SYMBOL_LANGUAGE (cstk.name) == 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. */
- 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)
+ if (outermost_context_p ())
{
lbrac_mismatch_complaint (symnum);
break;
}
- new = pop_context ();
- if (desc != new->depth)
+ cstk = pop_context ();
+ if (desc != cstk.depth)
lbrac_mismatch_complaint (symnum);
if (local_symbols != NULL)
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 = new->locals;
+ 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
/* Muzzle a compiler bug that makes end < start.
??? Which compilers? Is this ever harmful?. */
- if (new->start_addr > valu)
+ if (cstk.start_addr > valu)
{
- complaint (&symfile_complaints,
- _("block start larger than block end"));
- new->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, new->old_blocks,
- new->start_addr, valu, objfile);
+ finish_block (0, &local_symbols, cstk.old_blocks, NULL,
+ cstk.start_addr, valu);
}
}
else
n_opt_found = 0;
- if (last_source_file)
+ if (get_last_source_file ())
{
/* Check if previous symbol was also an N_SO (with some
sanity checks). If so, that one was actually the
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, objfile, SECT_OFF_TEXT (objfile));
+ end_symtab (valu, SECT_OFF_TEXT (objfile));
end_stabs ();
}
if (*name == '\000')
break;
- if (block_address_function_relative)
- function_start_offset = 0;
+ function_start_offset = 0;
start_stabs ();
- start_symtab (name, NULL, valu);
+ start_symtab (objfile, name, NULL, valu, language);
record_debugformat ("stabs");
break;
in the compilation of the main source file (whose name was
given in the N_SO symbol). Relocate for dynamic loading. */
valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
- start_subfile (name, current_subfile->dirname);
+ start_subfile (name);
break;
case N_BINCL:
push_subfile ();
add_new_header_file (name, valu);
- start_subfile (name, current_subfile->dirname);
+ start_subfile (name);
break;
case N_EINCL:
- start_subfile (pop_subfile (), current_subfile->dirname);
+ start_subfile (pop_subfile ());
break;
case N_EXCL:
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.
p = strchr (name, ':');
if (p != 0 && p[1] == 'S')
{
- /* The linker relocated it. We don't want to add an
- elfstab_offset_sections-type offset, but we *do*
+ /* The linker relocated it. We don't want to add a
+ Sun-stabs Tfoo.foo-like offset, but we *do*
want to add whatever solib.c passed to
symbol_file_add as addr (this is known to affect
- SunOS 4, and I suspect ELF too). Since
- elfstab_offset_sections currently does not muck
- with the text offset (there is no Ttext.text
- symbol), we can get addr from the text offset. If
- elfstab_offset_sections ever starts dealing with
- the text offset, and we still need to do this, we
- need to invent a SECT_OFF_ADDR_KLUDGE or something. */
+ SunOS 4, and I suspect ELF too). Since there is no
+ Ttext.text symbol, we can get addr from the text offset. */
valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
goto define_a_symbol;
}
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';
{
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
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
CORE_ADDR minsym_valu =
- find_stab_function_addr (name, last_source_file, objfile);
+ find_stab_function_addr (name, get_last_source_file (),
+ objfile);
/* The function find_stab_function_addr will return
0 if the minimal symbol wasn't found.
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;
- 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;
- new = pop_context ();
+ cstk = pop_context ();
/* Make a block for the local symbols within. */
- block = finish_block (new->name, &local_symbols,
- new->old_blocks, new->start_addr,
- valu, objfile);
+ block = finish_block (cstk.name, &local_symbols,
+ cstk.old_blocks, NULL,
+ cstk.start_addr, valu);
/* For C++, set the block's scope. */
- if (SYMBOL_LANGUAGE (new->name) == language_cplus)
- cp_set_block_scope (new->name, block,
- &objfile->objfile_obstack,
- "", 0);
+ if (SYMBOL_LANGUAGE (cstk.name) == language_cplus)
+ cp_set_block_scope (cstk.name, block,
+ &objfile->objfile_obstack);
}
- new = push_context (0, valu);
- new->name = define_symbol (valu, name, desc, type, objfile);
+ newobj = push_context (0, valu);
+ newobj->name = define_symbol (valu, name, desc, type, objfile);
break;
default:
if (strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0)
{
processing_gcc_compilation = 2;
-#if 0 /* Works, but is experimental. -fnf */
- /* For now, stay with AUTO_DEMANGLING for g++ output, as
- we don't know whether it will use the old style or v3
- mangling. */
- if (AUTO_DEMANGLING)
- {
- set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
- }
-#endif
}
else
n_opt_found = 1;
N_MAIN within a given objfile, complain() and choose
arbitrarily. (kingdon) */
if (name != NULL)
- set_main_name (name);
+ set_objfile_main_name (objfile, name, language_unknown);
break;
/* The following symbol types can be ignored. */
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;
perror_with_name (name);
stabsread_new_init ();
- buildsym_new_init ();
+ buildsym_init ();
free_header_files ();
init_header_files ();
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. */
perror_with_name (name);
stabsread_new_init ();
- buildsym_new_init ();
+ buildsym_init ();
free_header_files ();
init_header_files ();
symbuf_read = 0;
symbuf_left = bfd_section_size (objfile->obfd, 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
perror_with_name (name);
stabsread_new_init ();
- buildsym_new_init ();
+ buildsym_init ();
free_header_files ();
init_header_files ();
\f
static const struct sym_fns aout_sym_fns =
{
- bfd_target_aout_flavour,
dbx_new_init, /* init anything gbl to entire symtab */
dbx_symfile_init, /* read initial info, setup for sym_read() */
dbx_symfile_read, /* read a symbol file into symtab */
void
_initialize_dbxread (void)
{
- add_symtab_fns (&aout_sym_fns);
+ add_symtab_fns (bfd_target_aout_flavour, &aout_sym_fns);
dbx_objfile_data_key
= register_objfile_data_with_cleanup (NULL, dbx_free_symfile_info);
projects / deliverable / binutils-gdb.git / blobdiff