From patchwork Fri Jan 5 16:37:34 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 25235 Received: (qmail 21821 invoked by alias); 5 Jan 2018 16:37:41 -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 21709 invoked by uid 89); 5 Jan 2018 16:37:41 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-24.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_LAZY_DOMAIN_SECURITY, KAM_STOCKGEN, SPF_HELO_PASS, T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 spammy= X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 05 Jan 2018 16:37:39 +0000 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 13B4B85545; Fri, 5 Jan 2018 16:38:30 +0000 (UTC) Received: from [127.0.0.1] (ovpn04.gateway.prod.ext.ams2.redhat.com [10.39.146.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id DF0226A05D; Fri, 5 Jan 2018 16:37:36 +0000 (UTC) Subject: [PATCH] Fix gdb.ada/complete.exp's "complete break ada" test (PR, gdb/22670) (Re: [PATCH 2/3] Add "complete break ada" test to gdb.ada/complete.exp) To: Joel Brobecker , gdb-patches@sourceware.org References: <1515054953-81012-1-git-send-email-brobecker@adacore.com> <1515054953-81012-3-git-send-email-brobecker@adacore.com> From: Pedro Alves Message-ID: <05e600e1-c48c-de04-7e33-2c962b75bc25@redhat.com> Date: Fri, 5 Jan 2018 16:37:34 +0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.5.0 MIME-Version: 1.0 In-Reply-To: <1515054953-81012-3-git-send-email-brobecker@adacore.com> On 01/04/2018 08:35 AM, Joel Brobecker wrote: > This patch adds a new test to demonstrate a regression introduced by: > > commit b5ec771e60c1a0863e51eb491c85c674097e9e13 > Date: Wed Nov 8 14:22:32 2017 +0000 > Subject: Introduce lookup_name_info and generalize Ada's FULL/WILD name matching > > The original purpose of the new test is to exercise the "complete" > command with an expression for which a large number of matches are > returned and to verify that each match returned is a plausible match. > In this particular case, the commit above causes GDB to generate > additional matches which should in fact not appear in the list > (internally generated symbols, or symbols that should be enclosed > between "<...>"). These extraneous entries are easy to spot, because > they have uppercase characters, such as: > > break ada__stringsS > break ada__strings__R11s > [etc] > > For now, the new test is KFAIL'ed, to avoid generating a new FAIL > while we work on fixing that regression. And here's the fix for this one. Also pushed to the users/palves/literal-matching branch. I think I addressed all the Ada regressions you reported. Let me know if I missed some. From 2805fc780e497535f3966dea932023cad9b92b61 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Fri, 5 Jan 2018 12:21:25 +0000 Subject: [PATCH 2/2] Fix gdb.ada/complete.exp's "complete break ada" test (PR gdb/22670) This patch fixes the regression covered by the test added by: commit 344420da6beac1e0b2f7964e7101f8dcdb509b0d Date: Thu Jan 4 03:30:37 2018 -0500 Subject: Add "complete break ada" test to gdb.ada/complete.exp The regression had been introduced by: commit b5ec771e60c1a0863e51eb491c85c674097e9e13 Date: Wed Nov 8 14:22:32 2017 +0000 Subject: Introduce lookup_name_info and generalize Ada's FULL/WILD name matching The gist of it is that linespec completion in Ada mode is generating additional matches that should not appear in the match list (internally generated symbols, or symbols that should be enclosed between "<...>"). These extraneous entries have uppercase characters, such as: break ada__stringsS break ada__strings__R11s [etc] These matches come from minimal symbols. The problem is that Ada minsyms end up with no language set (language_auto), and thus we end up using the generic symbol name matcher for those instead of Ada's. We already had a special case for in compare_symbol_name to handle this, but it was limited to expressions, while the case at hand is completing a linespec. Fix this by applying the special case to linespec completion as well. I.e., remove the EXPRESSION check from compare_symbol_name. That alone turns out to not be sufficient still -- GDB would still show a couple entries that shouldn't be there: ~~ break ada__exceptions__exception_data__append_info_exception_name__2Xn break ada__exceptions__exception_data__exception_name_length__2Xn ~~ The reason is that these minimal symbols end up with their language set to language_cplus / C++, because those encoded names manage to demangle successfully as C++ symbols (using an old C++ mangling scheme): $ echo ada__exceptions__exception_data__append_info_exception_name__2Xn | c++filt Xn::ada__exceptions__exception_data__append_info_exception_name(void) It's unfortunate that Ada's encoding scheme doesn't start with some unique prefix like "_Z" in the C++ Itanium ABI mangling scheme. For now, paper over that by treating C++ minsyms as Ada minsyms. gdb/ChangeLog: yyyy-mm-dd Pedro Alves PR gdb/22670 * ada-lang.c (ada_collect_symbol_completion_matches): If the minsym's language is language_auto or language_cplus, pass down language_ada instead. * symtab.c (compare_symbol_name): Don't frob symbol language here. gdb/testsuite/ChangeLog: yyyy-mm-dd Pedro Alves PR gdb/22670 * gdb.ada/complete.exp ("complete break ada"): Replace kfail with a fail. --- gdb/ada-lang.c | 19 ++++++++++++++++++- gdb/symtab.c | 16 +--------------- gdb/testsuite/gdb.ada/complete.exp | 4 ++-- 3 files changed, 21 insertions(+), 18 deletions(-) diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 622cfd0a81e..ab1083830ed 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -6499,8 +6499,25 @@ ada_collect_symbol_completion_matches (completion_tracker &tracker, if (completion_skip_symbol (mode, msymbol)) continue; + language symbol_language = MSYMBOL_LANGUAGE (msymbol); + + /* Ada minimal symbols won't have their language set to Ada. If + we let completion_list_add_name compare using the + default/C-like matcher, then when completing e.g., symbols in a + package named "pck", we'd match internal Ada symbols like + "pckS", which are invalid in an Ada expression, unless you wrap + them in '<' '>' to request a verbatim match. + + Unfortunately, some Ada encoded names successfully demangle as + C++ symbols (using an old mangling scheme), such as "name__2Xn" + -> "Xn::name(void)" and thus some Ada minimal symbols end up + with the wrong language set. Paper over that issue here. */ + if (symbol_language == language_auto + || symbol_language == language_cplus) + symbol_language = language_ada; + completion_list_add_name (tracker, - MSYMBOL_LANGUAGE (msymbol), + symbol_language, MSYMBOL_LINKAGE_NAME (msymbol), lookup_name, text, word); } diff --git a/gdb/symtab.c b/gdb/symtab.c index 146dc2e4213..2fe249682f2 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -4704,21 +4704,7 @@ compare_symbol_name (const char *symbol_name, language symbol_language, const lookup_name_info &lookup_name, completion_match_result &match_res) { - const language_defn *lang; - - /* If we're completing for an expression and the symbol doesn't have - an explicit language set, fallback to the current language. Ada - minimal symbols won't have their language set to Ada, for - example, and if we compared using the default/C-like matcher, - then when completing e.g., symbols in a package named "pck", we'd - match internal Ada symbols like "pckS", which are invalid in an - Ada expression, unless you wrap them in '<' '>' to request a - verbatim match. */ - if (symbol_language == language_auto - && lookup_name.match_type () == symbol_name_match_type::EXPRESSION) - lang = current_language; - else - lang = language_def (symbol_language); + const language_defn *lang = language_def (symbol_language); symbol_name_matcher_ftype *name_match = language_get_symbol_name_matcher (lang, lookup_name); diff --git a/gdb/testsuite/gdb.ada/complete.exp b/gdb/testsuite/gdb.ada/complete.exp index c1f22c2a3e4..cb9e4ae7ffc 100644 --- a/gdb/testsuite/gdb.ada/complete.exp +++ b/gdb/testsuite/gdb.ada/complete.exp @@ -212,7 +212,7 @@ test_gdb_complete "ambiguous_func" \ # However, we want to sanity-check each one of them, knowing that # each result should start with "break ada" and that the proposed # completion should look like a valid symbol name (in particular, -# no uppercase letters...). +# no uppercase letters...). See gdb/22670. gdb_test_no_output "set max-completions unlimited" @@ -222,6 +222,6 @@ gdb_test_multiple "$test" $test { pass $test } -re "\[A-Z\].*$gdb_prompt $" { - kfail gdb/22670 $test + fail "$test (gdb/22670)" } }