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

Doug Evans
2015-07-25T21:24:17Z

Pierre-Marie de Rodat <derodat@adacore.com> writes:
> 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
>
> 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.

Hi.

There's a missing patch to scm-frame.c.:

../../bound-symbol/gdb/guile/scm-frame.c: In function ‘gdbscm_frame_read_var’:
../../bound-symbol/gdb/guile/scm-frame.c:914:8: error: incompatible types when assigning to type ‘struct symbol *’ from type ‘struct symbol_in_block’
var = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);

I've appended something that works here at the end.

One high level note.
What do you think of "block_symbol"?
"symbol_in_block" reads a bit clumsy.

grep for "====" to find other comments.

LGTM with the rename and the following nits fixed.

> ...
> 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;

====
The name "sym" shadows "sym" defined at function entry.
Renaming the one at function entry to "bsym" would be ok.

> 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);

====
Just pass sym here, instead of sym.symbol and 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};

====
Do we have to return NULL for block here?
I haven't dug into this, but it seems like we could just return
the "block" argument for the block here.

> }
> }
>
> @@ -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};

====
Do we have to return NULL for block here?
I haven't dug into this, but it seems like we could just return
the "block" argument for the block here.

> }
> }
>
> @@ -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);

====
Coding conventions require a blank line here.
I think a saw a few more places like this.
[blank line after local variable definitions]

> + 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));

Here are the guile patches.

diff --git a/gdb/guile/scm-frame.c b/gdb/guile/scm-frame.c
index 787b788..64ac0c0 100644
--- a/gdb/guile/scm-frame.c
+++ b/gdb/guile/scm-frame.c
@@ -911,7 +911,7 @@ gdbscm_frame_read_var (SCM self, SCM symbol_scm, SCM rest)
{
if (block == NULL)
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 (ex, RETURN_MASK_ALL)
{
diff --git a/gdb/guile/scm-symbol.c b/gdb/guile/scm-symbol.c
index 99ef928..01c9eb1 100644
--- a/gdb/guile/scm-symbol.c
+++ b/gdb/guile/scm-symbol.c
@@ -617,7 +617,7 @@ gdbscm_lookup_symbol (SCM name_scm, SCM rest)

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 (ex, RETURN_MASK_ALL)
{
@@ -657,7 +657,7 @@ gdbscm_lookup_global_symbol (SCM name_scm, SCM rest)

TRY
{
- symbol = lookup_global_symbol (name, NULL, domain);
+ symbol = lookup_global_symbol (name, NULL, domain).symbol;
}
CATCH (ex, RETURN_MASK_ALL)
{