From patchwork Sat Dec 14 23:29:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Christian Biesinger X-Patchwork-Id: 36879 Received: (qmail 63104 invoked by alias); 14 Dec 2019 23:30:45 -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 62825 invoked by uid 89); 14 Dec 2019 23:30:33 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-20.8 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_PASS, T_FILL_THIS_FORM_SHORT autolearn=ham version=3.3.1 spammy=distinction, 7157, pod, sk:insert_ X-HELO: mail-qk1-f193.google.com Received: from mail-qk1-f193.google.com (HELO mail-qk1-f193.google.com) (209.85.222.193) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 14 Dec 2019 23:30:14 +0000 Received: by mail-qk1-f193.google.com with SMTP id a203so1330555qkc.3 for ; Sat, 14 Dec 2019 15:30:07 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=NZFr0zRglr+RD0/qPrJjHdfWZLUwWZazjm5a+HTU9TQ=; b=WbCwPIgtw3tz+EQ3se8fh7Hx/UcMv1FmVQHnj4+wkbJcMwzkmPYmYCEe4EuqQ4ClQq 12WiFliOCmZ1yvPNj7xf5lGTZJv/LtTQY1RfqHTLUidLABUgGflpkTZ+OlpSh6PvVEFi sGn3xfP8egKY2O1tPPxe+hL35ZJE9ydgBYBKY= Return-Path: Received: from cbiesinger.united_club.ewr.united.com ([65.119.211.164]) by smtp.googlemail.com with ESMTPSA id x6sm4386956qkh.20.2019.12.14.15.30.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 14 Dec 2019 15:30:04 -0800 (PST) From: cbiesinger@chromium.org To: gdb-patches@sourceware.org Cc: Christian Biesinger Subject: [PATCH 2/3] Use an accessor function for general_symbol_info::language Date: Sat, 14 Dec 2019 18:29:58 -0500 Message-Id: <20191214232959.3973-3-cbiesinger@chromium.org> In-Reply-To: <20191214232959.3973-1-cbiesinger@chromium.org> References: <20191214232959.3973-1-cbiesinger@chromium.org> MIME-Version: 1.0 From: Christian Biesinger Also renames the member variable to m_language to make code easier to read when more functions become member functions. I was originally hoping to eventually make m_language private (after a few more patches), but unfortunately then it no longer counts as a POD type, which means gdbsupport/poison.h won't let us use memset to initialize this type, which psymtabs rely on to clear padding bytes so that bcache can work properly. gdb/ChangeLog: 2019-12-14 Christian Biesinger * ada-lang.c (ada_add_block_symbols): Update. (ada_collect_symbol_completion_matches): Update. * ax-gdb.c (gen_expr): Update. * block.c (block_lookup_symbol): Update. (block_lookup_symbol_primary): Update. (block_find_symbol): Update. * cp-namespace.c (cp_lookup_symbol_imports_or_template): Update. * dbxread.c (process_one_symbol): Update. * dictionary.c (insert_symbol_hashed): Update. (collate_pending_symbols_by_language): Update. (mdict_add_symbol): Update. * dwarf-index-write.c (write_psymbols): Update. * dwarf2read.c (fixup_go_packaging): Update. * findvar.c (read_var_value): Update. * ft32-tdep.c (ft32_skip_prologue): Update. * go-lang.c (go_symbol_package_name): Update. * language.c (language_alloc_type_symbol): Update. * language.h (scoped_switch_to_sym_language_if_auto:: scoped_switch_to_sym_language_if_auto): Update. * linespec.c (find_method): Update. (find_label_symbols_in_block): Update. * mdebugread.c (parse_symbol): Update. * mi/mi-cmd-stack.c (list_arg_or_local): Update. * minsyms.c (add_minsym_to_demangled_hash_table): Update. (minimal_symbol_reader::install): Update. * moxie-tdep.c (moxie_skip_prologue): Update. * parse.c (parse_exp_in_context): Update. * psymtab.c (psymbol_name_matches): Update. (match_partial_symbol): Update. (lookup_partial_symbol): Update. (psymbol_hash): Update. (psymbol_compare): Update. * python/py-framefilter.c (extract_sym): Update. (py_print_single_arg): Update. * stabsread.c (define_symbol): Update. * stack.c (print_frame_arg): Update. (find_frame_funname): Update. (info_frame_command_core): Update. * symfile.c (set_initial_language): Update. * symtab.c (symbol_set_demangled_name): Update. (symbol_get_demangled_name): Update. (symbol_set_language): Update. (symbol_find_demangled_name): Update. (symbol_set_names): Update. (general_symbol_info::natural_name): Update. (general_symbol_info::demangled_name): Update. (general_symbol_info::search_name): Update. (symbol_matches_search_name): Update. (eq_symbol_entry): Update. (iterate_over_symbols): Update. (completion_list_add_symbol): Update. (completion_list_add_msymbol): Update. (completion_list_add_fields): Update. * symtab.h (struct general_symbol_info) : New function. : Rename to... : ...this. (SYMBOL_LANGUAGE): Remove. (MSYMBOL_LANGUAGE): Remove. (struct symbol) : Update. * xstormy16-tdep.c (xstormy16_skip_prologue): Update. Change-Id: I6464d477457e61639c63ddf8b145e407a35c235a --- gdb/ada-lang.c | 13 ++++---- gdb/ax-gdb.c | 2 +- gdb/block.c | 10 +++---- gdb/cp-namespace.c | 2 +- gdb/dbxread.c | 4 +-- gdb/dictionary.c | 10 +++---- gdb/dwarf-index-write.c | 4 +-- gdb/dwarf2read.c | 2 +- gdb/findvar.c | 2 +- gdb/ft32-tdep.c | 2 +- gdb/go-lang.c | 2 +- gdb/language.c | 2 +- gdb/language.h | 2 +- gdb/linespec.c | 6 ++-- gdb/mdebugread.c | 4 +-- gdb/mi/mi-cmd-stack.c | 2 +- gdb/minsyms.c | 5 ++-- gdb/moxie-tdep.c | 2 +- gdb/parse.c | 2 +- gdb/psymtab.c | 16 +++++----- gdb/python/py-framefilter.c | 8 ++--- gdb/stabsread.c | 6 ++-- gdb/stack.c | 14 ++++----- gdb/symfile.c | 2 +- gdb/symtab.c | 60 ++++++++++++++++++------------------- gdb/symtab.h | 9 +++--- gdb/xstormy16-tdep.c | 2 +- 27 files changed, 95 insertions(+), 100 deletions(-) diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 3289a8e5c8..030c4aa131 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -6220,8 +6220,7 @@ ada_add_block_symbols (struct obstack *obstackp, sym != NULL; sym = block_iter_match_next (lookup_name, &iter)) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), - SYMBOL_DOMAIN (sym), domain)) + if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain)) { if (SYMBOL_CLASS (sym) != LOC_UNRESOLVED) { @@ -6260,7 +6259,7 @@ ada_add_block_symbols (struct obstack *obstackp, ALL_BLOCK_SYMBOLS (block, iter, sym) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), + if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain)) { int cmp; @@ -6428,7 +6427,7 @@ ada_collect_symbol_completion_matches (completion_tracker &tracker, if (completion_skip_symbol (mode, msymbol)) continue; - language symbol_language = MSYMBOL_LANGUAGE (msymbol); + language symbol_language = msymbol->language (); /* Ada minimal symbols won't have their language set to Ada. If we let completion_list_add_name compare using the @@ -6466,7 +6465,7 @@ ada_collect_symbol_completion_matches (completion_tracker &tracker, continue; completion_list_add_name (tracker, - SYMBOL_LANGUAGE (sym), + sym->language (), sym->linkage_name (), lookup_name, text, word); } @@ -6487,7 +6486,7 @@ ada_collect_symbol_completion_matches (completion_tracker &tracker, continue; completion_list_add_name (tracker, - SYMBOL_LANGUAGE (sym), + sym->language (), sym->linkage_name (), lookup_name, text, word); } @@ -6509,7 +6508,7 @@ ada_collect_symbol_completion_matches (completion_tracker &tracker, continue; completion_list_add_name (tracker, - SYMBOL_LANGUAGE (sym), + sym->language (), sym->linkage_name (), lookup_name, text, word); } diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index 8489587064..d25413ea1f 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -2230,7 +2230,7 @@ gen_expr (struct expression *exp, union exp_element **pc, b = block_for_pc (ax->scope); func = block_linkage_function (b); - lang = language_def (SYMBOL_LANGUAGE (func)); + lang = language_def (func->language ()); sym = lookup_language_this (lang, b).symbol; if (!sym) diff --git a/gdb/block.c b/gdb/block.c index b49c548adc..58441bfe89 100644 --- a/gdb/block.c +++ b/gdb/block.c @@ -729,7 +729,7 @@ block_lookup_symbol (const struct block *block, const char *name, STRUCT vs VAR domain symbols. So if a matching symbol is found, make sure there is no "better" matching symbol, i.e., one with exactly the same domain. PR 16253. */ - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), + if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain)) other = better_symbol (other, sym, domain); } @@ -750,7 +750,7 @@ block_lookup_symbol (const struct block *block, const char *name, ALL_BLOCK_SYMBOLS_WITH_NAME (block, lookup_name, iter, sym) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), + if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain)) { sym_found = sym; @@ -819,8 +819,7 @@ block_lookup_symbol_primary (const struct block *block, const char *name, STRUCT vs VAR domain symbols. So if a matching symbol is found, make sure there is no "better" matching symbol, i.e., one with exactly the same domain. PR 16253. */ - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), - SYMBOL_DOMAIN (sym), domain)) + if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain)) other = better_symbol (other, sym, domain); } @@ -847,8 +846,7 @@ block_find_symbol (const struct block *block, const char *name, { /* MATCHER is deliberately called second here so that it never sees a non-domain-matching symbol. */ - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), - SYMBOL_DOMAIN (sym), domain) + if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain) && matcher (sym, data)) return sym; } diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c index d813d05073..20067cdd03 100644 --- a/gdb/cp-namespace.c +++ b/gdb/cp-namespace.c @@ -516,7 +516,7 @@ cp_lookup_symbol_imports_or_template (const char *scope, domain_name (domain)); } - if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus) + if (function != NULL && function->language () == language_cplus) { /* Search the function's template parameters. */ if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function)) diff --git a/gdb/dbxread.c b/gdb/dbxread.c index 73f1ba8759..ecfa89ae0c 100644 --- a/gdb/dbxread.c +++ b/gdb/dbxread.c @@ -2456,7 +2456,7 @@ process_one_symbol (int type, int desc, CORE_ADDR valu, const char *name, cstk.start_addr, cstk.start_addr + valu); /* For C++, set the block's scope. */ - if (SYMBOL_LANGUAGE (cstk.name) == language_cplus) + if (cstk.name->language () == language_cplus) cp_set_block_scope (cstk.name, block, &objfile->objfile_obstack); /* May be switching to an assembler file which may not be using @@ -2823,7 +2823,7 @@ process_one_symbol (int type, int desc, CORE_ADDR valu, const char *name, cstk.start_addr, valu); /* For C++, set the block's scope. */ - if (SYMBOL_LANGUAGE (cstk.name) == language_cplus) + if (cstk.name->language () == language_cplus) cp_set_block_scope (cstk.name, block, &objfile->objfile_obstack); } diff --git a/gdb/dictionary.c b/gdb/dictionary.c index 0d13370b72..125a062d80 100644 --- a/gdb/dictionary.c +++ b/gdb/dictionary.c @@ -640,9 +640,9 @@ insert_symbol_hashed (struct dictionary *dict, /* We don't want to insert a symbol into a dictionary of a different language. The two may not use the same hashing algorithm. */ - gdb_assert (SYMBOL_LANGUAGE (sym) == DICT_LANGUAGE (dict)->la_language); + gdb_assert (sym->language () == DICT_LANGUAGE (dict)->la_language); - hash = search_name_hash (SYMBOL_LANGUAGE (sym), sym->search_name ()); + hash = search_name_hash (sym->language (), sym->search_name ()); hash_index = hash % DICT_HASHED_NBUCKETS (dict); sym->hash_next = buckets[hash_index]; buckets[hash_index] = sym; @@ -928,7 +928,7 @@ collate_pending_symbols_by_language (const struct pending *symbol_list) { for (int i = list_counter->nsyms - 1; i >= 0; --i) { - enum language language = SYMBOL_LANGUAGE (list_counter->symbol[i]); + enum language language = list_counter->symbol[i]->language (); nsyms[language].push_back (list_counter->symbol[i]); } } @@ -1116,13 +1116,13 @@ void mdict_add_symbol (struct multidictionary *mdict, struct symbol *sym) { struct dictionary *dict - = find_language_dictionary (mdict, SYMBOL_LANGUAGE (sym)); + = find_language_dictionary (mdict, sym->language ()); if (dict == nullptr) { /* SYM is of a new language that we haven't previously seen. Create a new dictionary for it. */ - dict = create_new_language_dictionary (mdict, SYMBOL_LANGUAGE (sym)); + dict = create_new_language_dictionary (mdict, sym->language ()); } dict_add_symbol (dict, sym); diff --git a/gdb/dwarf-index-write.c b/gdb/dwarf-index-write.c index cbad308430..66c2368b9c 100644 --- a/gdb/dwarf-index-write.c +++ b/gdb/dwarf-index-write.c @@ -543,7 +543,7 @@ write_psymbols (struct mapped_symtab *symtab, { struct partial_symbol *psym = *psymp; - if (psym->ginfo.language == language_ada) + if (psym->ginfo.language () == language_ada) error (_("Ada is not currently supported by the index; " "use the DWARF 5 index instead")); @@ -690,7 +690,7 @@ public: return; const char *name = psym->ginfo.search_name (); - if (psym->ginfo.language == language_ada) + if (psym->ginfo.language () == language_ada) { /* We want to ensure that the Ada main function's name appears verbatim in the index. However, this name will be of the diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index e009b523cc..6a09d5568b 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -9916,7 +9916,7 @@ fixup_go_packaging (struct dwarf2_cu *cu) { struct symbol *sym = list->symbol[i]; - if (SYMBOL_LANGUAGE (sym) == language_go + if (sym->language () == language_go && SYMBOL_CLASS (sym) == LOC_BLOCK) { char *this_package_name = go_symbol_package_name (sym); diff --git a/gdb/findvar.c b/gdb/findvar.c index 50e99f48d1..18dd3cd04f 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -807,7 +807,7 @@ struct value * read_var_value (struct symbol *var, const struct block *var_block, struct frame_info *frame) { - const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var)); + const struct language_defn *lang = language_def (var->language ()); gdb_assert (lang != NULL); gdb_assert (lang->la_read_var_value != NULL); diff --git a/gdb/ft32-tdep.c b/gdb/ft32-tdep.c index bded02fae4..56c2165037 100644 --- a/gdb/ft32-tdep.c +++ b/gdb/ft32-tdep.c @@ -299,7 +299,7 @@ ft32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) /* Found a function. */ sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol; /* Don't use line number debug info for assembly source files. */ - if ((sym != NULL) && SYMBOL_LANGUAGE (sym) != language_asm) + if ((sym != NULL) && sym->language () != language_asm) { sal = find_pc_line (func_addr, 0); if (sal.end && sal.end < func_end) diff --git a/gdb/go-lang.c b/gdb/go-lang.c index bf2eb1b6f7..b527d9f72e 100644 --- a/gdb/go-lang.c +++ b/gdb/go-lang.c @@ -420,7 +420,7 @@ go_symbol_package_name (const struct symbol *sym) char *name_buf; char *result; - gdb_assert (SYMBOL_LANGUAGE (sym) == language_go); + gdb_assert (sym->language () == language_go); name_buf = unpack_mangled_go_symbol (mangled_name, &package_name, &object_name, &method_type_package_name, diff --git a/gdb/language.c b/gdb/language.c index da6f7a860a..ed850350b1 100644 --- a/gdb/language.c +++ b/gdb/language.c @@ -1051,7 +1051,7 @@ language_alloc_type_symbol (enum language lang, struct type *type) symbol = new (gdbarch_obstack (gdbarch)) struct symbol (); symbol->name = TYPE_NAME (type); - symbol->set_language (language, lang, nullptr); + symbol_set_language (symbol, lang, nullptr); symbol->owner.arch = gdbarch; SYMBOL_OBJFILE_OWNED (symbol) = 0; SYMBOL_TYPE (symbol) = type; diff --git a/gdb/language.h b/gdb/language.h index 5fc25a235f..14d6fac303 100644 --- a/gdb/language.h +++ b/gdb/language.h @@ -715,7 +715,7 @@ public: { m_lang = current_language->la_language; m_switched = true; - set_language (SYMBOL_LANGUAGE (sym)); + set_language (sym->language ()); } else { diff --git a/gdb/linespec.c b/gdb/linespec.c index 61dcb4830e..9c17331a93 100644 --- a/gdb/linespec.c +++ b/gdb/linespec.c @@ -3683,7 +3683,7 @@ find_method (struct linespec_state *self, std::vector *file_symtabs, gdb_assert (!pspace->executing_startup); set_current_program_space (pspace); t = check_typedef (SYMBOL_TYPE (sym)); - find_methods (t, SYMBOL_LANGUAGE (sym), + find_methods (t, sym->language (), method_name, &result_names, &superclass_vec); /* Handle all items from a single program space at once; and be @@ -3696,7 +3696,7 @@ find_method (struct linespec_state *self, std::vector *file_symtabs, this program space, consider superclasses. */ if (result_names.size () == last_result_len) find_superclass_methods (std::move (superclass_vec), method_name, - SYMBOL_LANGUAGE (sym), &result_names); + sym->language (), &result_names); /* We have a list of candidate symbol names, so now we iterate over the symbol tables looking for all @@ -3998,7 +3998,7 @@ find_label_symbols_in_block (const struct block *block, ALL_BLOCK_SYMBOLS (block, iter, sym) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), + if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), LABEL_DOMAIN) && cmp (sym->search_name (), name, name_len) == 0) { diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index f279f13171..ceffc012c1 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -794,11 +794,11 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, /* All functions in C++ have prototypes. For C we don't have enough information in the debug info. */ - if (SYMBOL_LANGUAGE (s) == language_cplus) + if (s->language () == language_cplus) TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1; /* Create and enter a new lexical context. */ - b = new_block (FUNCTION_BLOCK, SYMBOL_LANGUAGE (s)); + b = new_block (FUNCTION_BLOCK, s->language ()); SYMBOL_BLOCK_VALUE (s) = b; BLOCK_FUNCTION (b) = s; BLOCK_START (b) = BLOCK_END (b) = sh->value; diff --git a/gdb/mi/mi-cmd-stack.c b/gdb/mi/mi-cmd-stack.c index 50843313f8..6cd255d072 100644 --- a/gdb/mi/mi-cmd-stack.c +++ b/gdb/mi/mi-cmd-stack.c @@ -543,7 +543,7 @@ list_arg_or_local (const struct frame_arg *arg, enum what_to_list what, get_no_prettyformat_print_options (&opts); opts.deref_ref = 1; common_val_print (arg->val, &stb, 0, &opts, - language_def (SYMBOL_LANGUAGE (arg->sym))); + language_def (arg->sym->language ())); } catch (const gdb_exception_error &except) { diff --git a/gdb/minsyms.c b/gdb/minsyms.c index 40bedbd3e7..6afa393633 100644 --- a/gdb/minsyms.c +++ b/gdb/minsyms.c @@ -162,7 +162,7 @@ add_minsym_to_demangled_hash_table (struct minimal_symbol *sym, { if (sym->demangled_hash_next == NULL) { - objfile->per_bfd->demangled_hash_languages.set (MSYMBOL_LANGUAGE (sym)); + objfile->per_bfd->demangled_hash_languages.set (sym->language ()); struct minimal_symbol **table = objfile->per_bfd->msymbol_demangled_hash; @@ -1420,8 +1420,7 @@ minimal_symbol_reader::install () build_minimal_symbol_hash_tables. */ if (msym->search_name () != msym->linkage_name ()) hash_values[idx].minsym_demangled_hash - = search_name_hash (MSYMBOL_LANGUAGE (msym), - msym->search_name ()); + = search_name_hash (msym->language (), msym->search_name ()); } { /* To limit how long we hold the lock, we only acquire it here diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c index 81fdb7111c..0c38438697 100644 --- a/gdb/moxie-tdep.c +++ b/gdb/moxie-tdep.c @@ -232,7 +232,7 @@ moxie_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol; /* Don't use line number debug info for assembly source files. */ - if (sym && SYMBOL_LANGUAGE (sym) != language_asm) + if (sym && sym->language () != language_asm) { sal = find_pc_line (func_addr, 0); if (sal.end && sal.end < func_end) diff --git a/gdb/parse.c b/gdb/parse.c index d7360aa6bb..399f776a71 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -1098,7 +1098,7 @@ parse_exp_in_context (const char **stringptr, CORE_ADDR pc, struct symbol *func = block_linkage_function (block); if (func != NULL) - lang = language_def (SYMBOL_LANGUAGE (func)); + lang = language_def (func->language ()); if (lang == NULL || lang->la_language == language_unknown) lang = current_language; } diff --git a/gdb/psymtab.c b/gdb/psymtab.c index 2cbc6d4f65..28b452b07f 100644 --- a/gdb/psymtab.c +++ b/gdb/psymtab.c @@ -531,7 +531,7 @@ static bool psymbol_name_matches (partial_symbol *psym, const lookup_name_info &lookup_name) { - const language_defn *lang = language_def (psym->ginfo.language); + const language_defn *lang = language_def (psym->ginfo.language ()); symbol_name_matcher_ftype *name_match = get_symbol_name_matcher (lang, lookup_name); return name_match (psym->ginfo.search_name (), lookup_name, NULL); @@ -581,7 +581,7 @@ match_partial_symbol (struct objfile *objfile, center = bottom + (top - bottom) / 2; gdb_assert (center < top); - enum language lang = (*center)->ginfo.language; + enum language lang = (*center)->ginfo.language (); const char *lang_ln = name.language_lookup_name (lang).c_str (); @@ -596,7 +596,7 @@ match_partial_symbol (struct objfile *objfile, while (top <= real_top && psymbol_name_matches (*top, name)) { - if (symbol_matches_domain ((*top)->ginfo.language, + if (symbol_matches_domain ((*top)->ginfo.language (), (*top)->domain, domain)) return *top; top++; @@ -610,7 +610,7 @@ match_partial_symbol (struct objfile *objfile, { for (psym = start; psym < start + length; psym++) { - if (symbol_matches_domain ((*psym)->ginfo.language, + if (symbol_matches_domain ((*psym)->ginfo.language (), (*psym)->domain, domain) && psymbol_name_matches (*psym, name)) return *psym; @@ -719,7 +719,7 @@ lookup_partial_symbol (struct objfile *objfile, while (top <= real_top && symbol_matches_search_name (&(*top)->ginfo, lookup_name)) { - if (symbol_matches_domain ((*top)->ginfo.language, + if (symbol_matches_domain ((*top)->ginfo.language (), (*top)->domain, domain)) return *top; top++; @@ -733,7 +733,7 @@ lookup_partial_symbol (struct objfile *objfile, { for (psym = start; psym < start + length; psym++) { - if (symbol_matches_domain ((*psym)->ginfo.language, + if (symbol_matches_domain ((*psym)->ginfo.language (), (*psym)->domain, domain) && symbol_matches_search_name (&(*psym)->ginfo, lookup_name)) return *psym; @@ -1526,7 +1526,7 @@ psymbol_hash (const void *addr, int length) { unsigned long h = 0; struct partial_symbol *psymbol = (struct partial_symbol *) addr; - unsigned int lang = psymbol->ginfo.language; + unsigned int lang = psymbol->ginfo.language (); unsigned int domain = psymbol->domain; unsigned int theclass = psymbol->aclass; @@ -1553,7 +1553,7 @@ psymbol_compare (const void *addr1, const void *addr2, int length) return (memcmp (&sym1->ginfo.value, &sym2->ginfo.value, sizeof (sym1->ginfo.value)) == 0 - && sym1->ginfo.language == sym2->ginfo.language + && sym1->ginfo.language () == sym2->ginfo.language () && sym1->domain == sym2->domain && sym1->aclass == sym2->aclass /* Note that psymbol names are interned via diff --git a/gdb/python/py-framefilter.c b/gdb/python/py-framefilter.c index 8e38d8d7a4..fd03d313e9 100644 --- a/gdb/python/py-framefilter.c +++ b/gdb/python/py-framefilter.c @@ -109,7 +109,7 @@ extract_sym (PyObject *obj, gdb::unique_xmalloc_ptr *name, from the symbol. If mode is not "auto", then the language has been explicitly set, use that. */ if (language_mode == language_mode_auto) - *language = language_def (SYMBOL_LANGUAGE (*sym)); + *language = language_def ((*sym)->language ()); else *language = current_language; } @@ -320,7 +320,7 @@ py_print_single_arg (struct ui_out *out, { if (fa->val == NULL && fa->error == NULL) return; - language = language_def (SYMBOL_LANGUAGE (fa->sym)); + language = language_def (fa->sym->language ()); val = fa->val; } else @@ -349,14 +349,14 @@ py_print_single_arg (struct ui_out *out, string_file stb; fprintf_symbol_filtered (&stb, fa->sym->print_name (), - SYMBOL_LANGUAGE (fa->sym), + fa->sym->language (), DMGL_PARAMS | DMGL_ANSI); if (fa->entry_kind == print_entry_values_compact) { stb.puts ("="); fprintf_symbol_filtered (&stb, fa->sym->print_name (), - SYMBOL_LANGUAGE (fa->sym), + fa->sym->language (), DMGL_PARAMS | DMGL_ANSI); } if (fa->entry_kind == print_entry_values_only diff --git a/gdb/stabsread.c b/gdb/stabsread.c index 91a73dd10d..1b5426e284 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -740,7 +740,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, normal: std::string new_name; - if (SYMBOL_LANGUAGE (sym) == language_cplus) + if (sym->language () == language_cplus) { char *name = (char *) alloca (p - string + 1); @@ -758,7 +758,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, SYMBOL_SET_NAMES (sym, gdb::string_view (string, p - string), true, objfile); - if (SYMBOL_LANGUAGE (sym) == language_cplus) + if (sym->language () == language_cplus) cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym, objfile); @@ -1225,7 +1225,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, This is important to do, because of forward references: The cleanup of undefined types stored in undef_types only uses STRUCT_DOMAIN symbols to perform the replacement. */ - synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T'); + synonym = (sym->language () == language_ada && p[-2] != 'T'); /* Typedef */ SYMBOL_TYPE (sym) = read_type (&p, objfile); diff --git a/gdb/stack.c b/gdb/stack.c index cc7b7e5bbe..2282052487 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -428,7 +428,7 @@ print_frame_arg (const frame_print_options &fp_opts, annotate_arg_emitter arg_emitter; ui_out_emit_tuple tuple_emitter (uiout, NULL); fprintf_symbol_filtered (&stb, arg->sym->print_name (), - SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI); + arg->sym->language (), DMGL_PARAMS | DMGL_ANSI); if (arg->entry_kind == print_entry_values_compact) { /* It is OK to provide invalid MI-like stream as with @@ -436,7 +436,7 @@ print_frame_arg (const frame_print_options &fp_opts, stb.puts ("="); fprintf_symbol_filtered (&stb, arg->sym->print_name (), - SYMBOL_LANGUAGE (arg->sym), + arg->sym->language (), DMGL_PARAMS | DMGL_ANSI); } if (arg->entry_kind == print_entry_values_only @@ -474,7 +474,7 @@ print_frame_arg (const frame_print_options &fp_opts, /* Use the appropriate language to display our symbol, unless the user forced the language to a specific language. */ if (language_mode == language_mode_auto) - language = language_def (SYMBOL_LANGUAGE (arg->sym)); + language = language_def (arg->sym->language ()); else language = current_language; @@ -1261,7 +1261,7 @@ find_frame_funname (struct frame_info *frame, enum language *funlang, { const char *print_name = func->print_name (); - *funlang = SYMBOL_LANGUAGE (func); + *funlang = func->language (); if (funcp) *funcp = func; if (*funlang == language_cplus) @@ -1291,7 +1291,7 @@ find_frame_funname (struct frame_info *frame, enum language *funlang, if (msymbol.minsym != NULL) { funname.reset (xstrdup (msymbol.minsym->print_name ())); - *funlang = MSYMBOL_LANGUAGE (msymbol.minsym); + *funlang = msymbol.minsym->language (); } } @@ -1495,7 +1495,7 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) if (func) { funname = func->print_name (); - funlang = SYMBOL_LANGUAGE (func); + funlang = func->language (); if (funlang == language_cplus) { /* It seems appropriate to use print_name() here, @@ -1517,7 +1517,7 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) if (msymbol.minsym != NULL) { funname = msymbol.minsym->print_name (); - funlang = MSYMBOL_LANGUAGE (msymbol.minsym); + funlang = msymbol.minsym->language (); } } calling_frame_info = get_prev_frame (fi); diff --git a/gdb/symfile.c b/gdb/symfile.c index 8852e2893a..5ca89b45b3 100644 --- a/gdb/symfile.c +++ b/gdb/symfile.c @@ -1697,7 +1697,7 @@ set_initial_language (void) struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL).symbol; if (sym != NULL) - lang = SYMBOL_LANGUAGE (sym); + lang = sym->language (); } if (lang == language_unknown) diff --git a/gdb/symtab.c b/gdb/symtab.c index 6fd1c8c4bc..a082ee21a9 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -675,7 +675,7 @@ symbol_set_demangled_name (struct general_symbol_info *gsymbol, const char *name, struct obstack *obstack) { - if (gsymbol->language == language_ada) + if (gsymbol->language () == language_ada) { if (name == NULL) { @@ -697,7 +697,7 @@ symbol_set_demangled_name (struct general_symbol_info *gsymbol, const char * symbol_get_demangled_name (const struct general_symbol_info *gsymbol) { - if (gsymbol->language == language_ada) + if (gsymbol->language () == language_ada) { if (!gsymbol->ada_mangled) return NULL; @@ -716,16 +716,16 @@ symbol_set_language (struct general_symbol_info *gsymbol, enum language language, struct obstack *obstack) { - gsymbol->language = language; - if (gsymbol->language == language_cplus - || gsymbol->language == language_d - || gsymbol->language == language_go - || gsymbol->language == language_objc - || gsymbol->language == language_fortran) + gsymbol->m_language = language; + if (language == language_cplus + || language == language_d + || language == language_go + || language == language_objc + || language == language_fortran) { symbol_set_demangled_name (gsymbol, NULL, obstack); } - else if (gsymbol->language == language_ada) + else if (language == language_ada) { gdb_assert (gsymbol->ada_mangled == 0); gsymbol->language_specific.obstack = obstack; @@ -819,12 +819,12 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol, char *demangled = NULL; int i; - if (gsymbol->language == language_unknown) - gsymbol->language = language_auto; + if (gsymbol->language () == language_unknown) + gsymbol->m_language = language_auto; - if (gsymbol->language != language_auto) + if (gsymbol->language () != language_auto) { - const struct language_defn *lang = language_def (gsymbol->language); + const struct language_defn *lang = language_def (gsymbol->language ()); language_sniff_from_mangled_name (lang, mangled, &demangled); return demangled; @@ -837,7 +837,7 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol, if (language_sniff_from_mangled_name (lang, mangled, &demangled)) { - gsymbol->language = l; + gsymbol->m_language = l; return demangled; } } @@ -864,7 +864,7 @@ symbol_set_names (struct general_symbol_info *gsymbol, { struct demangled_name_entry **slot; - if (gsymbol->language == language_ada) + if (gsymbol->language () == language_ada) { /* In Ada, we do the symbol lookups using the mangled name, so we can save some space by not storing the demangled name. */ @@ -898,7 +898,7 @@ symbol_set_names (struct general_symbol_info *gsymbol, if (*slot == NULL /* A C version of the symbol may have already snuck into the table. This happens to, e.g., main.init (__go_init_main). Cope. */ - || (gsymbol->language == language_go && (*slot)->demangled == nullptr)) + || (gsymbol->language () == language_go && (*slot)->demangled == nullptr)) { /* A 0-terminated copy of the linkage name. Callers must set COPY_NAME to true if the string might not be nullterminated. We have to make @@ -959,11 +959,11 @@ symbol_set_names (struct general_symbol_info *gsymbol, (gdb::string_view (mangled_ptr, linkage_name.length ())); } (*slot)->demangled = std::move (demangled_name); - (*slot)->language = gsymbol->language; + (*slot)->language = gsymbol->language (); } - else if (gsymbol->language == language_unknown - || gsymbol->language == language_auto) - gsymbol->language = (*slot)->language; + else if (gsymbol->language () == language_unknown + || gsymbol->language () == language_auto) + gsymbol->m_language = (*slot)->language; gsymbol->name = (*slot)->mangled.data (); if ((*slot)->demangled != nullptr) @@ -978,7 +978,7 @@ symbol_set_names (struct general_symbol_info *gsymbol, const char * general_symbol_info::natural_name () const { - switch (language) + switch (language ()) { case language_cplus: case language_d: @@ -1003,7 +1003,7 @@ general_symbol_info::demangled_name () const { const char *dem_name = NULL; - switch (language) + switch (language ()) { case language_cplus: case language_d: @@ -1026,7 +1026,7 @@ general_symbol_info::demangled_name () const const char * general_symbol_info::search_name () const { - if (language == language_ada) + if (language () == language_ada) return name; else return natural_name (); @@ -1039,7 +1039,7 @@ symbol_matches_search_name (const struct general_symbol_info *gsymbol, const lookup_name_info &name) { symbol_name_matcher_ftype *name_match - = get_symbol_name_matcher (language_def (gsymbol->language), name); + = get_symbol_name_matcher (language_def (gsymbol->language ()), name); return name_match (gsymbol->search_name (), name, NULL); } @@ -1219,8 +1219,7 @@ eq_symbol_entry (const struct symbol_cache_slot *slot, if (!SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name)) return 0; - if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym), - slot_domain, domain)) + if (!symbol_matches_domain (sym->language (), slot_domain, domain)) return 0; } } @@ -2846,8 +2845,7 @@ iterate_over_symbols (const struct block *block, ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), - SYMBOL_DOMAIN (sym), domain)) + if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain)) { struct block_symbol block_sym = {sym, block}; @@ -5262,7 +5260,7 @@ completion_list_add_symbol (completion_tracker &tracker, const lookup_name_info &lookup_name, const char *text, const char *word) { - completion_list_add_name (tracker, SYMBOL_LANGUAGE (sym), + completion_list_add_name (tracker, sym->language (), sym->natural_name (), lookup_name, text, word); } @@ -5275,7 +5273,7 @@ completion_list_add_msymbol (completion_tracker &tracker, const lookup_name_info &lookup_name, const char *text, const char *word) { - completion_list_add_name (tracker, MSYMBOL_LANGUAGE (sym), + completion_list_add_name (tracker, sym->language (), sym->natural_name (), lookup_name, text, word); } @@ -5409,7 +5407,7 @@ completion_list_add_fields (completion_tracker &tracker, if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT) for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++) if (TYPE_FIELD_NAME (t, j)) - completion_list_add_name (tracker, SYMBOL_LANGUAGE (sym), + completion_list_add_name (tracker, sym->language (), TYPE_FIELD_NAME (t, j), lookup_name, text, word); } diff --git a/gdb/symtab.h b/gdb/symtab.h index e8321d4bb8..09e2a20a36 100644 --- a/gdb/symtab.h +++ b/gdb/symtab.h @@ -425,6 +425,9 @@ struct general_symbol_info void set_linkage_name (const char *linkage_name) { name = linkage_name; } + enum language language () const + { return m_language; } + /* Name of the symbol. This is a required field. Storage for the name is allocated on the objfile_obstack for the associated objfile. For languages like C++ that make a distinction between @@ -479,7 +482,7 @@ struct general_symbol_info This is used to select one of the fields from the language specific union above. */ - ENUM_BITFIELD(language) language : LANGUAGE_BITS; + ENUM_BITFIELD(language) m_language : LANGUAGE_BITS; /* This is only used by Ada. If set, then the 'demangled_name' field of language_specific is valid. Otherwise, the 'obstack' field is @@ -522,7 +525,6 @@ extern CORE_ADDR get_symbol_address (const struct symbol *sym); #define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->value.common_block #define SYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block #define SYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain -#define SYMBOL_LANGUAGE(symbol) (symbol)->language #define SYMBOL_SECTION(symbol) (symbol)->section #define SYMBOL_OBJ_SECTION(objfile, symbol) \ (((symbol)->section >= 0) \ @@ -741,7 +743,6 @@ extern CORE_ADDR get_msymbol_address (struct objfile *objf, #define MSYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes #define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block #define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain -#define MSYMBOL_LANGUAGE(symbol) (symbol)->language #define MSYMBOL_SECTION(symbol) (symbol)->section #define MSYMBOL_OBJ_SECTION(objfile, symbol) \ (((symbol)->section >= 0) \ @@ -1098,7 +1099,7 @@ struct symbol : public general_symbol_info, public allocate_on_obstack name = nullptr; value.ivalue = 0; language_specific.obstack = nullptr; - language = language_unknown; + m_language = language_unknown; ada_mangled = 0; section = 0; /* GCC 4.8.5 (on CentOS 7) does not correctly compile class- diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c index 9b8b7e2864..52a6f3e2aa 100644 --- a/gdb/xstormy16-tdep.c +++ b/gdb/xstormy16-tdep.c @@ -430,7 +430,7 @@ xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) /* Found a function. */ sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol; /* Don't use line number debug info for assembly source files. */ - if (sym && SYMBOL_LANGUAGE (sym) != language_asm) + if (sym && sym->language () != language_asm) { sal = find_pc_line (func_addr, 0); if (sal.end && sal.end < func_end)