/* Read AIX xcoff symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986-2004, 2007-2012 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 Free Software Foundation, Inc.
Derived from coffread.c, dbxread.c, and a lot of hacking.
Contributed by IBM Corporation.
#include <sys/types.h>
#include <fcntl.h>
#include <ctype.h>
-#include "gdb_string.h"
-
-#include <sys/param.h>
#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
#endif
-#include "gdb_stat.h"
+#include <sys/stat.h>
#include "coff/internal.h"
#include "libcoff.h" /* FIXME, internal data from BFD */
char *c_name;
int c_symnum; /* Symbol number of this entry. */
int c_naux; /* 0 if syment only, 1 if syment + auxent. */
- long c_value;
+ CORE_ADDR c_value;
unsigned char c_sclass;
int c_secnum;
unsigned int c_type;
#define INITIAL_STABVECTOR_LENGTH 40
-/* Nonzero if within a function (so symbols should be local,
- if nothing says specifically). */
-
-int within_function;
-
/* Size of a COFF symbol. I think it is always 18, so I'm not sure
there is any reason not to just use a #define, but might as well
ask BFD for the size and store it here, I guess. */
{ ".dwabrev", NULL },
{ ".dwline", NULL },
{ ".dwloc", NULL },
- { NULL, NULL }, /* debug_macinfo */
- { NULL, NULL }, /* debug_macro */
+ { NULL, NULL }, /* debug_loclists */
+ /* AIX XCOFF defines one, named DWARF section for macro debug information.
+ XLC does not generate debug_macinfo for DWARF4 and below.
+ The section is assigned to debug_macro for DWARF5 and above. */
+ { NULL, NULL },
+ { ".dwmac", NULL },
{ ".dwstr", NULL },
+ { NULL, NULL }, /* debug_line_str */
{ ".dwrnges", NULL },
- { NULL, NULL }, /* debug_types */
+ { NULL, NULL }, /* debug_rnglists */
+ { ".dwpbtyp", NULL },
{ NULL, NULL }, /* debug_addr */
{ ".dwframe", NULL },
{ NULL, NULL }, /* eh_frame */
_("Mismatched .eb symbol ignored starting at symnum %d"), arg1);
}
-static void xcoff_initial_scan (struct objfile *, int);
+static void xcoff_initial_scan (struct objfile *, symfile_add_flags);
-static void scan_xcoff_symtab (struct objfile *);
+static void scan_xcoff_symtab (minimal_symbol_reader &,
+ struct objfile *);
-static char *xcoff_next_symbol_text (struct objfile *);
+static const char *xcoff_next_symbol_text (struct objfile *);
static void record_include_begin (struct coff_symbol *);
static void xcoff_symfile_finish (struct objfile *);
-static void xcoff_symfile_offsets (struct objfile *,
- struct section_addr_info *addrs);
-
static char *coff_getfilename (union internal_auxent *, struct objfile *);
static void read_symbol (struct internal_syment *, int);
else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
*args->resultp = SECT_OFF_DATA (objfile);
else
- *args->resultp = sect->index;
+ *args->resultp = gdb_bfd_section_index (abfd, sect);
*args->bfd_sect = sect;
}
}
struct linetable_entry *fentry; /* function entry vector */
int fentry_size; /* # of function entries */
struct linetable *newLineTb; /* new line table */
+ int extra_lines = 0;
#define NUM_OF_FUNCTIONS 20
fentry_size = NUM_OF_FUNCTIONS;
- fentry = (struct linetable_entry *)
- xmalloc (fentry_size * sizeof (struct linetable_entry));
+ fentry = XNEWVEC (struct linetable_entry, fentry_size);
for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii)
{
fentry[function_count].line = ii;
fentry[function_count].pc = oldLineTb->item[ii].pc;
++function_count;
+
+ /* If the function was compiled with XLC, we may have to add an
+ extra line entry later. Reserve space for that. */
+ if (ii + 1 < oldLineTb->nitems
+ && oldLineTb->item[ii].pc != oldLineTb->item[ii + 1].pc)
+ extra_lines++;
}
}
newLineTb = (struct linetable *)
xmalloc
(sizeof (struct linetable) +
- (oldLineTb->nitems - function_count) * sizeof (struct linetable_entry));
+ (oldLineTb->nitems - function_count + extra_lines) * sizeof (struct linetable_entry));
/* If line table does not start with a function beginning, copy up until
a function begin. */
for (ii = 0; ii < function_count; ++ii)
{
+ /* If the function was compiled with XLC, we may have to add an
+ extra line to cover the function prologue. */
+ jj = fentry[ii].line;
+ if (jj + 1 < oldLineTb->nitems
+ && oldLineTb->item[jj].pc != oldLineTb->item[jj + 1].pc)
+ {
+ newLineTb->item[newline] = oldLineTb->item[jj];
+ newLineTb->item[newline].line = oldLineTb->item[jj + 1].line;
+ newline++;
+ }
+
for (jj = fentry[ii].line + 1;
jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0;
++jj, ++newline)
newLineTb->item[newline] = oldLineTb->item[jj];
}
xfree (fentry);
- newLineTb->nitems = oldLineTb->nitems - function_count;
+ /* The number of items in the line table must include these
+ extra lines which were added in case of XLC compiled functions. */
+ newLineTb->nitems = oldLineTb->nitems - function_count + extra_lines;
return newLineTb;
}
{
if (inclTable == NULL)
{
- inclTable = (InclTable *)
- xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
- memset (inclTable,
- '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
+ inclTable = XCNEWVEC (InclTable, INITIAL_INCLUDE_TABLE_LENGTH);
inclLength = INITIAL_INCLUDE_TABLE_LENGTH;
inclIndx = 0;
}
else if (inclIndx >= inclLength)
{
inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
- inclTable = (InclTable *)
- xrealloc (inclTable, sizeof (InclTable) * inclLength);
+ inclTable = XRESIZEVEC (InclTable, inclTable, inclLength);
memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH,
'\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
}
start, 0, &main_source_baseline);
}
- if (strcmp (inclTable[ii].name, last_source_file) == 0)
+ if (strcmp (inclTable[ii].name, get_last_source_file ()) == 0)
{
/* The entry in the include table refers to the main source
file. Add the lines to the main subfile. */
{
/* Have a new subfile for the include file. */
- tmpSubfile = inclTable[ii].subfile =
- (struct subfile *) xmalloc (sizeof (struct subfile));
+ tmpSubfile = inclTable[ii].subfile = XNEW (struct subfile);
memset (tmpSubfile, '\0', sizeof (struct subfile));
firstLine = &(inclTable[ii].funStartLine);
fool it. */
#if 0
- start_subfile (inclTable[ii].name, (char *) 0);
+ start_subfile (inclTable[ii].name);
#else
{
/* Pick a fake name that will produce the same results as this
one when passed to deduce_language_from_filename. Kludge on
top of kludge. */
- char *fakename = strrchr (inclTable[ii].name, '.');
+ const char *fakename = strrchr (inclTable[ii].name, '.');
if (fakename == NULL)
fakename = " ?";
- start_subfile (fakename, (char *) 0);
+ start_subfile (fakename);
xfree (current_subfile->name);
}
current_subfile->name = xstrdup (inclTable[ii].name);
current_subfile->line_vector_length =
current_subfile->line_vector->nitems;
- start_subfile (pop_subfile (), (char *) 0);
+ start_subfile (pop_subfile ());
}
}
/* We don't want to keep alloc/free'ing the global include file table. */
inclIndx = 0;
-
- /* Start with a fresh subfile structure for the next file. */
- memset (&main_subfile, '\0', sizeof (struct subfile));
}
static void
-aix_process_linenos (void)
+aix_process_linenos (struct objfile *objfile)
{
/* There is no linenos to read if there are only dwarf info. */
if (this_symtab_psymtab == NULL)
text address for the file, and SIZE is the number of bytes of text. */
#define complete_symtab(name, start_addr) { \
- last_source_file = xstrdup (name); \
+ set_last_source_file (name); \
last_source_start_addr = start_addr; \
}
This function can read past the end of the symbol table
(into the string table) but this does no harm. */
-/* Create a new minimal symbol (using prim_record_minimal_symbol_and_info).
+/* Create a new minimal symbol (using record_with_info).
+
+ Creation of all new minimal symbols should go through this function
+ rather than calling the various record functions in order
+ to make sure that all symbol addresses get properly relocated.
Arguments are:
NAME - the symbol's name (but if NAME starts with a period, that
leading period is discarded).
- ADDRESS - the symbol's address.
+ ADDRESS - the symbol's address, prior to relocation. This function
+ relocates the address before recording the minimal symbol.
MS_TYPE - the symbol's type.
N_SCNUM - the symbol's XCOFF section number.
OBJFILE - the objfile associated with the minimal symbol. */
static void
-record_minimal_symbol (const char *name, CORE_ADDR address,
+record_minimal_symbol (minimal_symbol_reader &reader,
+ const char *name, CORE_ADDR address,
enum minimal_symbol_type ms_type,
int n_scnum,
struct objfile *objfile)
{
- int secnum;
- asection *bfd_sect;
-
if (name[0] == '.')
++name;
- xcoff_secnum_to_sections (n_scnum, objfile, &bfd_sect, &secnum);
- prim_record_minimal_symbol_and_info (name, address, ms_type,
- secnum, bfd_sect, objfile);
+ reader.record_with_info (name, address, ms_type,
+ secnum_to_section (n_scnum, objfile));
}
/* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
/* This is the function which stabsread.c calls to get symbol
continuations. */
-static char *
+static const char *
xcoff_next_symbol_text (struct objfile *objfile)
{
struct internal_syment symbol;
- char *retval;
+ const char *retval;
/* FIXME: is this the same as the passed arg? */
if (this_symtab_objfile)
unsigned int max_symnum;
int just_started = 1;
int depth = 0;
- int fcn_start_addr = 0;
+ CORE_ADDR fcn_start_addr = 0;
struct coff_symbol fcn_stab_saved = { 0 };
/* fcn_cs_saved is global because process_xcoff_symbol needs it. */
union internal_auxent fcn_aux_saved = main_aux;
- struct context_stack *new;
+ struct context_stack *newobj;
- char *filestring = " _start_ "; /* Name of the current file. */
+ const char *filestring = pst->filename; /* Name of the current file. */
const char *last_csect_name; /* Last seen csect's name. */
handling. */
local_symesz = coff_data (abfd)->local_symesz;
- last_source_file = NULL;
+ set_last_source_file (NULL);
last_csect_name = 0;
start_stabs ();
- start_symtab (filestring, (char *) NULL, file_start_addr);
+ start_symtab (objfile, filestring, (char *) NULL, file_start_addr,
+ language_unknown);
record_debugformat (debugfmt);
symnum = ((struct symloc *) pst->read_symtab_private)->first_symnum;
max_symnum =
{
char *p;
- p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1);
+ p = (char *) obstack_alloc (&objfile->objfile_obstack,
+ E_SYMNMLEN + 1);
strncpy (p, cs->c_name, E_SYMNMLEN);
p[E_SYMNMLEN] = '\0';
cs->c_name = p;
if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
{
- if (last_source_file)
+ if (get_last_source_file ())
{
- pst->symtab = end_symtab (cur_src_end_addr, objfile,
- SECT_OFF_TEXT (objfile));
+ pst->compunit_symtab = end_symtab (cur_src_end_addr,
+ SECT_OFF_TEXT (objfile));
end_stabs ();
}
start_stabs ();
- start_symtab ("_globals_", (char *) NULL, (CORE_ADDR) 0);
+ start_symtab (objfile, "_globals_", (char *) NULL, (CORE_ADDR) 0,
+ language_unknown);
record_debugformat (debugfmt);
cur_src_end_addr = first_object_file_end;
/* Done with all files, everything from here on is globals. */
}
- if ((cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT)
- && cs->c_naux == 1)
+ if (cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT ||
+ cs->c_sclass == C_WEAKEXT)
{
/* Dealing with a symbol with a csect entry. */
#define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
#define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
- /* Convert the auxent to something we can access. */
- bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
- 0, cs->c_naux, &main_aux);
+ /* Convert the auxent to something we can access.
+ XCOFF can have more than one auxiliary entries.
+
+ Actual functions will have two auxiliary entries, one to have the
+ function size and other to have the smtype/smclass (LD/PR).
+
+ c_type value of main symbol table will be set only in case of
+ C_EXT/C_HIDEEXT/C_WEAKEXT storage class symbols.
+ Bit 10 of type is set if symbol is a function, ie the value is set
+ to 32(0x20). So we need to read the first function auxiliay entry
+ which contains the size. */
+ if (cs->c_naux > 1 && ISFCN (cs->c_type))
+ {
+ /* a function entry point. */
+
+ fcn_start_addr = cs->c_value;
+
+ /* save the function header info, which will be used
+ when `.bf' is seen. */
+ fcn_cs_saved = *cs;
+
+ /* Convert the auxent to something we can access. */
+ bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
+ 0, cs->c_naux, &fcn_aux_saved);
+ continue;
+ }
+ /* Read the csect auxiliary header, which is always the last by
+ onvention. */
+ bfd_coff_swap_aux_in (abfd,
+ raw_auxptr
+ + ((coff_data (abfd)->local_symesz)
+ * (cs->c_naux - 1)),
+ cs->c_type, cs->c_sclass,
+ cs->c_naux - 1, cs->c_naux,
+ &main_aux);
switch (CSECT_SMTYP (&main_aux))
{
{
complete_symtab (filestring, file_start_addr);
cur_src_end_addr = file_end_addr;
- end_symtab (file_end_addr, objfile,
- SECT_OFF_TEXT (objfile));
+ end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
end_stabs ();
start_stabs ();
/* Give all csects for this source file the same
name. */
- start_symtab (filestring, NULL, (CORE_ADDR) 0);
+ start_symtab (objfile, filestring, NULL,
+ (CORE_ADDR) 0, language_unknown);
record_debugformat (debugfmt);
}
switch (CSECT_SCLAS (&main_aux))
{
+ /* We never really come to this part as this case has been
+ handled in ISFCN check above.
+ This and other cases of XTY_LD are kept just for
+ reference. */
case XMC_PR:
- /* a function entry point. */
- function_entry_point:
-
- fcn_start_addr = cs->c_value;
-
- /* save the function header info, which will be used
- when `.bf' is seen. */
- fcn_cs_saved = *cs;
- fcn_aux_saved = main_aux;
continue;
case XMC_GL:
}
}
- /* If explicitly specified as a function, treat is as one. This check
- evaluates to true for @FIX* bigtoc CSECT symbols, so it must occur
- after the above CSECT check. */
- if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
- {
- bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
- 0, cs->c_naux, &main_aux);
- goto function_entry_point;
- }
-
switch (cs->c_sclass)
{
case C_FILE:
complete_symtab (filestring, file_start_addr);
cur_src_end_addr = file_end_addr;
- end_symtab (file_end_addr, objfile, SECT_OFF_TEXT (objfile));
+ end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
end_stabs ();
/* XCOFF, according to the AIX 3.2 documentation, puts the
filestring = cs->c_name;
start_stabs ();
- start_symtab (filestring, (char *) NULL, (CORE_ADDR) 0);
+ start_symtab (objfile, filestring, (char *) NULL, (CORE_ADDR) 0,
+ language_unknown);
record_debugformat (debugfmt);
last_csect_name = 0;
within_function = 1;
- new = push_context (0, fcn_start_addr + off);
+ newobj = push_context (0, fcn_start_addr + off);
- new->name = define_symbol
+ newobj->name = define_symbol
(fcn_cs_saved.c_value + off,
fcn_stab_saved.c_name, 0, 0, objfile);
- if (new->name != NULL)
- SYMBOL_SECTION (new->name) = SECT_OFF_TEXT (objfile);
+ if (newobj->name != NULL)
+ SYMBOL_SECTION (newobj->name) = SECT_OFF_TEXT (objfile);
}
else if (strcmp (cs->c_name, ".ef") == 0)
{
within_function = 0;
break;
}
- new = pop_context ();
+ newobj = pop_context ();
/* Stack must be empty now. */
- if (context_stack_depth > 0 || new == NULL)
+ if (context_stack_depth > 0 || newobj == NULL)
{
ef_complaint (cs->c_symnum);
within_function = 0;
break;
}
- finish_block (new->name, &local_symbols, new->old_blocks,
- new->start_addr,
+ finish_block (newobj->name, &local_symbols, newobj->old_blocks,
+ NULL, newobj->start_addr,
(fcn_cs_saved.c_value
+ fcn_aux_saved.x_sym.x_misc.x_fsize
+ ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile))),
- objfile);
+ SECT_OFF_TEXT (objfile))));
within_function = 0;
}
break;
if (strcmp (cs->c_name, ".bb") == 0)
{
depth++;
- new = push_context (depth,
+ newobj = push_context (depth,
(cs->c_value
+ ANOFFSET (objfile->section_offsets,
SECT_OFF_TEXT (objfile))));
eb_complaint (cs->c_symnum);
break;
}
- new = pop_context ();
- if (depth-- != new->depth)
+ newobj = pop_context ();
+ if (depth-- != newobj->depth)
{
eb_complaint (cs->c_symnum);
break;
if (local_symbols && context_stack_depth > 0)
{
/* Make a block for the local symbols within. */
- finish_block (new->name, &local_symbols, new->old_blocks,
- new->start_addr,
+ finish_block (newobj->name, &local_symbols,
+ newobj->old_blocks, NULL,
+ newobj->start_addr,
(cs->c_value
+ ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile))),
- objfile);
+ SECT_OFF_TEXT (objfile))));
}
- local_symbols = new->locals;
+ local_symbols = newobj->locals;
}
break;
}
}
- if (last_source_file)
+ if (get_last_source_file ())
{
- struct symtab *s;
+ struct compunit_symtab *cust;
complete_symtab (filestring, file_start_addr);
cur_src_end_addr = file_end_addr;
- s = end_symtab (file_end_addr, objfile, SECT_OFF_TEXT (objfile));
+ cust = end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
/* When reading symbols for the last C_FILE of the objfile, try
- to make sure that we set pst->symtab to the symtab for the
+ to make sure that we set pst->compunit_symtab to the symtab for the
file, not to the _globals_ symtab. I'm not sure whether this
actually works right or when/if it comes up. */
- if (pst->symtab == NULL)
- pst->symtab = s;
+ if (pst->compunit_symtab == NULL)
+ pst->compunit_symtab = cust;
end_stabs ();
}
}
#define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
- (SYMBOL2) = (struct symbol *) \
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); \
+ (SYMBOL2) = XOBNEW (&objfile->objfile_obstack, struct symbol); \
*(SYMBOL2) = *(SYMBOL1);
#define SYMNAME_ALLOC(NAME, ALLOCED) \
- ((ALLOCED) ? (NAME) : obsavestring ((NAME), strlen (NAME), \
- &objfile->objfile_obstack))
+ ((ALLOCED) ? (NAME) : obstack_copy0 (&objfile->objfile_obstack, \
+ (NAME), strlen (NAME)))
/* process one xcoff symbol. */
if (name[0] == '.')
++name;
- memset (sym, '\0', sizeof (struct symbol));
+ initialize_objfile_symbol (sym);
/* default assumptions */
SYMBOL_VALUE_ADDRESS (sym) = cs->c_value + off;
will be patched with the type from its stab entry later on in
patch_block_stabs (), unless the file was compiled without -g. */
- SYMBOL_SET_LINKAGE_NAME (sym, SYMNAME_ALLOC (name, symname_alloced));
+ SYMBOL_SET_LINKAGE_NAME (sym, ((const char *)
+ SYMNAME_ALLOC (name, symname_alloced)));
SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_text_symbol;
- SYMBOL_CLASS (sym) = LOC_BLOCK;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
SYMBOL_DUP (sym, sym2);
- if (cs->c_sclass == C_EXT)
+ if (cs->c_sclass == C_EXT || C_WEAKEXT)
add_symbol_to_list (sym2, &global_symbols);
else if (cs->c_sclass == C_HIDEXT || cs->c_sclass == C_STAT)
add_symbol_to_list (sym2, &file_symbols);
static void
xcoff_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst)
{
- struct cleanup *old_chain;
int i;
if (!pst)
/* Init stuff necessary for reading in symbols. */
stabsread_init ();
buildsym_init ();
- old_chain = make_cleanup (really_free_pendings, 0);
+ scoped_free_pendings free_pending;
read_xcoff_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
-xcoff_psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
+xcoff_read_symtab (struct partial_symtab *self, struct objfile *objfile)
{
- 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 (((struct symloc *) pst->read_symtab_private)->numsyms != 0
- || pst->number_of_dependencies)
+ if (((struct symloc *) self->read_symtab_private)->numsyms != 0
+ || 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);
}
next_symbol_text_func = xcoff_next_symbol_text;
- xcoff_psymtab_to_symtab_1 (objfile, pst);
+ xcoff_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 struct partial_symtab *
xcoff_start_psymtab (struct objfile *objfile,
const char *filename, int first_symnum,
- struct partial_symbol **global_syms,
- struct partial_symbol **static_syms)
+ std::vector<partial_symbol *> &global_psymbols,
+ std::vector<partial_symbol *> &static_psymbols)
{
struct partial_symtab *result =
- start_psymtab_common (objfile, objfile->section_offsets,
+ start_psymtab_common (objfile,
filename,
/* We fill in textlow later. */
0,
- global_syms, static_syms);
+ 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);
((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum;
- result->read_symtab = xcoff_psymtab_to_symtab;
+ result->read_symtab = xcoff_read_symtab;
/* Deduce the source language from the filename for this psymtab. */
psymtab_language = deduce_language_from_filename (filename);
((struct symloc *) pst->read_symtab_private)->lineno_off =
first_fun_line_offset;
first_fun_line_offset = 0;
- 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);
- subpst->section_offsets = pst->section_offsets;
subpst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct symloc));
((struct symloc *) subpst->read_symtab_private)->first_symnum = 0;
/* We could save slight bits of space by only making one of these,
shared by the entire set of include files. FIXME-someday. */
- subpst->dependencies = (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 = NULL;
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;
}
into the minimal symbols. */
char *p;
- p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1);
+ p = (char *) obstack_alloc (&objfile->objfile_obstack,
+ E_SYMNMLEN + 1);
strncpy (p, symbol->n_name, E_SYMNMLEN);
p[E_SYMNMLEN] = '\0';
*name = p;
}
static void
-scan_xcoff_symtab (struct objfile *objfile)
+scan_xcoff_symtab (minimal_symbol_reader &reader,
+ struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
CORE_ADDR toc_offset = 0; /* toc offset value in data section. */
const char *filestring = NULL;
const char *namestring;
- int past_first_source_file = 0;
bfd *abfd;
asection *bfd_sect;
unsigned int nsyms;
(struct partial_symtab **) alloca (dependencies_allocated *
sizeof (struct partial_symtab *));
- last_source_file = NULL;
+ set_last_source_file (NULL);
abfd = objfile->obfd;
next_symbol_text_func = xcoff_next_symbol_text;
{
case C_EXT:
case C_HIDEXT:
+ case C_WEAKEXT:
{
/* The CSECT auxent--always the last auxent. */
union internal_auxent csect_aux;
if (!misc_func_recorded)
{
record_minimal_symbol
- (last_csect_name, last_csect_val,
+ (reader, last_csect_name, last_csect_val,
mst_text, last_csect_sec, objfile);
misc_func_recorded = 1;
}
(objfile,
filestring,
symnum_before,
- objfile->global_psymbols.next,
- objfile->static_psymbols.next);
+ objfile->global_psymbols,
+ objfile->static_psymbols);
}
}
/* Activate the misc_func_recorded mechanism for
/* Data variables are recorded in the minimal symbol
table, except for section symbols. */
if (*namestring != '.')
- prim_record_minimal_symbol_and_info
- (namestring, symbol.n_value,
+ record_minimal_symbol
+ (reader, namestring, symbol.n_value,
sclass == C_HIDEXT ? mst_file_data : mst_data,
- secnum_to_section (symbol.n_scnum, objfile),
- secnum_to_bfd_section (symbol.n_scnum, objfile),
- objfile);
+ symbol.n_scnum, objfile);
break;
case XMC_TC0:
if (first_fun_line_offset == 0 && symbol.n_numaux > 1)
first_fun_line_offset =
main_aux[0].x_sym.x_fcnary.x_fcn.x_lnnoptr;
- {
- record_minimal_symbol
- (namestring, symbol.n_value,
- sclass == C_HIDEXT ? mst_file_text : mst_text,
- symbol.n_scnum, objfile);
- misc_func_recorded = 1;
- }
+
+ record_minimal_symbol
+ (reader, namestring, symbol.n_value,
+ sclass == C_HIDEXT ? mst_file_text : mst_text,
+ symbol.n_scnum, objfile);
+ misc_func_recorded = 1;
break;
case XMC_GL:
symbols, we will choose mst_text over
mst_solib_trampoline. */
record_minimal_symbol
- (namestring, symbol.n_value,
+ (reader, namestring, symbol.n_value,
mst_solib_trampoline, symbol.n_scnum, objfile);
misc_func_recorded = 1;
break;
typically be XMC_RW; I suspect XMC_RO and
XMC_BS might be possible too. */
if (*namestring != '.')
- prim_record_minimal_symbol_and_info
- (namestring, symbol.n_value,
+ record_minimal_symbol
+ (reader, namestring, symbol.n_value,
sclass == C_HIDEXT ? mst_file_data : mst_data,
- secnum_to_section (symbol.n_scnum, objfile),
- secnum_to_bfd_section (symbol.n_scnum, objfile),
- objfile);
+ symbol.n_scnum, objfile);
break;
}
break;
/* Common variables are recorded in the minimal symbol
table, except for section symbols. */
if (*namestring != '.')
- prim_record_minimal_symbol_and_info
- (namestring, symbol.n_value,
+ record_minimal_symbol
+ (reader, namestring, symbol.n_value,
sclass == C_HIDEXT ? mst_file_bss : mst_bss,
- secnum_to_section (symbol.n_scnum, objfile),
- secnum_to_bfd_section (symbol.n_scnum, objfile),
- objfile);
+ symbol.n_scnum, objfile);
break;
}
break;
it as a function. This will take care of functions like
strcmp() compiled by xlc. */
- record_minimal_symbol (last_csect_name, last_csect_val,
+ record_minimal_symbol (reader, last_csect_name, last_csect_val,
mst_text, last_csect_sec, objfile);
misc_func_recorded = 1;
}
pst = xcoff_start_psymtab (objfile,
filestring,
symnum_before,
- objfile->global_psymbols.next,
- objfile->static_psymbols.next);
+ objfile->global_psymbols,
+ objfile->static_psymbols);
last_csect_name = NULL;
}
break;
case C_DECL:
case C_STSYM:
{
- char *p;
+ const char *p;
swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
&ssymnum, objfile);
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
- 0, symbol.n_value,
+ symbol.n_value,
psymtab_language, objfile);
continue;
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
- 0, symbol.n_value,
+ symbol.n_value,
psymtab_language, objfile);
continue;
add_psymbol_to_list (namestring, p - namestring, 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- symbol.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 (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- symbol.n_value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
p += 1;
}
}
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- symbol.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! */
enum constants in psymtabs, just in symtabs. */
add_psymbol_to_list (p, q - p, 1,
VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, 0,
+ &objfile->static_psymbols,
0, psymtab_language, objfile);
/* Point past the name. */
p = q;
/* Constant, e.g. from "const" in Pascal. */
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, symbol.n_value,
+ &objfile->static_psymbols,
0, psymtab_language, objfile);
continue;
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 (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, symbol.n_value,
+ symbol.n_value,
psymtab_language, objfile);
continue;
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';
loader-generated definitions. Keeping the global
symbols leads to "in psymbols but not in symbols"
errors. */
- if (strncmp (namestring, "@FIX", 4) == 0)
+ if (startswith (namestring, "@FIX"))
continue;
symbol.n_value += ANOFFSET (objfile->section_offsets,
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, symbol.n_value,
+ symbol.n_value,
psymtab_language, objfile);
continue;
loaded). */
static void
-xcoff_initial_scan (struct objfile *objfile, int symfile_flags)
+xcoff_initial_scan (struct objfile *objfile, symfile_add_flags symfile_flags)
{
bfd *abfd;
int val;
- struct cleanup *back_to;
int num_symbols; /* # of symbols */
file_ptr symtab_offset; /* symbol table and */
file_ptr stringtab_offset; /* string table file offsets */
struct coff_symfile_info *info;
- char *name;
+ const char *name;
unsigned int size;
info = XCOFF_DATA (objfile);
symfile_bfd = abfd = objfile->obfd;
- name = objfile->name;
+ name = objfile_name (objfile);
num_symbols = bfd_get_symcount (abfd); /* # of symbols */
symtab_offset = obj_sym_filepos (abfd); /* symbol table file offset */
/* Read the string table. */
init_stringtab (abfd, stringtab_offset, objfile);
- /* Read the .debug section, if present. */
- {
- struct bfd_section *secp;
- bfd_size_type length;
- bfd_byte *debugsec = NULL;
+ /* Read the .debug section, if present and if we're not ignoring
+ it. */
+ if (!(objfile->flags & OBJF_READNEVER))
+ {
+ struct bfd_section *secp;
+ bfd_size_type length;
+ bfd_byte *debugsec = NULL;
- secp = bfd_get_section_by_name (abfd, ".debug");
- if (secp)
- {
- length = bfd_section_size (abfd, secp);
- if (length)
- {
- debugsec = obstack_alloc (&objfile->objfile_obstack, length);
+ secp = bfd_get_section_by_name (abfd, ".debug");
+ if (secp)
+ {
+ length = bfd_section_size (abfd, secp);
+ if (length)
+ {
+ debugsec
+ = (bfd_byte *) obstack_alloc (&objfile->objfile_obstack,
+ length);
- if (!bfd_get_full_section_contents (abfd, secp, &debugsec))
- {
- error (_("Error reading .debug section of `%s': %s"),
- name, bfd_errmsg (bfd_get_error ()));
- }
- }
- }
- info->debugsec = debugsec;
- }
+ if (!bfd_get_full_section_contents (abfd, secp, &debugsec))
+ {
+ error (_("Error reading .debug section of `%s': %s"),
+ name, bfd_errmsg (bfd_get_error ()));
+ }
+ }
+ }
+ info->debugsec = (char *) debugsec;
+ }
}
/* Read the symbols. We keep them in core because we will want to
error (_("Error reading symbols from %s: %s"),
name, bfd_errmsg (bfd_get_error ()));
size = coff_data (abfd)->local_symesz * num_symbols;
- info->symtbl = obstack_alloc (&objfile->objfile_obstack, size);
+ info->symtbl = (char *) obstack_alloc (&objfile->objfile_obstack, size);
info->symtbl_num_syms = num_symbols;
val = bfd_bread (info->symtbl, size, abfd);
perror_with_name (_("reading symbol table"));
/* If we are reinitializing, or if we have never loaded syms yet, init. */
- if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
+ if (objfile->global_psymbols.capacity () == 0
+ && objfile->static_psymbols.capacity () == 0)
/* I'm not sure how how good num_symbols is; the rule of thumb in
init_psymbol_list was developed for a.out. On the one hand,
num_symbols includes auxents. On the other hand, it doesn't
init_psymbol_list (objfile, num_symbols);
free_pending_blocks ();
- back_to = make_cleanup (really_free_pendings, 0);
- init_minimal_symbol_collection ();
- make_cleanup_discard_minimal_symbols ();
+ scoped_free_pendings free_pending;
+ minimal_symbol_reader reader (objfile);
/* Now that the symbol table data of the executable file are all in core,
process them and define symbols accordingly. */
- scan_xcoff_symtab (objfile);
+ scan_xcoff_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 ();
/* DWARF2 sections. */
dwarf2_build_psymtabs (objfile);
dwarf2_build_frame_info (objfile);
-
- do_cleanups (back_to);
}
\f
static void
xcoff_symfile_offsets (struct objfile *objfile,
- struct section_addr_info *addrs)
+ const struct section_addr_info *addrs)
{
- asection *sect = NULL;
- int i;
+ const char *first_section_name;
- objfile->num_sections = bfd_count_sections (objfile->obfd);
- objfile->section_offsets = (struct section_offsets *)
- obstack_alloc (&objfile->objfile_obstack,
- SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
+ default_symfile_offsets (objfile, addrs);
- /* Initialize the section indexes for future use. */
- sect = bfd_get_section_by_name (objfile->obfd, ".text");
- if (sect)
- objfile->sect_index_text = sect->index;
+ /* Oneof the weird side-effects of default_symfile_offsets is that
+ it sometimes sets some section indices to zero for sections that,
+ in fact do not exist. See the body of default_symfile_offsets
+ for more info on when that happens. Undo that, as this then allows
+ us to test whether the associated section exists or not, and then
+ access it quickly (without searching it again). */
- sect = bfd_get_section_by_name (objfile->obfd, ".data");
- if (sect)
- objfile->sect_index_data = sect->index;
+ if (objfile->num_sections == 0)
+ return; /* Is that even possible? Better safe than sorry. */
- sect = bfd_get_section_by_name (objfile->obfd, ".bss");
- if (sect)
- objfile->sect_index_bss = sect->index;
+ first_section_name
+ = bfd_section_name (objfile->obfd, objfile->sections[0].the_bfd_section);
- sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
- if (sect)
- objfile->sect_index_rodata = sect->index;
+ if (objfile->sect_index_text == 0
+ && strcmp (first_section_name, ".text") != 0)
+ objfile->sect_index_text = -1;
- for (i = 0; i < objfile->num_sections; ++i)
- {
- /* syms_from_objfile kindly subtracts from addr the
- bfd_section_vma of the .text section. This strikes me as
- wrong--whether the offset to be applied to symbol reading is
- relative to the start address of the section depends on the
- symbol format. In any event, this whole "addr" concept is
- pretty broken (it doesn't handle any section but .text
- sensibly), so just ignore the addr parameter and use 0.
- rs6000-nat.c will set the correct section offsets via
- objfile_relocate. */
- (objfile->section_offsets)->offsets[i] = 0;
- }
+ if (objfile->sect_index_data == 0
+ && strcmp (first_section_name, ".data") != 0)
+ objfile->sect_index_data = -1;
+
+ if (objfile->sect_index_bss == 0
+ && strcmp (first_section_name, ".bss") != 0)
+ objfile->sect_index_bss = -1;
+
+ if (objfile->sect_index_rodata == 0
+ && strcmp (first_section_name, ".rodata") != 0)
+ objfile->sect_index_rodata = -1;
}
/* Register our ability to parse symbols for xcoff BFD files. */
xcoffread.c reads all the symbols and does in fact randomly access them
(in C_BSTAT and line number processing). */
- bfd_target_xcoff_flavour,
-
xcoff_new_init, /* init anything gbl to entire symtab */
xcoff_symfile_init, /* read initial info, setup for sym_read() */
xcoff_initial_scan, /* read a symbol file into symtab */
xfree (arg);
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_xcoffread;
-
void
_initialize_xcoffread (void)
{
- add_symtab_fns (&xcoff_sym_fns);
+ add_symtab_fns (bfd_target_xcoff_flavour, &xcoff_sym_fns);
xcoff_objfile_data_key = register_objfile_data_with_cleanup (NULL,
xcoff_free_info);
projects / deliverable / binutils-gdb.git / blobdiff