mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-12-27 04:52:05 +08:00
Code Issues Packages Projects Releases Wiki Activity
ab25d9bbe4
binutils-gdb/gdb/testsuite/gdb.linespec/cpls-ops.exp
Keith Seitz 64a9760601 Support template lookups in strncmp_iw_with_mode 
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>(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   <MULTIPLE>
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()<int> 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   <MULTIPLE>
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>(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.
2022-02-24 16:42:22 -08:00

576 lines
19 KiB
Plaintext
Raw Blame History

# Copyright 2017-2022 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# This file is part of the gdb testsuite.
load_lib completion-support.exp
standard_testfile cpls-ops.cc
if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile] {debug}]} {
return -1
}
# Tests below are about tab-completion, which doesn't work if readline
# library isn't used. Check it first.
if { ![readline_is_used] } {
untested "no tab completion support without readline"
return -1
}
gdb_test_no_output "set max-completions unlimited"
# Check that the explicit location completer manages to find the next
# option name after a "-function function" option. A useful test when
# the -function options's argument is a C++ operator, which can
# include characters like '-'.
proc check_explicit_skips_function_argument {function} {
test_gdb_complete_unique \
"b -function $function -sour" \
"b -function $function -source"
}
# Helper function for the operator new/new[] tests. CLASS_NAME is the
# name of the class that contains the operator we're testing.
# BRACKETS is set to [] if testing operator new[], and to empty if
# testing operator new.
proc test_operator_new {class_name brackets} {
global gdb_prompt
# Extract the type size_t is typedef-ed to.
set size_t ""
set test "get size_t underlying type"
gdb_test_multiple "ptype size_t" $test {
-re " = (\[ a-z\]*)\r\n$gdb_prompt $" {
set size_t $expect_out(1,string)
pass "$test"
}
}
# Complete all prefixes between "operato" and the full prototype.
foreach cmd_prefix {"b" "b -function"} {
set location "${class_name}::operator new${brackets}($size_t)"
set line "$cmd_prefix $location"
set start [index_after "operato" $line]
test_complete_prefix_range $line $start
check_bp_locations_match_list "$cmd_prefix $location" [list $location]
# Same, but with extra spaces. Note that the original spaces in
# the input line are preserved after completion.
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator new " \
"$cmd_prefix ${class_name}::operator new ${brackets}($size_t)"
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator new ${brackets} (" \
"$cmd_prefix ${class_name}::operator new ${brackets} ($size_t)"
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator new ${brackets} ( $size_t " \
"$cmd_prefix ${class_name}::operator new ${brackets} ( $size_t )"
check_setting_bp_fails "$cmd_prefix ${class_name}::operator"
set location_list \
[list \
"${class_name}::operator new${brackets}" \
"${class_name}::operator new${brackets} ($size_t)" \
"${class_name}::operator new ${brackets} ( $size_t )"]
foreach linespec $location_list {
check_bp_locations_match_list \
"$cmd_prefix $linespec" [list $location]
}
}
# Check that the explicit location completer manages to find the
# option name after -function, when the -function's argument is a
# C++ operator new / new[].
check_explicit_skips_function_argument \
"${class_name}::operator new ${brackets} ( $size_t )"
}
proc_with_prefix operator-new {} {
test_operator_new test_op_new ""
}
proc_with_prefix operator-new\[\] {} {
test_operator_new test_op_new_array "\[\]"
}
# Helper function for the operator delete/delete[] tests. CLASS_NAME
# is the name of the class that contains the operator we're testing.
# BRACKETS is set to "[]" if testing operator delete[], and to empty
# if testing operator delete.
proc test_operator_delete {class_name brackets} {
# Complete all prefixes between "operato" and the full prototype.
foreach cmd_prefix {"b" "b -function"} {
set location "${class_name}::operator delete${brackets}(void*)"
set line "$cmd_prefix $location"
set start [index_after "operato" $line]
test_complete_prefix_range $line $start
check_bp_locations_match_list "$cmd_prefix $location" [list $location]
# Same, but with extra spaces. Note that the original spaces in
# the input line are preserved after completion.
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator delete " \
"$cmd_prefix ${class_name}::operator delete ${brackets}(void*)"
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator delete ${brackets} (" \
"$cmd_prefix ${class_name}::operator delete ${brackets} (void*)"
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator delete ${brackets} ( void* " \
"$cmd_prefix ${class_name}::operator delete ${brackets} ( void* )"
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator delete ${brackets} ( void * " \
"$cmd_prefix ${class_name}::operator delete ${brackets} ( void * )"
check_setting_bp_fails "$cmd_prefix ${class_name}::operator"
set location_list \
[list \
"${class_name}::operator delete${brackets}" \
"${class_name}::operator delete${brackets}(void *)" \
"${class_name}::operator delete ${brackets} ( void * )"]
foreach linespec $location_list {
check_bp_locations_match_list \
"$cmd_prefix $linespec" [list $location]
}
}
# Check that the explicit location completer manages to find the
# option name after -function, when the -function's argument is a
# C++ operator delete / delete[].
check_explicit_skips_function_argument \
"${class_name}::operator delete ${brackets} ( void * )"
}
proc_with_prefix operator-delete {} {
test_operator_delete test_op_delete ""
}
proc_with_prefix operator-delete\[\] {} {
test_operator_delete test_op_delete_array "\[\]"
}
# Helper for testing both operator() and operator[]. Tests completion
# when the operator match is unique. CLASS_NAME is the class that
# holds the operator to test. OPN and CLS are the open and close
# characters ("()" or "[]").
proc test_operator_unique {class_name opn cls} {
# Complete all prefixes between "oper" and the full prototype.
foreach cmd_prefix {"b" "b -function"} {
set location "${class_name}::operator${opn}${cls}(int)"
set line "$cmd_prefix $location"
set start [index_after "${class_name}" $line]
test_complete_prefix_range $line $start
check_bp_locations_match_list "$cmd_prefix $location" [list $location]
# Same, but with extra spaces. Note that the original spaces in
# the input line are preserved after completion.
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator ${opn} ${cls} ( int " \
"$cmd_prefix ${class_name}::operator ${opn} ${cls} ( int )"
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator ${opn} ${cls}" \
"$cmd_prefix ${class_name}::operator ${opn} ${cls}(int)"
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator ${opn}${cls}" \
"$cmd_prefix ${class_name}::operator ${opn}${cls}(int)"
test_gdb_complete_unique \
"$cmd_prefix ${class_name}::operator ${opn}" \
"$cmd_prefix ${class_name}::operator ${opn}${cls}(int)"
check_setting_bp_fails "$cmd_prefix ${class_name}::operator"
set location_list \
[list \
"${class_name}::operator${opn}${cls}" \
"${class_name}::operator ${opn}${cls}" \
"${class_name}::operator ${opn}${cls}(int)" \
"${class_name}::operator ${opn} ${cls} ( int )"]
foreach linespec $location_list {
check_bp_locations_match_list \
"$cmd_prefix $linespec" [list $location]
}
}
# Check that the explicit location completer manages to find the
# option name after -function, when the -function's argument is a
# C++ operator().
check_explicit_skips_function_argument \
"${class_name}::operator ${opn} ${cls} ( int )"
}
# Helper for testing both operator() and operator[]. Tests completion
# when the operator match is ambiguous. CLASS_NAME is the class that
# holds the operator to test. OPN and CLS are the open and close
# characters ("()" or "[]").
proc test_operator_ambiguous {class_name opn cls} {
foreach cmd_prefix {"b" "b -function"} {
check_setting_bp_fails "$cmd_prefix ${class_name}::operator"
set linespec_noparams "${class_name}::operator${opn}${cls}"
set location_list \
[list \
"${class_name}::operator${opn}${cls}(int)" \
"${class_name}::operator${opn}${cls}(long)" \
"${class_name}::operator${opn}${cls}<int>(int*)"]
# The operator[] test can't have a "()" overload, since that
# wouldn't compile.
if {$opn == "("} {
set location_list \
[concat \
[list "${class_name}::operator${opn}${cls}()"] \
$location_list]
}
test_gdb_complete_multiple \
"$cmd_prefix " "$linespec_noparams" "" $location_list
check_bp_locations_match_list "$cmd_prefix $linespec_noparams" \
$location_list
check_bp_locations_match_list "$cmd_prefix $linespec_noparams<int>" \
[list "${class_name}::operator${opn}${cls}<int>(int*)"]
# Test the template version. Test both with and without
# return type.
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>(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>(int*)"]
}
}
}
# Add extra spaces.
test_gdb_complete_unique \
"$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} ( long )" \
[list "${class_name}::operator${opn}${cls}(long)"]
}
}
proc_with_prefix operator()-unique {} {
test_operator_unique test_unique_op_call "(" ")"
}
proc_with_prefix operator\[\]-unique {} {
test_operator_unique test_unique_op_array "\[" "\]"
}
proc_with_prefix operator()-ambiguous {} {
test_operator_ambiguous test_op_call "(" ")"
}
proc_with_prefix operator\[\]-ambiguous {} {
test_operator_ambiguous test_op_array "\[" "\]"
}
# Test arithmetic/logical operators. Test completing all C++
# arithmetic/logical operators, when all the operators are in the same
# class.
proc_with_prefix ops-valid-ambiguous {} {
set locations {
"test_ops::operator!(E)"
"test_ops::operator!=(E, E)"
"test_ops::operator%(E, E)"
"test_ops::operator%=(E, E)"
"test_ops::operator&&(E, E)"
"test_ops::operator&(E, E)"
"test_ops::operator&=(E, E)"
"test_ops::operator*(E, E)"
"test_ops::operator*=(E, E)"
"test_ops::operator+(E, E)"
"test_ops::operator++(E)"
"test_ops::operator++(E, int)"
"test_ops::operator+=(E, E)"
"test_ops::operator,(E, E)"
"test_ops::operator-(E, E)"
"test_ops::operator--(E)"
"test_ops::operator--(E, int)"
"test_ops::operator-=(E, E)"
"test_ops::operator/(E, E)"
"test_ops::operator/=(E, E)"
"test_ops::operator<(E, E)"
"test_ops::operator<<(E, E)"
"test_ops::operator<<=(E, E)"
"test_ops::operator<=(E, E)"
"test_ops::operator==(E, E)"
"test_ops::operator>(E, E)"
"test_ops::operator>=(E, E)"
"test_ops::operator>>(E, E)"
"test_ops::operator>>=(E, E)"
"test_ops::operator^(E, E)"
"test_ops::operator^=(E, E)"
"test_ops::operator|(E, E)"
"test_ops::operator|=(E, E)"
"test_ops::operator||(E, E)"
"test_ops::operator~(E)"
}
foreach linespec $locations {
foreach cmd_prefix {"b" "b -function"} {
test_gdb_complete_unique \
"$cmd_prefix $linespec" \
"$cmd_prefix $linespec"
}
check_explicit_skips_function_argument "$linespec"
}
foreach cmd_prefix {"b" "b -function"} {
test_gdb_complete_multiple \
"$cmd_prefix " "test_ops::operator" "" $locations
}
}
# Test completing all C++ operators, with and without spaces. The
# test without spaces makes sure the completion matches exactly the
# expected prototype. The version with whitespace is a bit more lax
# for simplicity. In that case, we only make sure we get back the
# terminating ')'. Each operator is defined in a separate class so
# that we can exercise unique completion matches.
proc_with_prefix ops-valid-unique {} {
set locations {
"test_op_BIT_AND::operator&(E, E)"
"test_op_BIT_AND_A::operator&=(E, E)"
"test_op_BIT_O::operator|(E, E)"
"test_op_COMMA::operator,(E, E)"
"test_op_DIV::operator/(E, E)"
"test_op_DIV_A::operator/=(E, E)"
"test_op_EQ::operator==(E, E)"
"test_op_GT::operator>(E, E)"
"test_op_GTE::operator>=(E, E)"
"test_op_LAND::operator&&(E, E)"
"test_op_LOR::operator||(E, E)"
"test_op_LT::operator<(E, E)"
"test_op_LTE::operator<=(E, E)"
"test_op_MINUS::operator-(E, E)"
"test_op_MINUS_A::operator-=(E, E)"
"test_op_MOD::operator%(E, E)"
"test_op_MOD_A::operator%=(E, E)"
"test_op_MUL::operator*(E, E)"
"test_op_MUL_A::operator*=(E, E)"
"test_op_NEG::operator~(E)"
"test_op_NEQ::operator!=(E, E)"
"test_op_NOT::operator!(E)"
"test_op_OE::operator|=(E, E)"
"test_op_PLUS::operator+(E, E)"
"test_op_PLUS_A::operator+=(E, E)"
"test_op_POST_DEC::operator--(E, int)"
"test_op_POST_INC::operator++(E, int)"
"test_op_PRE_DEC::operator--(E)"
"test_op_PRE_INC::operator++(E)"
"test_op_SL::operator<<(E, E)"
"test_op_SL_A::operator<<=(E, E)"
"test_op_SR::operator>>(E, E)"
"test_op_SR_A::operator>>=(E, E)"
"test_op_XOR::operator^(E, E)"
"test_op_XOR_A::operator^=(E, E)"
}
set linespecs_ws {
"test_op_BIT_AND::operator & ( E , E )"
"test_op_BIT_AND_A::operator &= ( E , E )"
"test_op_BIT_O::operator | (E , E )"
"test_op_COMMA::operator , ( E , E )"
"test_op_DIV::operator / (E , E )"
"test_op_DIV_A::operator /= ( E , E )"
"test_op_EQ::operator == ( E , E )"
"test_op_GT::operator > ( E , E )"
"test_op_GTE::operator >= ( E , E )"
"test_op_LAND::operator && ( E , E )"
"test_op_LOR::operator || ( E , E )"
"test_op_LT::operator < ( E , E )"
"test_op_LTE::operator <= ( E , E )"
"test_op_MINUS::operator - ( E , E )"
"test_op_MINUS_A::operator -= ( E , E )"
"test_op_MOD::operator % ( E , E )"
"test_op_MOD_A::operator %= ( E , E )"
"test_op_MUL::operator * ( E , E )"
"test_op_MUL_A::operator *= ( E , E )"
"test_op_NEG::operator ~ ( E )"
"test_op_NEQ::operator != ( E , E )"
"test_op_NOT::operator ! ( E )"
"test_op_OE::operator |= ( E , E )"
"test_op_PLUS::operator + ( E , E )"
"test_op_PLUS_A::operator += ( E , E )"
"test_op_POST_DEC::operator -- ( E , int )"
"test_op_POST_INC::operator ++ ( E , int )"
"test_op_PRE_DEC::operator -- ( E )"
"test_op_PRE_INC::operator ++ ( E )"
"test_op_SL::operator << ( E , E )"
"test_op_SL_A::operator <<= ( E , E )"
"test_op_SR::operator >> ( E , E )"
"test_op_SR_A::operator >>= ( E , E )"
"test_op_XOR::operator ^ ( E , E )"
"test_op_XOR_A::operator ^= ( E , E )"
}
foreach linespec $locations linespec_ws $linespecs_ws {
foreach cmd_prefix {"b" "b -function"} {
with_test_prefix "no-whitespace" {
set line "$cmd_prefix $linespec"
set start [index_after "::operato" $line]
test_complete_prefix_range $line $start
}
with_test_prefix "whitespace" {
set line_ws "$cmd_prefix $linespec_ws"
set start_ws [index_after "::operator " $line_ws]
test_complete_prefix_range_re \
$line_ws "$cmd_prefix test_op_.*::operator .*\\\)" $start_ws
}
}
check_explicit_skips_function_argument "$linespec"
check_explicit_skips_function_argument "$linespec_ws"
}
}
# Test completing an invalid (whitespace at the wrong place) operator
# name.
proc_with_prefix ops-invalid {} {
foreach linespec {
"test_op_BIT_AND_A::operator& =(E, E)"
"test_op_DIV_A::operator/ =(E, E)"
"test_op_EQ::operator= =(E, E)"
"test_op_GTE::operator> =(E, E)"
"test_op_LAND::operator& &(E, E)"
"test_op_LOR::operator| |(E, E)"
"test_op_LTE::operator< =(E, E)"
"test_op_MINUS_A::operator- =(E, E)"
"test_op_MOD_A::operator% =(E, E)"
"test_op_MUL_A::operator* =(E, E)"
"test_op_NEQ::operator! =(E, E)"
"test_op_OE::operator| =(E, E)"
"test_op_PLUS_A::operator+ =(E, E)"
"test_op_POST_DEC::operator- -(E, int)"
"test_op_POST_INC::operator+ +(E, int)"
"test_op_PRE_DEC::operator- -(E)"
"test_op_PRE_INC::operator+ +(E)"
"test_op_SL::operator< <(E, E)"
"test_op_SL_A::operator< < =(E, E)"
"test_op_SR::operator> >(E, E)"
"test_op_SR_A::operator> > =(E, E)"
"test_op_XOR_A::operator^ =(E, E)"
} {
foreach cmd_prefix {"b" "b -function"} {
test_gdb_complete_tab_none "$cmd_prefix $linespec"
check_setting_bp_fails "$cmd_prefix $linespec"
}
}
}
# Test completing function/method FUNCTION. Completion is tested at
# every point starting after START_AFTER. FUNCTION_WS is a version of
# FUNCTION with extra (but valid) whitespace. FUNCTION_INVALID is a
# version of FUNCTION with invalid whitespace. Tests that completion
# of FUNCTION_WS completes to self, and that a completion of
# FUNCTION_INVALID fails.
proc test_function {function start_after function_ws {function_invalid ""}} {
foreach cmd_prefix {"b" "b -function"} {
set line "$cmd_prefix $function"
set start [index_after $start_after $line]
test_complete_prefix_range $line $start
}
check_explicit_skips_function_argument $function
check_explicit_skips_function_argument $function_ws
foreach cmd_prefix {"b" "b -function"} {
test_gdb_complete_unique \
"$cmd_prefix $function_ws" \
"$cmd_prefix $function_ws"
if {$function_invalid != ""} {
test_gdb_complete_tab_none "$cmd_prefix $function_invalid"
check_setting_bp_fails "$cmd_prefix $function_invalid"
}
}
}
# Test completing a user-defined conversion operator.
proc_with_prefix conversion-operator {} {
test_function \
"test_op_conversion::operator test_op_conversion_res const volatile**() const volatile" \
"test_op_conversio" \
"test_op_conversion::operator test_op_conversion_res const volatile * * ( ) const volatile"}
# Test completing an assignment operator.
proc_with_prefix assignment-operator {} {
test_function \
"test_op_assign::operator=(test_op_assign const&)" \
"test_op_assig" \
"test_op_assign::operator = ( test_op_assign const & )" \
}
# Test completing an arrow operator.
proc_with_prefix arrow-operator {} {
test_function \
"test_op_arrow::operator->()" \
"test_op_arro" \
"test_op_arrow::operator -> ( )" \
"test_op_arrow::operator - > ( )"
}
# The testcase driver. Calls all test procedures.
proc test_driver {} {
operator-delete
operator-delete\[\]
operator-new
operator-new\[\]
operator()-unique
operator()-ambiguous
operator\[\]-unique
operator\[\]-ambiguous
ops-valid-ambiguous
ops-valid-unique
ops-invalid
conversion-operator
assignment-operator
arrow-operator
}
test_driver
Reference in New Issue View Git Blame Copy Permalink