Re: [PATCH] Replace the block_found global with explicit data-flow

Pierre-Marie de Rodat
2015-07-21T18:49:59Z

[-- Attachment #1: Type: text/plain, Size: 600 bytes --]

On 07/21/2015 06:36 PM, Pierre-Marie de Rodat wrote:
> As Pedro suggested on gdb-patches@ (see
> <https://sourceware.org/ml/gdb-patches/2015-05/msg00714.html>), this
> change makes symbol lookup functions return a structure that includes
> both the symbol found and the block in which it was found. This makes
> it possible to get rid of the block_found global variable and thus makes
> block hunting explicit.
>
> I saw no regression on x86_64-linux. Ok for trunk?

Ahem… here’s the patch… :-/ One day I will take some time to configure
git send-email...

--
Pierre-Marie de Rodat

[-- Attachment #2: 0001-Replace-the-block_found-global-with-explicit-data-fl.patch --]
[-- Type: text/x-patch, Size: 159620 bytes --]

From 0088559f6ca047360711404dabf9792bf4188c2d Mon Sep 17 00:00:00 2001
From: Pierre-Marie de Rodat <derodat@adacore.com>
Date: Tue, 21 Jul 2015 17:02:15 +0200
Subject: [PATCH] Replace the block_found global with explicit data-flow

As Pedro suggested on gdb-patches@ (see
https://sourceware.org/ml/gdb-patches/2015-05/msg00714.html), this
change makes symbol lookup functions return a structure that includes
both the symbol found and the block in which it was found. This makes
it possible to get rid of the block_found global variable and thus makes
block hunting explicit.

gdb/

* ada-exp.y (write_object_renaming): Replace struct
ada_symbol_info with struct symbol_in_block. Update field
references accordingly.
(block_lookup, select_possible_type_sym): Likewise.
(find_primitive_type): Likewise. Also update call to
ada_lookup_symbol to extract the symbol itself.
(write_var_or_type, write_name_assoc): Likewise.
* ada-lang.h (struct ada_symbol_info): Remove.
(ada_lookup_symbol_list): Replace struct ada_symbol_info with
struct symbol_in_block.
(ada_lookup_encoded_symbol, user_select_syms): Likewise.
(ada_lookup_symbol): Return struct symbol_in_block instead of a
mere symbol.
* ada-lang.c (defns_collected): Replace struct ada_symbol_info
with struct symbol_in_block.
(resolve_subexp, ada_resolve_function, sort_choices,
user_select_syms, is_nonfunction, add_defn_to_vec,
num_defns_collected, defns_collected,
symbols_are_identical_enums, remove_extra_symbols,
remove_irrelevant_renamings, add_lookup_symbol_list_worker,
ada_lookup_symbol_list, ada_iterate_over_symbols,
ada_lookup_encoded_symbol, get_var_value): Likewise.
(symbol_in_block): Return a symbol_in_block instead of a mere
symbol. Replace struct ada_symbol_info with struct
symbol_in_block.
(ada_lookup_symbol_nonlocal): Likewise.
(standard_lookup): Make block passing explicit through
lookup_symbol_in_language.
* ada-tasks.c (get_tcb_types_info): Update the calls to
lookup_symbol_in_language to extract the mere symbol out of the
returned value.
(ada_tasks_inferior_data_sniffer): Likewise.
* ax-gdb.c (gen_static_field): Likewise for the call to
lookup_symbol.
(gen_maybe_namespace_elt): Deal with struct symbol_in_block from
lookup functions.
(gen_expr): Likewise.
* c-exp.y: Likewise. Remove uses of block_found.
(lex_one_token, classify_name, classify_inner_name,
c_print_token): Likewise.
* c-valprint.c (print_unpacked_pointer): Likewise.
* compile/compile-c-symbols.c (convert_symbol_sym): Add a BLOCK
parameter. Use it to remove uses of block_found. Deal with
struct symbol_in_block from lookup functions.
(gcc_convert_symbol): Likewise. Update the call to
convert_symbol_sym.
* compile-object-load.c (compile_object_load): Deal with struct
symbol_in_block from lookup functions.
* cp-namespace.c (cp_lookup_nested_symbol_1,
cp_lookup_nested_symbol, cp_lookup_bare_symbol,
cp_search_static_and_baseclasses,
cp_lookup_symbol_in_namespace, cp_lookup_symbol_via_imports,
cp_lookup_symbol_imports_or_template,
cp_lookup_symbol_via_all_imports, cp_lookup_symbol_namespace,
lookup_namespace_scope, cp_lookup_nonlocal,
find_symbol_in_baseclass): Return struct symbol_in_block instead
of mere symbols and deal with struct symbol_in_block from lookup
functions.
* cp-support.c (inspect_type, replace_typedefs,
cp_lookup_rtti_type): Deal with struct symbol_in_block from
lookup functions.
* cp-support.h (cp_lookup_symbol_nonlocal,
cp_lookup_symbol_from_namespace,
cp_lookup_symbol_imports_or_template, cp_lookup_nested_symbol):
Return struct symbol_in_block instead of mere symbols.
* d-exp.y (d_type_from_name, d_module_from_name, push_variable,
push_module_name):
Deal with struct symbol_in_block from lookup functions. Remove
uses of block_found.
* eval.c (evaluate_subexp_standard): Update call to
cp_lookup_symbol_namespace.
* f-exp.y: Deal with struct symbol_in_block from lookup
functions. Remove uses of block_found.
(yylex): Likewise.
* gdbtypes.c (lookup_typename, lookup_struct, lookup_union,
lookup_enum, lookup_template_type, check_typedef): Deal with
struct symbol_in_block from lookup functions.
* gnu-v3-abi.c (gnuv3_get_typeid_type): Likewise.
* go-exp.y: Likewise. Remove uses of block_found.
(package_name_p, classify_packaged_name, classify_name):
Likewise.
* infrun.c (insert_exception_resume_breakpoint): Likewise.
* jv-exp.y (push_variable): Likewise.
* jv-lang.c (java_lookup_class, get_java_object_type): Likewise.
* language.c (language_bool_type): Likewise.
* language.h (struct language_defn): Update
la_lookup_symbol_nonlocal to return a struct symbol_in_block
rather than a mere symbol.
* linespec.c (find_label_symbols): Deal with struct
symbol_in_block from lookup functions.
* m2-exp.y: Likewise. Remove uses of block_found.
(yylex): Likewise.
* mi/mi-cmd-stack.c (list_args_or_locals): Likewise.
* objc-lang.c (lookup_struct_typedef, find_imps): Likewise.
* p-exp.y: Likewise. Remove uses of block_found.
(yylex): Likewise.
* p-valprint.c (pascal_val_print): Likewise.
* parse.c (write_dollar_variable): Likewise. Remove uses of
block_found.
* parser-defs.h (struct symtoken): Turn the SYM field into a
struct symbol_in_block.
* printcmd.c (address_info): Deal with struct symbol_in_block
from lookup functions.
* python/py-frame.c (frapy_read_var): Likewise.
* python/py-symbol.c (gdbpy_lookup_symbol,
gdbpy_lookup_global_symbol): Likewise.
* skip.c (skip_function_command): Likewise.
* solib-darwin.c (darwin_lookup_lib_symbol): Return a struct
symbol_in_block instead of a mere symbol.
* solib-spu.c (spu_lookup_lib_symbol): Likewise.
* solib-srv4.c (elf_lookup_lib_symbol): Likewise.
* solib.c (solib_global_lookup): Likewise.
* solist.h (solib_global_lookup): Likewise.
(struct target_so_ops): Update lookup_lib_global_symbol to
return a struct symbol_in_block rather than a mere symbol.
* source.c (select_source_symtab): Deal with struct
symbol_in_block from lookup functions.
* stack.c (print_frame_args, iterate_over_block_arg_vars):
Likewise.
* symfile.c (set_initial_language): Likewise.
* symtab.c (SYMBOL_LOOKUP_FAILED): Turn into a struct
symbol_in_block.
(SYMBOL_LOOKUP_FAILED_P): New predicate as a macro.
(struct symbol_cache_slot): Turn the FOUND field into a struct
symbol_in_block.
(block_found): Remove.
(eq_symbol_entry): Update to deal with struct symbol_in_block in
cache slots.
(symbol_cache_lookup): Return a struct symbol_in_block rather
than a mere symbol.
(symbol_cache_mark_found): Add a BLOCK parameter to fill
appropriately the cache slots. Update callers.
(symbol_cache_dump): Update cache slots handling to the type
change.
(lookup_symbol_in_language, lookup_symbol, lookup_language_this,
lookup_symbol_aux, lookup_local_symbol,
lookup_symbol_in_objfile, lookup_global_symbol_from_objfile,
lookup_symbol_in_objfile_symtabs,
lookup_symbol_in_objfile_from_linkage_name,
lookup_symbol_via_quick_fns, basic_lookup_symbol_nonlocal,
lookup_symbol_in_static_block, lookup_static_symbol,
lookup_global_symbol):
Return a struct symbol_in_block rather than a mere symbol. Deal
with struct symbol_in_block from other lookup functions. Remove
uses of block_found.
(lookup_symbol_in_block): Remove uses of block_found.
(struct global_sym_lookup_data): Turn the RESULT field into a
struct symbol_in_block.
(lookup_symbol_global_iterator_cb): Update references to the
RESULT field.
(search_symbols): Deal with struct symbol_in_block from lookup
functions.
* symtab.h (struct symbol_in_block): New structure.
(block_found): Remove.
(lookup_symbol_in_language, lookup_symbol,
basic_lookup_symbol_nonlocal, lookup_symbol_in_static_block,
looku_static_symbol, lookup_global_symbol,
lookup_symbol_in_block, lookup_language_this,
lookup_global_symbol_from_objfile): Return a struct
symbol_in_block rather than just a mere symbol. Update comments
to remove mentions of block_found.
* valops.c (find_function_in_inferior,
value_struct_elt_for_reference, value_maybe_namespace_elt,
value_of_this): Deal with struct symbol_in_block from lookup
functions.
* value.c (value_static_field, value_fn_field): Likewise.
---
gdb/ada-exp.y | 54 +++----
gdb/ada-lang.c | 224 ++++++++++++++--------------
gdb/ada-lang.h | 22 +--
gdb/ada-tasks.c | 15 +-
gdb/ax-gdb.c | 12 +-
gdb/c-exp.y | 85 +++++------
gdb/c-valprint.c | 2 +-
gdb/compile/compile-c-symbols.c | 28 ++--
gdb/compile/compile-object-load.c | 2 +-
gdb/cp-namespace.c | 177 +++++++++++-----------
gdb/cp-support.c | 6 +-
gdb/cp-support.h | 22 +--
gdb/d-exp.y | 28 ++--
gdb/eval.c | 2 +-
gdb/f-exp.y | 35 ++---
gdb/gdbtypes.c | 14 +-
gdb/gnu-v3-abi.c | 3 +-
gdb/go-exp.y | 32 ++--
gdb/infrun.c | 3 +-
gdb/jv-exp.y | 16 +-
gdb/jv-lang.c | 5 +-
gdb/language.c | 9 +-
gdb/language.h | 9 +-
gdb/linespec.c | 4 +-
gdb/m2-exp.y | 40 ++---
gdb/mi/mi-cmd-stack.c | 2 +-
gdb/objc-lang.c | 5 +-
gdb/p-exp.y | 57 +++----
gdb/p-valprint.c | 2 +-
gdb/parse.c | 8 +-
gdb/parser-defs.h | 2 +-
gdb/printcmd.c | 2 +-
gdb/python/py-frame.c | 2 +-
gdb/python/py-symbol.c | 4 +-
gdb/skip.c | 2 +-
gdb/solib-darwin.c | 4 +-
gdb/solib-spu.c | 4 +-
gdb/solib-svr4.c | 4 +-
gdb/solib.c | 4 +-
gdb/solist.h | 13 +-
gdb/source.c | 2 +-
gdb/stack.c | 4 +-
gdb/symfile.c | 2 +-
gdb/symtab.c | 305 +++++++++++++++++++-------------------
gdb/symtab.h | 86 ++++++-----
gdb/valops.c | 26 ++--
gdb/value.c | 8 +-
47 files changed, 713 insertions(+), 684 deletions(-)

diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y
index 9c0cace..16d8767 100644
--- a/gdb/ada-exp.y
+++ b/gdb/ada-exp.y
@@ -868,7 +868,7 @@ write_object_renaming (struct parser_state *par_state,
{
char *name;
enum { SIMPLE_INDEX, LOWER_BOUND, UPPER_BOUND } slice_state;
- struct ada_symbol_info sym_info;
+ struct symbol_in_block sym_info;

if (max_depth <= 0)
error (_("Could not find renamed symbol"));
@@ -878,9 +878,9 @@ write_object_renaming (struct parser_state *par_state,

name = obstack_copy0 (&temp_parse_space, renamed_entity, renamed_entity_len);
ada_lookup_encoded_symbol (name, orig_left_context, VAR_DOMAIN, &sym_info);
- if (sym_info.sym == NULL)
+ if (sym_info.symbol == NULL)
error (_("Could not find renamed variable: %s"), ada_decode (name));
- else if (SYMBOL_CLASS (sym_info.sym) == LOC_TYPEDEF)
+ else if (SYMBOL_CLASS (sym_info.symbol) == LOC_TYPEDEF)
/* We have a renaming of an old-style renaming symbol. Don't
trust the block information. */
sym_info.block = orig_left_context;
@@ -890,13 +890,13 @@ write_object_renaming (struct parser_state *par_state,
int inner_renamed_entity_len;
const char *inner_renaming_expr;

- switch (ada_parse_renaming (sym_info.sym, &inner_renamed_entity,
+ switch (ada_parse_renaming (sym_info.symbol, &inner_renamed_entity,
&inner_renamed_entity_len,
&inner_renaming_expr))
{
case ADA_NOT_RENAMING:
write_var_from_sym (par_state, orig_left_context, sym_info.block,
- sym_info.sym);
+ sym_info.symbol);
break;
case ADA_OBJECT_RENAMING:
write_object_renaming (par_state, sym_info.block,
@@ -939,7 +939,7 @@ write_object_renaming (struct parser_state *par_state,
{
const char *end;
char *index_name;
- struct ada_symbol_info index_sym_info;
+ struct symbol_in_block index_sym_info;

end = strchr (renaming_expr, 'X');
if (end == NULL)
@@ -952,13 +952,13 @@ write_object_renaming (struct parser_state *par_state,

ada_lookup_encoded_symbol (index_name, NULL, VAR_DOMAIN,
&index_sym_info);
- if (index_sym_info.sym == NULL)
+ if (index_sym_info.symbol == NULL)
error (_("Could not find %s"), index_name);
- else if (SYMBOL_CLASS (index_sym_info.sym) == LOC_TYPEDEF)
+ else if (SYMBOL_CLASS (index_sym_info.symbol) == LOC_TYPEDEF)
/* Index is an old-style renaming symbol. */
index_sym_info.block = orig_left_context;
write_var_from_sym (par_state, NULL, index_sym_info.block,
- index_sym_info.sym);
+ index_sym_info.symbol);
}
if (slice_state == SIMPLE_INDEX)
{
@@ -1013,7 +1013,7 @@ static const struct block*
block_lookup (const struct block *context, const char *raw_name)
{
const char *name;
- struct ada_symbol_info *syms;
+ struct symbol_in_block *syms;
int nsyms;
struct symtab *symtab;

@@ -1027,14 +1027,14 @@ block_lookup (const struct block *context, const char *raw_name)

nsyms = ada_lookup_symbol_list (name, context, VAR_DOMAIN, &syms);
if (context == NULL
- && (nsyms == 0 || SYMBOL_CLASS (syms[0].sym) != LOC_BLOCK))
+ && (nsyms == 0 || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK))
symtab = lookup_symtab (name);
else
symtab = NULL;

if (symtab != NULL)
return BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
- else if (nsyms == 0 || SYMBOL_CLASS (syms[0].sym) != LOC_BLOCK)
+ else if (nsyms == 0 || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK)
{
if (context == NULL)
error (_("No file or function \"%s\"."), raw_name);
@@ -1045,12 +1045,12 @@ block_lookup (const struct block *context, const char *raw_name)
{
if (nsyms > 1)
warning (_("Function name \"%s\" ambiguous here"), raw_name);
- return SYMBOL_BLOCK_VALUE (syms[0].sym);
+ return SYMBOL_BLOCK_VALUE (syms[0].symbol);
}
}

static struct symbol*
-select_possible_type_sym (struct ada_symbol_info *syms, int nsyms)
+select_possible_type_sym (struct symbol_in_block *syms, int nsyms)
{
int i;
int preferred_index;
@@ -1058,13 +1058,13 @@ select_possible_type_sym (struct ada_symbol_info *syms, int nsyms)

preferred_index = -1; preferred_type = NULL;
for (i = 0; i < nsyms; i += 1)
- switch (SYMBOL_CLASS (syms[i].sym))
+ switch (SYMBOL_CLASS (syms[i].symbol))
{
case LOC_TYPEDEF:
- if (ada_prefer_type (SYMBOL_TYPE (syms[i].sym), preferred_type))
+ if (ada_prefer_type (SYMBOL_TYPE (syms[i].symbol), preferred_type))
{
preferred_index = i;
- preferred_type = SYMBOL_TYPE (syms[i].sym);
+ preferred_type = SYMBOL_TYPE (syms[i].symbol);
}
break;
case LOC_REGISTER:
@@ -1079,7 +1079,7 @@ select_possible_type_sym (struct ada_symbol_info *syms, int nsyms)
}
if (preferred_type == NULL)
return NULL;
- return syms[preferred_index].sym;
+ return syms[preferred_index].symbol;
}

static struct type*
@@ -1101,7 +1101,7 @@ find_primitive_type (struct parser_state *par_state, char *name)
(char *) alloca (strlen (name) + sizeof ("standard__"));
strcpy (expanded_name, "standard__");
strcat (expanded_name, name);
- sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN, NULL);
+ sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN, NULL).symbol;
if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
type = SYMBOL_TYPE (sym);
}
@@ -1274,7 +1274,7 @@ write_var_or_type (struct parser_state *par_state,
while (tail_index > 0)
{
int nsyms;
- struct ada_symbol_info *syms;
+ struct symbol_in_block *syms;
struct symbol *type_sym;
struct symbol *renaming_sym;
const char* renaming;
@@ -1294,10 +1294,10 @@ write_var_or_type (struct parser_state *par_state,
if (nsyms == 1)
{
struct symbol *ren_sym =
- ada_find_renaming_symbol (syms[0].sym, syms[0].block);
+ ada_find_renaming_symbol (syms[0].symbol, syms[0].block);

if (ren_sym != NULL)
- syms[0].sym = ren_sym;
+ syms[0].symbol = ren_sym;
}

type_sym = select_possible_type_sym (syms, nsyms);
@@ -1305,7 +1305,7 @@ write_var_or_type (struct parser_state *par_state,
if (type_sym != NULL)
renaming_sym = type_sym;
else if (nsyms == 1)
- renaming_sym = syms[0].sym;
+ renaming_sym = syms[0].symbol;
else
renaming_sym = NULL;

@@ -1367,7 +1367,7 @@ write_var_or_type (struct parser_state *par_state,
if (nsyms == 1)
{
write_var_from_sym (par_state, block, syms[0].block,
- syms[0].sym);
+ syms[0].symbol);
write_selectors (par_state, encoded_name + tail_index);
return NULL;
}
@@ -1433,13 +1433,13 @@ write_name_assoc (struct parser_state *par_state, struct stoken name)
{
if (strchr (name.ptr, '.') == NULL)
{
- struct ada_symbol_info *syms;
+ struct symbol_in_block *syms;
int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block,
VAR_DOMAIN, &syms);
- if (nsyms != 1 || SYMBOL_CLASS (syms[0].sym) == LOC_TYPEDEF)
+ if (nsyms != 1 || SYMBOL_CLASS (syms[0].symbol) == LOC_TYPEDEF)
write_exp_op_with_string (par_state, OP_NAME, name);
else
- write_var_from_sym (par_state, NULL, syms[0].block, syms[0].sym);
+ write_var_from_sym (par_state, NULL, syms[0].block, syms[0].symbol);
}
else
if (write_var_or_type (par_state, NULL, name) != NULL)
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 06c72ee..ded195f 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -108,14 +108,14 @@ static void ada_add_block_symbols (struct obstack *,
const struct block *, const char *,
domain_enum, struct objfile *, int);

-static int is_nonfunction (struct ada_symbol_info *, int);
+static int is_nonfunction (struct symbol_in_block *, int);

static void add_defn_to_vec (struct obstack *, struct symbol *,
const struct block *);

static int num_defns_collected (struct obstack *);

-static struct ada_symbol_info *defns_collected (struct obstack *, int);
+static struct symbol_in_block *defns_collected (struct obstack *, int);

static struct value *resolve_subexp (struct expression **, int *, int,
struct type *);
@@ -223,7 +223,7 @@ static int find_struct_field (const char *, struct type *, int,
static struct value *ada_to_fixed_value_create (struct type *, CORE_ADDR,
struct value *);

-static int ada_resolve_function (struct ada_symbol_info *, int,
+static int ada_resolve_function (struct symbol_in_block *, int,
struct value **, int, const char *,
struct type *);

@@ -3311,7 +3311,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
case OP_VAR_VALUE:
if (SYMBOL_DOMAIN (exp->elts[pc + 2].symbol) == UNDEF_DOMAIN)
{
- struct ada_symbol_info *candidates;
+ struct symbol_in_block *candidates;
int n_candidates;

n_candidates =
@@ -3327,7 +3327,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
out all types. */
int j;
for (j = 0; j < n_candidates; j += 1)
- switch (SYMBOL_CLASS (candidates[j].sym))
+ switch (SYMBOL_CLASS (candidates[j].symbol))
{
case LOC_REGISTER:
case LOC_ARG:
@@ -3345,7 +3345,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
j = 0;
while (j < n_candidates)
{
- if (SYMBOL_CLASS (candidates[j].sym) == LOC_TYPEDEF)
+ if (SYMBOL_CLASS (candidates[j].symbol) == LOC_TYPEDEF)
{
candidates[j] = candidates[n_candidates - 1];
n_candidates -= 1;
@@ -3381,7 +3381,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
}

exp->elts[pc + 1].block = candidates[i].block;
- exp->elts[pc + 2].symbol = candidates[i].sym;
+ exp->elts[pc + 2].symbol = candidates[i].symbol;
if (innermost_block == NULL
|| contained_in (candidates[i].block, innermost_block))
innermost_block = candidates[i].block;
@@ -3403,7 +3403,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
if (exp->elts[pc + 3].opcode == OP_VAR_VALUE
&& SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN)
{
- struct ada_symbol_info *candidates;
+ struct symbol_in_block *candidates;
int n_candidates;

n_candidates =
@@ -3426,7 +3426,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
}

exp->elts[pc + 4].block = candidates[i].block;
- exp->elts[pc + 5].symbol = candidates[i].sym;
+ exp->elts[pc + 5].symbol = candidates[i].symbol;
if (innermost_block == NULL
|| contained_in (candidates[i].block, innermost_block))
innermost_block = candidates[i].block;
@@ -3456,7 +3456,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
case UNOP_ABS:
if (possible_user_operator_p (op, argvec))
{
- struct ada_symbol_info *candidates;
+ struct symbol_in_block *candidates;
int n_candidates;

n_candidates =
@@ -3468,8 +3468,9 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
if (i < 0)
break;

- replace_operator_with_call (expp, pc, nargs, 1,
- candidates[i].sym, candidates[i].block);
+ replace_operator_with_call (expp, pc, nargs, 1,
+ candidates[i].symbol,
+ candidates[i].block);
exp = *expp;
}
break;
@@ -3623,7 +3624,7 @@ return_match (struct type *func_type, struct type *context_type)
the process; the index returned is for the modified vector. */

static int
-ada_resolve_function (struct ada_symbol_info syms[],
+ada_resolve_function (struct symbol_in_block syms[],
int nsyms, struct value **args, int nargs,
const char *name, struct type *context_type)
{
@@ -3639,9 +3640,9 @@ ada_resolve_function (struct ada_symbol_info syms[],
{
for (k = 0; k < nsyms; k += 1)
{
- struct type *type = ada_check_typedef (SYMBOL_TYPE (syms[k].sym));
+ struct type *type = ada_check_typedef (SYMBOL_TYPE (syms[k].symbol));

- if (ada_args_match (syms[k].sym, args, nargs)
+ if (ada_args_match (syms[k].symbol, args, nargs)
&& (fallback || return_match (type, context_type)))
{
syms[m] = syms[k];
@@ -3704,19 +3705,19 @@ encoded_ordered_before (const char *N0, const char *N1)
encoded names. */

static void
-sort_choices (struct ada_symbol_info syms[], int nsyms)
+sort_choices (struct symbol_in_block syms[], int nsyms)
{
int i;

for (i = 1; i < nsyms; i += 1)
{
- struct ada_symbol_info sym = syms[i];
+ struct symbol_in_block sym = syms[i];
int j;

for (j = i - 1; j >= 0; j -= 1)
{
- if (encoded_ordered_before (SYMBOL_LINKAGE_NAME (syms[j].sym),
- SYMBOL_LINKAGE_NAME (sym.sym)))
+ if (encoded_ordered_before (SYMBOL_LINKAGE_NAME (syms[j].symbol),
+ SYMBOL_LINKAGE_NAME (sym.symbol)))
break;
syms[j + 1] = syms[j];
}
@@ -3733,7 +3734,7 @@ sort_choices (struct ada_symbol_info syms[], int nsyms)
to be re-integrated one of these days. */

int
-user_select_syms (struct ada_symbol_info *syms, int nsyms, int max_results)
+user_select_syms (struct symbol_in_block *syms, int nsyms, int max_results)
{
int i;
int *chosen = (int *) alloca (sizeof (int) * nsyms);
@@ -3765,22 +3766,22 @@ See set/show multiple-symbol."));

for (i = 0; i < nsyms; i += 1)
{
- if (syms[i].sym == NULL)
+ if (syms[i].symbol == NULL)
continue;

- if (SYMBOL_CLASS (syms[i].sym) == LOC_BLOCK)
+ if (SYMBOL_CLASS (syms[i].symbol) == LOC_BLOCK)
{
struct symtab_and_line sal =
- find_function_start_sal (syms[i].sym, 1);
+ find_function_start_sal (syms[i].symbol, 1);

if (sal.symtab == NULL)
printf_unfiltered (_("[%d] %s at <no source file available>:%d\n"),
i + first_choice,
- SYMBOL_PRINT_NAME (syms[i].sym),
+ SYMBOL_PRINT_NAME (syms[i].symbol),
sal.line);
else
printf_unfiltered (_("[%d] %s at %s:%d\n"), i + first_choice,
- SYMBOL_PRINT_NAME (syms[i].sym),
+ SYMBOL_PRINT_NAME (syms[i].symbol),
symtab_to_filename_for_display (sal.symtab),
sal.line);
continue;
@@ -3788,42 +3789,42 @@ See set/show multiple-symbol."));
else
{
int is_enumeral =
- (SYMBOL_CLASS (syms[i].sym) == LOC_CONST
- && SYMBOL_TYPE (syms[i].sym) != NULL
- && TYPE_CODE (SYMBOL_TYPE (syms[i].sym)) == TYPE_CODE_ENUM);
+ (SYMBOL_CLASS (syms[i].symbol) == LOC_CONST
+ && SYMBOL_TYPE (syms[i].symbol) != NULL
+ && TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) == TYPE_CODE_ENUM);
struct symtab *symtab = NULL;

- if (SYMBOL_OBJFILE_OWNED (syms[i].sym))
- symtab = symbol_symtab (syms[i].sym);
+ if (SYMBOL_OBJFILE_OWNED (syms[i].symbol))
+ symtab = symbol_symtab (syms[i].symbol);

- if (SYMBOL_LINE (syms[i].sym) != 0 && symtab != NULL)
+ if (SYMBOL_LINE (syms[i].symbol) != 0 && symtab != NULL)
printf_unfiltered (_("[%d] %s at %s:%d\n"),
i + first_choice,
- SYMBOL_PRINT_NAME (syms[i].sym),
+ SYMBOL_PRINT_NAME (syms[i].symbol),
symtab_to_filename_for_display (symtab),
- SYMBOL_LINE (syms[i].sym));
+ SYMBOL_LINE (syms[i].symbol));
else if (is_enumeral
- && TYPE_NAME (SYMBOL_TYPE (syms[i].sym)) != NULL)
+ && TYPE_NAME (SYMBOL_TYPE (syms[i].symbol)) != NULL)
{
printf_unfiltered (("[%d] "), i + first_choice);
- ada_print_type (SYMBOL_TYPE (syms[i].sym), NULL,
+ ada_print_type (SYMBOL_TYPE (syms[i].symbol), NULL,
gdb_stdout, -1, 0, &type_print_raw_options);
printf_unfiltered (_("'(%s) (enumeral)\n"),
- SYMBOL_PRINT_NAME (syms[i].sym));
+ SYMBOL_PRINT_NAME (syms[i].symbol));
}
else if (symtab != NULL)
printf_unfiltered (is_enumeral
? _("[%d] %s in %s (enumeral)\n")
: _("[%d] %s at %s:?\n"),
i + first_choice,
- SYMBOL_PRINT_NAME (syms[i].sym),
+ SYMBOL_PRINT_NAME (syms[i].symbol),
symtab_to_filename_for_display (symtab));
else
printf_unfiltered (is_enumeral
? _("[%d] %s (enumeral)\n")
: _("[%d] %s at ?\n"),
i + first_choice,
- SYMBOL_PRINT_NAME (syms[i].sym));
+ SYMBOL_PRINT_NAME (syms[i].symbol));
}
}

@@ -4603,13 +4604,13 @@ standard_lookup (const char *name, const struct block *block,
domain_enum domain)
{
/* Initialize it just to avoid a GCC false warning. */
- struct symbol *sym = NULL;
+ struct symbol_in_block sym = {NULL, NULL};

- if (lookup_cached_symbol (name, domain, &sym, NULL))
- return sym;
+ if (lookup_cached_symbol (name, domain, &sym.symbol, NULL))
+ return sym.symbol;
sym = lookup_symbol_in_language (name, block, domain, language_c, 0);
- cache_symbol (name, domain, sym, block_found);
- return sym;
+ cache_symbol (name, domain, sym.symbol, sym.block);
+ return sym.symbol;
}

@@ -4617,14 +4618,14 @@ standard_lookup (const char *name, const struct block *block,
in the symbol fields of SYMS[0..N-1]. We treat enumerals as functions,
since they contend in overloading in the same way. */
static int
-is_nonfunction (struct ada_symbol_info syms[], int n)
+is_nonfunction (struct symbol_in_block syms[], int n)
{
int i;

for (i = 0; i < n; i += 1)
- if (TYPE_CODE (SYMBOL_TYPE (syms[i].sym)) != TYPE_CODE_FUNC
- && (TYPE_CODE (SYMBOL_TYPE (syms[i].sym)) != TYPE_CODE_ENUM
- || SYMBOL_CLASS (syms[i].sym) != LOC_CONST))
+ if (TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) != TYPE_CODE_FUNC
+ && (TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) != TYPE_CODE_ENUM
+ || SYMBOL_CLASS (syms[i].symbol) != LOC_CONST))
return 1;

return 0;
@@ -4688,7 +4689,7 @@ lesseq_defined_than (struct symbol *sym0, struct symbol *sym1)
}
}

-/* Append (SYM,BLOCK,SYMTAB) to the end of the array of struct ada_symbol_info
+/* Append (SYM,BLOCK,SYMTAB) to the end of the array of struct symbol_in_block
records in OBSTACKP. Do nothing if SYM is a duplicate. */

static void
@@ -4697,7 +4698,7 @@ add_defn_to_vec (struct obstack *obstackp,
const struct block *block)
{
int i;
- struct ada_symbol_info *prevDefns = defns_collected (obstackp, 0);
+ struct symbol_in_block *prevDefns = defns_collected (obstackp, 0);

/* Do not try to complete stub types, as the debugger is probably
already scanning all symbols matching a certain name at the
@@ -4710,45 +4711,45 @@ add_defn_to_vec (struct obstack *obstackp,

for (i = num_defns_collected (obstackp) - 1; i >= 0; i -= 1)
{
- if (lesseq_defined_than (sym, prevDefns[i].sym))
+ if (lesseq_defined_than (sym, prevDefns[i].symbol))
return;
- else if (lesseq_defined_than (prevDefns[i].sym, sym))
+ else if (lesseq_defined_than (prevDefns[i].symbol, sym))
{
- prevDefns[i].sym = sym;
+ prevDefns[i].symbol = sym;
prevDefns[i].block = block;
return;
}
}

{
- struct ada_symbol_info info;
+ struct symbol_in_block info;

- info.sym = sym;
+ info.symbol = sym;
info.block = block;
- obstack_grow (obstackp, &info, sizeof (struct ada_symbol_info));
+ obstack_grow (obstackp, &info, sizeof (struct symbol_in_block));
}
}

-/* Number of ada_symbol_info structures currently collected in
+/* Number of symbol_in_block structures currently collected in
current vector in *OBSTACKP. */

static int
num_defns_collected (struct obstack *obstackp)
{
- return obstack_object_size (obstackp) / sizeof (struct ada_symbol_info);
+ return obstack_object_size (obstackp) / sizeof (struct symbol_in_block);
}

-/* Vector of ada_symbol_info structures currently collected in current
+/* Vector of symbol_in_block structures currently collected in current
vector in *OBSTACKP. If FINISH, close off the vector and return
its final address. */

-static struct ada_symbol_info *
+static struct symbol_in_block *
defns_collected (struct obstack *obstackp, int finish)
{
if (finish)
return obstack_finish (obstackp);
else
- return (struct ada_symbol_info *) obstack_base (obstackp);
+ return (struct symbol_in_block *) obstack_base (obstackp);
}

/* Return a bound minimal symbol matching NAME according to Ada
@@ -4879,7 +4880,7 @@ ada_identical_enum_types_p (struct type *type1, struct type *type2)
So, for practical purposes, we consider them as the same. */

static int
-symbols_are_identical_enums (struct ada_symbol_info *syms, int nsyms)
+symbols_are_identical_enums (struct symbol_in_block *syms, int nsyms)
{
int i;

@@ -4892,26 +4893,26 @@ symbols_are_identical_enums (struct ada_symbol_info *syms, int nsyms)

/* Quick check: All symbols should have an enum type. */
for (i = 0; i < nsyms; i++)
- if (TYPE_CODE (SYMBOL_TYPE (syms[i].sym)) != TYPE_CODE_ENUM)
+ if (TYPE_CODE (SYMBOL_TYPE (syms[i].symbol)) != TYPE_CODE_ENUM)
return 0;

/* Quick check: They should all have the same value. */
for (i = 1; i < nsyms; i++)
- if (SYMBOL_VALUE (syms[i].sym) != SYMBOL_VALUE (syms[0].sym))
+ if (SYMBOL_VALUE (syms[i].symbol) != SYMBOL_VALUE (syms[0].symbol))
return 0;

/* Quick check: They should all have the same number of enumerals. */
for (i = 1; i < nsyms; i++)
- if (TYPE_NFIELDS (SYMBOL_TYPE (syms[i].sym))
- != TYPE_NFIELDS (SYMBOL_TYPE (syms[0].sym)))
+ if (TYPE_NFIELDS (SYMBOL_TYPE (syms[i].symbol))
+ != TYPE_NFIELDS (SYMBOL_TYPE (syms[0].symbol)))
return 0;

/* All the sanity checks passed, so we might have a set of
identical enumeration types. Perform a more complete
comparison of the type of each symbol. */
for (i = 1; i < nsyms; i++)
- if (!ada_identical_enum_types_p (SYMBOL_TYPE (syms[i].sym),
- SYMBOL_TYPE (syms[0].sym)))
+ if (!ada_identical_enum_types_p (SYMBOL_TYPE (syms[i].symbol),
+ SYMBOL_TYPE (syms[0].symbol)))
return 0;

return 1;
@@ -4925,7 +4926,7 @@ symbols_are_identical_enums (struct ada_symbol_info *syms, int nsyms)
Returns the number of items in the modified list. */

static int
-remove_extra_symbols (struct ada_symbol_info *syms, int nsyms)
+remove_extra_symbols (struct symbol_in_block *syms, int nsyms)
{
int i, j;

@@ -4943,16 +4944,16 @@ remove_extra_symbols (struct ada_symbol_info *syms, int nsyms)
/* If two symbols have the same name and one of them is a stub type,
the get rid of the stub. */

- if (TYPE_STUB (SYMBOL_TYPE (syms[i].sym))
- && SYMBOL_LINKAGE_NAME (syms[i].sym) != NULL)
+ if (TYPE_STUB (SYMBOL_TYPE (syms[i].symbol))
+ && SYMBOL_LINKAGE_NAME (syms[i].symbol) != NULL)
{
for (j = 0; j < nsyms; j++)
{
if (j != i
- && !TYPE_STUB (SYMBOL_TYPE (syms[j].sym))
- && SYMBOL_LINKAGE_NAME (syms[j].sym) != NULL
- && strcmp (SYMBOL_LINKAGE_NAME (syms[i].sym),
- SYMBOL_LINKAGE_NAME (syms[j].sym)) == 0)
+ && !TYPE_STUB (SYMBOL_TYPE (syms[j].symbol))
+ && SYMBOL_LINKAGE_NAME (syms[j].symbol) != NULL
+ && strcmp (SYMBOL_LINKAGE_NAME (syms[i].symbol),
+ SYMBOL_LINKAGE_NAME (syms[j].symbol)) == 0)
remove_p = 1;
}
}
@@ -4960,19 +4961,20 @@ remove_extra_symbols (struct ada_symbol_info *syms, int nsyms)
/* Two symbols with the same name, same class and same address
should be identical. */

- else if (SYMBOL_LINKAGE_NAME (syms[i].sym) != NULL
- && SYMBOL_CLASS (syms[i].sym) == LOC_STATIC
- && is_nondebugging_type (SYMBOL_TYPE (syms[i].sym)))
+ else if (SYMBOL_LINKAGE_NAME (syms[i].symbol) != NULL
+ && SYMBOL_CLASS (syms[i].symbol) == LOC_STATIC
+ && is_nondebugging_type (SYMBOL_TYPE (syms[i].symbol)))
{
for (j = 0; j < nsyms; j += 1)
{
if (i != j
- && SYMBOL_LINKAGE_NAME (syms[j].sym) != NULL
- && strcmp (SYMBOL_LINKAGE_NAME (syms[i].sym),
- SYMBOL_LINKAGE_NAME (syms[j].sym)) == 0
- && SYMBOL_CLASS (syms[i].sym) == SYMBOL_CLASS (syms[j].sym)
- && SYMBOL_VALUE_ADDRESS (syms[i].sym)
- == SYMBOL_VALUE_ADDRESS (syms[j].sym))
+ && SYMBOL_LINKAGE_NAME (syms[j].symbol) != NULL
+ && strcmp (SYMBOL_LINKAGE_NAME (syms[i].symbol),
+ SYMBOL_LINKAGE_NAME (syms[j].symbol)) == 0
+ && SYMBOL_CLASS (syms[i].symbol)
+ == SYMBOL_CLASS (syms[j].symbol)
+ && SYMBOL_VALUE_ADDRESS (syms[i].symbol)
+ == SYMBOL_VALUE_ADDRESS (syms[j].symbol))
remove_p = 1;
}
}
@@ -5151,7 +5153,7 @@ old_renaming_is_invisible (const struct symbol *sym, const char *function_name)
the user will be unable to print such rename entities. */

static int
-remove_irrelevant_renamings (struct ada_symbol_info *syms,
+remove_irrelevant_renamings (struct symbol_in_block *syms,
int nsyms, const struct block *current_block)
{
struct symbol *current_function;
@@ -5165,7 +5167,7 @@ remove_irrelevant_renamings (struct ada_symbol_info *syms,
is_new_style_renaming = 0;
for (i = 0; i < nsyms; i += 1)
{
- struct symbol *sym = syms[i].sym;
+ struct symbol *sym = syms[i].symbol;
const struct block *block = syms[i].block;
const char *name;
const char *suffix;
@@ -5182,11 +5184,11 @@ remove_irrelevant_renamings (struct ada_symbol_info *syms,

is_new_style_renaming = 1;
for (j = 0; j < nsyms; j += 1)
- if (i != j && syms[j].sym != NULL
- && strncmp (name, SYMBOL_LINKAGE_NAME (syms[j].sym),
+ if (i != j && syms[j].symbol != NULL
+ && strncmp (name, SYMBOL_LINKAGE_NAME (syms[j].symbol),
name_len) == 0
&& block == syms[j].block)
- syms[j].sym = NULL;
+ syms[j].symbol = NULL;
}
}
if (is_new_style_renaming)
@@ -5194,7 +5196,7 @@ remove_irrelevant_renamings (struct ada_symbol_info *syms,
int j, k;

for (j = k = 0; j < nsyms; j += 1)
- if (syms[j].sym != NULL)
+ if (syms[j].symbol != NULL)
{
syms[k] = syms[j];
k += 1;
@@ -5223,9 +5225,9 @@ remove_irrelevant_renamings (struct ada_symbol_info *syms,
i = 0;
while (i < nsyms)
{
- if (ada_parse_renaming (syms[i].sym, NULL, NULL, NULL)
+ if (ada_parse_renaming (syms[i].symbol, NULL, NULL, NULL)
== ADA_OBJECT_RENAMING
- && old_renaming_is_invisible (syms[i].sym, current_function_name))
+ && old_renaming_is_invisible (syms[i].symbol, current_function_name))
{
int j;

@@ -5479,7 +5481,7 @@ add_nonlocal_symbols (struct obstack *obstackp, const char *name,
static int
ada_lookup_symbol_list_worker (const char *name0, const struct block *block0,
domain_enum domain,
- struct ada_symbol_info **results,
+ struct symbol_in_block **results,
int full_search)
{
struct symbol *sym;
@@ -5566,7 +5568,7 @@ done:
cache_symbol (name0, domain, NULL, NULL);

if (ndefns == 1 && full_search && syms_from_global_search)
- cache_symbol (name0, domain, (*results)[0].sym, (*results)[0].block);
+ cache_symbol (name0, domain, (*results)[0].symbol, (*results)[0].block);

ndefns = remove_irrelevant_renamings (*results, ndefns, block0);

@@ -5580,7 +5582,7 @@ done:

int
ada_lookup_symbol_list (const char *name0, const struct block *block0,
- domain_enum domain, struct ada_symbol_info **results)
+ domain_enum domain, struct symbol_in_block **results)
{
return ada_lookup_symbol_list_worker (name0, block0, domain, results, 1);
}
@@ -5594,12 +5596,12 @@ ada_iterate_over_symbols (const struct block *block,
void *data)
{
int ndefs, i;
- struct ada_symbol_info *results;
+ struct symbol_in_block *results;

ndefs = ada_lookup_symbol_list_worker (name, block, domain, &results, 0);
for (i = 0; i < ndefs; ++i)
{
- if (! (*callback) (results[i].sym, data))
+ if (! (*callback) (results[i].symbol, data))
break;
}
}
@@ -5639,20 +5641,20 @@ ada_name_for_lookup (const char *name)
void
ada_lookup_encoded_symbol (const char *name, const struct block *block,
domain_enum domain,
- struct ada_symbol_info *info)
+ struct symbol_in_block *info)
{
- struct ada_symbol_info *candidates;
+ struct symbol_in_block *candidates;
int n_candidates;

gdb_assert (info != NULL);
- memset (info, 0, sizeof (struct ada_symbol_info));
+ memset (info, 0, sizeof (struct symbol_in_block));

n_candidates = ada_lookup_symbol_list (name, block, domain, &candidates);
if (n_candidates == 0)
return;

*info = candidates[0];
- info->sym = fixup_symbol_section (info->sym, NULL);
+ info->symbol = fixup_symbol_section (info->symbol, NULL);
}

/* Return a symbol in DOMAIN matching NAME, in BLOCK0 and enclosing
@@ -5661,30 +5663,30 @@ ada_lookup_encoded_symbol (const char *name, const struct block *block,
choosing the first symbol if there are multiple choices.
If IS_A_FIELD_OF_THIS is not NULL, it is set to zero. */

-struct symbol *
+struct symbol_in_block
ada_lookup_symbol (const char *name, const struct block *block0,
domain_enum domain, int *is_a_field_of_this)
{
- struct ada_symbol_info info;
+ struct symbol_in_block info;

if (is_a_field_of_this != NULL)
*is_a_field_of_this = 0;

ada_lookup_encoded_symbol (ada_encode (ada_fold_name (name)),
block0, domain, &info);
- return info.sym;
+ return info;
}

-static struct symbol *
+static struct symbol_in_block
ada_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
const domain_enum domain)
{
- struct symbol *sym;
+ struct symbol_in_block sym;

sym = ada_lookup_symbol (name, block_static_block (block), domain, NULL);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;

/* If we haven't found a match at this point, try the primitive
@@ -5707,12 +5709,12 @@ ada_lookup_symbol_nonlocal (const struct language_defn *langdef,
gdbarch = target_gdbarch ();
else
gdbarch = block_gdbarch (block);
- sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
- if (sym != NULL)
+ sym.symbol = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
+ if (sym.symbol != NULL)
return sym;
}

- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

@@ -11372,7 +11374,7 @@ scan_discrim_bound (char *str, int k, struct value *dval, LONGEST * px,
static struct value *
get_var_value (char *name, char *err_msg)
{
- struct ada_symbol_info *syms;
+ struct symbol_in_block *syms;
int nsyms;

nsyms = ada_lookup_symbol_list (name, get_selected_block (0), VAR_DOMAIN,
@@ -11386,7 +11388,7 @@ get_var_value (char *name, char *err_msg)
error (("%s"), err_msg);
}

- return value_of_variable (syms[0].sym, syms[0].block);
+ return value_of_variable (syms[0].symbol, syms[0].block);
}

/* Value of integer variable named NAME in the current environment. If
diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h
index 12761bf..effa79a 100644
--- a/gdb/ada-lang.h
+++ b/gdb/ada-lang.h
@@ -79,17 +79,6 @@ struct ada_opname_map
/* Defined in ada-lang.c */
extern const struct ada_opname_map ada_opname_table[];

-/* A tuple representing one instance of a symbol-lookup operation. */
-
-struct ada_symbol_info
-{
- /* The symbol that was found. */
- struct symbol *sym;
-
- /* The block where the symbol was found. */
- const struct block *block;
-};
-
/* Denotes a type of renaming symbol (see ada_parse_renaming). */
enum ada_renaming_category
{
@@ -236,22 +225,23 @@ extern const char *ada_decode (const char*);
extern enum language ada_update_initial_language (enum language);

extern int ada_lookup_symbol_list (const char *, const struct block *,
- domain_enum, struct ada_symbol_info**);
+ domain_enum, struct symbol_in_block**);

extern char *ada_fold_name (const char *);

-extern struct symbol *ada_lookup_symbol (const char *, const struct block *,
- domain_enum, int *);
+extern struct symbol_in_block ada_lookup_symbol (const char *,
+ const struct block *,
+ domain_enum, int *);

extern void ada_lookup_encoded_symbol
(const char *name, const struct block *block, domain_enum domain,
- struct ada_symbol_info *symbol_info);
+ struct symbol_in_block *symbol_info);

extern struct bound_minimal_symbol ada_lookup_simple_minsym (const char *);

extern void ada_fill_in_ada_prototype (struct symbol *);

-extern int user_select_syms (struct ada_symbol_info *, int, int);
+extern int user_select_syms (struct symbol_in_block *, int, int);

extern int get_selections (int *, int, int, int, char *);

diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c
index fa28381..c97057e 100644
--- a/gdb/ada-tasks.c
+++ b/gdb/ada-tasks.c
@@ -471,23 +471,24 @@ get_tcb_types_info (void)

struct symbol *atcb_sym =
lookup_symbol_in_language (atcb_name, NULL, STRUCT_DOMAIN,
- language_c, NULL);
+ language_c, NULL).symbol;
const struct symbol *common_atcb_sym =
lookup_symbol_in_language (common_atcb_name, NULL, STRUCT_DOMAIN,
- language_c, NULL);
+ language_c, NULL).symbol;
const struct symbol *private_data_sym =
lookup_symbol_in_language (private_data_name, NULL, STRUCT_DOMAIN,
- language_c, NULL);
+ language_c, NULL).symbol;
const struct symbol *entry_call_record_sym =
lookup_symbol_in_language (entry_call_record_name, NULL, STRUCT_DOMAIN,
- language_c, NULL);
+ 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, NULL);
+ STRUCT_DOMAIN, language_c,
+ NULL).symbol;

if (atcb_sym == NULL || atcb_sym->type == NULL)
error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
@@ -863,7 +864,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)

/* Try to get pointer type and array length from the symtab. */
sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL, VAR_DOMAIN,
- language_c, NULL);
+ language_c, NULL).symbol;
if (sym != NULL)
{
/* Validate. */
@@ -908,7 +909,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
data->known_tasks_length = 1;

sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL, VAR_DOMAIN,
- language_c, NULL);
+ language_c, NULL).symbol;
if (sym != NULL && SYMBOL_VALUE_ADDRESS (sym) != 0)
{
/* Validate. */
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index b035486..d78f7ec 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -1556,7 +1556,7 @@ gen_static_field (struct gdbarch *gdbarch,
else
{
const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
- struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
+ struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0).symbol;

if (sym)
{
@@ -1647,20 +1647,20 @@ gen_maybe_namespace_elt (struct expression *exp,
const struct type *curtype, char *name)
{
const char *namespace_name = TYPE_TAG_NAME (curtype);
- struct symbol *sym;
+ struct symbol_in_block sym;

sym = cp_lookup_symbol_namespace (namespace_name, name,
block_for_pc (ax->scope),
VAR_DOMAIN);

- if (sym == NULL)
+ if (sym.symbol == NULL)
return 0;

- gen_var_ref (exp->gdbarch, ax, value, sym);
+ gen_var_ref (exp->gdbarch, ax, value, sym.symbol);

if (value->optimized_out)
error (_("`%s' has been optimized out, cannot use"),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));

return 1;
}
@@ -2194,7 +2194,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
func = block_linkage_function (b);
lang = language_def (SYMBOL_LANGUAGE (func));

- sym = lookup_language_this (lang, b);
+ sym = lookup_language_this (lang, b).symbol;
if (!sym)
error (_("no `%s' found"), lang->la_name_of_this);

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 3ea544d..b408215 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -923,8 +923,8 @@ exp : FALSEKEYWORD

block : BLOCKNAME
{
- if ($1.sym)
- $$ = SYMBOL_BLOCK_VALUE ($1.sym);
+ if ($1.sym.symbol)
+ $$ = SYMBOL_BLOCK_VALUE ($1.sym.symbol);
else
error (_("No file or function \"%s\"."),
copy_name ($1.stoken));
@@ -938,7 +938,7 @@ block : BLOCKNAME
block : block COLONCOLON name
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, NULL);
+ VAR_DOMAIN, NULL).symbol;
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
copy_name ($3));
@@ -946,7 +946,7 @@ block : block COLONCOLON name
;

variable: name_not_typename ENTRY
- { struct symbol *sym = $1.sym;
+ { struct symbol *sym = $1.sym.symbol;

if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
|| !symbol_read_needs_frame (sym))
@@ -961,24 +961,23 @@ variable: name_not_typename ENTRY
;

variable: block COLONCOLON name
- { struct symbol *sym;
- sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, NULL);
- if (sym == 0)
+ { struct symbol_in_block sym
+ = lookup_symbol (copy_name ($3), $1,
+ VAR_DOMAIN, NULL);
+ if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
copy_name ($3));
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0
- || contained_in (block_found,
+ || contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
}

write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- /* block_found is set by lookup_symbol. */
- write_exp_elt_block (pstate, block_found);
- write_exp_elt_sym (pstate, sym);
+ write_exp_elt_block (pstate, sym.block);
+ write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
;

@@ -1035,9 +1034,9 @@ variable: qualified_name
struct symbol *sym;
struct bound_minimal_symbol msymbol;

- sym =
- lookup_symbol (name, (const struct block *) NULL,
- VAR_DOMAIN, NULL);
+ sym
+ = lookup_symbol (name, (const struct block *) NULL,
+ VAR_DOMAIN, NULL).symbol;
if (sym)
{
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
@@ -1058,16 +1057,16 @@ variable: qualified_name
;

variable: name_not_typename
- { struct symbol *sym = $1.sym;
+ { struct symbol_in_block sym = $1.sym;

- if (sym)
+ if (sym.symbol)
{
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0
- || contained_in (block_found,
+ || contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
}

write_exp_elt_opcode (pstate, OP_VAR_VALUE);
@@ -1075,7 +1074,7 @@ variable: name_not_typename
another more inner frame which happens to
be in the same block. */
write_exp_elt_block (pstate, NULL);
- write_exp_elt_sym (pstate, sym);
+ write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
}
else if ($1.is_a_field_of_this)
@@ -1084,9 +1083,9 @@ variable: name_not_typename
not inadvertently convert from a method call
to data ref. */
if (innermost_block == 0
- || contained_in (block_found,
+ || contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
write_exp_elt_opcode (pstate, OP_THIS);
write_exp_elt_opcode (pstate, OP_THIS);
write_exp_elt_opcode (pstate, STRUCTOP_PTR);
@@ -2817,7 +2816,7 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
VAR_DOMAIN,
(parse_language (par_state)->la_language
== language_cplus ? &is_a_field_of_this
- : NULL))
+ : NULL)).symbol
!= NULL)
{
/* The keyword is shadowed. */
@@ -2838,7 +2837,8 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
saw_name_at_eof = 1;

yylval.ssym.stoken = yylval.sval;
- yylval.ssym.sym = NULL;
+ yylval.ssym.sym.symbol = NULL;
+ yylval.ssym.sym.block = NULL;
yylval.ssym.is_a_field_of_this = 0;
return NAME;
}
@@ -2873,7 +2873,7 @@ static int
classify_name (struct parser_state *par_state, const struct block *block,
int is_quoted_name)
{
- struct symbol *sym;
+ struct symbol_in_block sym;
char *copy;
struct field_of_this_result is_a_field_of_this;

@@ -2887,13 +2887,13 @@ classify_name (struct parser_state *par_state, const struct block *block,
parse_language (par_state)->la_name_of_this
? &is_a_field_of_this : NULL);

- if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_BLOCK)
{
yylval.ssym.sym = sym;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
return BLOCKNAME;
}
- else if (!sym)
+ else if (!sym.symbol)
{
/* If we found a field of 'this', we might have erroneously
found a constructor where we wanted a type name. Handle this
@@ -2908,9 +2908,9 @@ classify_name (struct parser_state *par_state, const struct block *block,

sym = lookup_symbol (copy, block, STRUCT_DOMAIN,
&inner_is_a_field_of_this);
- if (sym != NULL)
+ if (sym.symbol != NULL)
{
- yylval.tsym.type = SYMBOL_TYPE (sym);
+ yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
return TYPENAME;
}
}
@@ -2934,18 +2934,19 @@ classify_name (struct parser_state *par_state, const struct block *block,
}
}

- if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
{
- yylval.tsym.type = SYMBOL_TYPE (sym);
+ yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
return TYPENAME;
}

/* See if it's an ObjC classname. */
- if (parse_language (par_state)->la_language == language_objc && !sym)
+ if (parse_language (par_state)->la_language == language_objc && !sym.symbol)
{
CORE_ADDR Class = lookup_objc_class (parse_gdbarch (par_state), copy);
if (Class)
{
+ struct symbol *sym;
yylval.theclass.theclass = Class;
sym = lookup_struct_typedef (copy, expression_context_block, 1);
if (sym)
@@ -2957,7 +2958,7 @@ classify_name (struct parser_state *par_state, const struct block *block,
/* Input names that aren't symbols but ARE valid hex numbers, when
the input radix permits them, can be names or numbers depending
on the parse. Note we support radixes > 16 here. */
- if (!sym
+ if (!sym.symbol
&& ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
|| (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
{
@@ -2976,7 +2977,7 @@ classify_name (struct parser_state *par_state, const struct block *block,
yylval.ssym.sym = sym;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;

- if (sym == NULL
+ if (sym.symbol == NULL
&& parse_language (par_state)->la_language == language_cplus
&& is_a_field_of_this.type == NULL
&& lookup_minimal_symbol (copy, NULL, NULL).minsym == NULL)
@@ -3010,7 +3011,7 @@ classify_inner_name (struct parser_state *par_state,
/* If no symbol was found, search for a matching base class named
COPY. This will allow users to enter qualified names of class members
relative to the `this' pointer. */
- if (yylval.ssym.sym == NULL)
+ if (yylval.ssym.sym.symbol == NULL)
{
struct type *base_type = cp_find_type_baseclass_by_name (type, copy);

@@ -3023,7 +3024,7 @@ classify_inner_name (struct parser_state *par_state,
return ERROR;
}

- switch (SYMBOL_CLASS (yylval.ssym.sym))
+ switch (SYMBOL_CLASS (yylval.ssym.sym.symbol))
{
case LOC_BLOCK:
case LOC_LABEL:
@@ -3042,7 +3043,7 @@ classify_inner_name (struct parser_state *par_state,
return ERROR;

case LOC_TYPEDEF:
- yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);
+ yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
return TYPENAME;

default:
@@ -3302,8 +3303,8 @@ c_print_token (FILE *file, int type, YYSTYPE value)
case BLOCKNAME:
fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
copy_name (value.ssym.stoken),
- (value.ssym.sym == NULL
- ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym)),
+ (value.ssym.sym.symbol == NULL
+ ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym.symbol)),
value.ssym.is_a_field_of_this);
break;

diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 2009e95..1ad25cc 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -203,7 +203,7 @@ print_unpacked_pointer (struct type *type, struct type *elttype,

if (msymbol.minsym != NULL)
wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME(msymbol.minsym), block,
- VAR_DOMAIN, &is_this_fld);
+ VAR_DOMAIN, &is_this_fld).symbol;

if (wsym)
{
diff --git a/gdb/compile/compile-c-symbols.c b/gdb/compile/compile-c-symbols.c
index 68d38ba..5f27583 100644
--- a/gdb/compile/compile-c-symbols.c
+++ b/gdb/compile/compile-c-symbols.c
@@ -304,13 +304,12 @@ convert_one_symbol (struct compile_c_instance *context,

static void
convert_symbol_sym (struct compile_c_instance *context, const char *identifier,
- struct symbol *sym, domain_enum domain)
+ struct symbol *sym, domain_enum domain,
+ const struct block *block)
{
- const struct block *static_block, *found_block;
+ const struct block *static_block;
int is_local_symbol;

- found_block = block_found;
-
/* 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
symbol of the same name. This lets this unusual case work:
@@ -323,24 +322,24 @@ convert_symbol_sym (struct compile_c_instance *context, const char *identifier,
}
*/

- static_block = block_static_block (found_block);
+ static_block = block_static_block (block);
/* STATIC_BLOCK is NULL if FOUND_BLOCK is the global block. */
- is_local_symbol = (found_block != static_block && static_block != NULL);
+ is_local_symbol = (block != static_block && static_block != NULL);
if (is_local_symbol)
{
- struct symbol *global_sym;
+ struct symbol_in_block global_sym;

global_sym = lookup_symbol (identifier, NULL, domain, NULL);
/* If the outer symbol is in the static block, we ignore it, as
it cannot be referenced. */
- if (global_sym != NULL
- && block_found != block_static_block (block_found))
+ if (global_sym.symbol != NULL
+ && global_sym.block != block_static_block (global_sym.block))
{
if (compile_debug)
fprintf_unfiltered (gdb_stdlog,
"gcc_convert_symbol \"%s\": global symbol\n",
identifier);
- convert_one_symbol (context, global_sym, 1, 0);
+ convert_one_symbol (context, global_sym.symbol, 1, 0);
}
}

@@ -444,12 +443,13 @@ gcc_convert_symbol (void *datum,
is to simply emit a gcc error. */
TRY
{
- struct symbol *sym;
+ struct symbol_in_block sym;

sym = lookup_symbol (identifier, context->base.block, domain, NULL);
- if (sym != NULL)
+ if (sym.symbol != NULL)
{
- convert_symbol_sym (context, identifier, sym, domain);
+ convert_symbol_sym (context, identifier, sym.symbol, domain,
+ sym.block);
found = 1;
}
else if (domain == VAR_DOMAIN)
@@ -495,7 +495,7 @@ gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context,
struct symbol *sym;

/* We only need global functions here. */
- sym = lookup_symbol (identifier, NULL, VAR_DOMAIN, NULL);
+ sym = lookup_symbol (identifier, NULL, VAR_DOMAIN, NULL).symbol;
if (sym != NULL && SYMBOL_CLASS (sym) == LOC_BLOCK)
{
if (compile_debug)
diff --git a/gdb/compile/compile-object-load.c b/gdb/compile/compile-object-load.c
index 162227a..16775ab 100644
--- a/gdb/compile/compile-object-load.c
+++ b/gdb/compile/compile-object-load.c
@@ -676,7 +676,7 @@ compile_object_load (const char *object_file, const char *source_file,

func_sym = lookup_global_symbol_from_objfile (objfile,
GCC_FE_WRAPPER_FUNCTION,
- VAR_DOMAIN);
+ VAR_DOMAIN).symbol;
if (func_sym == NULL)
error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index 41f8d35..6efe05e 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -32,7 +32,7 @@
#include "buildsym.h"
#include "language.h"

-static struct symbol *
+static struct symbol_in_block
cp_lookup_nested_symbol_1 (struct type *container_type,
const char *nested_name,
const char *concatenated_name,
@@ -213,14 +213,14 @@ cp_is_in_anonymous (const char *symbol_name)
If IS_IN_ANONYMOUS is nonzero, the symbol in question is located
within an anonymous namespace. */

-static struct symbol *
+static struct symbol_in_block
cp_basic_lookup_symbol (const char *name, const struct block *block,
const domain_enum domain, int is_in_anonymous)
{
- struct symbol *sym;
+ struct symbol_in_block sym;

sym = lookup_symbol_in_static_block (name, block, domain);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;

if (is_in_anonymous)
@@ -232,12 +232,13 @@ cp_basic_lookup_symbol (const char *name, const struct block *block,
const struct block *global_block = block_global_block (block);

if (global_block != NULL)
- sym = lookup_symbol_in_block (name, global_block, domain);
+ {
+ sym.symbol = lookup_symbol_in_block (name, global_block, domain);
+ sym.block = global_block;
+ }
}
else
- {
- sym = lookup_global_symbol (name, block, domain);
- }
+ sym = lookup_global_symbol (name, block, domain);

return sym;
}
@@ -252,12 +253,12 @@ cp_basic_lookup_symbol (const char *name, const struct block *block,
If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
if so then also search for NAME in that class. */

-static struct symbol *
+static struct symbol_in_block
cp_lookup_bare_symbol (const struct language_defn *langdef,
const char *name, const struct block *block,
const domain_enum domain, int search)
{
- struct symbol *sym;
+ struct symbol_in_block 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
@@ -266,7 +267,7 @@ cp_lookup_bare_symbol (const struct language_defn *langdef,
gdb_assert (strchr (name, ':') == NULL);

sym = lookup_symbol_in_static_block (name, block, domain);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;

/* If we didn't find a definition for a builtin type in the static block,
@@ -283,30 +284,32 @@ cp_lookup_bare_symbol (const struct language_defn *langdef,
gdbarch = target_gdbarch ();
else
gdbarch = block_gdbarch (block);
- sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
- if (sym != NULL)
+ 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 != NULL)
+ if (sym.symbol != NULL)
return sym;

if (search)
{
- struct symbol *lang_this;
+ struct symbol_in_block lang_this;
struct type *type;

lang_this = lookup_language_this (language_def (language_cplus), block);
- if (lang_this == NULL)
- return NULL;
+ if (lang_this.symbol == NULL)
+ return (struct symbol_in_block) {NULL, NULL};

- type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this)));
+ 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;
+ return (struct symbol_in_block) {NULL, NULL};

/* Look for symbol NAME in this class. */
sym = cp_lookup_nested_symbol (type, name, block, domain);
@@ -324,17 +327,17 @@ cp_lookup_bare_symbol (const struct language_defn *langdef,
Note: At least in the case of Fortran, which also uses this code, there
may be no text after the last "::". */

-static struct symbol *
+static struct symbol_in_block
cp_search_static_and_baseclasses (const char *name,
const struct block *block,
const domain_enum domain,
unsigned int prefix_len,
int is_in_anonymous)
{
- struct symbol *sym;
+ struct symbol_in_block sym;
char *klass, *nested;
struct cleanup *cleanup;
- struct symbol *klass_sym;
+ struct symbol_in_block klass_sym;
struct type *klass_type;

/* The test here uses <= instead of < because Fortran also uses this,
@@ -361,12 +364,12 @@ cp_search_static_and_baseclasses (const char *name,
symbol_matches_domain (which should be replaced with something else,
but it's what we have today). */
klass_sym = lookup_global_symbol (klass, block, VAR_DOMAIN);
- if (klass_sym == NULL)
+ if (klass_sym.symbol == NULL)
{
do_cleanups (cleanup);
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}
- klass_type = SYMBOL_TYPE (klass_sym);
+ klass_type = SYMBOL_TYPE (klass_sym.symbol);

/* Look for a symbol named NESTED in this class.
The caller is assumed to have already have done a basic lookup of NAME.
@@ -387,7 +390,7 @@ cp_search_static_and_baseclasses (const char *name,
there is no scoping in which case we also try looking in the class of
"this" if we can compute it. */

-static struct symbol *
+static struct symbol_in_block
cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
const struct block *block,
const domain_enum domain, int search)
@@ -395,7 +398,7 @@ cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
char *concatenated_name = NULL;
int is_in_anonymous;
unsigned int prefix_len;
- struct symbol *sym;
+ struct symbol_in_block sym;

if (the_namespace[0] != '\0')
{
@@ -419,7 +422,7 @@ cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
is_in_anonymous
= the_namespace[0] != '\0' && cp_is_in_anonymous (the_namespace);
sym = cp_basic_lookup_symbol (name, block, domain, is_in_anonymous);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;

if (search)
@@ -466,7 +469,7 @@ reset_directive_searched (void *data)
SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
pass 0 for it. Internally we pass 1 when recursing. */

-static struct symbol *
+static struct symbol_in_block
cp_lookup_symbol_via_imports (const char *scope,
const char *name,
const struct block *block,
@@ -476,17 +479,19 @@ cp_lookup_symbol_via_imports (const char *scope,
const int search_parents)
{
struct using_direct *current;
- struct symbol *sym = NULL;
+ struct symbol_in_block sym;
int len;
int directive_match;
struct cleanup *searched_cleanup;

+ sym.symbol = NULL;
+
/* First, try to find the symbol in the given namespace if requested. */
if (search_scope_first)
sym = cp_lookup_symbol_in_namespace (scope, name,
block, domain, 1);

- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;

/* Go through the using directives. If any of them add new names to
@@ -532,12 +537,12 @@ cp_lookup_symbol_via_imports (const char *scope,
/* If this is a DECLARATION_ONLY search or a symbol was found
or this import statement was an import declaration, the
search of this import is complete. */
- if (declaration_only || sym != NULL || current->declaration)
+ if (declaration_only || sym.symbol != NULL || current->declaration)
{
current->searched = 0;
discard_cleanups (searched_cleanup);

- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;

continue;
@@ -575,12 +580,12 @@ cp_lookup_symbol_via_imports (const char *scope,
current->searched = 0;
discard_cleanups (searched_cleanup);

- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;
}
}

- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Helper function that searches an array of symbols for one named NAME. */
@@ -604,14 +609,14 @@ search_symbol_list (const char *name, int num,
searches through the template parameters of the function and the
function's type. */

-struct symbol *
+struct symbol_in_block
cp_lookup_symbol_imports_or_template (const char *scope,
const char *name,
const struct block *block,
const domain_enum domain)
{
struct symbol *function = BLOCK_FUNCTION (block);
- struct symbol *result;
+ struct symbol_in_block result;

if (symbol_lookup_debug)
{
@@ -629,20 +634,19 @@ cp_lookup_symbol_imports_or_template (const char *scope,
{
struct template_symbol *templ
= (struct template_symbol *) function;
-
- result = search_symbol_list (name,
- templ->n_template_arguments,
- templ->template_arguments);
- if (result != NULL)
+ struct symbol *sym = search_symbol_list (name,
+ templ->n_template_arguments,
+ templ->template_arguments);
+ if (sym != NULL)
{
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_symbol_imports_or_template"
" (...) = %s\n",
- host_address_to_string (result));
+ host_address_to_string (sym));
}
- return result;
+ return (struct symbol_in_block) {sym, NULL};
}
}

@@ -656,6 +660,7 @@ cp_lookup_symbol_imports_or_template (const char *scope,
const struct language_defn *lang = language_def (language_cplus);
struct gdbarch *arch = symbol_arch (function);
const struct block *parent = BLOCK_SUPERBLOCK (block);
+ struct symbol *sym;

while (1)
{
@@ -674,21 +679,21 @@ cp_lookup_symbol_imports_or_template (const char *scope,
if (context == NULL)
break;

- result
+ sym
= search_symbol_list (name,
TYPE_N_TEMPLATE_ARGUMENTS (context),
TYPE_TEMPLATE_ARGUMENTS (context));
- if (result != NULL)
+ if (sym != NULL)
{
do_cleanups (cleanups);
if (symbol_lookup_debug)
{
- fprintf_unfiltered (gdb_stdlog,
- "cp_lookup_symbol_imports_or_template"
- " (...) = %s\n",
- host_address_to_string (result));
+ fprintf_unfiltered
+ (gdb_stdlog,
+ "cp_lookup_symbol_imports_or_template (...) = %s\n",
+ host_address_to_string (sym));
}
- return result;
+ return (struct symbol_in_block) {sym, NULL};
}
}

@@ -701,8 +706,8 @@ cp_lookup_symbol_imports_or_template (const char *scope,
{
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_symbol_imports_or_template (...) = %s\n",
- result != NULL
- ? host_address_to_string (result) : "NULL");
+ result.symbol != NULL
+ ? host_address_to_string (result.symbol) : "NULL");
}
return result;
}
@@ -711,23 +716,23 @@ cp_lookup_symbol_imports_or_template (const char *scope,
and its parents. SCOPE is the namespace scope of the context in which the
search is being evaluated. */

-static struct symbol *
+static struct symbol_in_block
cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
const struct block *block,
const domain_enum domain)
{
- struct symbol *sym;
+ struct symbol_in_block sym;

while (block != NULL)
{
sym = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 0, 1);
- if (sym)
+ if (sym.symbol)
return sym;

block = BLOCK_SUPERBLOCK (block);
}

- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Searches for NAME in the current namespace, and by applying
@@ -735,13 +740,13 @@ cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
SCOPE is the namespace scope of the context in which the search is
being evaluated. */

-struct symbol *
+struct symbol_in_block
cp_lookup_symbol_namespace (const char *scope,
const char *name,
const struct block *block,
const domain_enum domain)
{
- struct symbol *sym;
+ struct symbol_in_block sym;

if (symbol_lookup_debug)
{
@@ -755,14 +760,15 @@ cp_lookup_symbol_namespace (const char *scope,
sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);

/* Search for name in namespaces imported to this and parent blocks. */
- if (sym == NULL)
+ if (sym.symbol == NULL)
sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);

if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_symbol_namespace (...) = %s\n",
- sym != NULL ? host_address_to_string (sym) : "NULL");
+ sym.symbol != NULL
+ ? host_address_to_string (sym.symbol) : "NULL");
}
return sym;
}
@@ -782,7 +788,7 @@ cp_lookup_symbol_namespace (const char *scope,
"A::x", and if that call fails, then the first call looks for
"x". */

-static struct symbol *
+static struct symbol_in_block
lookup_namespace_scope (const struct language_defn *langdef,
const char *name,
const struct block *block,
@@ -796,7 +802,7 @@ lookup_namespace_scope (const struct language_defn *langdef,
{
/* Recursively search for names in child namespaces first. */

- struct symbol *sym;
+ struct symbol_in_block sym;
int new_scope_len = scope_len;

/* If the current scope is followed by "::", skip past that. */
@@ -808,7 +814,7 @@ lookup_namespace_scope (const struct language_defn *langdef,
new_scope_len += cp_find_first_component (scope + new_scope_len);
sym = lookup_namespace_scope (langdef, name, block, domain,
scope, new_scope_len);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;
}

@@ -839,13 +845,13 @@ lookup_namespace_scope (const struct language_defn *langdef,
we're looking for, BLOCK is the block that we're searching within,
DOMAIN says what kind of symbols we're looking for. */

-struct symbol *
+struct symbol_in_block
cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
const domain_enum domain)
{
- struct symbol *sym;
+ struct symbol_in_block sym;
const char *scope = block_scope (block);

if (symbol_lookup_debug)
@@ -862,14 +868,15 @@ cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
sym = lookup_namespace_scope (langdef, name, block, domain, scope, 0);

/* Search for name in namespaces imported to this and parent blocks. */
- if (sym == NULL)
+ if (sym.symbol == NULL)
sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);

if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_symbol_nonlocal (...) = %s\n",
- sym != NULL ? host_address_to_string (sym) : "NULL");
+ sym.symbol != NULL
+ ? host_address_to_string (sym.symbol) : "NULL");
}
return sym;
}
@@ -905,17 +912,18 @@ cp_find_type_baseclass_by_name (struct type *parent_type, const char *name)
/* Search through the base classes of PARENT_TYPE for a symbol named
NAME in block BLOCK. */

-static struct symbol *
+static struct symbol_in_block
find_symbol_in_baseclass (struct type *parent_type, const char *name,
const struct block *block, const domain_enum domain,
int is_in_anonymous)
{
int i;
- struct symbol *sym;
+ struct symbol_in_block sym;
struct cleanup *cleanup;
char *concatenated_name;

- sym = NULL;
+ sym.symbol = NULL;
+ sym.block = NULL;
concatenated_name = NULL;
cleanup = make_cleanup (free_current_contents, &concatenated_name);

@@ -934,7 +942,7 @@ find_symbol_in_baseclass (struct type *parent_type, const char *name,

sym = cp_lookup_nested_symbol_1 (base_type, name, concatenated_name,
block, domain, 1, is_in_anonymous);
- if (sym != NULL)
+ if (sym.symbol != NULL)
break;
}

@@ -954,7 +962,7 @@ find_symbol_in_baseclass (struct type *parent_type, const char *name,
If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
namespace. */

-static struct symbol *
+static struct symbol_in_block
cp_lookup_nested_symbol_1 (struct type *container_type,
const char *nested_name,
const char *concatenated_name,
@@ -962,7 +970,7 @@ cp_lookup_nested_symbol_1 (struct type *container_type,
const domain_enum domain,
int basic_lookup, int is_in_anonymous)
{
- struct symbol *sym;
+ struct symbol_in_block sym;

/* NOTE: carlton/2003-11-10: We don't treat C++ class members
of classes like, say, data or function members. Instead,
@@ -975,7 +983,7 @@ cp_lookup_nested_symbol_1 (struct type *container_type,
{
sym = cp_basic_lookup_symbol (concatenated_name, block, domain,
is_in_anonymous);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;
}

@@ -986,7 +994,7 @@ cp_lookup_nested_symbol_1 (struct type *container_type,

/* First search in this symtab, what we want is possibly there. */
sym = lookup_symbol_in_static_block (concatenated_name, block, domain);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;

/* Nope. We now have to search all static blocks in all objfiles,
@@ -997,7 +1005,7 @@ cp_lookup_nested_symbol_1 (struct type *container_type,
if (!is_in_anonymous)
{
sym = lookup_static_symbol (concatenated_name, domain);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;
}

@@ -1007,11 +1015,11 @@ cp_lookup_nested_symbol_1 (struct type *container_type,
{
sym = find_symbol_in_baseclass (container_type, nested_name, block,
domain, is_in_anonymous);
- if (sym != NULL)
+ if (sym.symbol != NULL)
return sym;
}

- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Look up a symbol named NESTED_NAME that is nested inside the C++
@@ -1019,7 +1027,7 @@ cp_lookup_nested_symbol_1 (struct type *container_type,
given by BLOCK, and in DOMAIN.
Return NULL if there is no such nested symbol. */

-struct symbol *
+struct symbol_in_block
cp_lookup_nested_symbol (struct type *parent_type,
const char *nested_name,
const struct block *block,
@@ -1055,7 +1063,7 @@ cp_lookup_nested_symbol (struct type *parent_type,
{
int size;
const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
- struct symbol *sym;
+ struct symbol_in_block sym;
char *concatenated_name;
int is_in_anonymous;

@@ -1073,8 +1081,9 @@ cp_lookup_nested_symbol (struct type *parent_type,
{
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_nested_symbol (...) = %s\n",
- sym != NULL
- ? host_address_to_string (sym) : "NULL");
+ sym.symbol != NULL
+ ? host_address_to_string (sym.symbol)
+ : "NULL");
}
return sym;
}
@@ -1087,7 +1096,7 @@ cp_lookup_nested_symbol (struct type *parent_type,
"cp_lookup_nested_symbol (...) = NULL"
" (func/method)\n");
}
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};

default:
internal_error (__FILE__, __LINE__,
diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index 3db9751..1625d72 100644
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -175,7 +175,7 @@ inspect_type (struct demangle_parse_info *info,

TRY
{
- sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
@@ -457,7 +457,7 @@ replace_typedefs (struct demangle_parse_info *info,
sym = NULL;
TRY
{
- sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0);
+ sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
@@ -1455,7 +1455,7 @@ cp_lookup_rtti_type (const char *name, struct block *block)

/* 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);
+ rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;

if (rtti_sym == NULL)
{
diff --git a/gdb/cp-support.h b/gdb/cp-support.h
index e92d6e7..4b93f04 100644
--- a/gdb/cp-support.h
+++ b/gdb/cp-support.h
@@ -192,27 +192,29 @@ extern void cp_add_using_directive (const char *dest,
extern void cp_scan_for_anonymous_namespaces (const struct symbol *symbol,
struct objfile *objfile);

-extern struct symbol *cp_lookup_symbol_nonlocal
+extern struct symbol_in_block cp_lookup_symbol_nonlocal
(const struct language_defn *langdef,
const char *name,
const struct block *block,
const domain_enum domain);

-extern struct symbol *cp_lookup_symbol_namespace (const char *the_namespace,
- const char *name,
- const struct block *block,
- const domain_enum domain);
+extern struct symbol_in_block
+ cp_lookup_symbol_namespace (const char *the_namespace,
+ const char *name,
+ const struct block *block,
+ const domain_enum domain);

-extern struct symbol *cp_lookup_symbol_imports_or_template
+extern struct symbol_in_block cp_lookup_symbol_imports_or_template
(const char *scope,
const char *name,
const struct block *block,
const domain_enum domain);

-extern struct symbol *cp_lookup_nested_symbol (struct type *parent_type,
- const char *nested_name,
- const struct block *block,
- const domain_enum domain);
+extern struct symbol_in_block
+ cp_lookup_nested_symbol (struct type *parent_type,
+ const char *nested_name,
+ const struct block *block,
+ const domain_enum domain);

struct type *cp_lookup_transparent_type (const char *name);

diff --git a/gdb/d-exp.y b/gdb/d-exp.y
index 9936b6b..c95222b 100644
--- a/gdb/d-exp.y
+++ b/gdb/d-exp.y
@@ -1022,7 +1022,7 @@ d_type_from_name (struct stoken name)
char *copy = copy_name (name);

sym = lookup_symbol (copy, expression_context_block,
- STRUCT_DOMAIN, NULL);
+ STRUCT_DOMAIN, NULL).symbol;
if (sym != NULL)
return SYMBOL_TYPE (sym);

@@ -1038,7 +1038,7 @@ d_module_from_name (struct stoken name)
char *copy = copy_name (name);

sym = lookup_symbol (copy, expression_context_block,
- MODULE_DOMAIN, NULL);
+ MODULE_DOMAIN, NULL).symbol;
if (sym != NULL)
return SYMBOL_TYPE (sym);

@@ -1053,23 +1053,23 @@ push_variable (struct parser_state *ps, struct stoken name)
{
char *copy = copy_name (name);
struct field_of_this_result is_a_field_of_this;
- struct symbol *sym;
- sym = lookup_symbol (copy, expression_context_block, VAR_DOMAIN,
- &is_a_field_of_this);
- if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
+ struct symbol_in_block sym
+ = lookup_symbol (copy, expression_context_block, VAR_DOMAIN,
+ &is_a_field_of_this);
+ if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
{
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0 ||
- contained_in (block_found, innermost_block))
- innermost_block = block_found;
+ contained_in (sym.block, innermost_block))
+ innermost_block = sym.block;
}

write_exp_elt_opcode (ps, OP_VAR_VALUE);
/* We want to use the selected frame, not another more inner frame
which happens to be in the same block. */
write_exp_elt_block (ps, NULL);
- write_exp_elt_sym (ps, sym);
+ write_exp_elt_sym (ps, sym.symbol);
write_exp_elt_opcode (ps, OP_VAR_VALUE);
return 1;
}
@@ -1078,8 +1078,8 @@ push_variable (struct parser_state *ps, struct stoken name)
/* It hangs off of `this'. Must not inadvertently convert from a
method call to data ref. */
if (innermost_block == 0 ||
- contained_in (block_found, innermost_block))
- innermost_block = block_found;
+ contained_in (sym.block, innermost_block))
+ innermost_block = sym.block;
write_exp_elt_opcode (ps, OP_THIS);
write_exp_elt_opcode (ps, OP_THIS);
write_exp_elt_opcode (ps, STRUCTOP_PTR);
@@ -1180,10 +1180,10 @@ push_module_name (struct parser_state *ps, struct type *module,

copy = copy_name (name);
sym = lookup_symbol_in_static_block (copy, expression_context_block,
- VAR_DOMAIN);
+ VAR_DOMAIN).symbol;
if (sym != NULL)
sym = lookup_global_symbol (copy, expression_context_block,
- VAR_DOMAIN);
+ VAR_DOMAIN).symbol;

if (sym != NULL)
{
diff --git a/gdb/eval.c b/gdb/eval.c
index 5699aea..f981599 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1492,7 +1492,7 @@ evaluate_subexp_standard (struct type *expect_type,
function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
name,
get_selected_block (0),
- VAR_DOMAIN);
+ VAR_DOMAIN).symbol;
if (function == NULL)
error (_("No symbol \"%s\" in namespace \"%s\"."),
name, TYPE_TAG_NAME (type));
diff --git a/gdb/f-exp.y b/gdb/f-exp.y
index 94494f0..c57f919 100644
--- a/gdb/f-exp.y
+++ b/gdb/f-exp.y
@@ -509,23 +509,23 @@ exp : STRING_LITERAL
;

variable: name_not_typename
- { struct symbol *sym = $1.sym;
+ { struct symbol_in_block sym = $1.sym;

- if (sym)
+ if (sym.symbol)
{
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0
- || contained_in (block_found,
+ || contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
}
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
/* We want to use the selected frame, not
another more inner frame which happens to
be in the same block. */
write_exp_elt_block (pstate, NULL);
- write_exp_elt_sym (pstate, sym);
+ write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
break;
}
@@ -1198,7 +1198,7 @@ yylex (void)
The caller is not constrained to care about the distinction. */
{
char *tmp = copy_name (yylval.sval);
- struct symbol *sym;
+ struct symbol_in_block result;
struct field_of_this_result is_a_field_of_this;
enum domain_enum_tag lookup_domains[] =
{
@@ -1215,17 +1215,18 @@ yylex (void)
way we can refer to it unconditionally below. */
memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));

- sym = lookup_symbol (tmp, expression_context_block,
- lookup_domains[i],
- parse_language (pstate)->la_language
- == language_cplus ? &is_a_field_of_this : NULL);
- if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ result = lookup_symbol (tmp, expression_context_block,
+ lookup_domains[i],
+ parse_language (pstate)->la_language
+ == language_cplus
+ ? &is_a_field_of_this : NULL);
+ if (result.symbol && SYMBOL_CLASS (result.symbol) == LOC_TYPEDEF)
{
- yylval.tsym.type = SYMBOL_TYPE (sym);
+ yylval.tsym.type = SYMBOL_TYPE (result.symbol);
return TYPENAME;
}

- if (sym)
+ if (result.symbol)
break;
}

@@ -1238,7 +1239,7 @@ yylex (void)
/* Input names that aren't symbols but ARE valid hex numbers,
when the input radix permits them, can be names or numbers
depending on the parse. Note we support radixes > 16 here. */
- if (!sym
+ if (!result.symbol
&& ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
|| (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
{
@@ -1246,14 +1247,14 @@ yylex (void)
hextype = parse_number (pstate, tokstart, namelen, 0, &newlval);
if (hextype == INT)
{
- yylval.ssym.sym = sym;
+ yylval.ssym.sym = result;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
return NAME_OR_INT;
}
}

/* Any other kind of symbol */
- yylval.ssym.sym = sym;
+ yylval.ssym.sym = result;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
return NAME;
}
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index e44fd4f..be761e6 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1409,7 +1409,7 @@ lookup_typename (const struct language_defn *language,
struct type *type;

sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
- language->la_language, NULL);
+ language->la_language, NULL).symbol;
if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
return SYMBOL_TYPE (sym);

@@ -1453,7 +1453,7 @@ lookup_struct (const char *name, const struct block *block)
{
struct symbol *sym;

- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;

if (sym == NULL)
{
@@ -1476,7 +1476,7 @@ lookup_union (const char *name, const struct block *block)
struct symbol *sym;
struct type *t;

- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;

if (sym == NULL)
error (_("No union type named %s."), name);
@@ -1499,7 +1499,7 @@ lookup_enum (const char *name, const struct block *block)
{
struct symbol *sym;

- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
error (_("No enum type named %s."), name);
@@ -1528,7 +1528,7 @@ lookup_template_type (char *name, struct type *type,
strcat (nam, TYPE_NAME (type));
strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */

- sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
+ sym = lookup_symbol (nam, block, VAR_DOMAIN, 0).symbol;

if (sym == NULL)
{
@@ -2245,7 +2245,7 @@ check_typedef (struct type *type)
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
if (sym)
TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
else /* TYPE_CODE_UNDEF */
@@ -2336,7 +2336,7 @@ check_typedef (struct type *type)
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
if (sym)
{
/* Same as above for opaque types, we can replace the stub
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index e233fe6..85eed70 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -1063,7 +1063,8 @@ gnuv3_get_typeid_type (struct gdbarch *gdbarch)
struct symbol *typeinfo;
struct type *typeinfo_type;

- typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN, NULL);
+ typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
+ NULL).symbol;
if (typeinfo == NULL)
typeinfo_type = gdbarch_data (gdbarch, std_type_info_gdbarch_data);
else
diff --git a/gdb/go-exp.y b/gdb/go-exp.y
index a719d2f..1f43306 100644
--- a/gdb/go-exp.y
+++ b/gdb/go-exp.y
@@ -582,7 +582,7 @@ exp : FALSE_KEYWORD
;

variable: name_not_typename ENTRY
- { struct symbol *sym = $1.sym;
+ { struct symbol *sym = $1.sym.symbol;

if (sym == NULL
|| !SYMBOL_IS_ARGUMENT (sym)
@@ -598,16 +598,16 @@ variable: name_not_typename ENTRY
;

variable: name_not_typename
- { struct symbol *sym = $1.sym;
+ { struct symbol_in_block sym = $1.sym;

- if (sym)
+ if (sym.symbol)
{
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0
- || contained_in (block_found,
+ || contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
}

write_exp_elt_opcode (pstate, OP_VAR_VALUE);
@@ -615,7 +615,7 @@ variable: name_not_typename
another more inner frame which happens to
be in the same block. */
write_exp_elt_block (pstate, NULL);
- write_exp_elt_sym (pstate, sym);
+ write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
}
else if ($1.is_a_field_of_this)
@@ -1382,7 +1382,7 @@ package_name_p (const char *name, const struct block *block)
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);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this).symbol;

if (sym
&& SYMBOL_CLASS (sym) == LOC_TYPEDEF
@@ -1420,14 +1420,14 @@ static int
classify_packaged_name (const struct block *block)
{
char *copy;
- struct symbol *sym;
+ struct symbol_in_block sym;
struct field_of_this_result is_a_field_of_this;

copy = copy_name (yylval.sval);

sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);

- if (sym)
+ if (sym.symbol)
{
yylval.ssym.sym = sym;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
@@ -1448,7 +1448,7 @@ static int
classify_name (struct parser_state *par_state, const struct block *block)
{
struct type *type;
- struct symbol *sym;
+ struct symbol_in_block sym;
char *copy;
struct field_of_this_result is_a_field_of_this;

@@ -1471,7 +1471,7 @@ classify_name (struct parser_state *par_state, const struct block *block)

sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);

- if (sym)
+ if (sym.symbol)
{
yylval.ssym.sym = sym;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
@@ -1496,7 +1496,7 @@ classify_name (struct parser_state *par_state, const struct block *block)
xfree (current_package_name);
sym = lookup_symbol (sval.ptr, block, VAR_DOMAIN,
&is_a_field_of_this);
- if (sym)
+ if (sym.symbol)
{
yylval.ssym.stoken = sval;
yylval.ssym.sym = sym;
@@ -1517,13 +1517,15 @@ classify_name (struct parser_state *par_state, const struct block *block)
0, &newlval);
if (hextype == INT)
{
- yylval.ssym.sym = NULL;
+ yylval.ssym.sym.symbol = NULL;
+ yylval.ssym.sym.block = NULL;
yylval.ssym.is_a_field_of_this = 0;
return NAME_OR_INT;
}
}

- yylval.ssym.sym = NULL;
+ yylval.ssym.sym.symbol = NULL;
+ yylval.ssym.sym.block = NULL;
yylval.ssym.is_a_field_of_this = 0;
return NAME;
}
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 445a612..9a46242 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -6087,7 +6087,8 @@ insert_exception_resume_breakpoint (struct thread_info *tp,
CORE_ADDR handler;
struct breakpoint *bp;

- vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
+ vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN,
+ NULL).symbol;
value = read_var_value (vsym, frame);
/* If the value was optimized out, revert to the old behavior. */
if (! value_optimized_out (value))
diff --git a/gdb/jv-exp.y b/gdb/jv-exp.y
index 2ed1c17..2e6de6f 100644
--- a/gdb/jv-exp.y
+++ b/gdb/jv-exp.y
@@ -1270,24 +1270,24 @@ push_variable (struct parser_state *par_state, struct stoken name)
{
char *tmp = copy_name (name);
struct field_of_this_result is_a_field_of_this;
- struct symbol *sym;
+ struct symbol_in_block sym;

sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
&is_a_field_of_this);
- if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
+ if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
{
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0 ||
- contained_in (block_found, innermost_block))
- innermost_block = block_found;
+ contained_in (sym.block, innermost_block))
+ innermost_block = sym.block;
}

write_exp_elt_opcode (par_state, OP_VAR_VALUE);
/* We want to use the selected frame, not another more inner frame
which happens to be in the same block. */
write_exp_elt_block (par_state, NULL);
- write_exp_elt_sym (par_state, sym);
+ write_exp_elt_sym (par_state, sym.symbol);
write_exp_elt_opcode (par_state, OP_VAR_VALUE);
return 1;
}
@@ -1296,8 +1296,8 @@ push_variable (struct parser_state *par_state, struct stoken name)
/* it hangs off of `this'. Must not inadvertently convert from a
method call to data ref. */
if (innermost_block == 0 ||
- contained_in (block_found, innermost_block))
- innermost_block = block_found;
+ contained_in (sym.block, innermost_block))
+ innermost_block = sym.block;
write_exp_elt_opcode (par_state, OP_THIS);
write_exp_elt_opcode (par_state, OP_THIS);
write_exp_elt_opcode (par_state, STRUCTOP_PTR);
diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c
index fee816c..4598942 100644
--- a/gdb/jv-lang.c
+++ b/gdb/jv-lang.c
@@ -202,7 +202,8 @@ java_lookup_class (char *name)
{
struct symbol *sym;

- sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN, NULL);
+ sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN,
+ NULL).symbol;
if (sym != NULL)
return SYMBOL_TYPE (sym);
/* FIXME - should search inferior's symbol table. */
@@ -590,7 +591,7 @@ get_java_object_type (void)
{
struct symbol *sym;

- sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, NULL);
+ sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, NULL).symbol;
if (sym == NULL)
error (_("cannot find java.lang.Object"));
return SYMBOL_TYPE (sym);
diff --git a/gdb/language.c b/gdb/language.c
index 1e6b983..a8b432e 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -974,7 +974,7 @@ language_bool_type (const struct language_defn *la,
struct symbol *sym;

sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
- NULL, VAR_DOMAIN, NULL);
+ NULL, VAR_DOMAIN, NULL).symbol;
if (sym)
{
struct type *type = SYMBOL_TYPE (sym);
@@ -1075,10 +1075,9 @@ language_init_primitive_type_symbols (struct language_arch_info *lai,
}

/* Note: The result of symbol lookup is normally a symbol *and* the block
- it was found in (returned in global block_found). Builtin types don't
- live in blocks. We *could* give them one, but there is no current need
- so to keep things simple symbol lookup is extended to allow for
- BLOCK_FOUND to be NULL. */
+ it was found in. Builtin types don't live in blocks. We *could* give
+ them one, but there is no current need so to keep things simple symbol
+ lookup is extended to allow for BLOCK_FOUND to be NULL. */
}

/* See language.h. */
diff --git a/gdb/language.h b/gdb/language.h
index 436fd6e..2675b82 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -267,10 +267,11 @@ struct language_defn
the part of symbol lookup where C looks up static and global
variables. */

- struct symbol *(*la_lookup_symbol_nonlocal) (const struct language_defn *,
- const char *,
- const struct block *,
- const domain_enum);
+ struct symbol_in_block (*la_lookup_symbol_nonlocal)
+ (const struct language_defn *,
+ const char *,
+ const struct block *,
+ const domain_enum);

/* Find the definition of the type with the given name. */
struct type *(*la_lookup_transparent_type) (const char *);
diff --git a/gdb/linespec.c b/gdb/linespec.c
index 81f526d..2fe845f 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -3254,7 +3254,7 @@ find_label_symbols (struct linespec_state *self,
return NULL;
fn_sym = BLOCK_FUNCTION (block);

- sym = lookup_symbol (name, block, LABEL_DOMAIN, 0);
+ sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;

if (sym != NULL)
{
@@ -3269,7 +3269,7 @@ find_label_symbols (struct linespec_state *self,
{
set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym)));
block = SYMBOL_BLOCK_VALUE (fn_sym);
- sym = lookup_symbol (name, block, LABEL_DOMAIN, 0);
+ sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol;

if (sym != NULL)
{
diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index 933fa7d..a203218 100644
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -564,7 +564,7 @@ fblock : BLOCKNAME
{ struct symbol *sym
= lookup_symbol (copy_name ($1),
expression_context_block,
- VAR_DOMAIN, 0);
+ VAR_DOMAIN, 0).symbol;
$$ = sym;}
;

@@ -573,7 +573,7 @@ fblock : BLOCKNAME
fblock : block COLONCOLON BLOCKNAME
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, 0);
+ VAR_DOMAIN, 0).symbol;
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
copy_name ($3));
@@ -595,44 +595,44 @@ variable: INTERNAL_VAR

/* GDB scope operator */
variable: block COLONCOLON NAME
- { struct symbol *sym;
- sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, 0);
- if (sym == 0)
+ { struct symbol_in_block sym
+ = lookup_symbol (copy_name ($3), $1,
+ VAR_DOMAIN, 0);
+ if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
copy_name ($3));
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0
- || contained_in (block_found,
+ || contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
}

write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- /* block_found is set by lookup_symbol. */
- write_exp_elt_block (pstate, block_found);
- write_exp_elt_sym (pstate, sym);
+ write_exp_elt_block (pstate, sym.block);
+ write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
;

/* Base case for variables. */
variable: NAME
- { struct symbol *sym;
+ { struct symbol_in_block sym;
struct field_of_this_result is_a_field_of_this;

- sym = lookup_symbol (copy_name ($1),
+ sym = lookup_symbol (copy_name ($1),
expression_context_block,
VAR_DOMAIN,
&is_a_field_of_this);
- if (sym)
+
+ if (sym.symbol)
{
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0 ||
- contained_in (block_found,
+ contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
}

write_exp_elt_opcode (pstate, OP_VAR_VALUE);
@@ -640,7 +640,7 @@ variable: NAME
another more inner frame which happens to
be in the same block. */
write_exp_elt_block (pstate, NULL);
- write_exp_elt_sym (pstate, sym);
+ write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
}
else
@@ -1028,7 +1028,7 @@ yylex (void)

if (lookup_symtab (tmp))
return BLOCKNAME;
- sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0);
+ sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0).symbol;
if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
return BLOCKNAME;
if (lookup_typename (parse_language (pstate), parse_gdbarch (pstate),
diff --git a/gdb/mi/mi-cmd-stack.c b/gdb/mi/mi-cmd-stack.c
index 1b863eb..51a8ae6 100644
--- a/gdb/mi/mi-cmd-stack.c
+++ b/gdb/mi/mi-cmd-stack.c
@@ -648,7 +648,7 @@ list_args_or_locals (enum what_to_list what, enum print_values values,
if (SYMBOL_IS_ARGUMENT (sym))
sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
block, VAR_DOMAIN,
- NULL);
+ NULL).symbol;
else
sym2 = sym;
gdb_assert (sym2 != NULL);
diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c
index 0d1d96b..661d22f 100644
--- a/gdb/objc-lang.c
+++ b/gdb/objc-lang.c
@@ -85,7 +85,7 @@ lookup_struct_typedef (char *name, const struct block *block, int noerr)
{
struct symbol *sym;

- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;

if (sym == NULL)
{
@@ -1144,7 +1144,8 @@ find_imps (const char *method, VEC (const_char_ptr) **symbol_names)
add the selector itself as a symbol, if it exists. */
if (selector_case && !VEC_empty (const_char_ptr, *symbol_names))
{
- struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN, 0);
+ struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN,
+ 0).symbol;

if (sym != NULL)
VEC_safe_push (const_char_ptr, *symbol_names,
diff --git a/gdb/p-exp.y b/gdb/p-exp.y
index 5d5c22b..a2f86d6 100644
--- a/gdb/p-exp.y
+++ b/gdb/p-exp.y
@@ -668,8 +668,8 @@ exp : THIS

block : BLOCKNAME
{
- if ($1.sym != 0)
- $$ = SYMBOL_BLOCK_VALUE ($1.sym);
+ if ($1.sym.symbol != 0)
+ $$ = SYMBOL_BLOCK_VALUE ($1.sym.symbol);
else
{
struct symtab *tem =
@@ -687,7 +687,7 @@ block : BLOCKNAME
block : block COLONCOLON name
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, NULL);
+ VAR_DOMAIN, NULL).symbol;
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
copy_name ($3));
@@ -695,17 +695,16 @@ block : block COLONCOLON name
;

variable: block COLONCOLON name
- { struct symbol *sym;
+ { struct symbol_in_block sym;
sym = lookup_symbol (copy_name ($3), $1,
VAR_DOMAIN, NULL);
- if (sym == 0)
+ if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
copy_name ($3));

write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- /* block_found is set by lookup_symbol. */
- write_exp_elt_block (pstate, block_found);
- write_exp_elt_sym (pstate, sym);
+ write_exp_elt_block (pstate, sym.block);
+ write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
;

@@ -733,7 +732,7 @@ variable: qualified_name

sym =
lookup_symbol (name, (const struct block *) NULL,
- VAR_DOMAIN, NULL);
+ VAR_DOMAIN, NULL).symbol;
if (sym)
{
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
@@ -757,16 +756,16 @@ variable: qualified_name
;

variable: name_not_typename
- { struct symbol *sym = $1.sym;
+ { struct symbol_in_block sym = $1.sym;

- if (sym)
+ if (sym.symbol)
{
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
if (innermost_block == 0
- || contained_in (block_found,
+ || contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
}

write_exp_elt_opcode (pstate, OP_VAR_VALUE);
@@ -774,9 +773,9 @@ variable: name_not_typename
another more inner frame which happens to
be in the same block. */
write_exp_elt_block (pstate, NULL);
- write_exp_elt_sym (pstate, sym);
+ write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- current_type = sym->type; }
+ current_type = sym.symbol->type; }
else if ($1.is_a_field_of_this)
{
struct value * this_val;
@@ -785,9 +784,9 @@ variable: name_not_typename
not inadvertently convert from a method call
to data ref. */
if (innermost_block == 0
- || contained_in (block_found,
+ || contained_in (sym.block,
innermost_block))
- innermost_block = block_found;
+ innermost_block = sym.block;
write_exp_elt_opcode (pstate, OP_THIS);
write_exp_elt_opcode (pstate, OP_THIS);
write_exp_elt_opcode (pstate, STRUCTOP_PTR);
@@ -1508,7 +1507,7 @@ yylex (void)
static const char this_name[] = "this";

if (lookup_symbol (this_name, expression_context_block,
- VAR_DOMAIN, NULL))
+ VAR_DOMAIN, NULL).symbol)
{
free (uptokstart);
return THIS;
@@ -1558,7 +1557,7 @@ yylex (void)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this);
+ VAR_DOMAIN, &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)
{
@@ -1573,7 +1572,7 @@ yylex (void)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this);
+ VAR_DOMAIN, &is_a_field_of_this).symbol;
}
/* Third chance Capitalized (as GPC does). */
if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
@@ -1595,7 +1594,7 @@ yylex (void)
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN, &is_a_field_of_this);
+ VAR_DOMAIN, &is_a_field_of_this).symbol;
}

if (is_a_field || (is_a_field_of_this.type != NULL))
@@ -1605,7 +1604,8 @@ yylex (void)
tempbuf [namelen] = 0;
yylval.sval.ptr = tempbuf;
yylval.sval.length = namelen;
- yylval.ssym.sym = NULL;
+ yylval.ssym.sym.symbol = NULL;
+ yylval.ssym.sym.block = NULL;
free (uptokstart);
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
if (is_a_field)
@@ -1619,7 +1619,8 @@ yylex (void)
if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
|| lookup_symtab (tmp))
{
- yylval.ssym.sym = sym;
+ yylval.ssym.sym.symbol = sym;
+ yylval.ssym.sym.block = NULL;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
free (uptokstart);
return BLOCKNAME;
@@ -1686,7 +1687,7 @@ yylex (void)
memcpy (tmp1, namestart, p - namestart);
tmp1[p - namestart] = '\0';
cur_sym = lookup_symbol (ncopy, expression_context_block,
- VAR_DOMAIN, NULL);
+ VAR_DOMAIN, NULL).symbol;
if (cur_sym)
{
if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
@@ -1734,7 +1735,8 @@ yylex (void)
hextype = parse_number (pstate, tokstart, namelen, 0, &newlval);
if (hextype == INT)
{
- yylval.ssym.sym = sym;
+ yylval.ssym.sym.symbol = sym;
+ yylval.ssym.sym.block = NULL;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
free (uptokstart);
return NAME_OR_INT;
@@ -1743,7 +1745,8 @@ yylex (void)

free(uptokstart);
/* Any other kind of symbol. */
- yylval.ssym.sym = sym;
+ yylval.ssym.sym.symbol = sym;
+ yylval.ssym.sym.block = NULL;
return NAME;
}
}
diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index f736a79..a0b99f8 100644
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -250,7 +250,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
if (msymbol.minsym != NULL)
wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
block,
- VAR_DOMAIN, &is_this_fld);
+ VAR_DOMAIN, &is_this_fld).symbol;

if (wsym)
{
diff --git a/gdb/parse.c b/gdb/parse.c
index 6b59c4f..7bcf6c0 100644
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -615,7 +615,7 @@ mark_completion_tag (enum type_code tag, const char *ptr, int length)
void
write_dollar_variable (struct parser_state *ps, struct stoken str)
{
- struct symbol *sym = NULL;
+ struct symbol_in_block sym;
struct bound_minimal_symbol msym;
struct internalvar *isym = NULL;

@@ -672,11 +672,11 @@ write_dollar_variable (struct parser_state *ps, struct stoken str)

sym = lookup_symbol (copy_name (str), (struct block *) NULL,
VAR_DOMAIN, NULL);
- if (sym)
+ if (sym.symbol)
{
write_exp_elt_opcode (ps, OP_VAR_VALUE);
- write_exp_elt_block (ps, block_found); /* set by lookup_symbol */
- write_exp_elt_sym (ps, sym);
+ write_exp_elt_block (ps, sym.block);
+ write_exp_elt_sym (ps, sym.symbol);
write_exp_elt_opcode (ps, OP_VAR_VALUE);
return;
}
diff --git a/gdb/parser-defs.h b/gdb/parser-defs.h
index a377ec3..d7babe0 100644
--- a/gdb/parser-defs.h
+++ b/gdb/parser-defs.h
@@ -106,7 +106,7 @@ struct ttype
struct symtoken
{
struct stoken stoken;
- struct symbol *sym;
+ struct symbol_in_block sym;
int is_a_field_of_this;
};

diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index a739a89..f51e25c 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -1208,7 +1208,7 @@ address_info (char *exp, int from_tty)
error (_("Argument required."));

sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
- &is_a_field_of_this);
+ &is_a_field_of_this).symbol;
if (sym == NULL)
{
if (is_a_field_of_this.type != NULL)
diff --git a/gdb/python/py-frame.c b/gdb/python/py-frame.c
index cd6e859..7290056 100644
--- a/gdb/python/py-frame.c
+++ b/gdb/python/py-frame.c
@@ -540,7 +540,7 @@ frapy_read_var (PyObject *self, PyObject *args)

if (!block)
block = get_frame_block (frame, NULL);
- var = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);
+ var = lookup_symbol (var_name, block, VAR_DOMAIN, NULL).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
diff --git a/gdb/python/py-symbol.c b/gdb/python/py-symbol.c
index 4306f61..401e7e9 100644
--- a/gdb/python/py-symbol.c
+++ b/gdb/python/py-symbol.c
@@ -396,7 +396,7 @@ gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)

TRY
{
- symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
+ symbol = lookup_symbol (name, block, domain, &is_a_field_of_this).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
@@ -449,7 +449,7 @@ gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw)

TRY
{
- symbol = lookup_global_symbol (name, NULL, domain);
+ symbol = lookup_global_symbol (name, NULL, domain).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
diff --git a/gdb/skip.c b/gdb/skip.c
index ba38194..a1cdd72 100644
--- a/gdb/skip.c
+++ b/gdb/skip.c
@@ -131,7 +131,7 @@ skip_function_command (char *arg, int from_tty)
}
else
{
- if (lookup_symbol (arg, NULL, VAR_DOMAIN, NULL) == NULL)
+ if (lookup_symbol (arg, NULL, VAR_DOMAIN, NULL).symbol == NULL)
{
fprintf_filtered (gdb_stderr,
_("No function found named %s.\n"), arg);
diff --git a/gdb/solib-darwin.c b/gdb/solib-darwin.c
index f96841f..0249049 100644
--- a/gdb/solib-darwin.c
+++ b/gdb/solib-darwin.c
@@ -569,12 +569,12 @@ darwin_relocate_section_addresses (struct so_list *so,
so->addr_low = sec->addr;
}
\f
-static struct symbol *
+static struct symbol_in_block
darwin_lookup_lib_symbol (struct objfile *objfile,
const char *name,
const domain_enum domain)
{
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

static bfd *
diff --git a/gdb/solib-spu.c b/gdb/solib-spu.c
index 44fbf91..d0d2a3b 100644
--- a/gdb/solib-spu.c
+++ b/gdb/solib-spu.c
@@ -389,7 +389,7 @@ spu_bfd_open (char *pathname)
}

/* Lookup global symbol in a SPE executable. */
-static struct symbol *
+static struct symbol_in_block
spu_lookup_lib_symbol (struct objfile *objfile,
const char *name,
const domain_enum domain)
@@ -399,7 +399,7 @@ spu_lookup_lib_symbol (struct objfile *objfile,

if (svr4_so_ops.lookup_lib_global_symbol != NULL)
return svr4_so_ops.lookup_lib_global_symbol (objfile, name, domain);
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Enable shared library breakpoint. */
diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 909dfb7..a5c84e8 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -3211,7 +3211,7 @@ struct target_so_ops svr4_so_ops;
different rule for symbol lookup. The lookup begins here in the DSO, not in
the main executable. */

-static struct symbol *
+static struct symbol_in_block
elf_lookup_lib_symbol (struct objfile *objfile,
const char *name,
const domain_enum domain)
@@ -3229,7 +3229,7 @@ elf_lookup_lib_symbol (struct objfile *objfile,
}

if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL) != 1)
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};

return lookup_global_symbol_from_objfile (objfile, name, domain);
}
diff --git a/gdb/solib.c b/gdb/solib.c
index eb933c0..9b313fd 100644
--- a/gdb/solib.c
+++ b/gdb/solib.c
@@ -1511,7 +1511,7 @@ show_auto_solib_add (struct ui_file *file, int from_tty,
/* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
the library-specific handler if it is installed for the current target. */

-struct symbol *
+struct symbol_in_block
solib_global_lookup (struct objfile *objfile,
const char *name,
const domain_enum domain)
@@ -1520,7 +1520,7 @@ solib_global_lookup (struct objfile *objfile,

if (ops->lookup_lib_global_symbol != NULL)
return ops->lookup_lib_global_symbol (objfile, name, domain);
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Lookup the value for a specific symbol from dynamic symbol table. Look
diff --git a/gdb/solist.h b/gdb/solist.h
index 7021f5c..3031831 100644
--- a/gdb/solist.h
+++ b/gdb/solist.h
@@ -137,9 +137,10 @@ struct target_so_ops
unsigned o_flags, char **temp_pathname);

/* Hook for looking up global symbols in a library-specific way. */
- struct symbol * (*lookup_lib_global_symbol) (struct objfile *objfile,
- const char *name,
- const domain_enum domain);
+ struct symbol_in_block (*lookup_lib_global_symbol)
+ (struct objfile *objfile,
+ const char *name,
+ const domain_enum domain);

/* Given two so_list objects, one from the GDB thread list
and another from the list returned by current_sos, return 1
@@ -192,8 +193,8 @@ extern bfd *solib_bfd_open (char *in_pathname);
extern struct target_so_ops *current_target_so_ops;

/* Handler for library-specific global symbol lookup in solib.c. */
-struct symbol *solib_global_lookup (struct objfile *objfile,
- const char *name,
- const domain_enum domain);
+struct symbol_in_block solib_global_lookup (struct objfile *objfile,
+ const char *name,
+ const domain_enum domain);

#endif
diff --git a/gdb/source.c b/gdb/source.c
index fbec0f1..0c23b7e 100644
--- a/gdb/source.c
+++ b/gdb/source.c
@@ -274,7 +274,7 @@ select_source_symtab (struct symtab *s)

/* Make the default place to list be the function `main'
if one exists. */
- if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0))
+ if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0).symbol)
{
sals = decode_line_with_current_source (main_name (),
DECODE_LINE_FUNFIRSTLINE);
diff --git a/gdb/stack.c b/gdb/stack.c
index 4878825..b4cfdbd 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -621,7 +621,7 @@ print_frame_args (struct symbol *func, struct frame_info *frame,
struct symbol *nsym;

nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
- b, VAR_DOMAIN, NULL);
+ b, VAR_DOMAIN, NULL).symbol;
gdb_assert (nsym != NULL);
if (SYMBOL_CLASS (nsym) == LOC_REGISTER
&& !SYMBOL_IS_ARGUMENT (nsym))
@@ -2156,7 +2156,7 @@ iterate_over_block_arg_vars (const struct block *b,
are not combined in symbol-reading. */

sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
- b, VAR_DOMAIN, NULL);
+ b, VAR_DOMAIN, NULL).symbol;
(*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
}
}
diff --git a/gdb/symfile.c b/gdb/symfile.c
index 0c35ffa..856572a 100644
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -1696,7 +1696,7 @@ set_initial_language (void)
if (lang == language_unknown)
{
char *name = main_name ();
- struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL);
+ struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL).symbol;

if (sym != NULL)
lang = SYMBOL_LANGUAGE (sym);
diff --git a/gdb/symtab.c b/gdb/symtab.c
index decc5a9..e66ef14 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -68,19 +68,20 @@ static void rbreak_command (char *, int);

static int find_line_common (struct linetable *, int, int *, int);

-static struct symbol *lookup_symbol_aux (const char *name,
- const struct block *block,
- const domain_enum domain,
- enum language language,
- struct field_of_this_result *);
+static struct symbol_in_block
+ lookup_symbol_aux (const char *name,
+ const struct block *block,
+ const domain_enum domain,
+ enum language language,
+ struct field_of_this_result *);

static
-struct symbol *lookup_local_symbol (const char *name,
- const struct block *block,
- const domain_enum domain,
- enum language language);
+struct symbol_in_block lookup_local_symbol (const char *name,
+ const struct block *block,
+ const domain_enum domain,
+ enum language language);

-static struct symbol *
+static struct symbol_in_block
lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
const char *name, const domain_enum domain);

@@ -121,7 +122,9 @@ static const struct program_space_data *symbol_cache_key;

/* symbol_cache_lookup returns this if a previous lookup failed to find the
symbol in any objfile. */
-#define SYMBOL_LOOKUP_FAILED ((struct symbol *) 1)
+#define SYMBOL_LOOKUP_FAILED \
+ ((struct symbol_in_block) {(struct symbol *) 1, NULL})
+#define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)

/* Recording lookups that don't find the symbol is just as important, if not
more so, than recording found symbols. */
@@ -157,7 +160,7 @@ struct symbol_cache_slot

union
{
- struct symbol *found;
+ struct symbol_in_block found;
struct
{
char *name;
@@ -243,12 +246,6 @@ multiple_symbols_select_mode (void)
return multiple_symbols_mode;
}

-/* Block in which the most recently searched-for symbol was found.
- Might be better to make this a parameter to lookup_symbol and
- value_of_this. */
-
-const struct block *block_found;
-
/* Return the name of a domain_enum. */

const char *
@@ -1208,8 +1205,8 @@ eq_symbol_entry (const struct symbol_cache_slot *slot,
}
else
{
- slot_name = SYMBOL_SEARCH_NAME (slot->value.found);
- slot_domain = SYMBOL_DOMAIN (slot->value.found);
+ slot_name = SYMBOL_SEARCH_NAME (slot->value.found.symbol);
+ slot_domain = SYMBOL_DOMAIN (slot->value.found.symbol);
}

/* NULL names match. */
@@ -1240,7 +1237,7 @@ eq_symbol_entry (const struct symbol_cache_slot *slot,
}
else
{
- struct symbol *sym = slot->value.found;
+ struct symbol *sym = slot->value.found.symbol;

if (strcmp_iw (slot_name, name) != 0)
return 0;
@@ -1398,7 +1395,7 @@ set_symbol_cache_size_handler (char *args, int from_tty,
set to the cache and slot of the symbol to save the result of a full lookup
attempt. */

-static struct symbol *
+static struct symbol_in_block
symbol_cache_lookup (struct symbol_cache *cache,
struct objfile *objfile_context, int block,
const char *name, domain_enum domain,
@@ -1417,7 +1414,7 @@ symbol_cache_lookup (struct symbol_cache *cache,
{
*bsc_ptr = NULL;
*slot_ptr = NULL;
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

hash = hash_symbol_entry (objfile_context, name, domain);
@@ -1451,7 +1448,7 @@ symbol_cache_lookup (struct symbol_cache *cache,
name, domain_name (domain));
}
++bsc->misses;
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Clear out SLOT. */
@@ -1473,7 +1470,8 @@ static void
symbol_cache_mark_found (struct block_symbol_cache *bsc,
struct symbol_cache_slot *slot,
struct objfile *objfile_context,
- struct symbol *symbol)
+ struct symbol *symbol,
+ const struct block *block)
{
if (bsc == NULL)
return;
@@ -1484,7 +1482,8 @@ symbol_cache_mark_found (struct block_symbol_cache *bsc,
}
slot->state = SYMBOL_SLOT_FOUND;
slot->objfile_context = objfile_context;
- slot->value.found = symbol;
+ slot->value.found.symbol = symbol;
+ slot->value.found.block = block;
}

/* Mark symbol NAME, DOMAIN as not found in SLOT.
@@ -1597,11 +1596,16 @@ symbol_cache_dump (const struct symbol_cache *cache)
domain_name (slot->value.not_found.domain));
break;
case SYMBOL_SLOT_FOUND:
- printf_filtered (" [%4u] = %s, %s %s\n", i,
- host_address_to_string (slot->objfile_context),
- SYMBOL_PRINT_NAME (slot->value.found),
- domain_name (SYMBOL_DOMAIN (slot->value.found)));
- break;
+ {
+ struct symbol *found = slot->value.found.symbol;
+ const struct objfile *context = slot->objfile_context;
+
+ printf_filtered (" [%4u] = %s, %s %s\n", i,
+ host_address_to_string (context),
+ SYMBOL_PRINT_NAME (found),
+ domain_name (SYMBOL_DOMAIN (found)));
+ break;
+ }
}
}
}
@@ -1945,13 +1949,13 @@ demangle_for_lookup (const char *name, enum language lang,
variable and thus can probably assume it will never hit the C++
code). */

-struct symbol *
+struct symbol_in_block
lookup_symbol_in_language (const char *name, const struct block *block,
const domain_enum domain, enum language lang,
struct field_of_this_result *is_a_field_of_this)
{
const char *modified_name;
- struct symbol *returnval;
+ struct symbol_in_block returnval;
struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name);

returnval = lookup_symbol_aux (modified_name, block, domain, lang,
@@ -1963,7 +1967,7 @@ lookup_symbol_in_language (const char *name, const struct block *block,

/* See symtab.h. */

-struct symbol *
+struct symbol_in_block
lookup_symbol (const char *name, const struct block *block,
domain_enum domain,
struct field_of_this_result *is_a_field_of_this)
@@ -1975,12 +1979,12 @@ lookup_symbol (const char *name, const struct block *block,

/* See symtab.h. */

-struct symbol *
+struct symbol_in_block
lookup_language_this (const struct language_defn *lang,
const struct block *block)
{
if (lang->la_name_of_this == NULL || block == NULL)
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};

if (symbol_lookup_debug > 1)
{
@@ -2006,8 +2010,7 @@ lookup_language_this (const struct language_defn *lang,
host_address_to_string (sym),
host_address_to_string (block));
}
- block_found = block;
- return sym;
+ return (struct symbol_in_block) {sym, block};
}
if (BLOCK_FUNCTION (block))
break;
@@ -2016,7 +2019,7 @@ lookup_language_this (const struct language_defn *lang,

if (symbol_lookup_debug > 1)
fprintf_unfiltered (gdb_stdlog, " = NULL\n");
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Given TYPE, a structure/union,
@@ -2067,12 +2070,12 @@ check_field (struct type *type, const char *name,
/* Behave like lookup_symbol except that NAME is the natural name
(e.g., demangled name) of the symbol that we're looking for. */

-static struct symbol *
+static struct symbol_in_block
lookup_symbol_aux (const char *name, const struct block *block,
const domain_enum domain, enum language language,
struct field_of_this_result *is_a_field_of_this)
{
- struct symbol *sym;
+ struct symbol_in_block result;
const struct language_defn *langdef;

if (symbol_lookup_debug)
@@ -2087,13 +2090,6 @@ lookup_symbol_aux (const char *name, const struct block *block,
domain_name (domain), language_str (language));
}

- /* Initialize block_found so that the language la_lookup_symbol_nonlocal
- routines don't have to set it (to NULL) if a primitive type is found.
- We do this early so that block_found is also NULL if no symbol is
- found (though this is not part of the API, and callers cannot assume
- this). */
- block_found = NULL;
-
/* Make sure we do something sensible with is_a_field_of_this, since
the callers that set this parameter to some non-null value will
certainly use it later. If we don't set it, the contents of
@@ -2104,15 +2100,15 @@ lookup_symbol_aux (const char *name, const struct block *block,
/* Search specified block and its superiors. Don't search
STATIC_BLOCK or GLOBAL_BLOCK. */

- sym = lookup_local_symbol (name, block, domain, language);
- if (sym != NULL)
+ result = lookup_local_symbol (name, block, domain, language);
+ if (result.symbol != NULL)
{
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
- host_address_to_string (sym));
+ host_address_to_string (result.symbol));
}
- return sym;
+ return result;
}

/* If requested to do so by the caller and if appropriate for LANGUAGE,
@@ -2125,11 +2121,11 @@ lookup_symbol_aux (const char *name, const struct block *block,
means. */
if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
{
- struct symbol *sym = lookup_language_this (langdef, block);
+ result = lookup_language_this (langdef, block);

- if (sym)
+ if (result.symbol)
{
- struct type *t = sym->type;
+ struct type *t = result.symbol->type;

/* I'm not really sure that type of this can ever
be typedefed; just be safe. */
@@ -2150,7 +2146,7 @@ lookup_symbol_aux (const char *name, const struct block *block,
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_aux (...) = NULL\n");
}
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}
}
}
@@ -2158,33 +2154,35 @@ lookup_symbol_aux (const char *name, const struct block *block,
/* Now do whatever is appropriate for LANGUAGE to look
up static and global variables. */

- sym = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain);
- if (sym != NULL)
+ result = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain);
+ if (result.symbol != NULL)
{
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
- host_address_to_string (sym));
+ host_address_to_string (result.symbol));
}
- return sym;
+ return result;
}

/* Now search all static file-level symbols. Not strictly correct,
but more useful than an error. */

- sym = lookup_static_symbol (name, domain);
+ result = lookup_static_symbol (name, domain);
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
- sym != NULL ? host_address_to_string (sym) : "NULL");
+ result.symbol != NULL
+ ? host_address_to_string (result.symbol)
+ : "NULL");
}
- return sym;
+ return result;
}

/* Check to see if the symbol is defined in BLOCK or its superiors.
Don't search STATIC_BLOCK or GLOBAL_BLOCK. */

-static struct symbol *
+static struct symbol_in_block
lookup_local_symbol (const char *name, const struct block *block,
const domain_enum domain,
enum language language)
@@ -2196,19 +2194,20 @@ lookup_local_symbol (const char *name, const struct block *block,
/* Check if either no block is specified or it's a global block. */

if (static_block == NULL)
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};

while (block != static_block)
{
sym = lookup_symbol_in_block (name, block, domain);
if (sym != NULL)
- return sym;
+ return (struct symbol_in_block) {sym, block};

if (language == language_cplus || language == language_fortran)
{
- sym = cp_lookup_symbol_imports_or_template (scope, name, block,
- domain);
- if (sym != NULL)
+ struct symbol_in_block sym
+ = cp_lookup_symbol_imports_or_template (scope, name, block,
+ domain);
+ if (sym.symbol != NULL)
return sym;
}

@@ -2219,7 +2218,7 @@ lookup_local_symbol (const char *name, const struct block *block,

/* We've reached the end of the function without finding a result. */

- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* See symtab.h. */
@@ -2275,7 +2274,6 @@ lookup_symbol_in_block (const char *name, const struct block *block,
fprintf_unfiltered (gdb_stdlog, " = %s\n",
host_address_to_string (sym));
}
- block_found = block;
return fixup_symbol_section (sym, NULL);
}

@@ -2286,7 +2284,7 @@ lookup_symbol_in_block (const char *name, const struct block *block,

/* See symtab.h. */

-struct symbol *
+struct symbol_in_block
lookup_global_symbol_from_objfile (struct objfile *main_objfile,
const char *name,
const domain_enum domain)
@@ -2297,14 +2295,14 @@ lookup_global_symbol_from_objfile (struct objfile *main_objfile,
objfile;
objfile = objfile_separate_debug_iterate (main_objfile, objfile))
{
- struct symbol *sym = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
- name, domain);
+ struct symbol_in_block result
+ = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK, name, domain);

- if (sym != NULL)
- return sym;
+ if (result.symbol != NULL)
+ return result;
}

- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Check to see if the symbol is defined in one of the OBJFILE's
@@ -2312,7 +2310,7 @@ lookup_global_symbol_from_objfile (struct objfile *main_objfile,
depending on whether or not we want to search global symbols or
static symbols. */

-static struct symbol *
+static struct symbol_in_block
lookup_symbol_in_objfile_symtabs (struct objfile *objfile, int block_index,
const char *name, const domain_enum domain)
{
@@ -2334,27 +2332,29 @@ lookup_symbol_in_objfile_symtabs (struct objfile *objfile, int block_index,
{
const struct blockvector *bv;
const struct block *block;
- struct symbol *sym;
+ struct symbol_in_block result;

bv = COMPUNIT_BLOCKVECTOR (cust);
block = BLOCKVECTOR_BLOCK (bv, block_index);
- sym = block_lookup_symbol_primary (block, name, domain);
- if (sym)
+ result.symbol = block_lookup_symbol_primary (block, name, domain);
+ result.block = block;
+ if (result.symbol != NULL)
{
if (symbol_lookup_debug > 1)
{
fprintf_unfiltered (gdb_stdlog, " = %s (block %s)\n",
- host_address_to_string (sym),
+ host_address_to_string (result.symbol),
host_address_to_string (block));
}
- block_found = block;
- return fixup_symbol_section (sym, objfile);
+ result.symbol = fixup_symbol_section (result.symbol, objfile);
+ return result;
+
}
}

if (symbol_lookup_debug > 1)
fprintf_unfiltered (gdb_stdlog, " = NULL\n");
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
@@ -2366,7 +2366,7 @@ lookup_symbol_in_objfile_symtabs (struct objfile *objfile, int block_index,
different. Here we're called from search_symbols where it will only
call us for the the objfile that contains a matching minsym. */

-static struct symbol *
+static struct symbol_in_block
lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
const char *linkage_name,
domain_enum domain)
@@ -2386,22 +2386,22 @@ lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
cur_objfile;
cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
{
- struct symbol *sym;
+ struct symbol_in_block result;

- sym = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK,
- modified_name, domain);
- if (sym == NULL)
- sym = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK,
- modified_name, domain);
- if (sym != NULL)
+ result = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK,
+ modified_name, domain);
+ if (result.symbol == NULL)
+ result = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK,
+ modified_name, domain);
+ if (result.symbol != NULL)
{
do_cleanups (cleanup);
- return sym;
+ return result;
}
}

do_cleanups (cleanup);
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* A helper function that throws an exception when a symbol was found
@@ -2424,17 +2424,17 @@ Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
/* A helper function for various lookup routines that interfaces with
the "quick" symbol table functions. */

-static struct symbol *
+static struct symbol_in_block
lookup_symbol_via_quick_fns (struct objfile *objfile, int block_index,
const char *name, const domain_enum domain)
{
struct compunit_symtab *cust;
const struct blockvector *bv;
const struct block *block;
- struct symbol *sym;
+ struct symbol_in_block result;

if (!objfile->sf)
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};

if (symbol_lookup_debug > 1)
{
@@ -2454,36 +2454,37 @@ lookup_symbol_via_quick_fns (struct objfile *objfile, int block_index,
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_via_quick_fns (...) = NULL\n");
}
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

bv = COMPUNIT_BLOCKVECTOR (cust);
block = BLOCKVECTOR_BLOCK (bv, block_index);
- sym = block_lookup_symbol (block, name, domain);
- if (!sym)
+ result.symbol = block_lookup_symbol (block, name, domain);
+ if (result.symbol == NULL)
error_in_psymtab_expansion (block_index, name, cust);

if (symbol_lookup_debug > 1)
{
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
- host_address_to_string (sym),
+ host_address_to_string (result.symbol),
host_address_to_string (block));
}

- block_found = block;
- return fixup_symbol_section (sym, objfile);
+ result.symbol = fixup_symbol_section (result.symbol, objfile);
+ result.block = block;
+ return result;
}

/* See symtab.h. */

-struct symbol *
+struct symbol_in_block
basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *name,
const struct block *block,
const domain_enum domain)
{
- struct symbol *sym;
+ struct symbol_in_block result;

/* NOTE: carlton/2003-05-19: The comments below were written when
this (or what turned into this) was part of lookup_symbol_aux;
@@ -2517,9 +2518,9 @@ basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
the current objfile. Searching the current objfile first is useful
for both matching user expectations as well as performance. */

- sym = lookup_symbol_in_static_block (name, block, domain);
- if (sym != NULL)
- return sym;
+ result = lookup_symbol_in_static_block (name, block, domain);
+ if (result.symbol != NULL)
+ return result;

/* 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
@@ -2535,9 +2536,11 @@ basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
gdbarch = target_gdbarch ();
else
gdbarch = block_gdbarch (block);
- sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
- if (sym != NULL)
- return sym;
+ result.symbol = language_lookup_primitive_type_as_symbol (langdef,
+ gdbarch, name);
+ result.block = NULL;
+ if (result.symbol != NULL)
+ return result;
}

return lookup_global_symbol (name, block, domain);
@@ -2545,7 +2548,7 @@ basic_lookup_symbol_nonlocal (const struct language_defn *langdef,

/* See symtab.h. */

-struct symbol *
+struct symbol_in_block
lookup_symbol_in_static_block (const char *name,
const struct block *block,
const domain_enum domain)
@@ -2554,7 +2557,7 @@ lookup_symbol_in_static_block (const char *name,
struct symbol *sym;

if (static_block == NULL)
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};

if (symbol_lookup_debug)
{
@@ -2576,7 +2579,7 @@ lookup_symbol_in_static_block (const char *name,
"lookup_symbol_in_static_block (...) = %s\n",
sym != NULL ? host_address_to_string (sym) : "NULL");
}
- return sym;
+ return (struct symbol_in_block) {sym, static_block};
}

/* Perform the standard symbol lookup of NAME in OBJFILE:
@@ -2584,11 +2587,11 @@ lookup_symbol_in_static_block (const char *name,
2) Search the "quick" symtabs (partial or .gdb_index).
BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */

-static struct symbol *
+static struct symbol_in_block
lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
const char *name, const domain_enum domain)
{
- struct symbol *result;
+ struct symbol_in_block result;

if (symbol_lookup_debug)
{
@@ -2602,14 +2605,14 @@ lookup_symbol_in_objfile (struct objfile *objfile, int block_index,

result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
name, domain);
- if (result != NULL)
+ if (result.symbol != NULL)
{
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_in_objfile (...) = %s"
" (in symtabs)\n",
- host_address_to_string (result));
+ host_address_to_string (result.symbol));
}
return result;
}
@@ -2620,22 +2623,22 @@ lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
{
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_in_objfile (...) = %s%s\n",
- result != NULL
- ? host_address_to_string (result)
+ result.symbol != NULL
+ ? host_address_to_string (result.symbol)
: "NULL",
- result != NULL ? " (via quick fns)" : "");
+ result.symbol != NULL ? " (via quick fns)" : "");
}
return result;
}

/* See symtab.h. */

-struct symbol *
+struct symbol_in_block
lookup_static_symbol (const char *name, const domain_enum domain)
{
struct symbol_cache *cache = get_symbol_cache (current_program_space);
struct objfile *objfile;
- struct symbol *result;
+ struct symbol_in_block result;
struct block_symbol_cache *bsc;
struct symbol_cache_slot *slot;

@@ -2643,27 +2646,28 @@ lookup_static_symbol (const char *name, const domain_enum domain)
NULL for OBJFILE_CONTEXT. */
result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain,
&bsc, &slot);
- if (result != NULL)
+ if (result.symbol != NULL)
{
- if (result == SYMBOL_LOOKUP_FAILED)
- return NULL;
+ if (SYMBOL_LOOKUP_FAILED_P (result))
+ return (struct symbol_in_block) {NULL, NULL};
return result;
}

ALL_OBJFILES (objfile)
{
result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain);
- if (result != NULL)
+ if (result.symbol != NULL)
{
/* Still pass NULL for OBJFILE_CONTEXT here. */
- symbol_cache_mark_found (bsc, slot, NULL, result);
+ symbol_cache_mark_found (bsc, slot, NULL, result.symbol,
+ result.block);
return result;
}
}

/* Still pass NULL for OBJFILE_CONTEXT here. */
symbol_cache_mark_not_found (bsc, slot, NULL, name, domain);
- return NULL;
+ return (struct symbol_in_block) {NULL, NULL};
}

/* Private data to be used with lookup_symbol_global_iterator_cb. */
@@ -2677,8 +2681,8 @@ struct global_sym_lookup_data
domain_enum domain;

/* The field where the callback should store the symbol if found.
- It should be initialized to NULL before the search is started. */
- struct symbol *result;
+ It should be initialized to {NULL, NULL} before the search is started. */
+ struct symbol_in_block result;
};

/* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
@@ -2693,25 +2697,26 @@ lookup_symbol_global_iterator_cb (struct objfile *objfile,
struct global_sym_lookup_data *data =
(struct global_sym_lookup_data *) cb_data;

- gdb_assert (data->result == NULL);
+ gdb_assert (data->result.symbol == NULL
+ && data->result.block == NULL);

data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
data->name, data->domain);

/* If we found a match, tell the iterator to stop. Otherwise,
keep going. */
- return (data->result != NULL);
+ return (data->result.symbol != NULL);
}

/* See symtab.h. */

-struct symbol *
+struct symbol_in_block
lookup_global_symbol (const char *name,
const struct block *block,
const domain_enum domain)
{
struct symbol_cache *cache = get_symbol_cache (current_program_space);
- struct symbol *sym;
+ struct symbol_in_block result;
struct objfile *objfile;
struct global_sym_lookup_data lookup_data;
struct block_symbol_cache *bsc;
@@ -2721,21 +2726,21 @@ lookup_global_symbol (const char *name,

/* First see if we can find the symbol in the cache.
This works because we use the current objfile to qualify the lookup. */
- sym = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain,
- &bsc, &slot);
- if (sym != NULL)
+ result = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain,
+ &bsc, &slot);
+ if (result.symbol != NULL)
{
- if (sym == SYMBOL_LOOKUP_FAILED)
- return NULL;
- return sym;
+ if (SYMBOL_LOOKUP_FAILED_P (result))
+ return (struct symbol_in_block) {NULL, NULL};
+ return result;
}

/* Call library-specific lookup procedure. */
if (objfile != NULL)
- sym = solib_global_lookup (objfile, name, domain);
+ result = solib_global_lookup (objfile, name, domain);

/* If that didn't work go a global search (of global blocks, heh). */
- if (sym == NULL)
+ if (result.symbol == NULL)
{
memset (&lookup_data, 0, sizeof (lookup_data));
lookup_data.name = name;
@@ -2743,15 +2748,15 @@ lookup_global_symbol (const char *name,
gdbarch_iterate_over_objfiles_in_search_order
(objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
lookup_symbol_global_iterator_cb, &lookup_data, objfile);
- sym = lookup_data.result;
+ result = lookup_data.result;
}

- if (sym != NULL)
- symbol_cache_mark_found (bsc, slot, objfile, sym);
+ if (result.symbol != NULL)
+ symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block);
else
symbol_cache_mark_not_found (bsc, slot, objfile, name, domain);

- return sym;
+ return result;
}

int
@@ -4602,7 +4607,7 @@ search_symbols (const char *regexp, enum search_domain kind,
(MSYMBOL_VALUE_ADDRESS (objfile, msymbol)) == NULL)
: (lookup_symbol_in_objfile_from_linkage_name
(objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
- == NULL))
+ .symbol == NULL))
found_misc = 1;
}
}
@@ -4705,7 +4710,7 @@ search_symbols (const char *regexp, enum search_domain kind,
{
if (lookup_symbol_in_objfile_from_linkage_name
(objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
- == NULL)
+ .symbol == NULL)
{
/* match */
struct symbol_search *psr = (struct symbol_search *)
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 6a0b8da..73026b3 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -782,6 +782,19 @@ struct symbol
struct symbol *hash_next;
};

+/* Several lookup functions return both a symbol and the block in which the
+ symbol is found. This structure is used in these cases. */
+
+struct symbol_in_block
+{
+ /* The symbol that was found, or NULL if no symbol was found. */
+ struct symbol *symbol;
+
+ /* If SYMBOL is not NULL, then this is the block in which the symbol is
+ defined. */
+ const struct block *block;
+};
+
extern const struct symbol_impl *symbol_impls;

/* Note: There is no accessor macro for symbol.owner because it is
@@ -1141,10 +1154,6 @@ DEF_VEC_P (compunit_symtab_ptr);

extern int currently_reading_symtab;

-/* The block in which the most recently looked up symbol was found. */
-
-extern const struct block *block_found;
-
/* symtab.c lookup functions */

extern const char multiple_symbols_ask[];
@@ -1190,27 +1199,27 @@ struct field_of_this_result
C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
NAME is a field of the current implied argument `this'. If so fill in the
fields of IS_A_FIELD_OF_THIS, otherwise the fields are set to NULL.
- 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).
The symbol's section is fixed up if necessary. */

-extern struct symbol *lookup_symbol_in_language (const char *,
- const struct block *,
- const domain_enum,
- enum language,
- struct field_of_this_result *);
+extern struct symbol_in_block
+ lookup_symbol_in_language (const char *,
+ const struct block *,
+ const domain_enum,
+ enum language,
+ struct field_of_this_result *);

/* Same as lookup_symbol_in_language, but using the current language. */

-extern struct symbol *lookup_symbol (const char *, const struct block *,
- const domain_enum,
- struct field_of_this_result *);
+extern struct symbol_in_block lookup_symbol (const char *,
+ const struct block *,
+ const domain_enum,
+ struct field_of_this_result *);

/* A default version of lookup_symbol_nonlocal for use by languages
that can't think of anything better to do.
This implements the C lookup rules. */

-extern struct symbol *
+extern struct symbol_in_block
basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *,
const struct block *,
@@ -1221,19 +1230,18 @@ extern struct symbol *

/* Lookup a symbol in the static block associated to BLOCK, if there
is one; do nothing if BLOCK is NULL or a global block.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */

-extern struct symbol *lookup_symbol_in_static_block (const char *name,
- const struct block *block,
- const domain_enum domain);
+extern struct symbol_in_block
+ lookup_symbol_in_static_block (const char *name,
+ const struct block *block,
+ const domain_enum domain);

/* Search all static file-level symbols for NAME from DOMAIN.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */

-extern struct symbol *lookup_static_symbol (const char *name,
- const domain_enum domain);
+extern struct symbol_in_block lookup_static_symbol (const char *name,
+ const domain_enum domain);

/* Lookup a symbol in all files' global blocks.

@@ -1244,26 +1252,27 @@ extern struct symbol *lookup_static_symbol (const char *name,
if the target requires it.
See gdbarch_iterate_over_objfiles_in_search_order.

- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */

-extern struct symbol *lookup_global_symbol (const char *name,
- const struct block *block,
- const domain_enum domain);
+extern struct symbol_in_block
+ lookup_global_symbol (const char *name,
+ const struct block *block,
+ const domain_enum domain);

/* Lookup a symbol in block BLOCK.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */

-extern struct symbol *lookup_symbol_in_block (const char *name,
- const struct block *block,
- const domain_enum domain);
+extern struct symbol *
+ lookup_symbol_in_block (const char *name,
+ const struct block *block,
+ const domain_enum domain);

/* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
found, or NULL if not found. */

-extern struct symbol *lookup_language_this (const struct language_defn *lang,
- const struct block *block);
+extern struct symbol_in_block
+ lookup_language_this (const struct language_defn *lang,
+ const struct block *block);

/* Lookup a [struct, union, enum] by name, within a specified block. */

@@ -1524,10 +1533,9 @@ extern enum language main_language (void);
/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks.
This searches MAIN_OBJFILE as well as any associated separate debug info
objfiles of MAIN_OBJFILE.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */

-extern struct symbol *
+extern struct symbol_in_block
lookup_global_symbol_from_objfile (struct objfile *main_objfile,
const char *name,
const domain_enum domain);
diff --git a/gdb/valops.c b/gdb/valops.c
index d68e9f3..d326f93 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -127,21 +127,21 @@ show_overload_resolution (struct ui_file *file, int from_tty,
struct value *
find_function_in_inferior (const char *name, struct objfile **objf_p)
{
- struct symbol *sym;
+ struct symbol_in_block sym;

sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
- if (sym != NULL)
+ if (sym.symbol != NULL)
{
- if (SYMBOL_CLASS (sym) != LOC_BLOCK)
+ if (SYMBOL_CLASS (sym.symbol) != LOC_BLOCK)
{
error (_("\"%s\" exists in this program but is not a function."),
name);
}

if (objf_p)
- *objf_p = symbol_objfile (sym);
+ *objf_p = symbol_objfile (sym.symbol);

- return value_of_variable (sym, NULL);
+ return value_of_variable (sym.symbol, sym.block);
}
else
{
@@ -3453,7 +3453,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0);
+ 0, VAR_DOMAIN, 0).symbol;

if (s == NULL)
return NULL;
@@ -3484,7 +3484,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0);
+ 0, VAR_DOMAIN, 0).symbol;

if (s == NULL)
return NULL;
@@ -3560,19 +3560,19 @@ value_maybe_namespace_elt (const struct type *curtype,
enum noside noside)
{
const char *namespace_name = TYPE_TAG_NAME (curtype);
- struct symbol *sym;
+ struct symbol_in_block sym;
struct value *result;

sym = cp_lookup_symbol_namespace (namespace_name, name,
get_selected_block (0), VAR_DOMAIN);

- if (sym == NULL)
+ if (sym.symbol == NULL)
return NULL;
else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
- && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
- result = allocate_value (SYMBOL_TYPE (sym));
+ && (SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF))
+ result = allocate_value (SYMBOL_TYPE (sym.symbol));
else
- result = value_of_variable (sym, get_selected_block (0));
+ result = value_of_variable (sym.symbol, sym.block);

if (want_address)
result = value_addr (result);
@@ -3736,7 +3736,7 @@ value_of_this (const struct language_defn *lang)

b = get_frame_block (frame, NULL);

- sym = lookup_language_this (lang, b);
+ sym = lookup_language_this (lang, b).symbol;
if (sym == NULL)
error (_("current stack frame does not contain a variable named `%s'"),
lang->la_name_of_this);
diff --git a/gdb/value.c b/gdb/value.c
index 4399493..1e331de 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -2937,9 +2937,9 @@ value_static_field (struct type *type, int fieldno)
{
const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
/* TYPE_FIELD_NAME (type, fieldno); */
- struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
+ struct symbol_in_block sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);

- if (sym == NULL)
+ if (sym.symbol == NULL)
{
/* With some compilers, e.g. HP aCC, static data members are
reported as non-debuggable symbols. */
@@ -2955,7 +2955,7 @@ value_static_field (struct type *type, int fieldno)
}
}
else
- retval = value_of_variable (sym, NULL);
+ retval = value_of_variable (sym.symbol, sym.block);
break;
}
default:
@@ -3122,7 +3122,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
struct symbol *sym;
struct bound_minimal_symbol msym;

- sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0);
+ sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0).symbol;
if (sym != NULL)
{
memset (&msym, 0, sizeof (msym));
--
2.4.5