/* Support routines for building symbol tables in GDB's internal format.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
struct block *block;
};
-static int compare_line_numbers (const void *ln1p, const void *ln2p);
-
/* Initial sizes of data structures. These are realloc'd larger if
needed, and realloc'd down to the size actually used, when
completed. */
{
if (m_pending_macros == nullptr)
m_pending_macros = new_macro_table (&m_objfile->per_bfd->storage_obstack,
- m_objfile->per_bfd->macro_cache,
+ &m_objfile->per_bfd->macro_cache,
m_compunit_symtab);
return m_pending_macros;
}
struct pending *link;
/* If this is an alias for another symbol, don't add it. */
- if (symbol->ginfo.name && symbol->ginfo.name[0] == '#')
+ if (symbol->name && symbol->name[0] == '#')
return;
/* We keep PENDINGSIZE symbols in each link of the list. If we
{
for (j = list->nsyms; --j >= 0;)
{
- pp = SYMBOL_LINKAGE_NAME (list->symbol[j]);
+ pp = list->symbol[j]->linkage_name ();
if (*pp == *name && strncmp (pp, name, length) == 0
&& pp[length] == '\0')
{
if (symbol)
{
- BLOCK_DICT (block)
- = dict_create_linear (&m_objfile->objfile_obstack,
- m_language, *listhead);
+ BLOCK_MULTIDICT (block)
+ = mdict_create_linear (&m_objfile->objfile_obstack, *listhead);
}
else
{
if (expandable)
{
- BLOCK_DICT (block) = dict_create_hashed_expandable (m_language);
- dict_add_pending (BLOCK_DICT (block), *listhead);
+ BLOCK_MULTIDICT (block) = mdict_create_hashed_expandable (m_language);
+ mdict_add_pending (BLOCK_MULTIDICT (block), *listhead);
}
else
{
- BLOCK_DICT (block) =
- dict_create_hashed (&m_objfile->objfile_obstack,
- m_language, *listhead);
+ BLOCK_MULTIDICT (block) =
+ mdict_create_hashed (&m_objfile->objfile_obstack, *listhead);
}
}
if (symbol)
{
struct type *ftype = SYMBOL_TYPE (symbol);
- struct dict_iterator iter;
+ struct mdict_iterator miter;
SYMBOL_BLOCK_VALUE (symbol) = block;
BLOCK_FUNCTION (block) = symbol;
/* Here we want to directly access the dictionary, because
we haven't fully initialized the block yet. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
{
if (SYMBOL_IS_ARGUMENT (sym))
nparams++;
iparams = 0;
/* Here we want to directly access the dictionary, because
we haven't fully initialized the block yet. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
{
if (iparams == nparams)
break;
{
complaint (_("block end address less than block "
"start address in %s (patched it)"),
- SYMBOL_PRINT_NAME (symbol));
+ symbol->print_name ());
}
else
{
if (symbol)
{
complaint (_("inner block not inside outer block in %s"),
- SYMBOL_PRINT_NAME (symbol));
+ symbol->print_name ());
}
else
{
/* Needed in order to sort line tables from IBM xcoff files. Sigh! */
-static int
-compare_line_numbers (const void *ln1p, const void *ln2p)
+static bool
+lte_is_less_than (const linetable_entry &ln1, const linetable_entry &ln2)
{
- struct linetable_entry *ln1 = (struct linetable_entry *) ln1p;
- struct linetable_entry *ln2 = (struct linetable_entry *) ln2p;
-
/* Note: this code does not assume that CORE_ADDRs can fit in ints.
Please keep it that way. */
- if (ln1->pc < ln2->pc)
- return -1;
+ if (ln1.pc < ln2.pc)
+ return true;
- if (ln1->pc > ln2->pc)
- return 1;
+ if (ln1.pc > ln2.pc)
+ return false;
/* If pc equal, sort by line. I'm not sure whether this is optimum
behavior (see comment at struct linetable in symtab.h). */
- return ln1->line - ln2->line;
+ return ln1.line < ln2.line;
}
\f
/* Subroutine of end_symtab to simplify it. Look for a subfile that
int section, int expandable)
{
struct compunit_symtab *cu = m_compunit_symtab;
- struct symtab *symtab;
struct blockvector *blockvector;
struct subfile *subfile;
CORE_ADDR end_addr;
scrambled in reordered executables. Sort it if
OBJF_REORDERED is true. */
if (m_objfile->flags & OBJF_REORDERED)
- qsort (subfile->line_vector->item,
- subfile->line_vector->nitems,
- sizeof (struct linetable_entry), compare_line_numbers);
+ std::sort (subfile->line_vector->item,
+ subfile->line_vector->item
+ + subfile->line_vector->nitems,
+ lte_is_less_than);
}
/* Allocate a symbol table if necessary. */
if (subfile->symtab == NULL)
subfile->symtab = allocate_symtab (cu, subfile->name);
- symtab = subfile->symtab;
+ struct symtab *symtab = subfile->symtab;
/* Fill in its components. */
main_symtab = m_main_subfile->symtab;
prev_symtab = NULL;
- ALL_COMPUNIT_FILETABS (cu, symtab)
+ for (symtab *symtab : compunit_filetabs (cu))
{
if (symtab == main_symtab)
{
{
/* Reallocate the dirname on the symbol obstack. */
const char *comp_dir = m_comp_dir.get ();
- COMPUNIT_DIRNAME (cu)
- = (const char *) obstack_copy0 (&m_objfile->objfile_obstack,
- comp_dir, strlen (comp_dir));
+ COMPUNIT_DIRNAME (cu) = obstack_strdup (&m_objfile->objfile_obstack,
+ comp_dir);
}
/* Save the debug format string (if any) in the symtab. */
int block_i;
/* The main source file's symtab. */
- symtab = COMPUNIT_FILETABS (cu);
+ struct symtab *symtab = COMPUNIT_FILETABS (cu);
for (block_i = 0; block_i < BLOCKVECTOR_NBLOCKS (blockvector); block_i++)
{
struct block *block = BLOCKVECTOR_BLOCK (blockvector, block_i);
struct symbol *sym;
- struct dict_iterator iter;
+ struct mdict_iterator miter;
/* Inlined functions may have symbols not in the global or
static symbol lists. */
/* Note that we only want to fix up symbols from the local
blocks, not blocks coming from included symtabs. That is why
we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
if (symbol_symtab (sym) == NULL)
symbol_set_symtab (sym, symtab);
}
to the primary symtab. */
set_missing_symtab (m_file_symbols, cust);
- dict_add_pending (BLOCK_DICT (block), m_file_symbols);
+ mdict_add_pending (BLOCK_MULTIDICT (block), m_file_symbols);
}
if (m_global_symbols != NULL)
to the primary symtab. */
set_missing_symtab (m_global_symbols, cust);
- dict_add_pending (BLOCK_DICT (block),
+ mdict_add_pending (BLOCK_MULTIDICT (block),
m_global_symbols);
}
}