/* Read AIX xcoff symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
Derived from coffread.c, dbxread.c, and a lot of hacking.
Contributed by IBM Corporation.
#include <sys/file.h>
#endif
#include <sys/stat.h>
+#include <algorithm>
#include "coff/internal.h"
#include "libcoff.h" /* FIXME, internal data from BFD */
{ NULL, NULL },
{ ".dwmac", NULL },
{ ".dwstr", NULL },
+ { NULL, NULL }, /* debug_str_offsets */
{ NULL, NULL }, /* debug_line_str */
{ ".dwrnges", NULL },
{ NULL, NULL }, /* debug_rnglists */
static struct symbol *process_xcoff_symbol (struct coff_symbol *,
struct objfile *);
-static void read_xcoff_symtab (struct objfile *, struct partial_symtab *);
+static void read_xcoff_symtab (struct objfile *, legacy_psymtab *);
#if 0
static void add_stab_to_list (char *, struct pending_stabs **);
#endif
-static int compare_lte (const void *, const void *);
-
static struct linetable *arrange_linetable (struct linetable *);
static void record_include_end (struct coff_symbol *);
/* *INDENT-ON* */
-
-/* compare line table entry addresses. */
-
-static int
-compare_lte (const void *lte1p, const void *lte2p)
-{
- struct linetable_entry *lte1 = (struct linetable_entry *) lte1p;
- struct linetable_entry *lte2 = (struct linetable_entry *) lte2p;
-
- return lte1->pc - lte2->pc;
-}
-
/* Given a line table with function entries are marked, arrange its
functions in ascending order and strip off function entry markers
and return it in a newly created table. If the old one is good
for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii)
{
+ if (oldLineTb->item[ii].is_stmt == 0)
+ continue;
+
if (oldLineTb->item[ii].line == 0)
{ /* Function entry found. */
if (function_count >= fentry_size)
fentry_size * sizeof (struct linetable_entry));
}
fentry[function_count].line = ii;
+ fentry[function_count].is_stmt = 1;
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. */
+ extra line entry later. Reserve space for that. */
if (ii + 1 < oldLineTb->nitems
&& oldLineTb->item[ii].pc != oldLineTb->item[ii + 1].pc)
extra_lines++;
return oldLineTb;
}
else if (function_count > 1)
- qsort (fentry, function_count,
- sizeof (struct linetable_entry), compare_lte);
+ std::sort (fentry, fentry + function_count,
+ [] (const linetable_entry <e1, const linetable_entry& lte2)
+ { return lte1.pc < lte2.pc; });
/* Allocate a new line table. */
newLineTb = (struct linetable *)
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. */
+ 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)
if (inclDepth)
{
/* In xcoff, we assume include files cannot be nested (not in .c files
- of course, but in corresponding .s files.). */
+ of course, but in corresponding .s files.). */
/* This can happen with old versions of GCC.
- GCC 2.3.3-930426 does not exhibit this on a test case which
- a user said produced the message for him. */
+ GCC 2.3.3-930426 does not exhibit this on a test case which
+ a user said produced the message for him. */
complaint (_("Nested C_BINCL symbols"));
}
++inclDepth;
/* Global variable to pass the psymtab down to all the routines involved
in psymtab to symtab processing. */
-static struct partial_symtab *this_symtab_psymtab;
+static legacy_psymtab *this_symtab_psymtab;
/* Objfile related to this_symtab_psymtab; set at the same time. */
static struct objfile *this_symtab_objfile;
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. */
+ /* The entry in the include table refers to the main source
+ file. Add the lines to the main subfile. */
main_source_baseline = inclTable[ii].funStartLine;
enter_line_range
}
/* All the include files' line have been processed at this point. Now,
- enter remaining lines of the main file, if any left. */
+ enter remaining lines of the main file, if any left. */
if (offset < max_offset + 1 - linesz)
{
enter_line_range (&main_subfile, offset, 0, start, end,
lv = main_subfile.line_vector;
/* Line numbers are not necessarily ordered. xlc compilation will
- put static function to the end. */
+ put static function to the end. */
struct subfile *current_subfile = get_current_subfile ();
lineTb = arrange_linetable (lv);
for (ii = 0; ii < inclIndx; ++ii)
{
if (inclTable[ii].subfile != ((struct subfile *) &main_subfile)
- && (inclTable[ii].subfile)->line_vector) /* Useless if!!!
+ && (inclTable[ii].subfile)->line_vector) /* Useless if!!!
FIXMEmgo */
{
struct linetable *lineTb, *lv;
/* Enter a given range of lines into the line vector.
can be called in the following two ways:
enter_line_range (subfile, beginoffset, endoffset,
- startaddr, 0, firstLine) or
+ startaddr, 0, firstLine) or
enter_line_range (subfile, beginoffset, 0,
- startaddr, endaddr, firstLine)
+ startaddr, endaddr, firstLine)
endoffset points to the last line table entry that we should pay
attention to. */
CORE_ADDR endaddr, unsigned *firstLine)
{
struct objfile *objfile = this_symtab_objfile;
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
unsigned int curoffset;
CORE_ADDR addr;
void *ext_lnno;
addr = (int_lnno.l_lnno
? int_lnno.l_addr.l_paddr
: read_symbol_nvalue (int_lnno.l_addr.l_symndx));
- addr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+ addr += objfile->text_section_offset ();
if (addr < startaddr || (endaddr && addr >= endaddr))
return;
complaint (_("Unexpected symbol continuation"));
/* Return something which points to '\0' and hope the symbol reading
- code does something reasonable. */
+ code does something reasonable. */
retval = "";
}
else if (symbol.n_sclass & 0x80)
complaint (_("Unexpected symbol continuation"));
/* Return something which points to '\0' and hope the symbol reading
- code does something reasonable. */
+ code does something reasonable. */
retval = "";
}
return retval;
/* Read symbols for a given partial symbol table. */
static void
-read_xcoff_symtab (struct objfile *objfile, struct partial_symtab *pst)
+read_xcoff_symtab (struct objfile *objfile, legacy_psymtab *pst)
{
bfd *abfd = objfile->obfd;
char *raw_auxptr; /* Pointer to first raw aux entry for sym. */
/* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
/* read one symbol into `cs' structure. After processing the
- whole symbol table, only string table will be kept in memory,
- symbol table and debug section of xcoff will be freed. Thus
- we can mark symbols with names in string table as
- `alloced'. */
+ whole symbol table, only string table will be kept in memory,
+ symbol table and debug section of xcoff will be freed. Thus
+ we can mark symbols with names in string table as
+ `alloced'. */
{
int ii;
{
/* A program csect is seen. We have to allocate one
- symbol table for each program csect. Normally gdb
- prefers one symtab for each source file. In case
- of AIX, one source file might include more than one
- [PR] csect, and they don't have to be adjacent in
- terms of the space they occupy in memory. Thus, one
- single source file might get fragmented in the
- memory and gdb's file start and end address
- approach does not work! GCC (and I think xlc) seem
- to put all the code in the unnamed program csect. */
+ symbol table for each program csect. Normally gdb
+ prefers one symtab for each source file. In case
+ of AIX, one source file might include more than one
+ [PR] csect, and they don't have to be adjacent in
+ terms of the space they occupy in memory. Thus, one
+ single source file might get fragmented in the
+ memory and gdb's file start and end address
+ approach does not work! GCC (and I think xlc) seem
+ to put all the code in the unnamed program csect. */
if (last_csect_name)
{
}
/* If this is the very first csect seen,
- basically `__start'. */
+ basically `__start'. */
if (just_started)
{
first_object_file_end
}
file_start_addr =
- cs->c_value + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ cs->c_value + objfile->text_section_offset ();
file_end_addr = file_start_addr + CSECT_LEN (&main_aux);
if (cs->c_name && (cs->c_name[0] == '.' || cs->c_name[0] == '@'))
case C_FCN:
if (strcmp (cs->c_name, ".bf") == 0)
{
- CORE_ADDR off = ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ CORE_ADDR off = objfile->text_section_offset ();
bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
0, cs->c_naux, &main_aux);
0, cs->c_naux, &main_aux);
/* The value of .ef is the address of epilogue code;
- not useful for gdb. */
+ not useful for gdb. */
/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
- contains number of lines to '}' */
+ contains number of lines to '}' */
if (outermost_context_p ())
{ /* We attempted to pop an empty context stack. */
NULL, cstk.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->text_section_offset ()));
within_function = 0;
}
break;
depth++;
newobj = push_context (depth,
(cs->c_value
- + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile))));
+ + objfile->text_section_offset ()));
}
else if (strcmp (cs->c_name, ".eb") == 0)
{
cstk.old_blocks, NULL,
cstk.start_addr,
(cs->c_value
- + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile))));
+ + objfile->text_section_offset ()));
}
*get_local_symbols () = cstk.locals;
}
cur_src_end_addr = file_end_addr;
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->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. */
+ 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->compunit_symtab == NULL)
pst->compunit_symtab = cust;
end_stabs ();
}
}
-#define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
- (SYMBOL2) = XOBNEW (&objfile->objfile_obstack, struct symbol); \
- *(SYMBOL2) = *(SYMBOL1);
-
-
#define SYMNAME_ALLOC(NAME, ALLOCED) \
((ALLOCED) ? (NAME) : obstack_strdup (&objfile->objfile_obstack, \
(NAME)))
if (cs->c_secnum < 0)
{
/* The value is a register number, offset within a frame, etc.,
- and does not get relocated. */
+ and does not get relocated. */
off = 0;
sec = -1;
}
else
{
sec = secnum_to_section (cs->c_secnum, objfile);
- off = ANOFFSET (objfile->section_offsets, sec);
+ off = objfile->section_offsets[sec];
}
name = cs->c_name;
if (name[0] == '.')
++name;
- initialize_objfile_symbol (sym);
-
/* default assumptions */
SET_SYMBOL_VALUE_ADDRESS (sym, cs->c_value + off);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
if (ISFCN (cs->c_type))
{
/* At this point, we don't know the type of the function. This
- will be patched with the type from its stab entry later on in
- patch_block_stabs (), unless the file was compiled without -g. */
+ 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));
+ sym->set_linkage_name (SYMNAME_ALLOC (name, symname_alloced));
SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_text_symbol;
SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
- SYMBOL_DUP (sym, sym2);
+ sym2 = new (&objfile->objfile_obstack) symbol (*sym);
if (cs->c_sclass == C_EXT || C_WEAKEXT)
add_symbol_to_list (sym2, get_global_symbols ());
if (*pp == 'V' && !within_function)
*pp = 'S';
sym = define_symbol ((cs->c_value
- + ANOFFSET (objfile->section_offsets,
- static_block_section)),
+ + objfile->section_offsets[static_block_section]),
cs->c_name, 0, 0, objfile);
if (sym != NULL)
{
}
\f
static void
-xcoff_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst)
+xcoff_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile)
{
- int i;
-
- if (!pst)
- return;
-
- if (pst->readin)
- {
- fprintf_unfiltered
- (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
- pst->filename);
- return;
- }
+ gdb_assert (!pst->readin);
/* Read in all partial symtabs on which this one is dependent. */
- for (i = 0; i < pst->number_of_dependencies; i++)
- if (!pst->dependencies[i]->readin)
- {
- /* Inform about additional files that need to be read in. */
- if (info_verbose)
- {
- fputs_filtered (" ", gdb_stdout);
- wrap_here ("");
- fputs_filtered ("and ", gdb_stdout);
- wrap_here ("");
- printf_filtered ("%s...", pst->dependencies[i]->filename);
- wrap_here (""); /* Flush output */
- gdb_flush (gdb_stdout);
- }
- xcoff_psymtab_to_symtab_1 (objfile, pst->dependencies[i]);
- }
+ pst->expand_dependencies (objfile);
if (((struct symloc *) pst->read_symtab_private)->numsyms != 0)
{
read_xcoff_symtab (objfile, pst);
}
- pst->readin = 1;
+ pst->readin = true;
}
/* Read in all of the symbols for a given psymtab for real.
Be verbose about it if the user wants that. SELF is not NULL. */
static void
-xcoff_read_symtab (struct partial_symtab *self, struct objfile *objfile)
+xcoff_read_symtab (legacy_psymtab *self, struct objfile *objfile)
{
- if (self->readin)
- {
- fprintf_unfiltered
- (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
- self->filename);
- return;
- }
+ gdb_assert (!self->readin);
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...", self->filename);
- gdb_flush (gdb_stdout);
- }
-
next_symbol_text_func = xcoff_next_symbol_text;
- xcoff_psymtab_to_symtab_1 (objfile, self);
+ self->expand_psymtab (objfile);
/* Match with global symbols. This only needs to be done once,
- after all of the symtabs and dependencies have been read in. */
+ after all of the symtabs and dependencies have been read in. */
scan_file_globals (objfile);
-
- /* Finish up the debug error message. */
- if (info_verbose)
- printf_filtered ("done.\n");
}
}
\f
is the address relative to which its symbols are (incremental) or 0
(normal). */
-static struct partial_symtab *
+static legacy_psymtab *
xcoff_start_psymtab (struct objfile *objfile,
const char *filename, int first_symnum)
{
- struct partial_symtab *result =
- start_psymtab_common (objfile,
- filename,
- /* We fill in textlow later. */
- 0);
+ /* We fill in textlow later. */
+ legacy_psymtab *result = new legacy_psymtab (filename, objfile, 0);
result->read_symtab_private =
XOBNEW (&objfile->objfile_obstack, struct symloc);
((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum;
- result->read_symtab = xcoff_read_symtab;
+ result->legacy_read_symtab = xcoff_read_symtab;
+ result->legacy_expand_psymtab = xcoff_expand_psymtab;
/* Deduce the source language from the filename for this psymtab. */
psymtab_language = deduce_language_from_filename (filename);
INCLUDE_LIST, NUM_INCLUDES, DEPENDENCY_LIST, and NUMBER_DEPENDENCIES
are the information for includes and dependencies. */
-static struct partial_symtab *
-xcoff_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
+static legacy_psymtab *
+xcoff_end_psymtab (struct objfile *objfile, legacy_psymtab *pst,
const char **include_list, int num_includes,
int capping_symbol_number,
- struct partial_symtab **dependency_list,
+ legacy_psymtab **dependency_list,
int number_dependencies, int textlow_not_set)
{
int i;
first_fun_line_offset;
first_fun_line_offset = 0;
- end_psymtab_common (objfile, pst);
+ pst->end ();
pst->number_of_dependencies = number_dependencies;
if (number_dependencies)
pst->dependencies
= objfile->partial_symtabs->allocate_dependencies (number_dependencies);
memcpy (pst->dependencies, dependency_list,
- number_dependencies * sizeof (struct partial_symtab *));
+ number_dependencies * sizeof (legacy_psymtab *));
}
else
pst->dependencies = 0;
for (i = 0; i < num_includes; i++)
{
- struct partial_symtab *subpst =
- allocate_psymtab (include_list[i], objfile);
+ legacy_psymtab *subpst =
+ new legacy_psymtab (include_list[i], objfile);
subpst->read_symtab_private = XOBNEW (&objfile->objfile_obstack, symloc);
((struct symloc *) subpst->read_symtab_private)->first_symnum = 0;
((struct symloc *) subpst->read_symtab_private)->numsyms = 0;
/* We could save slight bits of space by only making one of these,
- shared by the entire set of include files. FIXME-someday. */
+ shared by the entire set of include files. FIXME-someday. */
subpst->dependencies =
objfile->partial_symtabs->allocate_dependencies (1);
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;
- subpst->read_symtab = pst->read_symtab;
+ subpst->legacy_read_symtab = pst->legacy_read_symtab;
+ subpst->legacy_expand_psymtab = pst->legacy_expand_psymtab;
}
if (num_includes == 0
&& number_dependencies == 0
- && pst->n_global_syms == 0
- && pst->n_static_syms == 0)
+ && pst->empty ())
{
- /* Throw away this psymtab, it's empty. We can't deallocate it, since
- it is on the obstack, but we can forget to chain it on the list. */
+ /* Throw away this psymtab, it's empty. */
/* Empty psymtabs happen as a result of header files which don't have
- any symbols in them. There can be a lot of them. */
+ any symbols in them. There can be a lot of them. */
- discard_psymtab (objfile, pst);
+ objfile->partial_symtabs->discard_psymtab (pst);
/* Indicate that psymtab was thrown away. */
pst = NULL;
if (symbol->n_zeroes)
{
/* If it's exactly E_SYMNMLEN characters long it isn't
- '\0'-terminated. */
+ '\0'-terminated. */
if (symbol->n_name[E_SYMNMLEN - 1] != '\0')
{
/* FIXME: wastes memory for symbols which we don't end up putting
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;
unsigned int nsyms;
/* Current partial symtab */
- struct partial_symtab *pst;
+ legacy_psymtab *pst;
/* List of current psymtab's include files. */
const char **psymtab_include_list;
int includes_used;
/* Index within current psymtab dependency list. */
- struct partial_symtab **dependency_list;
+ legacy_psymtab **dependency_list;
int dependencies_used, dependencies_allocated;
char *sraw_symbol;
int misc_func_recorded = 0; /* true if any misc. function. */
int textlow_not_set = 1;
- pst = (struct partial_symtab *) 0;
+ pst = (legacy_psymtab *) 0;
includes_allocated = 30;
includes_used = 0;
dependencies_allocated = 30;
dependencies_used = 0;
dependency_list =
- (struct partial_symtab **) alloca (dependencies_allocated *
- sizeof (struct partial_symtab *));
+ (legacy_psymtab **) alloca (dependencies_allocated *
+ sizeof (legacy_psymtab *));
set_last_source_file (NULL);
switch (p[1])
{
case 'S':
- if (gdbarch_static_transform_name_p (gdbarch))
- namestring = gdbarch_static_transform_name
- (gdbarch, namestring);
-
- add_psymbol_to_list (namestring, p - namestring, true,
- VAR_DOMAIN, LOC_STATIC,
- SECT_OFF_DATA (objfile),
- psymbol_placement::STATIC,
- symbol.n_value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
+ psymbol_placement::STATIC,
+ symbol.n_value,
+ psymtab_language, objfile);
continue;
case 'G':
/* The addresses in these entries are reported to be
wrong. See the code that reads 'G's for symtabs. */
- add_psymbol_to_list (namestring, p - namestring, true,
- VAR_DOMAIN, LOC_STATIC,
- SECT_OFF_DATA (objfile),
- psymbol_placement::GLOBAL,
- symbol.n_value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
+ psymbol_placement::GLOBAL,
+ symbol.n_value,
+ psymtab_language, objfile);
continue;
case 'T':
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list (namestring, p - namestring, true,
- STRUCT_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
- add_psymbol_to_list (namestring, p - namestring, true,
- VAR_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
p += 1;
}
}
case 't':
if (p != namestring) /* a name is there, not just :T... */
{
- add_psymbol_to_list (namestring, p - namestring, true,
- VAR_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
}
check_enum:
/* If this is an enumerated type, we need to
;
/* Note that the value doesn't matter for
enum constants in psymtabs, just in symtabs. */
- add_psymbol_to_list (p, q - p, true,
- VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (p, q - p), true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
/* Point past the name. */
p = q;
/* Skip over the value. */
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (namestring, p - namestring, true,
- VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
continue;
case 'f':
function_outside_compilation_unit_complaint (name);
xfree (name);
}
- add_psymbol_to_list (namestring, p - namestring, true,
- VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::STATIC,
- symbol.n_value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::STATIC,
+ symbol.n_value,
+ psymtab_language, objfile);
continue;
/* Global functions were ignored here, but now they
if (startswith (namestring, "@FIX"))
continue;
- add_psymbol_to_list (namestring, p - namestring, true,
- VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::GLOBAL,
- symbol.n_value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::GLOBAL,
+ symbol.n_value,
+ psymtab_language, objfile);
continue;
/* Two things show up here (hopefully); static symbols of
if (val != size)
perror_with_name (_("reading symbol table"));
- /* 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
- include N_SLINE. */
- init_psymbol_list (objfile, num_symbols);
-
scoped_free_pendings free_pending;
minimal_symbol_reader reader (objfile);
us to test whether the associated section exists or not, and then
access it quickly (without searching it again). */
- if (objfile->num_sections == 0)
+ if (objfile->section_offsets.empty ())
return; /* Is that even possible? Better safe than sorry. */
first_section_name = bfd_section_name (objfile->sections[0].the_bfd_section);
return l_nimpid - 1;
}
+void _initialize_xcoffread ();
void
-_initialize_xcoffread (void)
+_initialize_xcoffread ()
{
add_symtab_fns (bfd_target_xcoff_flavour, &xcoff_sym_fns);
}