/* Read AIX xcoff symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2015 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. */
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);
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[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;
}
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
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)
/* Create a new minimal symbol (using prim_record_minimal_symbol_and_info).
+ Creation of all new minimal symbols should go through this function
+ rather than calling the various prim_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. */
int n_scnum,
struct objfile *objfile)
{
+ int section = secnum_to_section (n_scnum, objfile);
+
if (name[0] == '.')
++name;
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. */
last_csect_name = 0;
start_stabs ();
- start_symtab (filestring, (char *) NULL, file_start_addr);
+ start_symtab (objfile, filestring, (char *) NULL, file_start_addr);
record_debugformat (debugfmt);
symnum = ((struct symloc *) pst->read_symtab_private)->first_symnum;
max_symnum =
{
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);
record_debugformat (debugfmt);
cur_src_end_addr = first_object_file_end;
/* Done with all files, everything from here on is globals. */
{
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);
record_debugformat (debugfmt);
}
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);
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,
+ 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,
+ 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 (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 ();
}
}
if (name[0] == '.')
++name;
- initialize_symbol (sym);
+ initialize_objfile_symbol (sym);
/* default assumptions */
SYMBOL_VALUE_ADDRESS (sym) = cs->c_value + off;
subpst->n_static_syms = 0;
subpst->readin = 0;
- subpst->symtab = 0;
+ subpst->compunit_symtab = NULL;
subpst->read_symtab = pst->read_symtab;
}
/* Data variables are recorded in the minimal symbol
table, except for section symbols. */
if (*namestring != '.')
- prim_record_minimal_symbol_and_info
+ record_minimal_symbol
(namestring, symbol.n_value,
sclass == C_HIDEXT ? mst_file_data : mst_data,
- secnum_to_section (symbol.n_scnum, objfile),
- objfile);
+ symbol.n_scnum, objfile);
break;
case XMC_TC0:
typically be XMC_RW; I suspect XMC_RO and
XMC_BS might be possible too. */
if (*namestring != '.')
- prim_record_minimal_symbol_and_info
+ record_minimal_symbol
(namestring, symbol.n_value,
sclass == C_HIDEXT ? mst_file_data : mst_data,
- secnum_to_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
+ record_minimal_symbol
(namestring, symbol.n_value,
sclass == C_HIDEXT ? mst_file_bss : mst_bss,
- secnum_to_section (symbol.n_scnum, objfile),
- objfile);
+ symbol.n_scnum, objfile);
break;
}
break;
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 */
}
}
}
- info->debugsec = debugsec;
+ info->debugsec = (char *) debugsec;
}
}
\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 */
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