static struct block_symbol
cp_basic_lookup_symbol (const char *name, const struct block *block,
const domain_enum domain, int is_in_anonymous)
{
struct block_symbol sym;
sym = lookup_symbol_in_static_block (name, block, domain);
if (sym.symbol != NULL)
return sym;
if (is_in_anonymous)
{
/* Symbols defined in anonymous namespaces have external linkage
but should be treated as local to a single file nonetheless.
So we only search the current file's global block. */
const struct block *global_block = block_global_block (block);
if (global_block != NULL)
{
sym.symbol = lookup_symbol_in_block (name, global_block, domain);
sym.block = global_block;
}
}
else
sym = lookup_global_symbol (name, block, domain);
return sym;
}
static struct block_symbol
find_symbol_in_baseclass (struct type *parent_type, const char *name,
const struct block *block)
{
char *concatenated_name = NULL;
struct block_symbol sym;
struct cleanup *cleanup;
int i;
sym.symbol = NULL;
sym.block = NULL;
cleanup = make_cleanup (free_current_contents, &concatenated_name);
for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
{
size_t len;
struct type *base_type = TYPE_BASECLASS (parent_type, i);
const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
if (base_name == NULL)
continue;
/* Search this particular base class. */
sym = d_lookup_symbol_in_module (base_name, name, block,
VAR_DOMAIN, 0);
if (sym.symbol != NULL)
break;
/* Now search all static file-level symbols. We have to do this for
things like typedefs in the class. First search in this symtab,
what we want is possibly there. */
len = strlen (base_name) + strlen (name) + 2;
concatenated_name = (char *) xrealloc (concatenated_name, len);
xsnprintf (concatenated_name, len, "%s.%s", base_name, name);
sym = lookup_symbol_in_static_block (concatenated_name, block,
VAR_DOMAIN);
if (sym.symbol != NULL)
break;
/* Nope. We now have to search all static blocks in all objfiles,
even if block != NULL, because there's no guarantees as to which
symtab the symbol we want is in. */
sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
if (sym.symbol != NULL)
break;
/* If this class has base classes, search them next. */
base_type = check_typedef (base_type);
if (TYPE_N_BASECLASSES (base_type) > 0)
{
sym = find_symbol_in_baseclass (base_type, name, block);
if (sym.symbol != NULL)
break;
}
}
do_cleanups (cleanup);
return sym;
}
static struct block_symbol
cp_lookup_bare_symbol (const struct language_defn *langdef,
const char *name, const struct block *block,
const domain_enum domain, int search)
{
struct block_symbol sym;
/* Note: We can't do a simple assert for ':' not being in NAME because
':' may be in the args of a template spec. This isn't intended to be
a complete test, just cheap and documentary. */
if (strchr (name, '<') == NULL && strchr (name, '(') == NULL)
gdb_assert (strchr (name, ':') == NULL);
sym = lookup_symbol_in_static_block (name, block, domain);
if (sym.symbol != NULL)
return sym;
/* If we didn't find a definition for a builtin type in the static block,
search for it now. This is actually the right thing to do and can be
a massive performance win. E.g., when debugging a program with lots of
shared libraries we could search all of them only to find out the
builtin type isn't defined in any of them. This is common for types
like "void". */
if (langdef != NULL && domain == VAR_DOMAIN)
{
struct gdbarch *gdbarch;
if (block == NULL)
gdbarch = target_gdbarch ();
else
gdbarch = block_gdbarch (block);
sym.symbol
= language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
sym.block = NULL;
if (sym.symbol != NULL)
return sym;
}
sym = lookup_global_symbol (name, block, domain);
if (sym.symbol != NULL)
return sym;
if (search)
{
struct block_symbol lang_this;
struct type *type;
lang_this = lookup_language_this (language_def (language_cplus), block);
if (lang_this.symbol == NULL)
return null_block_symbol;
type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
/* If TYPE_NAME is NULL, abandon trying to find this symbol.
This can happen for lambda functions compiled with clang++,
which outputs no name for the container class. */
if (TYPE_NAME (type) == NULL)
return null_block_symbol;
/* Look for symbol NAME in this class. */
sym = cp_lookup_nested_symbol (type, name, block, domain);
}
return sym;
}
static struct block_symbol
d_lookup_symbol (const struct language_defn *langdef,
const char *name, const struct block *block,
const domain_enum domain, int search)
{
struct block_symbol sym;
sym = lookup_symbol_in_static_block (name, block, domain);
if (sym.symbol != NULL)
return sym;
/* If we didn't find a definition for a builtin type in the static block,
such as "ucent" which is a specialist type, search for it now. */
if (langdef != NULL && domain == VAR_DOMAIN)
{
struct gdbarch *gdbarch;
if (block == NULL)
gdbarch = target_gdbarch ();
else
gdbarch = block_gdbarch (block);
sym.symbol
= language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
sym.block = NULL;
if (sym.symbol != NULL)
return sym;
}
sym = lookup_global_symbol (name, block, domain);
if (sym.symbol != NULL)
return sym;
if (search)
{
char *classname, *nested;
unsigned int prefix_len;
struct cleanup *cleanup;
struct block_symbol class_sym;
/* A simple lookup failed. Check if the symbol was defined in
a base class. */
cleanup = make_cleanup (null_cleanup, NULL);
/* Find the name of the class and the name of the method,
variable, etc. */
prefix_len = d_entire_prefix_len (name);
/* If no prefix was found, search "this". */
if (prefix_len == 0)
{
struct type *type;
struct block_symbol lang_this;
lang_this = lookup_language_this (language_def (language_d), block);
if (lang_this.symbol == NULL)
{
do_cleanups (cleanup);
return null_block_symbol;
}
type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
classname = xstrdup (TYPE_NAME (type));
nested = xstrdup (name);
}
else
{
/* The class name is everything up to and including PREFIX_LEN. */
classname = savestring (name, prefix_len);
/* The rest of the name is everything else past the initial scope
operator. */
nested = xstrdup (name + prefix_len + 1);
}
/* Add cleanups to free memory for these strings. */
make_cleanup (xfree, classname);
make_cleanup (xfree, nested);
/* Lookup a class named CLASSNAME. If none is found, there is nothing
more that can be done. */
class_sym = lookup_global_symbol (classname, block, domain);
if (class_sym.symbol == NULL)
{
do_cleanups (cleanup);
return null_block_symbol;
}
/* Look for a symbol named NESTED in this class. */
sym = d_lookup_nested_symbol (SYMBOL_TYPE (class_sym.symbol),
nested, block);
do_cleanups (cleanup);
}
return sym;
}
