OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move lookup_block_symbol to block.c, rename to block_lookup_symbol. 

There is another function, lookup_symbol_aux_block, and
the names lookup_block_symbol and lookup_symbol_aux_block don't
convey any real difference between them.

The difference is that lookup_block_symbol lives in the lower level
block API, and lookup_symbol_aux_block lives in the higher level symtab API.
This patch makes this distinction clear.

gdb/ChangeLog:

	* symtab.c (lookup_block_symbol): Moved to ...
	* block.c (block_lookup_symbol):  ... here and renamed.
	All callers updated.
	* block.h (block_lookup_symbol): Declare.
	* symtab.h (lookup_block_symbol): Delete.
This commit is contained in:
Doug Evans 2014-11-06 22:32:25 -08:00
parent 4057240502
commit 16b2eaa164
8 changed files with 85 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gdb/ChangeLog
View File

@ -1,3 +1,11 @@
2014-11-06 Doug Evans <xdje42@gmail.com>
* symtab.c (lookup_block_symbol): Moved to ...
* block.c (block_lookup_symbol): ... here and renamed.
All callers updated.
* block.h (block_lookup_symbol): Declare.
* symtab.h (lookup_block_symbol): Delete.
2014-11-06 Doug Evans <xdje42@gmail.com>
* ada-lang.c (ada_make_symbol_completion_list): Use

58
gdb/block.c
View File

@ -685,3 +685,61 @@ block_iter_match_next (const char *name,
return block_iter_match_step (iterator, name, compare, 0);
}
/* See block.h.
Note that if NAME is the demangled form of a C++ symbol, we will fail
to find a match during the binary search of the non-encoded names, but
for now we don't worry about the slight inefficiency of looking for
a match we'll never find, since it will go pretty quick. Once the
binary search terminates, we drop through and do a straight linear
search on the symbols. Each symbol which is marked as being a ObjC/C++
symbol (language_cplus or language_objc set) has both the encoded and
non-encoded names tested for a match. */
struct symbol *
block_lookup_symbol (const struct block *block, const char *name,
const domain_enum domain)
{
struct block_iterator iter;
struct symbol *sym;
if (!BLOCK_FUNCTION (block))
{
for (sym = block_iter_name_first (block, name, &iter);
sym != NULL;
sym = block_iter_name_next (name, &iter))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
return sym;
}
return NULL;
}
else
{
/* Note that parameter symbols do not always show up last in the
list; this loop makes sure to take anything else other than
parameter symbols first; it only uses parameter symbols as a
last resort. Note that this only takes up extra computation
time on a match. */
struct symbol *sym_found = NULL;
for (sym = block_iter_name_first (block, name, &iter);
sym != NULL;
sym = block_iter_name_next (name, &iter))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
{
sym_found = sym;
if (!SYMBOL_IS_ARGUMENT (sym))
{
break;
}
}
}
return (sym_found); /* Will be NULL if not found. */
}
}

6
gdb/block.h
View File

@ -271,6 +271,12 @@ extern struct symbol *block_iter_match_next (const char *name,
symbol_compare_ftype *compare,
struct block_iterator *iterator);
/* Search BLOCK for symbol NAME in DOMAIN. */
extern struct symbol *block_lookup_symbol (const struct block *block,
const char *name,
const domain_enum domain);
/* Macro to loop through all symbols in BLOCK, in no particular
order. ITER helps keep track of the iteration, and must be a
struct block_iterator. SYM points to the current symbol. */

2
gdb/dwarf2read.c
View File

@ -3616,7 +3616,7 @@ dw2_lookup_symbol (struct objfile *objfile, int block_index,
const struct blockvector *bv = BLOCKVECTOR (stab);
struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
sym = lookup_block_symbol (block, name, domain);
sym = block_lookup_symbol (block, name, domain);
}
if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)

6
gdb/psymtab.c
View File

@ -519,7 +519,7 @@ lookup_symbol_aux_psymtabs (struct objfile *objfile,
const struct blockvector *bv = BLOCKVECTOR (stab);
struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
sym = lookup_block_symbol (block, name, domain);
sym = block_lookup_symbol (block, name, domain);
}
if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
@ -2038,7 +2038,7 @@ maintenance_check_psymtabs (char *ignore, int from_tty)
length = ps->n_static_syms;
while (length--)
{
sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
SYMBOL_DOMAIN (*psym));
if (!sym)
{
@ -2055,7 +2055,7 @@ maintenance_check_psymtabs (char *ignore, int from_tty)
length = ps->n_global_syms;
while (length--)
{
sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
SYMBOL_DOMAIN (*psym));
if (!sym)
{

2
gdb/spu-tdep.c
View File

@ -1987,7 +1987,7 @@ spu_catch_start (struct objfile *objfile)
struct symbol *sym;
struct symtab_and_line sal;
sym = lookup_block_symbol (block, "main", VAR_DOMAIN);
sym = block_lookup_symbol (block, "main", VAR_DOMAIN);
if (sym)
{
fixup_symbol_section (sym, objfile);

74
gdb/symtab.c
View File

@ -1344,7 +1344,7 @@ lookup_language_this (const struct language_defn *lang,
{
struct symbol *sym;
sym = lookup_block_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
sym = block_lookup_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
if (sym != NULL)
{
block_found = block;
@ -1572,7 +1572,7 @@ lookup_symbol_aux_block (const char *name, const struct block *block,
{
struct symbol *sym;
sym = lookup_block_symbol (block, name, domain);
sym = block_lookup_symbol (block, name, domain);
if (sym)
{
block_found = block;
@ -1604,7 +1604,7 @@ lookup_global_symbol_from_objfile (const struct objfile *main_objfile,
{
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
sym = lookup_block_symbol (block, name, domain);
sym = block_lookup_symbol (block, name, domain);
if (sym)
{
block_found = block;
@ -1639,7 +1639,7 @@ lookup_symbol_aux_objfile (struct objfile *objfile, int block_index,
{
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, block_index);
sym = lookup_block_symbol (block, name, domain);
sym = block_lookup_symbol (block, name, domain);
if (sym)
{
block_found = block;
@ -1747,7 +1747,7 @@ lookup_symbol_aux_quick (struct objfile *objfile, int block_index,
bv = BLOCKVECTOR (symtab);
block = BLOCKVECTOR_BLOCK (bv, block_index);
sym = lookup_block_symbol (block, name, domain);
sym = block_lookup_symbol (block, name, domain);
if (!sym)
error_in_psymtab_expansion (block_index, name, symtab);
block_found = block;
@ -1931,7 +1931,7 @@ basic_lookup_transparent_type_quick (struct objfile *objfile, int block_index,
bv = BLOCKVECTOR (symtab);
block = BLOCKVECTOR_BLOCK (bv, block_index);
sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
sym = block_lookup_symbol (block, name, STRUCT_DOMAIN);
if (!sym)
error_in_psymtab_expansion (block_index, name, symtab);
@ -1968,7 +1968,7 @@ basic_lookup_transparent_type (const char *name)
{
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
sym = block_lookup_symbol (block, name, STRUCT_DOMAIN);
if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
{
return SYMBOL_TYPE (sym);
@ -1996,7 +1996,7 @@ basic_lookup_transparent_type (const char *name)
{
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
sym = block_lookup_symbol (block, name, STRUCT_DOMAIN);
if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
{
return SYMBOL_TYPE (sym);
@ -2014,64 +2014,6 @@ basic_lookup_transparent_type (const char *name)
return (struct type *) 0;
}
/* See symtab.h.
Note that if NAME is the demangled form of a C++ symbol, we will fail
to find a match during the binary search of the non-encoded names, but
for now we don't worry about the slight inefficiency of looking for
a match we'll never find, since it will go pretty quick. Once the
binary search terminates, we drop through and do a straight linear
search on the symbols. Each symbol which is marked as being a ObjC/C++
symbol (language_cplus or language_objc set) has both the encoded and
non-encoded names tested for a match. */
struct symbol *
lookup_block_symbol (const struct block *block, const char *name,
const domain_enum domain)
{
struct block_iterator iter;
struct symbol *sym;
if (!BLOCK_FUNCTION (block))
{
for (sym = block_iter_name_first (block, name, &iter);
sym != NULL;
sym = block_iter_name_next (name, &iter))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
return sym;
}
return NULL;
}
else
{
/* Note that parameter symbols do not always show up last in the
list; this loop makes sure to take anything else other than
parameter symbols first; it only uses parameter symbols as a
last resort. Note that this only takes up extra computation
time on a match. */
struct symbol *sym_found = NULL;
for (sym = block_iter_name_first (block, name, &iter);
sym != NULL;
sym = block_iter_name_next (name, &iter))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
{
sym_found = sym;
if (!SYMBOL_IS_ARGUMENT (sym))
{
break;
}
}
}
return (sym_found); /* Will be NULL if not found. */
}
}
/* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
For each symbol that matches, CALLBACK is called. The symbol and

5
gdb/symtab.h
View File

@ -1125,11 +1125,6 @@ extern struct symbol *lookup_language_this (const struct language_defn *lang,
extern struct symbol *lookup_static_symbol_aux (const char *name,
const domain_enum domain);
/* Search BLOCK for symbol NAME in DOMAIN. */
extern struct symbol *lookup_block_symbol (const struct block *, const char *,
const domain_enum);
/* Lookup a [struct, union, enum] by name, within a specified block. */
extern struct type *lookup_struct (const char *, const struct block *);