From patchwork Sat Jul 25 21:23:07 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Doug Evans X-Patchwork-Id: 7856 Received: (qmail 83795 invoked by alias); 25 Jul 2015 21:24:17 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 83784 invoked by uid 89); 25 Jul 2015 21:24:16 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.3 required=5.0 tests=AWL, BAYES_50, FREEMAIL_ENVFROM_END_DIGIT, FREEMAIL_FROM, KAM_STOCKGEN, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=no version=3.3.2 X-HELO: mail-pa0-f45.google.com Received: from mail-pa0-f45.google.com (HELO mail-pa0-f45.google.com) (209.85.220.45) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Sat, 25 Jul 2015 21:24:01 +0000 Received: by pabkd10 with SMTP id kd10so30993318pab.2 for ; Sat, 25 Jul 2015 14:23:59 -0700 (PDT) X-Received: by 10.66.231.69 with SMTP id te5mr47558711pac.98.1437859439030; Sat, 25 Jul 2015 14:23:59 -0700 (PDT) Received: from seba.sebabeach.org.gmail.com (173-13-178-53-sfba.hfc.comcastbusiness.net. [173.13.178.53]) by smtp.gmail.com with ESMTPSA id ra10sm21556479pab.19.2015.07.25.14.23.57 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sat, 25 Jul 2015 14:23:58 -0700 (PDT) From: Doug Evans To: Pierre-Marie de Rodat Cc: GDB Patches , Pedro Alves Subject: Re: [PATCH] Replace the block_found global with explicit data-flow References: <55AE7520.1010307@adacore.com> <55AE943F.3000009@adacore.com> Date: Sat, 25 Jul 2015 14:23:07 -0700 In-Reply-To: <55AE943F.3000009@adacore.com> (Pierre-Marie de Rodat's message of "Tue, 21 Jul 2015 20:49:35 +0200") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.5 (gnu/linux) MIME-Version: 1.0 X-IsSubscribed: yes Pierre-Marie de Rodat writes: > On 07/21/2015 06:36 PM, Pierre-Marie de Rodat wrote: >> As Pedro suggested on gdb-patches@ (see >> ), 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 > 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 :%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", > 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; > } > > -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) {