775e0f0481
GDB in default prints the symbol associated on an address, and tests assume that there is no symbol on address zero. However, on bare metal target, address may be mapped to zero and there may be a symbol. Then, some tests fail as below: print const_cast<void *> (0)^M $8 = (void *) 0x0 <_ftext>^M (gdb) FAIL: gdb.cp/casts.exp: const_cast of 0 p acp->c1^M $9 = (A *) 0x0 <_ftext>^M (gdb) FAIL: gdb.cp/class2.exp: p acp->c1 This patch is to set print symbol off in these tests, like what I did previously https://sourceware.org/ml/gdb-patches/2014-07/msg00257.html gdb/testsuite: 2014-08-15 Yao Qi <yao@codesourcery.com> * gdb.cp/casts.exp: Set print symbol off. * gdb.cp/class2.exp: Likewise. * gdb.cp/overload.exp: Likewise. * gdb.cp/templates.exp: Likewise.
365 lines
14 KiB
Text
365 lines
14 KiB
Text
# Copyright 1998-2014 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/>.
|
|
|
|
# written by Elena Zannoni (ezannoni@cygnus.com)
|
|
# Rewritten by Michael Chastain <mec.gnu@mindspring.com>
|
|
|
|
# This file is part of the gdb testsuite
|
|
|
|
# Tests for overloaded member functions.
|
|
|
|
set ws "\[\r\n\t \]+"
|
|
set nl "\[\r\n\]+"
|
|
|
|
|
|
if { [skip_cplus_tests] } { continue }
|
|
|
|
standard_testfile .cc
|
|
|
|
if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
|
|
return -1
|
|
}
|
|
|
|
# Set it up at a breakpoint so we can play with the variable values.
|
|
|
|
if ![runto 'marker1'] then {
|
|
perror "couldn't run to marker1"
|
|
continue
|
|
}
|
|
|
|
# Prevent symbol on address 0x0 being printed.
|
|
gdb_test_no_output "set print symbol off"
|
|
|
|
gdb_test "up" ".*main.*" "up from marker1"
|
|
|
|
# Print the monster class type.
|
|
# See virtfunc.exp for a discussion of ptype.
|
|
#
|
|
# This is hairy to begin with. It is even more hairy because of the
|
|
# XX_* alternate patterns to catch the KFAIL and XFAIL cases.
|
|
|
|
set re_class "((struct|class) foo \{${ws}public:|struct foo \{)"
|
|
set re_fields "int ifoo;${ws}const char ?\\* ?ccpfoo;"
|
|
set XX_fields "int ifoo;${ws}char ?\\* ?ccpfoo;"
|
|
set re_ctor "foo\\(int\\);${ws}foo\\(int, (char const|const char) ?\\*\\);${ws}foo\\(foo ?&\\);"
|
|
set re_dtor "~foo\\((void|)\\);"
|
|
set XX_dtor "~foo\\(int\\);"
|
|
set re_methods "void foofunc\\(int\\);"
|
|
set re_methods "${re_methods}${ws}void foofunc\\(int, signed char ?\\*\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\((void|)\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(char\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(signed char\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(unsigned char\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(short( int)?\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\((unsigned short|short unsigned)( int)?\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(int\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(unsigned int\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(long( int)?\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\((unsigned long|long unsigned)( int)?\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(float\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(double\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(int \\*\\);"
|
|
set re_methods "${re_methods}${ws}int overload1arg\\(void \\*\\);"
|
|
set re_methods "${re_methods}${ws}int overloadfnarg\\((void|)\\);"
|
|
set re_methods "${re_methods}${ws}int overloadfnarg\\(int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadfnarg\\(int, int ?\\(\\*\\) ?\\(int\\)\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int, int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int, int, int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int, int, int, int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int, int, int, int, int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int, int, int, int, int, int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int, int, int, int, int, int, int, int\\);"
|
|
set re_methods "${re_methods}${ws}int overloadargs\\(int, int, int, int, int, int, int, int, int, int, int\\);"
|
|
set re_synth "foo & operator=\\(foo const ?&\\);"
|
|
|
|
gdb_test "print foo_instance1" "\\$\[0-9\]+ = \{ifoo = 111, ccpfoo = 0x0\}"
|
|
|
|
gdb_test_multiple "ptype foo_instance1" "ptype foo_instance1" {
|
|
-re "type = $re_class${ws}$re_fields${ws}$re_ctor${ws}$re_dtor${ws}$re_methods$nl\}$nl$gdb_prompt $" {
|
|
# gcc 2.95.3 -gdwarf-2
|
|
# TODO: this is not a quirk!
|
|
pass "ptype foo_instance1 (HP aCC -- known quirk with ~foo parameter list)"
|
|
}
|
|
-re "type = $re_class${ws}$XX_fields${ws}$re_synth${ws}$re_dtor${ws}$re_ctor${ws}$re_methods$nl\}$nl$gdb_prompt $" {
|
|
# gcc 2.95.3 -gstabs+, no "const" on "const char *"
|
|
# TODO: gdb.base/constvar.exp has XFAILed this kind of problem for a
|
|
# long time, but an XFAIL really needs an external bug report.
|
|
# -- chastain 2003-12-31
|
|
# setup_xfail "*-*-*"
|
|
# fail "ptype foo_instance1"
|
|
# TODO: this should be a KFAIL.
|
|
pass "ptype foo_instance1 (shorter match)"
|
|
}
|
|
-re "type = $re_class${ws}$re_fields${ws}$re_synth${ws}$re_dtor${ws}$re_ctor${ws}$re_methods$nl\}$nl$gdb_prompt $" {
|
|
# gcc 2.95.3 -gstabs+ if "const char *" ever gets fixed
|
|
pass "ptype foo_instance1"
|
|
}
|
|
-re "type = $re_class${ws}$re_fields${ws}$re_ctor${ws}$XX_dtor${ws}$re_methods$nl\}$nl$gdb_prompt $" {
|
|
# gcc 3.3.2 -gdwarf-2, "~foo(int)"
|
|
# TODO: kfail this
|
|
# kfail "gdb/1113" "ptype foo_instance1"
|
|
pass "ptype foo_instance1 (shorter match)"
|
|
}
|
|
-re "type = $re_class${ws}$re_fields${ws}$re_ctor${ws}$re_dtor${ws}$re_methods$nl\}$nl$gdb_prompt $" {
|
|
# gcc 3.3.2 -gdwarf-2, if the dtor bug gets fixed
|
|
# gcc HEAD -gdwarf-2 (abi-2)
|
|
# TODO: just pass this
|
|
pass "ptype foo_instance1 (shorter match)"
|
|
}
|
|
-re "type = $re_class${ws}$re_fields${ws}$re_synth${ws}$re_ctor${ws}$re_dtor${ws}$re_methods$nl\}$nl$gdb_prompt $" {
|
|
# gcc 3.3.2 -gstabs+
|
|
# TODO: enough with the "shorter match"
|
|
pass "ptype foo_instance1 (shorter match)"
|
|
}
|
|
-re "type = $re_class${ws}$re_fields${ws}$re_ctor${ws}$re_dtor${ws}$re_methods${ws}$re_synth$nl\}$nl$gdb_prompt $" {
|
|
# gcc HEAD -gstabs+ (abi-2)
|
|
pass "ptype foo_instance1 (shorter match)"
|
|
}
|
|
}
|
|
|
|
# Print variables and method calls.
|
|
# This is a walk in the park.
|
|
|
|
gdb_test "print foo_instance2" "\\$\[0-9\]+ = \{ifoo = 222, ccpfoo = $hex \"A\"\}"
|
|
gdb_test "print foo_instance3" "\\$\[0-9\]+ = \{ifoo = 222, ccpfoo = $hex \"A\"\}"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1)" "\\$\[0-9\]+ = 1" \
|
|
"print call overloaded func 1 arg"
|
|
|
|
# Regression test for overloading with function pointer type.
|
|
gdb_test "print foo_instance1.overloadfnarg(23, intintfunc)" " = 23"
|
|
|
|
# If GDB fails to restore the selected frame properly after the
|
|
# inferior function call above (see GDB PR 1155 for an explanation of
|
|
# why this might happen), all the subsequent tests will fail. We
|
|
# should detect and report that failure, but let the marker call
|
|
# finish so that the rest of the tests can run undisturbed.
|
|
|
|
gdb_test_multiple "frame" "re-selected 'main' frame after inferior call" {
|
|
-re "#0 marker1.*$gdb_prompt $" {
|
|
setup_kfail "gdb/1155" s390-*-linux-gnu
|
|
fail "re-selected 'main' frame after inferior call"
|
|
gdb_test "finish" ".*main.*at .*overload.cc:.*// marker1-returns-here.*" \
|
|
"finish call to marker1"
|
|
}
|
|
-re "#1 ($hex in )?main.*$gdb_prompt $" {
|
|
pass "re-selected 'main' frame after inferior call"
|
|
}
|
|
}
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2)" \
|
|
"\\$\[0-9\]+ = 2" \
|
|
"print call overloaded func 2 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3)" \
|
|
"\\$\[0-9\]+ = 3" \
|
|
"print call overloaded func 3 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3, 4)" \
|
|
"\\$\[0-9\]+ = 4" \
|
|
"print call overloaded func 4 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3, 4, 5)" \
|
|
"\\$\[0-9\]+ = 5" \
|
|
"print call overloaded func 5 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3, 4, 5, 6)" \
|
|
"\\$\[0-9\]+ = 6" \
|
|
"print call overloaded func 6 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3, 4, 5, 6, 7)" \
|
|
"\\$\[0-9\]+ = 7" \
|
|
"print call overloaded func 7 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3, 4, 5, 6, 7, 8)" \
|
|
"\\$\[0-9\]+ = 8" \
|
|
"print call overloaded func 8 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3, 4, 5, 6, 7, 8, 9)" \
|
|
"\\$\[0-9\]+ = 9" \
|
|
"print call overloaded func 9 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)" \
|
|
"\\$\[0-9\]+ = 10" \
|
|
"print call overloaded func 10 args"
|
|
|
|
gdb_test "print foo_instance1.overloadargs(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)" \
|
|
"\\$\[0-9\]+ = 11" \
|
|
"print call overloaded func 11 args"
|
|
|
|
gdb_test "print foo_instance1.overload1arg()" \
|
|
"\\$\[0-9\]+ = 1" \
|
|
"print call overloaded func void arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((char)arg2)" \
|
|
"\\$\[0-9\]+ = 2" \
|
|
"print call overloaded func char arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((signed char)arg3)" \
|
|
"\\$\[0-9\]+ = 3" \
|
|
"print call overloaded func signed char arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((unsigned char)arg4)" \
|
|
"\\$\[0-9\]+ = 4" \
|
|
"print call overloaded func unsigned char arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((short)arg5)" \
|
|
"\\$\[0-9\]+ = 5" \
|
|
"print call overloaded func short arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((unsigned short)arg6)" \
|
|
"\\$\[0-9\]+ = 6" \
|
|
"print call overloaded func unsigned short arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((int)arg7)" \
|
|
"\\$\[0-9\]+ = 7" \
|
|
"print call overloaded func int arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((unsigned int)arg8)" \
|
|
"\\$\[0-9\]+ = 8" \
|
|
"print call overloaded func unsigned int arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((long)arg9)" \
|
|
"\\$\[0-9\]+ = 9" \
|
|
"print call overloaded func long arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((unsigned long)arg10)" \
|
|
"\\$\[0-9\]+ = 10" \
|
|
"print call overloaded func unsigned long arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((float)arg11)" \
|
|
"\\$\[0-9\]+ = 11" \
|
|
"print call overloaded func float arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg((double)arg12)" \
|
|
"\\$\[0-9\]+ = 12" \
|
|
"print call overloaded func double arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg(&arg13)" \
|
|
"\\$\[0-9\]+ = 13" \
|
|
"print call overloaded func int\\* arg"
|
|
|
|
gdb_test "print foo_instance1.overload1arg(&arg14)" \
|
|
"\\$\[0-9\]+ = 14" \
|
|
"print call overloaded func char\\* arg"
|
|
|
|
gdb_test "print bar(a)" "= 11"
|
|
gdb_test "print bar(b)" "= 22"
|
|
gdb_test "print bar(c)" "= 22"
|
|
gdb_test "print bar(d)" "= 22"
|
|
|
|
# ---
|
|
|
|
# List overloaded functions.
|
|
|
|
# The void case is tricky because some compilers say "(void)"
|
|
# and some compilers say "()".
|
|
|
|
gdb_test_no_output "set listsize 1" ""
|
|
gdb_test_multiple "info func overloadfnarg" "list overloaded function with no args" {
|
|
-re ".*overloadfnarg\\(void\\).*$gdb_prompt $" {
|
|
# gcc 2
|
|
gdb_test "list foo::overloadfnarg(void)"\
|
|
".*int foo::overloadfnarg.*\\(void\\).*" \
|
|
"list overloaded function with no args"
|
|
}
|
|
-re ".*overloadfnarg\\(\\).*$gdb_prompt $" {
|
|
# gcc 3
|
|
gdb_test "list foo::overloadfnarg()"\
|
|
".*int foo::overloadfnarg.*\\(void\\).*" \
|
|
"list overloaded function with no args"
|
|
}
|
|
}
|
|
|
|
gdb_test "list foo::overloadfnarg(int)" \
|
|
"int foo::overloadfnarg.*\\(int arg\\).*" \
|
|
"list overloaded function with int arg"
|
|
|
|
gdb_test "list foo::overloadfnarg(int, int (*)(int))" \
|
|
"int foo::overloadfnarg.*\\(int arg, int \\(\\*foo\\) \\(int\\)\\).*" \
|
|
"list overloaded function with function ptr args"
|
|
|
|
gdb_test "list \"foo::overloadfnarg(int, int (*)(int))\"" \
|
|
"int foo::overloadfnarg.*\\(int arg, int \\(\\*foo\\) \\(int\\)\\).*" \
|
|
"list overloaded function with function ptr args - quotes around argument"
|
|
|
|
# Test list with filename.
|
|
|
|
gdb_test "list ${srcfile}:intToChar" "int intToChar.*"
|
|
gdb_test "list ${srcfile}:intToChar(char)" "int intToChar.*"
|
|
gdb_test "list ${srcfile}:'intToChar(char)'" "int intToChar.*"
|
|
gdb_test "list '${srcfile}:intToChar(char)'" "int intToChar.*"
|
|
gdb_test "list '${srcfile}':intToChar(char)" "int intToChar.*"
|
|
gdb_test "list '${srcfile}':'intToChar(char)'" "int intToChar.*"
|
|
|
|
# And with filename and namespace.
|
|
|
|
gdb_test "list ${srcfile}:foo::overloadfnarg(int)" "int foo::overloadfnarg.*}"
|
|
gdb_test "list ${srcfile}:'foo::overloadfnarg(int)'" "int foo::overloadfnarg.*}"
|
|
|
|
# Now some tests to see how overloading and namespaces interact.
|
|
|
|
gdb_test "print overloadNamespace(1)" ".\[0-9\]* = 1"
|
|
gdb_test "print overloadNamespace('a')" ".\[0-9\]* = 1"
|
|
gdb_test "print overloadNamespace(dummyInstance)" ".\[0-9\]* = 2"
|
|
|
|
# Static methods.
|
|
gdb_test "print K::staticoverload ()" " = 1"
|
|
gdb_test "print K::staticoverload (2)" " = 2"
|
|
gdb_test "print K::staticoverload (2, 3)" " = 5"
|
|
|
|
# Namespace-qualified functions.
|
|
gdb_test "print N::nsoverload ()" " = 1"
|
|
gdb_test "print N::nsoverload (2)" " = 2"
|
|
gdb_test "print N::nsoverload (2, 3)" " = 5"
|
|
|
|
if ![runto 'XXX::marker2'] then {
|
|
perror "couldn't run to XXX::marker2"
|
|
continue
|
|
}
|
|
|
|
gdb_test "print overloadNamespace(1)" ".\[0-9\]* = 3" "print overloadNamespace(1) in XXX"
|
|
gdb_test "print overloadNamespace('a')" ".\[0-9\]* = 3" "print overloadNamespace('a') in XXX"
|
|
gdb_test "print overloadNamespace(dummyInstance)" ".\[0-9\]* = 2" "print overloadNamespace(dummyInstance) in XXX"
|
|
|
|
# One last mysterious test.
|
|
# I wonder what this is for?
|
|
|
|
gdb_test "print intToChar(1)" "\\$\[0-9\]+ = 297"
|
|
|
|
# Test expression evaluation with overloaded methods
|
|
gdb_test "print foo::overload1arg" \
|
|
"non-unique member `overload1arg' requires type instantiation" \
|
|
"print foo::overload1arg"
|
|
|
|
gdb_test "print foo::overload1arg(char***)" \
|
|
"no member function matches that type instantiation" \
|
|
"print foo::overload1arg(char***)"
|
|
|
|
gdb_test "print foo::overload1arg(void)" \
|
|
"\\$$decimal = {int \\(foo \\*( const|)\\)} $hex <foo::overload1arg\\(\\)>" \
|
|
"print foo::overload1arg(void)"
|
|
|
|
foreach t [list char "signed char" "unsigned char" "short" \
|
|
"unsigned short" int "unsigned int" long "unsigned long" \
|
|
float double] {
|
|
gdb_test "print foo::overload1arg($t)" \
|
|
"\\$$decimal = {int \\(foo \\*( const|), $t\\)} $hex <foo::overload1arg\\($t\\)>" \
|
|
"print foo::overload1arg($t)"
|
|
}
|