From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 3A4EC3858013 for ; Thu, 9 Dec 2021 19:18:33 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 3A4EC3858013 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-19-ChkgAwxQO_SwwIOF0pxa1w-1; Thu, 09 Dec 2021 14:18:28 -0500 X-MC-Unique: ChkgAwxQO_SwwIOF0pxa1w-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id EDE4C81CCB6 for ; Thu, 9 Dec 2021 19:18:26 +0000 (UTC) Received: from guittard.uglyboxes.com (unknown [10.2.16.44]) by smtp.corp.redhat.com (Postfix) with ESMTP id 43F2E5D9D5 for ; Thu, 9 Dec 2021 19:18:26 +0000 (UTC) From: Keith Seitz To: gdb-patches@sourceware.org Subject: [PATCH v3 3/3] Support template lookups in strncmp_iw_with_mode Date: Thu, 9 Dec 2021 11:17:50 -0800 Message-Id: <20211209191750.2601228-4-keiths@redhat.com> In-Reply-To: <20211209191750.2601228-1-keiths@redhat.com> References: <20211209191750.2601228-1-keiths@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII" X-Spam-Status: No, score=-12.2 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_STOCKGEN, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP, WEIRD_PORT autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 09 Dec 2021 19:18:37 -0000 This patch adds support for wild template parameter list matches, similar to how ABI tags or function overloads are now handled. With this patch, users will be able to "gloss over" the details of matching template parameter lists. This is accomplished by adding (yet more) logic to strncmp_iw_with_mode to skip parameter lists if none is explicitly given by the user. Here's a simple example using gdb.linespec/cpls-ops.exp: Before ------ (gdb) ptype test_op_call type = struct test_op_call { public: void operator()(void); void operator()(int); void operator()(long); void operator()(int *); } (gdb) b test_op_call::operator() Breakpoint 1 at 0x400583: test_op_call::operator(). (3 locations) (gdb) i b Num Type Disp Enb Address What 1 breakpoint keep y 1.1 y 0x400583 in test_op_call::operator()(int) at cpls-ops.cc:43 1.2 y 0x40058e in test_op_call::operator()() at cpls-ops.cc:47 1.3 y 0x40059e in test_op_call::operator()(long) at cpls-ops.cc:51 The breakpoint at test_op_call::operator() was never set. After ----- (gdb) b test_op_call::operator() Breakpoint 1 at 0x400583: test_op_call::operator(). (4 locations) (gdb) i b Num Type Disp Enb Address What 1 breakpoint keep y 1.1 y 0x400583 in test_op_call::operator()(int) at cpls-ops.cc:43 1.2 y 0x40058e in test_op_call::operator()() at cpls-ops.cc:47 1.3 y 0x40059e in test_op_call::operator()(long) at cpls-ops.cc:51 1.4 y 0x4008d0 in test_op_call::operator()(int*) at cpls-ops.cc:57 Similar to how scope lookups work, passing "-qualified" to the break command will cause a literal lookup of the symbol. In the example immediately above, this will cause GDB to only find the three non-template functions. --- gdb/NEWS | 4 + gdb/cp-support.c | 8 +- gdb/doc/gdb.texinfo | 46 +++ gdb/testsuite/gdb.cp/templates.cc | 47 +++ gdb/testsuite/gdb.cp/templates.exp | 67 +++ gdb/testsuite/gdb.linespec/cpcompletion.exp | 437 +++++++++++++++++++- gdb/testsuite/gdb.linespec/cpls-ops.exp | 53 ++- gdb/testsuite/gdb.linespec/cpls.cc | 110 ++++- gdb/utils.c | 82 +++- gdb/utils.h | 7 +- 10 files changed, 821 insertions(+), 40 deletions(-) diff --git a/gdb/NEWS b/gdb/NEWS index 13b66286876..6f5bf73f331 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -3,6 +3,10 @@ *** Changes since GDB 11 +* C++ developers may now ignore template parameter lists when specifying + locations, e.g., while setting breakpoints. This is analogous to how + completion and symbol lookup handle overloaded functions or ABI tags. + * New commands maint set backtrace-on-fatal-signal on|off diff --git a/gdb/cp-support.c b/gdb/cp-support.c index 7cc089cbc17..04d0b4394ef 100644 --- a/gdb/cp-support.c +++ b/gdb/cp-support.c @@ -1692,6 +1692,12 @@ cp_search_name_hash (const char *search_name) && string[5] != ':') break; + /* Ignore template parameter lists. */ + if (string[0] == '<' + && string[1] != '(' && string[1] != '<' && string[1] != '=' + && string[1] != ' ' && string[1] != '\0') + break; + hash = SYMBOL_HASH_NEXT (hash, *string); } return hash; @@ -1745,7 +1751,7 @@ cp_symbol_name_matches_1 (const char *symbol_search_name, while (true) { if (strncmp_iw_with_mode (sname, lookup_name, lookup_name_len, - mode, language_cplus, match_for_lcd) == 0) + mode, language_cplus, match_for_lcd, true) == 0) { if (comp_match_res != NULL) { diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index d0c5bcf18e1..f62035df434 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -16874,6 +16874,52 @@ also use the @value{GDBN} command-line word completion facilities to list the available choices, or to finish the type list for you. @xref{Completion,, Command Completion}, for details on how to do this. +@item @r{Breakpoints in template functions} + +Similar to overloaded symbols, @value{GDBN} will set breakpoints in all +template instantiations with the user-specified name. To set a breakpoint in +a specific template instantiation, include the template parameter list. + +@smallexample +(gdb) b mytemplate +Breakpoint 1 at 0x40085b: mytemplate. (2 locations) +(gdb) info breakpoints +Num Type Disp Enb Address What +1 breakpoint keep y +1.1 y 0x40085b in mytemplate(int) + at mytemplate.cc:8 +1.2 y 0x40087a in mytemplate(double) + at mytemplate.cc:8 +@end smallexample + +@noindent +In the above example, @value{GDBN} searches all namespaces and types for +functions named @code{mytemplate}, ignoring template parameter lists and +function arguments. + +In the below example, a template parameter list is specified, and @value{GDBN} +searches all namespaces and types for the specific instantiation: + +@smallexample +(gdb) b mytemplate +Breakpoint 2 at 0x40085b: file mytemplate.cc, line 8. +(gdb) info breakpoints +Num Type Disp Enb Address What +2 breakpoint keep y 0x40085b in mytemplate(int) + at mytemplate.cc:8 +@end smallexample + +Just as with function overloads, the @kbd{-qualified} flag may be used to +override this behavior, causing @value{GDBN} to search for a specific +function without ignoring template parameter lists. + +@smallexample +(gdb) b mytemplate +Breakpoint 3 at 0x40085b: mytemplate. (2 locations) +(gdb) b -qualified mytemplate +Function "mytemplate" not defined. +@end smallexample + @item @r{Breakpoints in functions with ABI tags} The GNU C@t{++} compiler introduced the notion of ABI ``tags'', which diff --git a/gdb/testsuite/gdb.cp/templates.cc b/gdb/testsuite/gdb.cp/templates.cc index d5b24af3a4e..1b9a2d48819 100644 --- a/gdb/testsuite/gdb.cp/templates.cc +++ b/gdb/testsuite/gdb.cp/templates.cc @@ -742,6 +742,34 @@ template int FunctionArg::method(Empty)> &arg) Empty)> empty; FunctionArg arg; +template +struct Foozle +{ + int x; + T1 t; + template + T2 fogey (T2 plop); +}; + +template +template +T2 Foozle::fogey (T2 plop) +{ + return plop; +} + +template +int operator< (T &lhs, T &rhs) +{ + return 0; +} + +template +int operator<< (T &obj, T &val) +{ + return 1; +}; + int main() { int i; @@ -815,5 +843,24 @@ int main() arg.method(empty); + Empty e; + Foozle fzi; + x = fzi.fogey (0); + c = fzi.fogey ('a'); + e = fzi.fogey> (e); + Foozle fzc; + c = fzc.fogey ('b'); + x = fzc.fogey (0); + e = fzc.fogey> (e); + Foozle> fze; + e = fze.fogey (e); + c = fze.fogey ('c'); + x = fze.fogey (0); + + z = e < e; + z += e << e; + z += fzi < fzi; + z += fzi << fzi; + return 0; /* Final breakpoint. */ } diff --git a/gdb/testsuite/gdb.cp/templates.exp b/gdb/testsuite/gdb.cp/templates.exp index 5f0538d8d4b..c0d574ed08a 100644 --- a/gdb/testsuite/gdb.cp/templates.exp +++ b/gdb/testsuite/gdb.cp/templates.exp @@ -614,3 +614,70 @@ gdb_test "print Garply >::garply" \ # Now should work fine gdb_test "break Garply >::garply" \ "Breakpoint \[0-9\]* at $hex: file .*templates.cc, line.*" + +# +# Template wild-matching tests +# + +# Turn off "ask" when multiple symbols are seen. +gdb_test_no_output "set multiple-symbols all" + +# Test setting breakpoints in a method of all class template instantiations, +# including overloads. +gdb_test "break Foo::foo" "Breakpoint.*at.* \\(3 locations\\)" +foreach t [list "int" "char" "volatile char *"] { + gdb_breakpoint "Foo<$t>::foo (int, $t)" + gdb_breakpoint "Foo::foo (int, $t)" +} + +gdb_test "break Bar::bar" "Breakpoint.*at.* \\(2 locations\\)" +gdb_test "break Bar::bar (int, int)" "Breakpoint.*at.* \\(2 locations\\)" +foreach val [list 1 33] { + gdb_breakpoint "Bar::bar (int, int)" +} + +# Test setting breakpoints in a member function template of a class template, +# including overloads. +gdb_test "break Foozle::fogey" "Breakpoint.*at.* \\(9 locations\\)" \ + "break at template method fogey" +foreach t [list "int" "char" "Empty"] { + gdb_test "break Foozle::fogey ($t)" "Breakpoint.*at.* \\(3 locations\\)" + gdb_test "break Foozle::fogey<$t>" "Breakpoint.*at.* \\(3 locations\\)" + foreach u [list "int" "char" "Empty"] { + gdb_breakpoint "Foozle<$t>::fogey<$u>" message + gdb_breakpoint "Foozle<$t>::fogey<$u> ($u)" message + } +} + +# Test templated operators < and <<. Restrict results to only the test +# source file. +# operator<: +# 1. operator< (const T2&, const T2&) +# 2. operator< (const T2&, char) +# 3. operator< > +# 4. operator< > +# +# operator<<: +# 1. operator<< > +# 2. operator<< > +gdb_test "break -source $srcfile -func operator<" \ + "Breakpoint.*at.* \\(4 locations\\)" +gdb_test "break -source $srcfile -func operator<<" \ + "Breakpoint.*at.* \\(2 locations\\)" +foreach t [list "Empty" "Foozle"] { + set tt "$t" + gdb_breakpoint "operator< <$tt>" message + gdb_breakpoint "operator<< <$tt>" message + + # Try a specific instance, both with and without whitespace + # after the template-template parameter. + gdb_breakpoint "operator< <$tt> ($tt&, $tt&)" message + gdb_breakpoint "operator< <$tt > ($tt&, $tt&)" message + gdb_breakpoint "operator<< <$tt> ($tt&, $tt&)" message + gdb_breakpoint "operator<< <$tt > ($tt&, $tt&)" message +} + +# Test that "-qualified" finds no matching locations. +gdb_test_no_output "set breakpoint pending off" +gdb_test "break -qualified Foozle::fogey" \ + "Function \"Foozle::fogey\" not defined." diff --git a/gdb/testsuite/gdb.linespec/cpcompletion.exp b/gdb/testsuite/gdb.linespec/cpcompletion.exp index ebac3f90c2d..b4b10048f16 100644 --- a/gdb/testsuite/gdb.linespec/cpcompletion.exp +++ b/gdb/testsuite/gdb.linespec/cpcompletion.exp @@ -16,6 +16,7 @@ # This file is part of the gdb testsuite. load_lib completion-support.exp +load_lib data-structures.exp standard_testfile cpls.cc cpls2.cc cpls-hyphen.cc @@ -32,6 +33,217 @@ if { ![readline_is_used] } { return -1 } +# +# Some convenience procedures for testing template parameter list +# completion. +# + +# For the variable named ARGLISTVAR, which should be the name of an +# argument list in the calling frame, "consume" the top-most token. +# [See comments for makefoo for description of arglist format.] + +proc consume {arglistvar} { + upvar $arglistvar arglist + + # ARGLIST is a string -- simply strip off the first character. + set arglist [string range $arglist 1 end] +} + +# Create a function template named NAME, using the given stack ID to grab +# NUM template parameters. The result is pushed back onto the +# stack. NUM may be "all," in which case we use the entire stack +# to create the function template, including function arguments. +# The resulting template function's arguments are taken from the test +# source code for the function "foo" and is not generalized. + +proc maket {sid name {num 1}} { + + # Set up a temporary stack of parameters. This will reverse + # the order in SID so that when they are popped again below, + # we get them in the correct order. This also takes into account + # how many levels of the result stack we want to consider. + + set paramstack [::Stack::new] + if {[string equal $num "all"]} { + while {![stack empty $sid]} { + stack push $paramstack [stack pop $sid] + } + } else { + for {set i 0} {$i < $num} {incr i} { + stack push $paramstack [stack pop $sid] + } + } + + # Construct the function template and push it back to the + # top of the stack given by SID. + set result "" + set first true + while {![stack empty $paramstack]} { + set top [stack pop $paramstack] + if {$first} { + set first false + } else { + append result ", " + } + append result $top + } + + # Save argument list. + set args $result + + # GDB outputs "> >" instead of ">>". + if {[string index $top end] == ">"} { + append result " " + } + set result "$name<$result>" + if {[string equal $num "all"]} { + append result "($args)" + } + stack push $sid $result + stack delete $paramstack +} + +# Given the stack SID and the name of a variable of the desired template +# parameters, construct the actual template parameter and push it to the +# top of the stack. + +proc makearg {sid arglistvar} { + upvar $arglistvar arglist + + set c [string index $arglist 0] + consume arglist + switch $c { + A - + B { + makearg $sid arglist + makearg $sid arglist + maket $sid $c 2 + } + + a - + b - + c - + d { + makearg $sid arglist + maket $sid $c + } + + i { + stack push $sid "int" + } + + n { + # These are not templates. + set c [string index $arglist 0] + stack push $sid "n::n$c" + consume arglist + } + + N { + set c [string index $arglist 0] + makearg $sid arglist + set top [stack pop $sid] + stack push $sid "n::N$top" + } + + default { error "unhandled arglist identifier: '$c'" } + } +} + +# Given ARGLIST, construct a class template for the type and return +# it as a string. + +proc maketype {arglist} { + set s [Stack::new] + makearg $s arglist + set result [stack pop $s] + stack delete $s + return $result +} + +# Returns a function template declaration for the function "foo" in the +# corresponding test source code. ARGLIST specifies the exact instantiation +# that is desired. +# +# Generically, this procedure returns a string of the form, +# "foo (arg-list)", where ARGLIST describes the parameter(s). +# +# Valid specifiers for ARGLIST (must be kept in sync with source code): +# +# i: Creates an "int" type. +# a, b, c, d: Creates the struct template of the same name, taking a single +# template parameter. +# A, B: Creates the struct template of the same name, taking two template +# parameters. +# na, nb: Creates the non-template structs n::na and n::nb, respectively. +# NA, NB: Creates the struct templates n::NA and n::NB, respectively, which +# take two template parameters. +# +# Examples: +# makefoo i +# --> foo (int) +# makefoo ii +# --> foo (int, int) +# makefoo Aiabi +# --> foo > > > (A > >) +# makefoo NANAiaiNBbiabi +# --> foo >, n::NB, a > > > > +# (n::NA >, n::NB, a > > >) + +proc makefoo {arglist} { + set s [::Stack::new] + while {[string length $arglist] > 0} { + makearg $s arglist + } + + maket $s "foo" all + set result [stack pop $s] + stack delete $s + return $result +} + +# Test wrapper for a single "makefoo" unit test. + +proc test_makefoo_1 {arglist expected} { + set exp "foo<$expected" + if {[string index $exp end] == ">"} { + append exp " " + } + append exp ">" + append exp "($expected)" + + set calc [makefoo $arglist] + send_log "makefoo $arglist = $calc\n" + send_log "expecting: $exp\n" + if {[string equal $exp $calc]} { + pass "makefoo unit test: $arglist" + } else { + fail "makefoo unit test: $arglist" + } +} + +# Test whether the procedure "makefoo" is functioning as expected. + +proc test_makefoo {} { + test_makefoo_1 "i" "int" + test_makefoo_1 "ai" "a" + test_makefoo_1 "aai" "a >" + test_makefoo_1 "ii" "int, int" + test_makefoo_1 "aaibi" "a >, b" + test_makefoo_1 \ + "ababiibababai" "a > > >, int, b > > > > >" + test_makefoo_1 "Aii" "A" + test_makefoo_1 "ABaibibi" "A, b >, b >" + test_makefoo_1 "na" "n::na" + test_makefoo_1 "nana" "n::na, n::na" + test_makefoo_1 "NAii" "n::NA" + test_makefoo_1 "NANAiiNAii" "n::NA, n::NA >" +} + +# +# Tests start here. +# + # Disable the completion limit for the whole testcase. gdb_test_no_output "set max-completions unlimited" @@ -385,12 +597,11 @@ proc_with_prefix template-ret-type {} { test_complete_prefix_range $complete_line $start } - # Setting a breakpoint without the template params doesn't work. - check_setting_bp_fails "$cmd_prefix template2_fn" - # However, setting a breakpoint with template params and without - # the method params does work, just like with non-template - # functions. It also works with or without return type. + # Setting a breakpoint with or without template params and without + # the method params works, just like with non-template functions. + # It also works with or without return type. foreach linespec [list \ + "template2_fn" \ "${method_name}" \ "${method_name}${param_list}" \ "${struct_type}::${method_name}" \ @@ -404,6 +615,218 @@ proc_with_prefix template-ret-type {} { } } +# Test completion of function template foo. + +proc_with_prefix template-function-foo {} { + + foreach cmd_prefix {"b" "b -function"} { + # "foo" is ambiguous, this will set many different breakpoints. + set completion_list \ + [list \ + [makefoo Aabiaai] \ + [makefoo Aabiabi] \ + [makefoo Aabicdi] \ + [makefoo AabicdiAabiaai] \ + [makefoo AabicdiAabiabi] \ + [makefoo AabicdiBabicdi] \ + [makefoo Babicdi] \ + [makefoo aai] \ + [makefoo aaiabi] \ + [makefoo aaicci] \ + [makefoo aaicdi] \ + [makefoo abi] \ + [makefoo anabnb] \ + [makefoo cci] \ + [makefoo cdi] \ + [makefoo NAnanbNBnanb] \ + [makefoo nanb]] + test_gdb_complete_multiple "$cmd_prefix " "foo" "<" $completion_list + check_bp_locations_match_list "$cmd_prefix foo" $completion_list + + # "foo<" should give the same result, but it should not set any + # breakpoints. + test_gdb_complete_multiple "$cmd_prefix " "foo<" "" $completion_list + check_setting_bp_fails "$cmd_prefix foo<" + + # "foo >, " \ + $completion_list + check_setting_bp_fails "$cmd_prefix foo" should give any function with one parameter of any type + # of A. While the parameter list in the template should be ignored, + # the function's argument list should not be ignored. + set completion_list \ + [list \ + [makefoo Aabiaai] \ + [makefoo Aabiabi] \ + [makefoo Aabicdi]] + test_gdb_complete_multiple "$cmd_prefix " "foo" \ + "(A >, " $completion_list + check_bp_locations_match_list "$cmd_prefix foo" $completion_list + + # "foo, a" should give all completions starting with + # "Aabia" but it is insufficient to set breakpoints. + set completion_list \ + [list \ + [makefoo Aabiaai] \ + [makefoo Aabiabi]] + test_gdb_complete_multiple "$cmd_prefix " "foo >, a" \ + "<" $completion_list + check_setting_bp_fails "$cmd_prefix foo >, a" + + # "foo, a<" should yield the same results as above. + test_gdb_complete_multiple "$cmd_prefix " "foo >, a<" \ + "" $completion_list + check_setting_bp_fails "$cmd_prefix foo >, a<" + + # "foo, a") + test_gdb_complete_unique "$cmd_prefix foo >, a >, a, a"). + test_gdb_complete_unique "$cmd_prefix foo >, a >, a" yields the same unique result and sets a breakpoint. + # Since the input skips the parameter list, so does the completion. + test_gdb_complete_unique "$cmd_prefix foo" \ + "$cmd_prefix foo(B >, c > >)" + check_bp_locations_match_list "$cmd_prefix foo" \ + [list [makefoo Babicdi]] + + # "foo >" is unique and sets a breakpoint. + # Multiple template parameter lists are skipped, so GDB will ignore + # them in the completion. + test_gdb_complete_unique "$cmd_prefix foo >" \ + "$cmd_prefix foo >(A >, c > >)" + check_bp_locations_match_list "$cmd_prefix foo >" \ + [list [makefoo Aabicdi]] + } +} + +# Helper for template-class-with-method to build completion lists. + +proc makem {arglist_list} { + set completion_list {} + foreach arglist $arglist_list { + lappend completion_list "[maketype $arglist]::method()" + } + return $completion_list +} + +# Returns a list of elements that look like +# void TYPE::method() +# where TYPE is derived from each arglist in ARGLIST_LIST. + +proc test_makem_1 {arglist_list expected_list} { + set result [makem $arglist_list] + send_log "makem $arglist = $result\n" + send_log "expecting $expected_list\n" + + # Do list equality via canonical strings. + if {[expr {[list {*}$expected_list] eq [list {*}$result]}]} { + pass "makem unit test: $arglist" + } else { + fail "makem unit test: $arglist" + } +} + +# Unit tests for makem. + +proc test_makem {} { + test_makem_1 ai {"a::method()"} + test_makem_1 bi {"b::method()"} + test_makem_1 {ai bi} {"a::method()" "b::method()"} + test_makem_1 {Aaiaai Bbibbi abi cdi} { + "A, a > >::method()" + "B, b > >::method()" + "a >::method()" + "c >::method()" + } +} + +# Test class template containing a (non-templated) method called "method." + +proc_with_prefix template-class-with-method {} { + + foreach {type type_list} \ + [list \ + "" {aai abi cci cdi Aabicdi Aabiaai Aabiabi Babicdi} \ + "a" {aai abi} \ + "b" {} \ + "c" {cci cdi} \ + "A" {Aabicdi Aabiaai Aabiabi} \ + "B" {Babicdi} \ + "A" {Aabiaai Aabiabi} \ + "A, c>" {Aabicdi}\ + "A" {} \ + "B" {} \ + "B" {} \ + "B" {Babicdi}] \ + { + foreach cmd_prefix {"b" "b -function"} { + set c "$cmd_prefix " + if {$type != ""} { + append c "${type}::" + } + append c "method" + + if {[llength $type_list] > 0} { + test_gdb_complete_unique $c "${c}()" + check_bp_locations_match_list $c [makem $type_list] + } else { + test_gdb_complete_none $c + } + } + } +} + # Test completion of a const-overloaded funtion (const-overload). # Note that "const" appears after the function/method parameters. @@ -947,6 +1370,10 @@ proc test_driver {} { overload-3 template-overload template-ret-type + #test_makefoo + template-function-foo + #test_makem + template-class-with-method const-overload const-overload-quoted append-end-quote-char-when-unambiguous diff --git a/gdb/testsuite/gdb.linespec/cpls-ops.exp b/gdb/testsuite/gdb.linespec/cpls-ops.exp index e8838c6f0f1..452b67c6fcf 100644 --- a/gdb/testsuite/gdb.linespec/cpls-ops.exp +++ b/gdb/testsuite/gdb.linespec/cpls-ops.exp @@ -248,20 +248,6 @@ proc test_operator_ambiguous {class_name opn cls} { test_gdb_complete_multiple \ "$cmd_prefix " "$linespec_noparams" "" $location_list - # Setting the breakpoint doesn't create a breakpoint location - # for the template, because immediately after - # "operator()/operator[]" we have the template parameters, not - # the parameter list. - set location_list \ - [list \ - "${class_name}::operator${opn}${cls}(int)" \ - "${class_name}::operator${opn}${cls}(long)"] - if {$opn == "("} { - set location_list \ - [concat \ - [list "${class_name}::operator${opn}${cls}()"] \ - $location_list] - } check_bp_locations_match_list "$cmd_prefix $linespec_noparams" \ $location_list check_bp_locations_match_list "$cmd_prefix $linespec_noparams" \ @@ -269,26 +255,33 @@ proc test_operator_ambiguous {class_name opn cls} { # Test the template version. Test both with and without # return type. - test_gdb_complete_unique \ - "$cmd_prefix ${class_name}::operator${opn}${cls}(in" \ - "$cmd_prefix ${class_name}::operator${opn}${cls}(int*)" - check_bp_locations_match_list \ - "$cmd_prefix ${class_name}::operator${opn}${cls}(int*)" \ - [list "${class_name}::operator${opn}${cls}(int*)"] - test_gdb_complete_unique \ - "$cmd_prefix void ${class_name}::operator${opn}${cls}(in" \ - "$cmd_prefix void ${class_name}::operator${opn}${cls}(int*)" - check_bp_locations_match_list \ - "$cmd_prefix void ${class_name}::operator${opn}${cls}(int*)" \ - [list "${class_name}::operator${opn}${cls}(int*)"] + set f "${class_name}::operator" + foreach ws1 {"" " "} { + foreach ws2 {"" " "} { + foreach ws3 {"" " "} { + test_gdb_complete_unique \ + "$cmd_prefix ${f}${opn}${ws1}${cls}<${ws2}int${ws3}>(in" \ + "$cmd_prefix ${f}${opn}${ws1}${cls}<${ws2}int${ws3}>(int*)" + check_bp_locations_match_list \ + "$cmd_prefix ${f}${opn}${ws1}${cls}<${ws2}int${ws3}>(int*)" \ + [list "${f}${opn}${cls}(int*)"] + test_gdb_complete_unique \ + "$cmd_prefix void ${f}${opn}${ws1}${cls}<${ws2}int${ws3}>(in" \ + "$cmd_prefix void ${f}${opn}${ws1}${cls}<${ws2}int${ws3}>(int*)" + check_bp_locations_match_list \ + "$cmd_prefix void ${f}${opn}${ws1}${cls}<${ws2}int${ws3}>(int*)" \ + [list "${f}${opn}${cls}(int*)"] + } + } + } # Add extra spaces. test_gdb_complete_unique \ - "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( in" \ - "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( int)" + "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( lo" \ + "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( long)" check_bp_locations_match_list \ - "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( int )" \ - [list "${class_name}::operator${opn}${cls}(int)"] + "$cmd_prefix ${class_name}::operator ${opn} ${cls} ( long )" \ + [list "${class_name}::operator${opn}${cls}(long)"] } } diff --git a/gdb/testsuite/gdb.linespec/cpls.cc b/gdb/testsuite/gdb.linespec/cpls.cc index 9da45e8fc0d..6b3ffd8bf07 100644 --- a/gdb/testsuite/gdb.linespec/cpls.cc +++ b/gdb/testsuite/gdb.linespec/cpls.cc @@ -146,7 +146,7 @@ namespace ns_overload3_test } } -/* Code for the template-overload tests. */ +/* Code for the template-function_foo (template parameter completion) tests. */ template struct template_struct @@ -163,6 +163,113 @@ T template_struct::template_overload_fn (T t) template_struct template_struct_int; template_struct template_struct_long; +/* Code for the template-parameter-overload test. */ + +template +void foo (T c) {} + +template +void foo (T1 a, T2 b) {} + +template +struct a +{ + void method () {} +}; + +template +struct b +{ + void method () {} +}; + +template +struct c +{ + void method () {} +}; + +template +struct d +{ + void method () {}; +}; + +template +struct A +{ + void method () {} +}; + +template +struct B +{ + void method () {} +}; + +namespace n +{ + struct na {}; + struct nb {}; + + template + struct NA {}; + + template + struct NB {}; +}; + +static void +template_function_foo () +{ + a> aa; + aa.method (); + a> ab; + ab.method (); + c> cc; + cc.method (); + c> cd; + cd.method (); + foo (aa); + foo (ab); + foo (cc); + foo (cd); + foo (aa, ab); + foo (aa, cc); + foo (aa, cd); + + A>, c>> Aabcd; + Aabcd.method (); + foo (Aabcd); + + A>, a>> Aabaa; + Aabaa.method (); + foo (Aabaa); + + A>, a>> Aabab; + Aabab.method (); + foo (Aabab); + + B>, c>> Babcd; + Babcd.method (); + foo (Babcd); + + foo (Aabcd, Babcd); + foo (Aabcd, Aabaa); + foo (Aabcd, Aabab); + + n::na na; + n::nb nb; + foo (na, nb); + a ana; + b bnb; + foo (ana, bnb); + + n::NA NAnanb; + n::NB Nbnanb; + foo (NAnanb, Nbnanb); +} + /* Code for the template2-ret-type tests. */ template @@ -381,6 +488,7 @@ main () template2_struct_inst.template2_fn (); template_struct_int.template_overload_fn(0); template_struct_long.template_overload_fn(0); + template_function_foo (); return 0; } diff --git a/gdb/utils.c b/gdb/utils.c index c4d926cff84..d0fad8b2cb6 100644 --- a/gdb/utils.c +++ b/gdb/utils.c @@ -2473,13 +2473,45 @@ skip_abi_tag (const char **name) return false; } +/* If *NAME points at a template parameter list, skip it and return true. + Otherwise do nothing and return false. */ + +static bool +skip_template_parameter_list (const char **name) +{ + const char *p = *name; + + if (*p == '<') + { + const char *template_param_list_end = find_toplevel_char (p + 1, '>'); + + if (template_param_list_end == NULL) + return false; + + p = template_param_list_end + 1; + + /* Skip any whitespace that might occur after the closing of the + parameter list, but only if it is the end of parameter list. */ + const char *q = p; + while (ISSPACE (*q)) + ++q; + if (*q == '>') + p = q; + *name = p; + return true; + } + + return false; +} + /* See utils.h. */ int strncmp_iw_with_mode (const char *string1, const char *string2, size_t string2_len, strncmp_iw_mode mode, enum language language, - completion_match_for_lcd *match_for_lcd) + completion_match_for_lcd *match_for_lcd, + bool ignore_template_params) { const char *string1_start = string1; const char *end_str2 = string2 + string2_len; @@ -2529,6 +2561,48 @@ strncmp_iw_with_mode (const char *string1, const char *string2, string1++; } + /* Skip template parameters in STRING1 if STRING2 does not contain + any. E.g.: + + Case 1: User is looking for all functions named "foo". + string1: foo <...> (...) + string2: foo + + Case 2: User is looking for all methods named "foo" in all template + class instantiations. + string1: Foo<...>::foo <...> (...) + string2: Foo::foo (...) + + Case 3: User is looking for a specific overload of a template + function or method. + string1: foo<...> + string2: foo(...) + + Case 4: User is looking for a specific overload of a specific + template instantiation. + string1: foo (...) + string2: foo (...) + + Case 5: User is looking wild parameter match. + string1: foo > > > (...) + string2: foomark_ignored_range (template_start, string1); + } + } + if (*string1 == '\0' || string2 == end_str2) break; @@ -2637,6 +2711,12 @@ strncmp_iw_with_mode (const char *string1, const char *string2, break; if (*string1 == '(' || *string2 == '(') break; + + /* If STRING1 or STRING2 starts with a template + parameter list, break out of operator processing. */ + skip_ws (string1, string2, end_str2); + if (*string1 == '<' || *string2 == '<') + break; } continue; diff --git a/gdb/utils.h b/gdb/utils.h index 6f3a70213a4..c3ef28e2c27 100644 --- a/gdb/utils.h +++ b/gdb/utils.h @@ -63,11 +63,14 @@ enum class strncmp_iw_mode MATCH_FOR_LCD is passed down so that the function can mark parts of the symbol name as ignored for completion matching purposes (e.g., - to handle abi tags). */ + to handle abi tags). If IGNORE_TEMPLATE_PARAMS is true, all template + parameter lists will be ignored when language is C++. */ + extern int strncmp_iw_with_mode (const char *string1, const char *string2, size_t string2_len, strncmp_iw_mode mode, enum language language, - completion_match_for_lcd *match_for_lcd = NULL); + completion_match_for_lcd *match_for_lcd = NULL, + bool ignore_template_params = false); /* Do a strncmp() type operation on STRING1 and STRING2, ignoring any differences in whitespace. STRING2_LEN is STRING2's length. -- 2.31.1