yggdrasil/binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Simplify block_find_symbol

Browse Source 
block_find_symbol takes a callback function, but only two callbacks
are ever passed to it -- and they are similar enough that it seems
cleaner to just have block_find_symbol do the work itself.  Also,
block_find_symbol can take a lookup_name_info as an argument,
following the general idea of pushing the construction of these
objects as high in the call chain as feasible.

Regression tested on x86-64 Fedora 38.

Tested-By: Alexandra Petlanova Hajkova <ahajkova@redhat.com>
This commit is contained in:
Tom Tromey 2023-03-30 08:41:17 -06:00
parent def2803789
commit b7a92724c5
4 changed files with 27 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
gdb/block.c
View File

@ -778,46 +778,25 @@ block_lookup_symbol_primary (const struct block *block, const char *name,
/* See block.h. */
struct symbol *
block_find_symbol (const struct block *block, const char *name,
const domain_enum domain,
block_symbol_matcher_ftype *matcher, void *data)
block_find_symbol (const struct block *block, const lookup_name_info &name,
const domain_enum domain, struct symbol **stub)
{
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
/* Verify BLOCK is STATIC_BLOCK or GLOBAL_BLOCK. */
gdb_assert (block->superblock () == NULL
|| block->superblock ()->superblock () == NULL);
for (struct symbol *sym : block_iterator_range (block, &lookup_name))
for (struct symbol *sym : block_iterator_range (block, &name))
{
/* MATCHER is deliberately called second here so that it never sees
a non-domain-matching symbol. */
if (sym->matches (domain)
&& matcher (sym, data))
if (!sym->matches (domain))
continue;
if (!TYPE_IS_OPAQUE (sym->type ()))
return sym;
if (stub != nullptr)
*stub = sym;
}
return NULL;
}
/* See block.h. */
int
block_find_non_opaque_type (struct symbol *sym, void *data)
{
return !TYPE_IS_OPAQUE (sym->type ());
}
/* See block.h. */
int
block_find_non_opaque_type_preferred (struct symbol *sym, void *data)
{
struct symbol **best = (struct symbol **) data;
if (!TYPE_IS_OPAQUE (sym->type ()))
return 1;
*best = sym;
return 0;
return nullptr;
}
/* See block.h. */

36
gdb/block.h
View File

@ -556,39 +556,15 @@ extern struct symbol *block_lookup_symbol_primary (const struct block *block,
const char *name,
const domain_enum domain);
/* The type of the MATCHER argument to block_find_symbol. */
typedef int (block_symbol_matcher_ftype) (struct symbol *, void *);
/* Find symbol NAME in BLOCK and in DOMAIN that satisfies MATCHER.
DATA is passed unchanged to MATCHER.
BLOCK must be STATIC_BLOCK or GLOBAL_BLOCK. */
/* Find symbol NAME in BLOCK and in DOMAIN. This will return a
matching symbol whose type is not a "opaque", see TYPE_IS_OPAQUE.
If STUB is non-NULL, an otherwise matching symbol whose type is a
opaque will be stored here. */
extern struct symbol *block_find_symbol (const struct block *block,
const char *name,
const lookup_name_info &name,
const domain_enum domain,
block_symbol_matcher_ftype *matcher,
void *data);
/* A matcher function for block_find_symbol to find only symbols with
non-opaque types. */
extern int block_find_non_opaque_type (struct symbol *sym, void *data);
/* A matcher function for block_find_symbol to prefer symbols with
non-opaque types. The way to use this function is as follows:
struct symbol *with_opaque = NULL;
struct symbol *sym
= block_find_symbol (block, name, domain,
block_find_non_opaque_type_preferred, &with_opaque);
At this point if SYM is non-NULL then a non-opaque type has been found.
Otherwise, if WITH_OPAQUE is non-NULL then an opaque type has been found.
Otherwise, the symbol was not found. */
extern int block_find_non_opaque_type_preferred (struct symbol *sym,
void *data);
struct symbol **stub);
/* Given a vector of pairs, allocate and build an obstack allocated
blockranges struct for a block. */

10
gdb/symfile-debug.c
View File

@ -260,23 +260,19 @@ objfile::lookup_symbol (block_enum kind, const char *name, domain_enum domain)
const struct blockvector *bv = stab->blockvector ();
const struct block *block = bv->block (kind);
sym = block_find_symbol (block, name, domain,
block_find_non_opaque_type_preferred,
&with_opaque);
sym = block_find_symbol (block, lookup_name, domain, &with_opaque);
/* Some caution must be observed with overloaded functions
and methods, since the index will not contain any overload
information (but NAME might contain it). */
if (sym != NULL
&& symbol_matches_search_name (sym, lookup_name))
if (sym != nullptr)
{
retval = stab;
/* Found it. */
return false;
}
if (with_opaque != NULL
&& symbol_matches_search_name (with_opaque, lookup_name))
if (with_opaque != nullptr)
retval = stab;
/* Keep looking through other psymtabs. */

13
gdb/symtab.c
View File

@ -2679,9 +2679,10 @@ basic_lookup_transparent_type_quick (struct objfile *objfile,
bv = cust->blockvector ();
block = bv->block (block_index);
sym = block_find_symbol (block, name, STRUCT_DOMAIN,
block_find_non_opaque_type, NULL);
if (sym == NULL)
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
sym = block_find_symbol (block, lookup_name, STRUCT_DOMAIN, nullptr);
if (sym == nullptr)
error_in_psymtab_expansion (block_index, name, cust);
gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
return sym->type ();
@ -2700,13 +2701,13 @@ basic_lookup_transparent_type_1 (struct objfile *objfile,
const struct block *block;
const struct symbol *sym;
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
for (compunit_symtab *cust : objfile->compunits ())
{
bv = cust->blockvector ();
block = bv->block (block_index);
sym = block_find_symbol (block, name, STRUCT_DOMAIN,
block_find_non_opaque_type, NULL);
if (sym != NULL)
sym = block_find_symbol (block, lookup_name, STRUCT_DOMAIN, nullptr);
if (sym != nullptr)
{
gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
return sym->type ();