struct block_symbol lookup_symbol_nonlocal
(const char *name, const struct block *block,
- const domain_enum domain) const override
+ const domain_search_flags domain) const override
{
struct block_symbol sym;
- domain_search_flags flags = to_search_flags (domain);
- if (domain == VAR_DOMAIN)
- flags |= SEARCH_TYPE_DOMAIN | SEARCH_FUNCTION_DOMAIN;
-
sym = ada_lookup_symbol (name,
(block == nullptr
? nullptr
: block->static_block ()),
- flags);
+ domain);
if (sym.symbol != NULL)
return sym;
languages, we search the primitive types this late and only after
having searched the global symbols without success. */
- if (domain == VAR_DOMAIN)
+ if ((domain & SEARCH_TYPE_DOMAIN) != 0)
{
struct gdbarch *gdbarch;
C-like) lookups to get the first match. */
struct symbol *atcb_sym =
- lookup_symbol_in_language (atcb_name, NULL, STRUCT_DOMAIN,
+ lookup_symbol_in_language (atcb_name, NULL, SEARCH_STRUCT_DOMAIN,
language_c, NULL).symbol;
const struct symbol *common_atcb_sym =
- lookup_symbol_in_language (common_atcb_name, NULL, STRUCT_DOMAIN,
+ lookup_symbol_in_language (common_atcb_name, NULL, SEARCH_STRUCT_DOMAIN,
language_c, NULL).symbol;
const struct symbol *private_data_sym =
- lookup_symbol_in_language (private_data_name, NULL, STRUCT_DOMAIN,
+ lookup_symbol_in_language (private_data_name, NULL, SEARCH_STRUCT_DOMAIN,
language_c, NULL).symbol;
const struct symbol *entry_call_record_sym =
- lookup_symbol_in_language (entry_call_record_name, NULL, STRUCT_DOMAIN,
+ lookup_symbol_in_language (entry_call_record_name, NULL,
+ SEARCH_STRUCT_DOMAIN,
language_c, NULL).symbol;
if (atcb_sym == NULL || atcb_sym->type () == NULL)
/* In Ravenscar run-time libs, the ATCB does not have a dynamic
size, so the symbol name differs. */
atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL,
- STRUCT_DOMAIN, language_c,
+ SEARCH_STRUCT_DOMAIN, language_c,
NULL).symbol;
if (atcb_sym == NULL || atcb_sym->type () == NULL)
data->known_tasks_addr = msym.value_address ();
/* Try to get pointer type and array length from the symtab. */
- sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL, VAR_DOMAIN,
+ sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL,
+ SEARCH_VAR_DOMAIN,
language_c, NULL).symbol;
if (sym != NULL)
{
data->known_tasks_addr = msym.value_address ();
data->known_tasks_length = 1;
- sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL, VAR_DOMAIN,
+ sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL,
+ SEARCH_VAR_DOMAIN,
language_c, NULL).symbol;
if (sym != NULL && sym->value_address () != 0)
{
symbol reading. */
sym = NULL;
else
- sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN,
+ sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, SEARCH_LABEL_DOMAIN,
0).symbol;
}
else
{
const char *phys_name = type->field (fieldno).loc_physname ();
- struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0).symbol;
+ struct symbol *sym = lookup_symbol (phys_name, 0,
+ SEARCH_VAR_DOMAIN, 0).symbol;
if (sym)
{
sym = cp_lookup_symbol_namespace (namespace_name, name,
block_for_pc (ax->scope),
- VAR_DOMAIN);
+ SEARCH_VAR_DOMAIN);
if (sym.symbol == NULL)
return 0;
/* See block.h. */
bool
-best_symbol (struct symbol *a, const domain_enum domain)
+best_symbol (struct symbol *a, const domain_search_flags domain)
{
- return (a->domain () == domain
- && a->aclass () != LOC_UNRESOLVED);
+ if (a->aclass () == LOC_UNRESOLVED)
+ return false;
+
+ if ((domain & SEARCH_VAR_DOMAIN) != 0)
+ return a->domain () == VAR_DOMAIN;
+
+ return a->matches (domain);
}
/* See block.h. */
struct symbol *
-better_symbol (struct symbol *a, struct symbol *b, const domain_enum domain)
+better_symbol (struct symbol *a, struct symbol *b,
+ const domain_search_flags domain)
{
if (a == NULL)
return b;
if (b == NULL)
return a;
- if (a->domain () == domain && b->domain () != domain)
+ if (a->matches (domain) && !b->matches (domain))
return a;
- if (b->domain () == domain && a->domain () != domain)
+ if (b->matches (domain) && !a->matches (domain))
return b;
if (a->aclass () != LOC_UNRESOLVED && b->aclass () == LOC_UNRESOLVED)
struct symbol *
block_lookup_symbol (const struct block *block, const char *name,
symbol_name_match_type match_type,
- const domain_enum domain)
+ const domain_search_flags domain)
{
lookup_name_info lookup_name (name, match_type);
struct symbol *
block_lookup_symbol_primary (const struct block *block, const char *name,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct symbol *sym, *other;
struct mdict_iterator mdict_iter;
struct symbol *
block_find_symbol (const struct block *block, const lookup_name_info &name,
- const domain_enum domain, struct symbol **stub)
+ const domain_search_flags domain, struct symbol **stub)
{
/* Verify BLOCK is STATIC_BLOCK or GLOBAL_BLOCK. */
gdb_assert (block->superblock () == NULL
/* Return true if symbol A is the best match possible for DOMAIN. */
-extern bool best_symbol (struct symbol *a, const domain_enum domain);
+extern bool best_symbol (struct symbol *a, const domain_search_flags domain);
/* Return symbol B if it is a better match than symbol A for DOMAIN.
Otherwise return A. */
extern struct symbol *better_symbol (struct symbol *a, struct symbol *b,
- const domain_enum domain);
+ const domain_search_flags domain);
/* Search BLOCK for symbol NAME in DOMAIN. */
extern struct symbol *block_lookup_symbol (const struct block *block,
const char *name,
symbol_name_match_type match_type,
- const domain_enum domain);
+ const domain_search_flags domain);
/* Search BLOCK for symbol NAME in DOMAIN but only in primary symbol table of
BLOCK. BLOCK must be STATIC_BLOCK or GLOBAL_BLOCK. Function is useful if
one iterates all global/static blocks of an objfile. */
-extern struct symbol *block_lookup_symbol_primary (const struct block *block,
- const char *name,
- const domain_enum domain);
+extern struct symbol *block_lookup_symbol_primary
+ (const struct block *block,
+ const char *name,
+ const domain_search_flags domain);
/* Find symbol NAME in BLOCK and in DOMAIN. This will return a
matching symbol whose type is not a "opaque", see TYPE_IS_OPAQUE.
extern struct symbol *block_find_symbol (const struct block *block,
const lookup_name_info &name,
- const domain_enum domain,
+ const domain_search_flags domain,
struct symbol **stub);
/* Given a vector of pairs, allocate and build an obstack allocated
std::string copy = copy_name ($3);
struct symbol *tem
= lookup_symbol (copy.c_str (), $1,
- VAR_DOMAIN, NULL).symbol;
+ SEARCH_FUNCTION_DOMAIN,
+ nullptr).symbol;
- if (!tem || tem->aclass () != LOC_BLOCK)
+ if (tem == nullptr)
error (_("No function \"%s\" in specified context."),
copy.c_str ());
$$ = tem->value_block (); }
std::string copy = copy_name ($3);
struct block_symbol sym
= lookup_symbol (copy.c_str (), $1,
- VAR_DOMAIN, NULL);
+ SEARCH_VFT, NULL);
if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
struct block_symbol sym
= lookup_symbol (name.c_str (),
(const struct block *) NULL,
- VAR_DOMAIN, NULL);
+ SEARCH_VFT, NULL);
pstate->push_symbol (name.c_str (), sym);
}
;
$$.sym
= lookup_symbol ($1.ptr,
pstate->expression_context_block,
- VAR_DOMAIN,
+ SEARCH_VFT,
&is_a_field_of_this);
$$.is_a_field_of_this
= is_a_field_of_this.type != NULL;
if (lookup_symbol (copy.c_str (),
pstate->expression_context_block,
- VAR_DOMAIN,
+ SEARCH_VFT,
(par_state->language ()->la_language
== language_cplus ? &is_a_field_of_this
: NULL)).symbol
we can refer to it unconditionally below. */
memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
- bsym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN,
+ bsym = lookup_symbol (copy.c_str (), block, SEARCH_VFT,
par_state->language ()->name_of_this ()
? &is_a_field_of_this : NULL);
{
struct field_of_this_result inner_is_a_field_of_this;
- bsym = lookup_symbol (copy.c_str (), block, STRUCT_DOMAIN,
+ bsym = lookup_symbol (copy.c_str (), block, SEARCH_STRUCT_DOMAIN,
&inner_is_a_field_of_this);
if (bsym.symbol != NULL)
{
std::string copy = copy_name (yylval.ssym.stoken);
/* N.B. We assume the symbol can only be in VAR_DOMAIN. */
yylval.ssym.sym = cp_lookup_nested_symbol (type, copy.c_str (), block,
- VAR_DOMAIN);
+ SEARCH_VFT);
/* If no symbol was found, search for a matching base class named
COPY. This will allow users to enter qualified names of class members
struct block_symbol lookup_symbol_nonlocal
(const char *name, const struct block *block,
- const domain_enum domain) const override
+ const domain_search_flags domain) const override
{
return cp_lookup_symbol_nonlocal (this, name, block, domain);
}
{
const char *search_name = msymbol.minsym->search_name ();
wsym = lookup_symbol_search_name (search_name, NULL,
- VAR_DOMAIN).symbol;
+ SEARCH_VAR_DOMAIN).symbol;
}
if (wsym)
static void
convert_symbol_sym (compile_c_instance *context, const char *identifier,
- struct block_symbol sym, domain_enum domain)
+ struct block_symbol sym, domain_search_flags domain)
{
int is_local_symbol;
{
compile_c_instance *context
= static_cast<compile_c_instance *> (datum);
- domain_enum domain;
+ domain_search_flags domain;
int found = 0;
switch (request)
{
case GCC_C_ORACLE_SYMBOL:
- domain = VAR_DOMAIN;
+ domain = SEARCH_VFT;
break;
case GCC_C_ORACLE_TAG:
- domain = STRUCT_DOMAIN;
+ domain = SEARCH_STRUCT_DOMAIN;
break;
case GCC_C_ORACLE_LABEL:
- domain = LABEL_DOMAIN;
+ domain = SEARCH_LABEL_DOMAIN;
break;
default:
gdb_assert_not_reached ("Unrecognized oracle request.");
convert_symbol_sym (context, identifier, sym, domain);
found = 1;
}
- else if (domain == VAR_DOMAIN)
+ else if (request == GCC_C_ORACLE_SYMBOL)
{
struct bound_minimal_symbol bmsym;
struct symbol *sym;
/* We only need global functions here. */
- sym = lookup_symbol (identifier, NULL, VAR_DOMAIN, NULL).symbol;
- if (sym != NULL && sym->aclass () == LOC_BLOCK)
+ sym = lookup_symbol (identifier, nullptr, SEARCH_FUNCTION_DOMAIN,
+ nullptr).symbol;
+ if (sym != nullptr)
{
if (compile_debug)
gdb_printf (gdb_stdlog,
static void
convert_symbol_sym (compile_cplus_instance *instance,
const char *identifier, struct block_symbol sym,
- domain_enum domain)
+ domain_search_flags domain)
{
/* If we found a symbol and it is not in the static or global
scope, then we should first convert any static or global scope
This will find variables in the current scope. */
struct block_symbol sym
- = lookup_symbol (identifier, instance->block (), VAR_DOMAIN, nullptr);
+ = lookup_symbol (identifier, instance->block (), SEARCH_VFT, nullptr);
if (sym.symbol != nullptr)
{
found = true;
- convert_symbol_sym (instance, identifier, sym, VAR_DOMAIN);
+ convert_symbol_sym (instance, identifier, sym, SEARCH_VFT);
}
/* Then use linespec.c's multi-symbol search. This should find
{
found = true;
convert_symbol_sym (instance, identifier, it,
- it.symbol->domain ());
+ to_search_flags (it.symbol->domain ()));
}
}
try
{
struct symbol *sym
- = lookup_symbol (identifier, nullptr, VAR_DOMAIN, nullptr).symbol;
+ = lookup_symbol (identifier, nullptr, SEARCH_FUNCTION_DOMAIN,
+ nullptr).symbol;
- if (sym != nullptr && sym->aclass () == LOC_BLOCK)
+ if (sym != nullptr)
{
if (compile_debug)
gdb_printf (gdb_stdlog,
/* Look up the resulting name. */
struct block_symbol bsymbol
- = lookup_symbol (lookup_name.c_str (), block, VAR_DOMAIN, nullptr);
+ = lookup_symbol (lookup_name.c_str (), block, SEARCH_VFT, nullptr);
if (bsymbol.symbol != nullptr)
{
scope_component comp
= {
decl_name (type->name ()).get (),
- lookup_symbol (type->name (), block (), VAR_DOMAIN, nullptr)
+ lookup_symbol (type->name (), block (), SEARCH_VFT, nullptr)
};
scope.push_back (comp);
}
const char *physname = type->field (i).loc_physname ();
struct block_symbol sym
= lookup_symbol (physname, instance->block (),
- VAR_DOMAIN, nullptr);
+ SEARCH_VFT, nullptr);
if (sym.symbol == nullptr)
{
gcc_type method_type;
struct block_symbol sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (methods, j),
- instance->block (), VAR_DOMAIN, nullptr);
+ instance->block (), SEARCH_VFT, nullptr);
if (sym.symbol == nullptr)
{
gdb_val_sym = block_lookup_symbol (block,
COMPILE_I_EXPR_VAL,
symbol_name_match_type::SEARCH_NAME,
- VAR_DOMAIN);
+ SEARCH_VFT);
if (gdb_val_sym == NULL)
continue;
gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE,
symbol_name_match_type::SEARCH_NAME,
- VAR_DOMAIN);
+ SEARCH_VFT);
if (gdb_ptr_type_sym == NULL)
error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
gdb_ptr_type = gdb_ptr_type_sym->type ();
func_sym = lookup_global_symbol_from_objfile (objfile,
GLOBAL_BLOCK,
GCC_FE_WRAPPER_FUNCTION,
- VAR_DOMAIN).symbol;
+ SEARCH_VFT).symbol;
if (func_sym == NULL)
error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
const char *nested_name,
const char *concatenated_name,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
int basic_lookup, int is_in_anonymous);
static struct type *cp_lookup_transparent_type_loop (const char *name,
static struct block_symbol
cp_basic_lookup_symbol (const char *name, const struct block *block,
- const domain_enum domain, int is_in_anonymous)
+ const domain_search_flags domain, int is_in_anonymous)
{
struct block_symbol 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)
+ const domain_search_flags domain, int search)
{
struct block_symbol sym;
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)
+ if (langdef != nullptr && (domain & SEARCH_TYPE_DOMAIN) != 0)
{
struct gdbarch *gdbarch;
static struct block_symbol
cp_search_static_and_baseclasses (const char *name,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
unsigned int prefix_len,
int is_in_anonymous)
{
symbol_matches_domain (which should be replaced with something
else, but it's what we have today). */
block_symbol scope_sym = lookup_symbol_in_static_block (scope.c_str (),
- block, VAR_DOMAIN);
+ block, SEARCH_VFT);
if (scope_sym.symbol == NULL)
- scope_sym = lookup_global_symbol (scope.c_str (), block, VAR_DOMAIN);
+ scope_sym = lookup_global_symbol (scope.c_str (), block, SEARCH_VFT);
if (scope_sym.symbol == NULL)
return {};
static variable. E.g., "print 'function()::static_var'". */
if ((scope_type->code () == TYPE_CODE_FUNC
|| scope_type->code () == TYPE_CODE_METHOD)
- && domain == VAR_DOMAIN)
+ && (domain & SEARCH_VAR_DOMAIN) != 0)
return lookup_symbol (nested, scope_sym.symbol->value_block (),
- VAR_DOMAIN, NULL);
+ domain, NULL);
/* Look for a symbol named NESTED in this class/namespace.
The caller is assumed to have already have done a basic lookup of NAME.
static struct block_symbol
cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
const struct block *block,
- const domain_enum domain, int search)
+ const domain_search_flags domain, int search)
{
char *concatenated_name = NULL;
int is_in_anonymous;
cp_lookup_symbol_via_imports (const char *scope,
const char *name,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
const int search_scope_first,
const int declaration_only,
const int search_parents,
cp_lookup_symbol_via_imports (const char *scope,
const char *name,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
const int declaration_only,
const int search_parents)
{
cp_lookup_symbol_imports_or_template (const char *scope,
const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct symbol *function = block->function ();
symbol_lookup_debug_printf
("cp_lookup_symbol_imports_or_template (%s, %s, %s, %s)",
- scope, name, host_address_to_string (block), domain_name (domain));
+ scope, name, host_address_to_string (block),
+ domain_name (domain).c_str ());
if (function != NULL && function->language () == language_cplus)
{
static struct block_symbol
cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct block_symbol sym;
cp_lookup_symbol_namespace (const char *scope,
const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct block_symbol sym;
symbol_lookup_debug_printf ("cp_lookup_symbol_namespace (%s, %s, %s, %s)",
scope, name, host_address_to_string (block),
- domain_name (domain));
+ domain_name (domain).c_str ());
/* First, try to find the symbol in the given namespace. */
sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
lookup_namespace_scope (const struct language_defn *langdef,
const char *name,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
const char *scope,
int scope_len)
{
cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct block_symbol sym;
const char *scope = block == nullptr ? "" : block->scope ();
symbol_lookup_debug_printf
("cp_lookup_symbol_non_local (%s, %s (scope %s), %s)",
- name, host_address_to_string (block), scope, domain_name (domain));
+ name, host_address_to_string (block), scope,
+ domain_name (domain).c_str ());
/* First, try to find the symbol in the given namespace, and all
containing namespaces. */
static struct block_symbol
find_symbol_in_baseclass (struct type *parent_type, const char *name,
- const struct block *block, const domain_enum domain,
+ const struct block *block,
+ const domain_search_flags domain,
int is_in_anonymous)
{
int i;
const char *nested_name,
const char *concatenated_name,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
int basic_lookup, int is_in_anonymous)
{
struct block_symbol sym;
cp_lookup_nested_symbol (struct type *parent_type,
const char *nested_name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
/* type_name_or_error provides better error reporting using the
original type. */
symbol_lookup_debug_printf ("cp_lookup_nested_symbol (%s, %s, %s, %s)",
type_name != NULL ? type_name : "unnamed",
nested_name, host_address_to_string (block),
- domain_name (domain));
+ domain_name (domain).c_str ());
}
switch (parent_type->code ())
try
{
- sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, 0, SEARCH_VFT, 0).symbol;
}
catch (const gdb_exception &except)
{
try
{
sym = lookup_symbol (local_name.get (), 0,
- VAR_DOMAIN, 0).symbol;
+ SEARCH_VFT, 0).symbol;
}
catch (const gdb_exception &except)
{
/* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
- rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
+ rtti_sym = lookup_symbol (name, block, SEARCH_VFT, NULL).symbol;
if (rtti_sym == NULL)
{
(const struct language_defn *langdef,
const char *name,
const struct block *block,
- const domain_enum domain);
+ const domain_search_flags domain);
extern struct block_symbol
cp_lookup_symbol_namespace (const char *the_namespace,
const char *name,
const struct block *block,
- const domain_enum domain);
+ const domain_search_flags domain);
extern struct block_symbol cp_lookup_symbol_imports_or_template
(const char *scope,
const char *name,
const struct block *block,
- const domain_enum domain);
+ const domain_search_flags domain);
extern struct block_symbol
cp_lookup_nested_symbol (struct type *parent_type,
const char *nested_name,
const struct block *block,
- const domain_enum domain);
+ const domain_search_flags domain);
struct type *cp_lookup_transparent_type (const char *name);
/* Handle VAR, which could be local or global. */
sym = lookup_symbol (copy.c_str (),
pstate->expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this);
+ SEARCH_VFT, &is_a_field_of_this);
if (sym.symbol && sym.symbol->aclass () != LOC_TYPEDEF)
{
if (symbol_read_needs_frame (sym.symbol))
sym =
lookup_symbol (name.c_str (),
(const struct block *) NULL,
- VAR_DOMAIN, NULL);
+ SEARCH_VFT, NULL);
pstate->push_symbol (name.c_str (), sym);
}
else
std::string copy = copy_name (yylval.sval);
- sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
+ sym = lookup_symbol (copy.c_str (), block, SEARCH_VFT, &is_a_field_of_this);
if (sym.symbol && sym.symbol->aclass () == LOC_TYPEDEF)
{
yylval.tsym.type = sym.symbol->type ();
else if (sym.symbol == NULL)
{
/* Look-up first for a module name, then a type. */
- sym = lookup_symbol (copy.c_str (), block, MODULE_DOMAIN, NULL);
+ sym = lookup_symbol (copy.c_str (), block, SEARCH_MODULE_DOMAIN,
+ nullptr);
if (sym.symbol == NULL)
- sym = lookup_symbol (copy.c_str (), block, STRUCT_DOMAIN, NULL);
+ sym = lookup_symbol (copy.c_str (), block, SEARCH_STRUCT_DOMAIN,
+ nullptr);
if (sym.symbol != NULL)
{
struct block_symbol lookup_symbol_nonlocal
(const char *name, const struct block *block,
- const domain_enum domain) const override
+ const domain_search_flags domain) const override
{
return d_lookup_symbol_nonlocal (this, name, block, domain);
}
/* Defined in d-namespace.c */
-extern struct block_symbol d_lookup_symbol_nonlocal (const struct language_defn *,
- const char *,
- const struct block *,
- const domain_enum);
+extern struct block_symbol d_lookup_symbol_nonlocal
+ (const struct language_defn *,
+ const char *,
+ const struct block *,
+ const domain_search_flags);
extern struct block_symbol d_lookup_nested_symbol (struct type *, const char *,
const struct block *);
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)
+ const domain_search_flags domain, int search)
{
struct block_symbol 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)
+ if (langdef != nullptr && (domain & SEARCH_TYPE_DOMAIN) != 0)
{
struct gdbarch *gdbarch;
static struct block_symbol
d_lookup_symbol_in_module (const char *module, const char *name,
const struct block *block,
- const domain_enum domain, int search)
+ const domain_search_flags domain, int search)
{
char *concatenated_name = NULL;
static struct block_symbol
lookup_module_scope (const struct language_defn *langdef,
const char *name, const struct block *block,
- const domain_enum domain, const char *scope,
+ const domain_search_flags domain, const char *scope,
int scope_len)
{
char *module;
/* Search this particular base class. */
sym = d_lookup_symbol_in_module (base_name, name, block,
- VAR_DOMAIN, 0);
+ SEARCH_VFT, 0);
if (sym.symbol != NULL)
break;
what we want is possibly there. */
std::string concatenated_name = std::string (base_name) + "." + name;
sym = lookup_symbol_in_static_block (concatenated_name.c_str (), block,
- VAR_DOMAIN);
+ SEARCH_VFT);
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.c_str (), VAR_DOMAIN);
+ sym = lookup_static_symbol (concatenated_name.c_str (), SEARCH_VFT);
if (sym.symbol != NULL)
break;
const char *parent_name = type_name_or_error (saved_parent_type);
struct block_symbol sym
= d_lookup_symbol_in_module (parent_name, nested_name,
- block, VAR_DOMAIN, 0);
+ block, SEARCH_VFT, 0);
char *concatenated_name;
if (sym.symbol != NULL)
xsnprintf (concatenated_name, size, "%s.%s",
parent_name, nested_name);
- sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
+ sym = lookup_static_symbol (concatenated_name, SEARCH_VFT);
if (sym.symbol != NULL)
return sym;
static struct block_symbol
d_lookup_symbol_imports (const char *scope, const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct using_direct *current;
struct block_symbol sym;
static struct block_symbol
d_lookup_symbol_module (const char *scope, const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct block_symbol sym;
d_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct block_symbol sym;
const char *scope = block == nullptr ? "" : block->scope ();
{
const char *name = get_imported_name (sym);
block_symbol real_symbol = lookup_global_symbol (name, nullptr,
- VAR_DOMAIN);
+ SEARCH_VFT);
if (real_symbol.symbol == nullptr)
error (_("could not find alias '%s' for function '%s'"),
name, sym->print_name ());
value *
compute_var_value (const char *name)
{
- struct block_symbol sym = lookup_symbol (name, nullptr, VAR_DOMAIN,
+ struct block_symbol sym = lookup_symbol (name, nullptr, SEARCH_VAR_DOMAIN,
nullptr);
if (sym.symbol != nullptr)
return value_of_variable (sym.symbol, sym.block);
function = cp_lookup_symbol_namespace (type->name (),
name.c_str (),
get_selected_block (0),
- VAR_DOMAIN).symbol;
+ SEARCH_FUNCTION_DOMAIN).symbol;
if (function == NULL)
error (_("No symbol \"%s\" in namespace \"%s\"."),
name.c_str (), type->name ());
{
CORE_ADDR addr = func->address ();
const block *blk = block_for_pc (addr);
- struct block_symbol sym = lookup_symbol (var, blk, VAR_DOMAIN, NULL);
+ struct block_symbol sym = lookup_symbol (var, blk, SEARCH_VAR_DOMAIN,
+ nullptr);
if (sym.symbol == NULL)
error (_("No symbol \"%s\" in specified context."), var);
return evaluate_var_value (noside, sym.block, sym.symbol);
{
std::string tmp = copy_name (yylval.sval);
struct block_symbol result;
- const domain_enum lookup_domains[] =
+ const domain_search_flags lookup_domains[] =
{
- STRUCT_DOMAIN,
- VAR_DOMAIN,
- MODULE_DOMAIN
+ SEARCH_STRUCT_DOMAIN,
+ SEARCH_VFT,
+ SEARCH_MODULE_DOMAIN
};
int hextype;
struct block_symbol
f_language::lookup_symbol_nonlocal (const char *name,
const struct block *block,
- const domain_enum domain) const
+ const domain_search_flags domain) const
{
return cp_lookup_symbol_nonlocal (this, name, block, domain);
}
struct block_symbol lookup_symbol_nonlocal
(const char *name, const struct block *block,
- const domain_enum domain) const override;
+ const domain_search_flags domain) const override;
/* See language.h. */
value field before printing its value. */
struct block_symbol sym
= lookup_symbol (field_name, get_selected_block (nullptr),
- VAR_DOMAIN, nullptr);
+ SEARCH_VFT, nullptr);
if (sym.symbol == nullptr)
error (_("failed to find symbol for name list component %s"),
field_name);
{
/* Fetch offsets from debug symbols in rtld. */
struct symbol *obj_entry_sym
- = lookup_symbol_in_language ("Struct_Obj_Entry", NULL, STRUCT_DOMAIN,
- language_c, NULL).symbol;
+ = lookup_symbol_in_language ("Struct_Obj_Entry", nullptr,
+ SEARCH_STRUCT_DOMAIN,
+ language_c, nullptr).symbol;
if (obj_entry_sym == NULL)
error (_("Unable to find Struct_Obj_Entry symbol"));
data->off_linkmap = lookup_struct_elt (obj_entry_sym->type (),
/* In some language (for example Fortran) there will be no minimal
symbol with the name of the main function. In this case we should
search the full symbols to see if we can find a match. */
- struct block_symbol bs = lookup_symbol (name, NULL, VAR_DOMAIN, 0);
+ struct block_symbol bs = lookup_symbol (name, nullptr,
+ SEARCH_VFT, nullptr);
/* We might have found some unrelated symbol. For example, the
Rust compiler can emit both a subprogram and a namespace with
plg_end = ft32_analyze_prologue (func_addr,
func_end, &cache, gdbarch);
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (func_name, nullptr, SEARCH_FUNCTION_DOMAIN,
+ nullptr).symbol;
/* Don't use line number debug info for assembly source files. */
if ((sym != NULL) && sym->language () != language_asm)
{
{
struct symbol *sym;
- sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
+ sym = lookup_symbol_in_language (name, block, SEARCH_VFT,
language->la_language, NULL).symbol;
if (sym != NULL && sym->aclass () == LOC_TYPEDEF)
{
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, SEARCH_STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
struct symbol *sym;
struct type *t;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, SEARCH_STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
error (_("No union type named %s."), name);
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, SEARCH_STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
error (_("No enum type named %s."), name);
nam += type->name ();
nam += " >"; /* FIXME, extra space still introduced in gcc? */
- symbol *sym = lookup_symbol (nam.c_str (), block, VAR_DOMAIN, 0).symbol;
+ symbol *sym = lookup_symbol (nam.c_str (), block,
+ SEARCH_STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, nullptr, SEARCH_STRUCT_DOMAIN,
+ nullptr).symbol;
if (sym)
type->set_target_type (sym->type ());
else /* TYPE_CODE_UNDEF */
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, nullptr, SEARCH_STRUCT_DOMAIN,
+ nullptr).symbol;
if (sym)
{
/* Same as above for opaque types, we can replace the stub
struct symbol *typeinfo;
struct type *typeinfo_type;
- typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
+ typeinfo = lookup_symbol ("std::type_info", NULL, SEARCH_STRUCT_DOMAIN,
NULL).symbol;
if (typeinfo == NULL)
{
struct symbol *sym;
struct field_of_this_result is_a_field_of_this;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this).symbol;
+ sym = lookup_symbol (name, block, SEARCH_STRUCT_DOMAIN,
+ &is_a_field_of_this).symbol;
if (sym
&& sym->aclass () == LOC_TYPEDEF
std::string copy = copy_name (yylval.sval);
- sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
+ sym = lookup_symbol (copy.c_str (), block, SEARCH_VFT, &is_a_field_of_this);
if (sym.symbol)
{
/* TODO: What about other types? */
- sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
+ sym = lookup_symbol (copy.c_str (), block, SEARCH_VFT, &is_a_field_of_this);
if (sym.symbol)
{
strlen (current_package_name.get ()),
copy.c_str (), copy.size ());
- sym = lookup_symbol (sval.ptr, block, VAR_DOMAIN,
+ sym = lookup_symbol (sval.ptr, block, SEARCH_VFT,
&is_a_field_of_this);
if (sym.symbol)
{
if (block == NULL)
block = get_frame_block (frame_info_ptr (frame), NULL);
- lookup_sym = lookup_symbol (var_name.get (), block, VAR_DOMAIN,
+ lookup_sym = lookup_symbol (var_name.get (), block, SEARCH_VFT,
NULL);
var = lookup_sym.symbol;
block = lookup_sym.block;
gdbscm_gdb_exception except {};
try
{
- symbol = lookup_symbol (name, block, (domain_enum) domain,
+ domain_search_flags flags = from_scripting_domain (domain);
+ symbol = lookup_symbol (name, block, flags,
&is_a_field_of_this).symbol;
}
catch (const gdb_exception &ex)
try
{
- symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
+ domain_search_flags flags = from_scripting_domain (domain);
+ symbol = lookup_global_symbol (name, NULL, flags).symbol;
}
catch (const gdb_exception &ex)
{
#undef X
#define DOMAIN(X) \
- { "SYMBOL_" #X "_DOMAIN", X ## _DOMAIN },
+ { "SYMBOL_" #X "_DOMAIN", to_scripting_domain (X ## _DOMAIN) }, \
+ { "SEARCH_" #X "_DOMAIN", to_scripting_domain (SEARCH_ ## X ## _DOMAIN) },
#include "sym-domains.def"
#undef DOMAIN
- /* These were never correct. */
- { "SYMBOL_VARIABLES_DOMAIN", VAR_DOMAIN },
- { "SYMBOL_FUNCTIONS_DOMAIN", VAR_DOMAIN },
- { "SYMBOL_TYPES_DOMAIN", VAR_DOMAIN },
+ /* Historical. */
+ { "SYMBOL_VARIABLES_DOMAIN", to_scripting_domain (SEARCH_VAR_DOMAIN) },
+ { "SYMBOL_FUNCTIONS_DOMAIN", to_scripting_domain (SEARCH_FUNCTION_DOMAIN) },
+ { "SYMBOL_TYPES_DOMAIN", to_scripting_domain (SEARCH_TYPE_DOMAIN) },
END_INTEGER_CONSTANTS
};
struct breakpoint *bp;
vsym = lookup_symbol_search_name (sym->search_name (),
- b, VAR_DOMAIN);
+ b, SEARCH_VAR_DOMAIN);
value = read_var_value (vsym.symbol, vsym.block, frame);
/* If the value was optimized out, revert to the old behavior. */
if (! value->optimized_out ())
{
struct symbol *sym;
- sym = lookup_symbol (m_bool_type_name, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (m_bool_type_name, nullptr, SEARCH_TYPE_DOMAIN,
+ nullptr).symbol;
if (sym != nullptr)
{
struct type *type = sym->type ();
virtual struct block_symbol lookup_symbol_nonlocal
(const char *name,
const struct block *block,
- const domain_enum domain) const;
+ const domain_search_flags domain) const;
/* Return an expression that can be used for a location
watchpoint. TYPE is a pointer type that points to the memory
for (struct symbol *sym : block_iterator_range (block))
{
- if (sym->matches (LABEL_DOMAIN)
+ if (sym->domain () == LABEL_DOMAIN
&& cmp (sym->search_name (), name, name_len) == 0)
{
result->push_back ({sym, block});
else
{
struct block_symbol label_sym
- = lookup_symbol (name, block, LABEL_DOMAIN, 0);
+ = lookup_symbol (name, block, SEARCH_LABEL_DOMAIN, 0);
if (label_sym.symbol != NULL)
{
{ struct symbol *sym
= lookup_symbol (copy_name ($1).c_str (),
pstate->expression_context_block,
- VAR_DOMAIN, 0).symbol;
+ SEARCH_VFT, 0).symbol;
$$ = sym;}
;
fblock : block COLONCOLON BLOCKNAME
{ struct symbol *tem
= lookup_symbol (copy_name ($3).c_str (), $1,
- VAR_DOMAIN, 0).symbol;
+ SEARCH_VFT, 0).symbol;
if (!tem || tem->aclass () != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
copy_name ($3).c_str ());
variable: block COLONCOLON NAME
{ struct block_symbol sym
= lookup_symbol (copy_name ($3).c_str (), $1,
- VAR_DOMAIN, 0);
+ SEARCH_VFT, 0);
if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
sym
= lookup_symbol (name.c_str (),
pstate->expression_context_block,
- VAR_DOMAIN,
+ SEARCH_VFT,
&is_a_field_of_this);
pstate->push_symbol (name.c_str (), sym);
if (lookup_symtab (tmp.c_str ()))
return BLOCKNAME;
sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
- VAR_DOMAIN, 0).symbol;
+ SEARCH_VFT, 0).symbol;
if (sym && sym->aclass () == LOC_BLOCK)
return BLOCKNAME;
if (lookup_typename (pstate->language (),
struct frame_arg arg, entryarg;
if (sym->is_argument ())
- sym2 = lookup_symbol_search_name (sym->search_name (),
- block, VAR_DOMAIN).symbol;
+ sym2 = (lookup_symbol_search_name
+ (sym->search_name (),
+ block, SEARCH_VAR_DOMAIN).symbol);
else
sym2 = sym;
gdb_assert (sym2 != NULL);
plg_end = moxie_analyze_prologue (func_addr,
func_end, &cache, gdbarch);
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (func_name, nullptr,
+ SEARCH_FUNCTION_DOMAIN, nullptr).symbol;
/* Don't use line number debug info for assembly source
files. */
if (sym && sym->language () != language_asm)
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
+ sym = lookup_symbol (name, block, SEARCH_STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
add the selector itself as a symbol, if it exists. */
if (selector_case && !symbol_names->empty ())
{
- struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN,
+ struct symbol *sym = lookup_symbol (selector, NULL, SEARCH_VFT,
0).symbol;
if (sym != NULL)
contains !TYPE_OPAQUE symbol prefer its compunit. If it contains
only TYPE_OPAQUE symbol(s), return at least that compunit. */
struct compunit_symtab *lookup_symbol (block_enum kind, const char *name,
- domain_enum domain);
+ domain_search_flags domain);
/* See quick_symbol_functions. */
void print_stats (bool print_bcache);
std::string copy = copy_name ($3);
struct symbol *tem
= lookup_symbol (copy.c_str (), $1,
- VAR_DOMAIN, NULL).symbol;
+ SEARCH_FUNCTION_DOMAIN,
+ nullptr).symbol;
- if (!tem || tem->aclass () != LOC_BLOCK)
+ if (tem == nullptr)
error (_("No function \"%s\" in specified context."),
copy.c_str ());
$$ = tem->value_block (); }
std::string copy = copy_name ($3);
sym = lookup_symbol (copy.c_str (), $1,
- VAR_DOMAIN, NULL);
+ SEARCH_VFT, NULL);
if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
copy.c_str ());
struct block_symbol sym
= lookup_symbol (name.c_str (), nullptr,
- VAR_DOMAIN, nullptr);
+ SEARCH_VFT, nullptr);
pstate->push_symbol (name.c_str (), sym);
}
;
static const char this_name[] = "this";
if (lookup_symbol (this_name, pstate->expression_context_block,
- VAR_DOMAIN, NULL).symbol)
+ SEARCH_VFT, NULL).symbol)
{
free (uptokstart);
return THIS;
sym = NULL;
else
sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this).symbol;
+ SEARCH_VFT, &is_a_field_of_this).symbol;
/* second chance uppercased (as Free Pascal does). */
if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
{
sym = NULL;
else
sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this).symbol;
+ SEARCH_VFT, &is_a_field_of_this).symbol;
}
/* Third chance Capitalized (as GPC does). */
if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
sym = NULL;
else
sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this).symbol;
+ SEARCH_VFT, &is_a_field_of_this).symbol;
}
if (is_a_field || (is_a_field_of_this.type != NULL))
cur_sym
= lookup_symbol (ncopy,
pstate->expression_context_block,
- VAR_DOMAIN, NULL).symbol;
+ SEARCH_VFT, NULL).symbol;
if (cur_sym)
{
if (cur_sym->aclass () == LOC_TYPEDEF)
{
const char *search_name = msymbol.minsym->search_name ();
wsym = lookup_symbol_search_name (search_name, NULL,
- VAR_DOMAIN).symbol;
+ SEARCH_VFT).symbol;
}
if (wsym)
/* On some systems, such as HP-UX and hppa-linux, certain system routines
have names beginning with $ or $$. Check for those, first. */
- sym = lookup_symbol (copy.c_str (), NULL, VAR_DOMAIN, NULL);
+ sym = lookup_symbol (copy.c_str (), nullptr,
+ SEARCH_VAR_DOMAIN | SEARCH_FUNCTION_DOMAIN, nullptr);
if (sym.symbol)
{
push_new<expr::var_value_operation> (sym);
if (exp == 0)
error (_("Argument required."));
- sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
+ sym = lookup_symbol (exp, get_selected_block (&context_pc), SEARCH_VFT,
&is_a_field_of_this).symbol;
if (sym == NULL)
{
sym = block_lookup_symbol (b, psym->ginfo.search_name (),
symbol_name_match_type::SEARCH_NAME,
- psym->domain);
+ to_search_flags (psym->domain));
if (!sym)
{
gdb_printf ("Static symbol `");
{
sym = block_lookup_symbol (b, psym->ginfo.search_name (),
symbol_name_match_type::SEARCH_NAME,
- psym->domain);
+ to_search_flags (psym->domain));
if (!sym)
{
gdb_printf ("Global symbol `");
if (!block)
block = get_frame_block (frame, NULL);
- lookup_sym = lookup_symbol (var_name.get (), block, VAR_DOMAIN, NULL);
+ lookup_sym = lookup_symbol (var_name.get (), block,
+ SEARCH_VFT, nullptr);
var = lookup_sym.symbol;
block = lookup_sym.block;
}
try
{
+ domain_search_flags flags = from_scripting_domain (domain);
struct symbol *sym = lookup_global_symbol_from_objfile
- (obj->objfile, GLOBAL_BLOCK, symbol_name, (domain_enum) domain).symbol;
+ (obj->objfile, GLOBAL_BLOCK, symbol_name, flags).symbol;
if (sym == nullptr)
Py_RETURN_NONE;
try
{
+ domain_search_flags flags = from_scripting_domain (domain);
struct symbol *sym = lookup_global_symbol_from_objfile
- (obj->objfile, STATIC_BLOCK, symbol_name, (domain_enum) domain).symbol;
+ (obj->objfile, STATIC_BLOCK, symbol_name, flags).symbol;
if (sym == nullptr)
Py_RETURN_NONE;
try
{
- symbol = lookup_symbol (name, block, (domain_enum) domain,
- &is_a_field_of_this).symbol;
+ domain_search_flags flags = from_scripting_domain (domain);
+ symbol = lookup_symbol (name, block, flags, &is_a_field_of_this).symbol;
}
catch (const gdb_exception &except)
{
try
{
- symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
+ domain_search_flags flags = from_scripting_domain (domain);
+ symbol = lookup_global_symbol (name, NULL, flags).symbol;
}
catch (const gdb_exception &except)
{
try
{
+ domain_search_flags flags = from_scripting_domain (domain);
+
if (block != nullptr)
symbol
- = lookup_symbol_in_static_block (name, block,
- (domain_enum) domain).symbol;
+ = lookup_symbol_in_static_block (name, block, flags).symbol;
if (symbol == nullptr)
- symbol = lookup_static_symbol (name, (domain_enum) domain).symbol;
+ symbol = lookup_static_symbol (name, flags).symbol;
}
catch (const gdb_exception &except)
{
try
{
+ domain_search_flags flags = from_scripting_domain (domain);
+
/* Expand any symtabs that contain potentially matching symbols. */
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
expand_symtabs_matching (NULL, lookup_name, NULL, NULL,
if (block != nullptr)
{
symbol *symbol = lookup_symbol_in_static_block
- (name, block, (domain_enum) domain).symbol;
+ (name, block, flags).symbol;
if (symbol != nullptr)
{
#define DOMAIN(X) \
if (PyModule_AddIntConstant (gdb_module, "SYMBOL_" #X "_DOMAIN", \
- X ## _DOMAIN) < 0) \
+ to_scripting_domain (X ## _DOMAIN)) < 0 \
+ || PyModule_AddIntConstant (gdb_module, "SEARCH_" #X "_DOMAIN", \
+ to_scripting_domain (SEARCH_ ## X ## _DOMAIN)) < 0) \
return -1;
#include "sym-domains.def"
#undef DOMAIN
const struct block *block = get_selected_block (0);
struct block_symbol sym = lookup_symbol (name.c_str (), block,
- VAR_DOMAIN, NULL);
+ SEARCH_VFT,
+ nullptr);
if (sym.symbol == NULL)
error (_("Could not find function named '%s'"), name.c_str ());
struct block_symbol
rust_language::lookup_symbol_nonlocal
(const char *name, const struct block *block,
- const domain_enum domain) const
+ const domain_search_flags domain) const
{
struct block_symbol result = {};
symbol_lookup_debug_printf
("rust_lookup_symbol_non_local (%s, %s (scope %s), %s)",
name, host_address_to_string (block), scope,
- domain_name (domain));
+ domain_name (domain).c_str ());
/* Look up bare names in the block's scope. */
std::string scopedname;
struct block_symbol lookup_symbol_nonlocal
(const char *name, const struct block *block,
- const domain_enum domain) const override;
+ const domain_search_flags domain) const override;
/* See language.h. */
void update_innermost_block (struct block_symbol sym);
struct block_symbol lookup_symbol (const char *name,
const struct block *block,
- const domain_enum domain);
+ const domain_search_flags domain);
struct type *rust_lookup_type (const char *name);
/* Clear some state. This is only used for testing. */
struct block_symbol
rust_parser::lookup_symbol (const char *name, const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct block_symbol result;
const struct block *block = pstate->expression_context_block;
munge_name_and_block (&name, &block);
- result = ::lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
+ result = ::lookup_symbol (name, block, SEARCH_STRUCT_DOMAIN, NULL);
if (result.symbol != NULL)
{
update_innermost_block (result);
{
struct block_symbol sym = lookup_symbol (name.c_str (),
pstate->expression_context_block,
- VAR_DOMAIN);
+ SEARCH_VFT);
if (sym.symbol != nullptr && sym.symbol->aclass () != LOC_TYPEDEF)
return make_operation<var_value_operation> (sym);
/* Make the default place to list be the function `main'
if one exists. */
- block_symbol bsym = lookup_symbol (main_name (), 0, VAR_DOMAIN, 0);
- if (bsym.symbol != nullptr && bsym.symbol->aclass () == LOC_BLOCK)
+ block_symbol bsym = lookup_symbol (main_name (), nullptr,
+ SEARCH_FUNCTION_DOMAIN, nullptr);
+ if (bsym.symbol != nullptr)
{
symtab_and_line sal = find_function_start_sal (bsym.symbol, true);
if (sal.symtab == NULL)
struct symbol *nsym;
nsym = lookup_symbol_search_name (sym->search_name (),
- b, VAR_DOMAIN).symbol;
+ b, SEARCH_VAR_DOMAIN).symbol;
gdb_assert (nsym != NULL);
if (nsym->aclass () == LOC_REGISTER
&& !nsym->is_argument ())
struct symbol *sym2
= lookup_symbol_search_name (sym->search_name (),
- b, VAR_DOMAIN).symbol;
+ b, SEARCH_VAR_DOMAIN).symbol;
cb (sym->print_name (), sym2);
}
}
}
struct compunit_symtab *
-objfile::lookup_symbol (block_enum kind, const char *name, domain_enum domain)
+objfile::lookup_symbol (block_enum kind, const char *name,
+ domain_search_flags domain)
{
struct compunit_symtab *retval = nullptr;
gdb_printf (gdb_stdlog,
"qf->lookup_symbol (%s, %d, \"%s\", %s)\n",
objfile_debug_name (this), kind, name,
- domain_name (domain));
+ domain_name (domain).c_str ());
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
return true;
};
- domain_search_flags flags = to_search_flags (domain);
- if (domain == VAR_DOMAIN)
- flags |= SEARCH_TYPE_DOMAIN | SEARCH_FUNCTION_DOMAIN;
-
for (const auto &iter : qf)
{
if (!iter->expand_symtabs_matching (this,
kind == GLOBAL_BLOCK
? SEARCH_GLOBAL_BLOCK
: SEARCH_STATIC_BLOCK,
- flags))
+ domain))
break;
}
{
const char *name = main_name ();
struct symbol *sym
- = lookup_symbol_in_language (name, NULL, VAR_DOMAIN, default_lang,
- NULL).symbol;
+ = lookup_symbol_in_language (name, nullptr, SEARCH_FUNCTION_DOMAIN,
+ default_lang, nullptr).symbol;
if (sym != NULL)
lang = sym->language ();
lookup_symbol_aux (const char *name,
symbol_name_match_type match_type,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
enum language language,
struct field_of_this_result *);
struct block_symbol lookup_local_symbol (const char *name,
symbol_name_match_type match_type,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
enum language language);
static struct block_symbol
lookup_symbol_in_objfile (struct objfile *objfile,
enum block_enum block_index,
- const char *name, const domain_enum domain);
+ const char *name,
+ const domain_search_flags domain);
static void set_main_name (program_space *pspace, const char *name,
language lang);
lookup was saved in the cache, but cache space is pretty cheap. */
const struct objfile *objfile_context;
+ /* The domain that was searched for initially. This must exactly
+ match. */
+ domain_search_flags domain;
+
union
{
struct block_symbol found;
- struct
- {
- char *name;
- domain_enum domain;
- } not_found;
+ char *name;
} value;
};
symbol_cache_clear_slot (struct symbol_cache_slot *slot)
{
if (slot->state == SYMBOL_SLOT_NOT_FOUND)
- xfree (slot->value.not_found.name);
+ xfree (slot->value.name);
slot->state = SYMBOL_SLOT_UNUSED;
}
static unsigned int
hash_symbol_entry (const struct objfile *objfile_context,
- const char *name, domain_enum domain)
+ const char *name, domain_search_flags domain)
{
unsigned int hash = (uintptr_t) objfile_context;
if (name != NULL)
hash += htab_hash_string (name);
- /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
- to map to the same slot. */
- if (domain == STRUCT_DOMAIN)
- hash += VAR_DOMAIN * 7;
- else
- hash += domain * 7;
+ hash += domain * 7;
return hash;
}
static int
eq_symbol_entry (const struct symbol_cache_slot *slot,
const struct objfile *objfile_context,
- const char *name, domain_enum domain)
+ const char *name, domain_search_flags domain)
{
const char *slot_name;
- domain_enum slot_domain;
if (slot->state == SYMBOL_SLOT_UNUSED)
return 0;
if (slot->objfile_context != objfile_context)
return 0;
+ domain_search_flags slot_domain = slot->domain;
if (slot->state == SYMBOL_SLOT_NOT_FOUND)
- {
- slot_name = slot->value.not_found.name;
- slot_domain = slot->value.not_found.domain;
- }
+ slot_name = slot->value.name;
else
- {
- slot_name = slot->value.found.symbol->search_name ();
- slot_domain = slot->value.found.symbol->domain ();
- }
+ slot_name = slot->value.found.symbol->search_name ();
/* NULL names match. */
if (slot_name == NULL && name == NULL)
the first time through. If the slot records a found symbol,
then this means using the symbol name comparison function of
the symbol's language with symbol->search_name (). See
- dictionary.c. It also means using symbol_matches_domain for
- found symbols. See block.c.
+ dictionary.c.
If the slot records a not-found symbol, then require a precise match.
We could still be lax with whitespace like strcmp_iw though. */
+ if (slot_domain != domain)
+ return 0;
+
if (slot->state == SYMBOL_SLOT_NOT_FOUND)
{
if (strcmp (slot_name, name) != 0)
return 0;
- if (slot_domain != domain)
- return 0;
}
else
{
if (!symbol_matches_search_name (sym, lookup_name))
return 0;
-
- if (!symbol_matches_domain (sym->language (), slot_domain, domain))
- return 0;
}
}
else
static struct block_symbol
symbol_cache_lookup (struct symbol_cache *cache,
struct objfile *objfile_context, enum block_enum block,
- const char *name, domain_enum domain,
+ const char *name, domain_search_flags domain,
struct block_symbol_cache **bsc_ptr,
struct symbol_cache_slot **slot_ptr)
{
block == GLOBAL_BLOCK ? "Global" : "Static",
slot->state == SYMBOL_SLOT_NOT_FOUND
? " (not found)" : "", name,
- domain_name (domain));
+ domain_name (domain).c_str ());
++bsc->hits;
if (slot->state == SYMBOL_SLOT_NOT_FOUND)
return SYMBOL_LOOKUP_FAILED;
symbol_lookup_debug_printf ("%s block symbol cache miss for %s, %s",
block == GLOBAL_BLOCK ? "Global" : "Static",
- name, domain_name (domain));
+ name, domain_name (domain).c_str ());
++bsc->misses;
return {};
}
struct symbol_cache_slot *slot,
struct objfile *objfile_context,
struct symbol *symbol,
- const struct block *block)
+ const struct block *block,
+ domain_search_flags domain)
{
if (bsc == NULL)
return;
slot->objfile_context = objfile_context;
slot->value.found.symbol = symbol;
slot->value.found.block = block;
+ slot->domain = domain;
}
/* Mark symbol NAME, DOMAIN as not found in SLOT.
symbol_cache_mark_not_found (struct block_symbol_cache *bsc,
struct symbol_cache_slot *slot,
struct objfile *objfile_context,
- const char *name, domain_enum domain)
+ const char *name, domain_search_flags domain)
{
if (bsc == NULL)
return;
}
slot->state = SYMBOL_SLOT_NOT_FOUND;
slot->objfile_context = objfile_context;
- slot->value.not_found.name = xstrdup (name);
- slot->value.not_found.domain = domain;
+ slot->value.name = xstrdup (name);
+ slot->domain = domain;
}
/* Flush the symbol cache of PSPACE. */
case SYMBOL_SLOT_NOT_FOUND:
gdb_printf (" [%4u] = %s, %s %s (not found)\n", i,
host_address_to_string (slot->objfile_context),
- slot->value.not_found.name,
- domain_name (slot->value.not_found.domain));
+ slot->value.name,
+ domain_name (slot->domain).c_str ());
break;
case SYMBOL_SLOT_FOUND:
{
struct block_symbol
lookup_symbol_in_language (const char *name, const struct block *block,
- const domain_enum domain, enum language lang,
+ const domain_search_flags domain,
+ enum language lang,
struct field_of_this_result *is_a_field_of_this)
{
SYMBOL_LOOKUP_SCOPED_DEBUG_ENTER_EXIT;
struct block_symbol
lookup_symbol (const char *name, const struct block *block,
- domain_enum domain,
+ domain_search_flags domain,
struct field_of_this_result *is_a_field_of_this)
{
return lookup_symbol_in_language (name, block, domain,
struct block_symbol
lookup_symbol_search_name (const char *search_name, const struct block *block,
- domain_enum domain)
+ domain_search_flags domain)
{
return lookup_symbol_aux (search_name, symbol_name_match_type::SEARCH_NAME,
block, domain, language_asm, NULL);
sym = block_lookup_symbol (block, lang->name_of_this (),
symbol_name_match_type::SEARCH_NAME,
- VAR_DOMAIN);
+ SEARCH_VFT);
if (sym != NULL)
{
symbol_lookup_debug_printf_v
static struct block_symbol
lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
const struct block *block,
- const domain_enum domain, enum language language,
+ const domain_search_flags domain, enum language language,
struct field_of_this_result *is_a_field_of_this)
{
SYMBOL_LOOKUP_SCOPED_DEBUG_ENTER_EXIT;
objfile != NULL ? objfile_debug_name (objfile) : "NULL");
symbol_lookup_debug_printf
("domain name = \"%s\", language = \"%s\")",
- domain_name (domain), language_str (language));
+ domain_name (domain).c_str (), language_str (language));
}
/* Make sure we do something sensible with is_a_field_of_this, since
/* Don't do this check if we are searching for a struct. It will
not be found by check_field, but will be found by other
means. */
- if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
+ if (is_a_field_of_this != NULL && (domain & SEARCH_STRUCT_DOMAIN) == 0)
{
result = lookup_language_this (langdef, block);
lookup_local_symbol (const char *name,
symbol_name_match_type match_type,
const struct block *block,
- const domain_enum domain,
+ const domain_search_flags domain,
enum language language)
{
if (block == nullptr)
struct symbol *
lookup_symbol_in_block (const char *name, symbol_name_match_type match_type,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct symbol *sym;
("lookup_symbol_in_block (%s, %s (objfile %s), %s)",
name, host_address_to_string (block),
objfile != nullptr ? objfile_debug_name (objfile) : "NULL",
- domain_name (domain));
+ domain_name (domain).c_str ());
}
sym = block_lookup_symbol (block, name, match_type, domain);
lookup_global_symbol_from_objfile (struct objfile *main_objfile,
enum block_enum block_index,
const char *name,
- const domain_enum domain)
+ const domain_search_flags domain)
{
gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
static struct block_symbol
lookup_symbol_in_objfile_symtabs (struct objfile *objfile,
enum block_enum block_index, const char *name,
- const domain_enum domain)
+ const domain_search_flags domain)
{
gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
("lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
objfile_debug_name (objfile),
block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
- name, domain_name (domain));
+ name, domain_name (domain).c_str ());
struct block_symbol other;
other.symbol = NULL;
static struct block_symbol
lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
const char *linkage_name,
- domain_enum domain)
+ domain_search_flags domain)
{
enum language lang = current_language->la_language;
struct objfile *main_objfile;
static struct block_symbol
lookup_symbol_via_quick_fns (struct objfile *objfile,
enum block_enum block_index, const char *name,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct compunit_symtab *cust;
const struct blockvector *bv;
("lookup_symbol_via_quick_fns (%s, %s, %s, %s)",
objfile_debug_name (objfile),
block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
- name, domain_name (domain));
+ name, domain_name (domain).c_str ());
cust = objfile->lookup_symbol (block_index, name, domain);
if (cust == NULL)
struct block_symbol
language_defn::lookup_symbol_nonlocal (const char *name,
const struct block *block,
- const domain_enum domain) const
+ const domain_search_flags domain) const
{
struct block_symbol result;
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 (domain == VAR_DOMAIN)
+ if ((domain & SEARCH_TYPE_DOMAIN) != 0)
{
struct gdbarch *gdbarch;
struct block_symbol
lookup_symbol_in_static_block (const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
if (block == nullptr)
return {};
("lookup_symbol_in_static_block (%s, %s (objfile %s), %s)",
name, host_address_to_string (block),
objfile != nullptr ? objfile_debug_name (objfile) : "NULL",
- domain_name (domain));
+ domain_name (domain).c_str ());
}
sym = lookup_symbol_in_block (name,
static struct block_symbol
lookup_symbol_in_objfile (struct objfile *objfile, enum block_enum block_index,
- const char *name, const domain_enum domain)
+ const char *name, const domain_search_flags domain)
{
struct block_symbol result;
objfile_debug_name (objfile),
block_index == GLOBAL_BLOCK
? "GLOBAL_BLOCK" : "STATIC_BLOCK",
- name, domain_name (domain));
+ name, domain_name (domain).c_str ());
result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
name, domain);
lookup_global_or_static_symbol (const char *name,
enum block_enum block_index,
struct objfile *objfile,
- const domain_enum domain)
+ const domain_search_flags domain)
{
struct symbol_cache *cache = get_symbol_cache (current_program_space);
struct block_symbol result;
objfile);
if (result.symbol != NULL)
- symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block);
+ symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block,
+ domain);
else
symbol_cache_mark_not_found (bsc, slot, objfile, name, domain);
/* See symtab.h. */
struct block_symbol
-lookup_static_symbol (const char *name, const domain_enum domain)
+lookup_static_symbol (const char *name, const domain_search_flags domain)
{
return lookup_global_or_static_symbol (name, STATIC_BLOCK, nullptr, domain);
}
struct block_symbol
lookup_global_symbol (const char *name,
const struct block *block,
- const domain_enum domain)
+ const domain_search_flags domain)
{
/* If a block was passed in, we want to search the corresponding
global block first. This yields "more expected" behavior, and is
const struct block *block;
struct symbol *sym;
- cust = objfile->lookup_symbol (block_index, name, STRUCT_DOMAIN);
+ cust = objfile->lookup_symbol (block_index, name, SEARCH_STRUCT_DOMAIN);
if (cust == NULL)
return NULL;
block = bv->block (block_index);
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
- sym = block_find_symbol (block, lookup_name, STRUCT_DOMAIN, nullptr);
+ sym = block_find_symbol (block, lookup_name, SEARCH_STRUCT_DOMAIN, nullptr);
if (sym == nullptr)
error_in_psymtab_expansion (block_index, name, cust);
gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
{
bv = cust->blockvector ();
block = bv->block (block_index);
- sym = block_find_symbol (block, lookup_name, STRUCT_DOMAIN, nullptr);
+ sym = block_find_symbol (block, lookup_name, SEARCH_STRUCT_DOMAIN,
+ nullptr);
if (sym != nullptr)
{
gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
(msymbol->value_address (objfile)) == NULL)
: (lookup_symbol_in_objfile_from_linkage_name
(objfile, msymbol->linkage_name (),
- VAR_DOMAIN)
+ SEARCH_VFT)
.symbol == NULL))
found_msymbol = true;
}
{
if (lookup_symbol_in_objfile_from_linkage_name
(objfile, msymbol->linkage_name (),
- VAR_DOMAIN).symbol == NULL)
+ SEARCH_VFT).symbol == NULL)
{
/* Matching msymbol, add it to the results list. */
if (results->size () < m_max_search_results)
extern struct block_symbol
lookup_symbol_in_language (const char *,
const struct block *,
- const domain_enum,
+ const domain_search_flags,
enum language,
struct field_of_this_result *);
extern struct block_symbol lookup_symbol (const char *,
const struct block *,
- const domain_enum,
+ const domain_search_flags,
struct field_of_this_result *);
/* Find the definition for a specified symbol search name in domain
pointer, or NULL if no symbol is found. The symbol's section is
fixed up if necessary. */
-extern struct block_symbol lookup_symbol_search_name (const char *search_name,
- const struct block *block,
- domain_enum domain);
+extern struct block_symbol lookup_symbol_search_name
+ (const char *search_name,
+ const struct block *block,
+ domain_search_flags domain);
/* Some helper functions for languages that need to write their own
lookup_symbol_nonlocal functions. */
extern struct block_symbol
lookup_symbol_in_static_block (const char *name,
const struct block *block,
- const domain_enum domain);
+ const domain_search_flags domain);
/* Search all static file-level symbols for NAME from DOMAIN.
Upon success fixes up the symbol's section if necessary. */
-extern struct block_symbol lookup_static_symbol (const char *name,
- const domain_enum domain);
+extern struct block_symbol lookup_static_symbol
+ (const char *name, const domain_search_flags domain);
/* Lookup a symbol in all files' global blocks.
extern struct block_symbol
lookup_global_symbol (const char *name,
const struct block *block,
- const domain_enum domain);
+ const domain_search_flags domain);
/* Lookup a symbol in block BLOCK.
Upon success fixes up the symbol's section if necessary. */
lookup_symbol_in_block (const char *name,
symbol_name_match_type match_type,
const struct block *block,
- const domain_enum domain);
+ const domain_search_flags domain);
/* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
found, or NULL if not found. */
lookup_global_symbol_from_objfile (struct objfile *main_objfile,
enum block_enum block_index,
const char *name,
- const domain_enum domain);
+ const domain_search_flags domain);
/* Return 1 if the supplied producer string matches the ARM RealView
compiler (armcc). */
{
struct block_symbol sym;
- sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
+ sym = lookup_symbol (name, nullptr, SEARCH_TYPE_DOMAIN, nullptr);
if (sym.symbol != NULL)
{
- if (sym.symbol->aclass () != LOC_BLOCK)
- {
- error (_("\"%s\" exists in this program but is not a function."),
- name);
- }
-
if (objf_p)
*objf_p = sym.symbol->objfile ();
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0).symbol;
+ 0, SEARCH_FUNCTION_DOMAIN, 0).symbol;
if (s == NULL)
return NULL;
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0).symbol;
+ 0, SEARCH_FUNCTION_DOMAIN, 0).symbol;
if (s == NULL)
return NULL;
struct value *result;
sym = cp_lookup_symbol_namespace (namespace_name, name,
- get_selected_block (0), VAR_DOMAIN);
+ get_selected_block (0), SEARCH_VFT);
if (sym.symbol == NULL)
return NULL;
{
const char *phys_name = type->field (fieldno).loc_physname ();
/* type->field (fieldno).name (); */
- struct block_symbol sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
+ struct block_symbol sym = lookup_symbol (phys_name, nullptr,
+ SEARCH_VAR_DOMAIN, nullptr);
if (sym.symbol == NULL)
{
struct symbol *sym;
struct bound_minimal_symbol msym;
- sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0).symbol;
+ sym = lookup_symbol (physname, nullptr, SEARCH_FUNCTION_DOMAIN,
+ nullptr).symbol;
if (sym == nullptr)
{
msym = lookup_bound_minimal_symbol (physname);
return plg_end;
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
+ sym = lookup_symbol (func_name, NULL, SEARCH_FUNCTION_DOMAIN,
+ nullptr).symbol;
/* Don't use line number debug info for assembly source files. */
if (sym && sym->language () != language_asm)
{
projects / thirdparty / binutils-gdb.git / commitdiff
