dw2_lookup_symbol (struct objfile *objfile, int block_index,
const char *name, domain_enum domain)
{
- /* We do all the work in the pre_expand_symtabs_matching hook
+ /* We do all the work in the expand_one_symtab_matching hook
instead. */
return NULL;
}
}
}
-static void
-dw2_pre_expand_symtabs_matching (struct objfile *objfile,
- int kind, const char *name,
- domain_enum domain)
+static struct symbol *
+dw2_expand_one_symtab_matching (struct objfile *objfile,
+ int kind, const char *name,
+ domain_enum domain,
+ struct symbol *(*matcher) (struct symtab *,
+ int,
+ const char *,
+ domain_enum,
+ void *),
+ void *data)
{
- dw2_do_expand_symtabs_matching (objfile, name);
+ dw2_setup (objfile);
+
+ if (dwarf2_per_objfile->index_table)
+ {
+ offset_type *vec;
+
+ if (find_slot_in_mapped_hash (dwarf2_per_objfile->index_table,
+ name, &vec))
+ {
+ offset_type i, len = MAYBE_SWAP (*vec);
+ for (i = 0; i < len; ++i)
+ {
+ offset_type cu_index = MAYBE_SWAP (vec[i + 1]);
+ struct dwarf2_per_cu_data *cu = dw2_get_cu (cu_index);
+ struct symtab *symtab;
+ struct symbol *sym;
+
+ if (cu->v.quick->symtab)
+ continue;
+
+ symtab = dw2_instantiate_symtab (objfile, cu);
+ sym = matcher (symtab, kind, name, domain, data);
+ if (sym)
+ return sym;
+ }
+ }
+ }
+
+ return NULL;
}
static void
dw2_forget_cached_source_info,
dw2_lookup_symtab,
dw2_lookup_symbol,
- dw2_pre_expand_symtabs_matching,
+ dw2_expand_one_symtab_matching,
dw2_print_stats,
dw2_dump,
dw2_relocate,
int kind, const char *name,
domain_enum domain);
- /* This is called to expand symbol tables before looking up a
- symbol. A backend can choose to implement this and then have its
- `lookup_symbol' hook always return NULL, or the reverse. (It
- doesn't make sense to implement both.) The arguments are as for
- `lookup_symbol'. */
- void (*pre_expand_symtabs_matching) (struct objfile *objfile,
- int kind, const char *name,
- domain_enum domain);
+ /* Expand each symbol table in OBJFILE that may have items matching
+ KIND, NAME, and DOMAIN -- these arguments are as for
+ `lookup_symbol'. For each such symbol table, call MATCHER with
+ the symbol table and DATA arguments. If MATCHER returns NULL,
+ keep going. Otherwise, return the result of MATCHER. If MATCHER
+ never returns non-NULL, return NULL. A backend can choose to
+ implement this and then have its `lookup_symbol' hook always
+ return NULL, or the reverse. (It doesn't make sense to implement
+ both.) */
+ struct symbol *(*expand_one_symtab_matching)
+ (struct objfile *objfile,
+ int kind, const char *name,
+ domain_enum domain,
+ struct symbol *(*matcher) (struct symtab *symtab,
+ int kind,
+ const char *name,
+ domain_enum domain,
+ void *data),
+ void *data);
/* Print statistics about any indices loaded for OBJFILE. The
statistics should be printed to gdb_stdout. This is used for
const struct block *block,
const domain_enum domain,
enum language language,
- int *is_a_field_of_this);
+ int *is_a_field_of_this,
+ int for_type);
static
struct symbol *lookup_symbol_aux_local (const char *name,
C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
NAME is a field of the current implied argument `this'. If so set
*IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
+ FOR_TYPE is non-zero if searching specifically for a type; zero
+ otherwise.
BLOCK_FOUND is set to the block in which NAME is found (in the case of
a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
variable and thus can probably assume it will never hit the C++
code). */
-struct symbol *
-lookup_symbol_in_language (const char *name, const struct block *block,
- const domain_enum domain, enum language lang,
- int *is_a_field_of_this)
+static struct symbol *
+lookup_symbol_in_language_full (const char *name, const struct block *block,
+ const domain_enum domain, enum language lang,
+ int *is_a_field_of_this, int for_type)
{
char *demangled_name = NULL;
const char *modified_name = NULL;
}
returnval = lookup_symbol_aux (modified_name, block, domain, lang,
- is_a_field_of_this);
+ is_a_field_of_this, for_type);
do_cleanups (cleanup);
return returnval;
}
+/* Find the definition for a specified symbol name NAME
+ in domain DOMAIN, visible from lexical block BLOCK.
+ Returns the struct symbol pointer, or zero if no symbol is found.
+ C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
+ NAME is a field of the current implied argument `this'. If so set
+ *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
+ BLOCK_FOUND is set to the block in which NAME is found (in the case of
+ a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
+
+struct symbol *
+lookup_symbol_in_language (const char *name, const struct block *block,
+ const domain_enum domain, enum language lang,
+ int *is_a_field_of_this)
+{
+ return lookup_symbol_in_language_full (name, block, domain, lang,
+ is_a_field_of_this, 0);
+}
+
+/* Like lookup_symbol_in_language, but search specifically for a
+ type. */
+
+struct symbol *
+lookup_type_symbol (const char *name, const struct block *block,
+ const domain_enum domain, enum language lang)
+{
+ return lookup_symbol_in_language_full (name, block, domain, lang,
+ NULL, 1);
+}
+
/* Behave like lookup_symbol_in_language, but performed with the
current language. */
static struct symbol *
lookup_symbol_aux (const char *name, const struct block *block,
const domain_enum domain, enum language language,
- int *is_a_field_of_this)
+ int *is_a_field_of_this,
+ int for_type)
{
struct symbol *sym;
const struct language_defn *langdef;
}
/* Now do whatever is appropriate for LANGUAGE to look
- up static and global variables. */
+ up static and global variables. If we are searching for a type,
+ we bypass this lookup, because types aren't global. */
- sym = langdef->la_lookup_symbol_nonlocal (name, block, domain);
- if (sym != NULL)
- return sym;
+ if (!for_type)
+ {
+ sym = langdef->la_lookup_symbol_nonlocal (name, block, domain);
+ if (sym != NULL)
+ return sym;
+ }
- /* Now search all static file-level symbols. Not strictly correct,
- but more useful than an error. */
+ /* Now search all static file-level symbols. When searching for a
+ type, this is what we generally want, because types are put into
+ the file scope. For other objects, not strictly correct, but
+ more useful than an error. */
return lookup_static_symbol_aux (name, domain);
}
return NULL;
}
+/* A helper for lookup_symbol_aux_symtabs that is passed as a callback
+ to the expand_one_symtab_matching quick function. */
+
+static struct symbol *
+match_symbol_aux (struct symtab *symtab,
+ int kind, const char *name, domain_enum domain,
+ void *arg)
+{
+ struct objfile *objfile = arg;
+
+ if (symtab->primary)
+ {
+ struct symbol *sym;
+ struct blockvector *bv;
+ const struct block *block;
+
+ bv = BLOCKVECTOR (symtab);
+ block = BLOCKVECTOR_BLOCK (bv, kind);
+ sym = lookup_block_symbol (block, name, domain);
+ if (sym)
+ {
+ block_found = block;
+ return fixup_symbol_section (sym, objfile);
+ }
+ }
+
+ return NULL;
+}
+
/* Check to see if the symbol is defined in one of the symtabs.
BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
depending on whether or not we want to search global symbols or
ALL_OBJFILES (objfile)
{
- if (objfile->sf)
- objfile->sf->qf->pre_expand_symtabs_matching (objfile,
- block_index,
- name, domain);
-
ALL_OBJFILE_SYMTABS (objfile, s)
if (s->primary)
{
return fixup_symbol_section (sym, objfile);
}
}
+
+ if (objfile->sf)
+ {
+ sym = objfile->sf->qf->expand_one_symtab_matching (objfile,
+ block_index,
+ name, domain,
+ match_symbol_aux,
+ objfile);
+ if (sym)
+ return sym;
+ }
}
return NULL;
return NULL;
}
+/* A helper function for basic_lookup_transparent_type that is passed
+ to the expand_one_symtab_matching quick function. */
+
+static struct symbol *
+match_transparent_type (struct symtab *symtab,
+ int kind, const char *name, domain_enum domain,
+ void *data)
+{
+ if (symtab->primary)
+ {
+ struct blockvector *bv;
+ struct block *block;
+ struct symbol *sym;
+
+ bv = BLOCKVECTOR (symtab);
+ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+ sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+ if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+ return sym;
+ }
+
+ return NULL;
+}
+
/* The standard implementation of lookup_transparent_type. This code
was modeled on lookup_symbol -- the parts not relevant to looking
up types were just left out. In particular it's assumed here that
ALL_OBJFILES (objfile)
{
- if (objfile->sf)
- objfile->sf->qf->pre_expand_symtabs_matching (objfile,
- GLOBAL_BLOCK,
- name, STRUCT_DOMAIN);
-
ALL_OBJFILE_SYMTABS (objfile, s)
if (s->primary)
{
return SYMBOL_TYPE (sym);
}
}
+
+ if (objfile->sf)
+ {
+ sym
+ = objfile->sf->qf->expand_one_symtab_matching (objfile,
+ GLOBAL_BLOCK, name,
+ STRUCT_DOMAIN,
+ match_transparent_type,
+ NULL);
+ if (sym)
+ return SYMBOL_TYPE (sym);
+ }
}
ALL_OBJFILES (objfile)
ALL_OBJFILES (objfile)
{
- if (objfile->sf)
- objfile->sf->qf->pre_expand_symtabs_matching (objfile, STATIC_BLOCK,
- name, STRUCT_DOMAIN);
-
ALL_OBJFILE_SYMTABS (objfile, s)
{
bv = BLOCKVECTOR (s);
return SYMBOL_TYPE (sym);
}
}
+
+ if (objfile->sf)
+ {
+ sym
+ = objfile->sf->qf->expand_one_symtab_matching (objfile,
+ STATIC_BLOCK, name,
+ STRUCT_DOMAIN,
+ match_transparent_type,
+ NULL);
+ if (sym)
+ return SYMBOL_TYPE (sym);
+ }
}
ALL_OBJFILES (objfile)
projects / external / binutils.git / commitdiff