This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[RFA] testsuite/gdb.c++/cplusfuncs.{exp,cc}: work with either g++ demangler
- To: gdb-patches at sources dot redhat dot com
- Subject: [RFA] testsuite/gdb.c++/cplusfuncs.{exp,cc}: work with either g++ demangler
- From: Michael Elizabeth Chastain <chastain at cygnus dot com>
- Date: Sun, 4 Feb 2001 20:18:26 -0800
This is Sunday Sourceware patch #2.
gdb has two g++ demanglers. This patch enhances
testsuite/gdb.c++/cplusfuncs.{cc,exp} to work with either demangler.
Currently, this test script works okay on the v2 demangler, but gives
83 FAILs with the v3 demangler.
The bulk of the change is handling formatting differences:
old demangler new demangler
--- --------- --- ---------
"operator, " "operator,"
"char *" "char*"
"int *" "int*"
"long *" "long*"
"void *" "void*"
"foo &" "foo&"
"unsigned int" "unsigned"
"void" ""
While working on this test script, I discovered two bugs in gdb.
I have filed bug reports in gnats:
gdb/18 gdb can't parse "info func operator*" or "info func operator\*"
gdb/19 gdb v3 demangler fails on hairyfunc5 hairyfunc6 hairyfunc7
gdb/18 occurs with both demanglers (it is not a demangler bug). The test
script used to XFAIL some tests and had strange code in other tests to
accomodate the bug. That's not how a gdb test script is supposed to deal
with gdb bugs! I changed the script to issue the correct commands and
FAIL if they don't work. This causes 5 new FAILs with either demangler.
The new FAILs caused by the bug in gdb/18 are:
FAIL: gdb.c++/cplusfuncs.exp: info function for "operator*("
FAIL: gdb.c++/cplusfuncs.exp: info function for "operator*=("
FAIL: gdb.c++/cplusfuncs.exp: info function for "operator->*("
FAIL: gdb.c++/cplusfuncs.exp: info function for "operator[]("
FAIL: gdb.c++/cplusfuncs.exp: info function for "operator char *("
gdb/19 is a bug in the v3 demangler. If the v3 demangler is used, there
are 3 new FAILs. If the v2 demangler is used, there are no new FAILs.
The new FAILs caused by the bug in gdb/19 are:
FAIL: gdb.c++/cplusfuncs.exp: print &'hairyfunc5'
FAIL: gdb.c++/cplusfuncs.exp: print &'hairyfunc6'
FAIL: gdb.c++/cplusfuncs.exp: print &'hairyfunc7'
Testing: I tested on Red Hat Linux 7 native and Solaris 2.6 native.
On each platform, I ran before-and-after tests with both the v2 demangler
(using an older compiler) and the v3 demangler (using the sourceware cvs
gcc compiler).
OK to apply?
Michael Elizabeth Chastain
<chastain@redhat.com>
"love without fear"
===
2001-02-04 Michael Chastain <chastain@redhat.com>
* gdb.c++/cplusfuncs.cc (dm_type_char_star): New function
helps the test script figure out which demangler is in use.
(dm_type_foo_ref): Ditto.
(dm_type_int_star): Ditto.
(dm_type_long_star): Ditto.
(dm_type_unsigned_int): Ditto.
(dm_type_void): Ditto.
(dm_type_void_star): Ditto.
* gdb.base/cplusfuncs.exp (probe_demangler): New function.
Probe the gdb demangler and set variables to accommodate
formatting differences.
(info_func_regexp): New function. Same as info_func, but
matches against a regexp.
(info_func): Match against a literal string.
(print_addr_2): New function. Match against a literal string,
which can be different from the input to gdb.
(print_addr): Simply call print_addr_2 with the same argument twice.
(test_lookup_operator_functions): Use demangler formatting variables.
Blow away the xfails and workarounds for gnats gdb bug gdb/18. Sort
the tests in the same order as the C++ class declaration.
(test_paddr_operator_functions): Ditto.
(test_paddr_overloaded_functions): Ditto.
(test_paddr_hairy_functions): Use demangler formatting variables.
Note that some tests currently fail due to gnats gdb bug gdb/19.
(do_tests): Call probe_demangler.
===
Index: gdb/testsuite/gdb.c++/cplusfuncs.cc
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/cplusfuncs.cc,v
retrieving revision 1.1.1.3
diff -c -3 -p -r1.1.1.3 cplusfuncs.cc
*** gdb/testsuite/gdb.c++/cplusfuncs.cc 1999/08/02 23:46:53 1.1.1.3
--- gdb/testsuite/gdb.c++/cplusfuncs.cc 2001/02/05 03:29:48
*************** int hairyfunc4 (PFPFPc_s_i arg) { arg
*** 183,185 ****
--- 183,196 ----
int hairyfunc5 (PFPc_PFl_i arg) { arg = 0; return 0; }
int hairyfunc6 (PFPi_PFl_i arg) { arg = 0; return 0; }
int hairyfunc7 (PFPFPc_i_PFl_i arg) { arg = 0; return 0; }
+
+ /* gdb has two demanglers (one for g++ 2.95, one for g++ 3).
+ These marker functions help me figure out which demangler is in use. */
+
+ int dm_type_char_star (char * p) { return (int) p; }
+ int dm_type_foo_ref (foo & foo) { return foo.ifoo; }
+ int dm_type_int_star (int * p) { return (int) p; }
+ int dm_type_long_star (long * p) { return (int) p; }
+ int dm_type_unsigned_int (unsigned int i) { return i; }
+ int dm_type_void (void) { return 0; }
+ int dm_type_void_star (void * p) { return (int) p; }
Index: gdb/testsuite/gdb.c++/cplusfuncs.exp
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/cplusfuncs.exp,v
retrieving revision 1.1.1.3
diff -c -3 -p -r1.1.1.3 cplusfuncs.exp
*** gdb/testsuite/gdb.c++/cplusfuncs.exp 1999/09/09 00:00:27 1.1.1.3
--- gdb/testsuite/gdb.c++/cplusfuncs.exp 2001/02/05 03:29:49
***************
*** 1,4 ****
! # Copyright (C) 1992, 1997, 1999 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
--- 1,4 ----
! # Copyright (C) 1992, 1997, 1999, 2001 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
***************
*** 18,23 ****
--- 18,24 ----
# bug-gdb@prep.ai.mit.edu
# This file was written by Fred Fish. (fnf@cygnus.com)
+ # Adapted for g++ 3.0 ABI by Michael Chastain. (chastain@redhat.com)
if $tracelevel then {
strace $tracelevel
*************** if { [gdb_compile "${srcdir}/${subdir}/
*** 38,100 ****
}
#
! # Cause gdb to lookup a specific C++ function and print the demangled
! # form.
#
! proc info_func { regex demangled } {
global gdb_prompt
! send_gdb "info function $regex\n"
gdb_expect {
! -re "File .*:\r\n$demangled\r\n.*$gdb_prompt $" {
! pass "info function for \"$regex\""
}
! -re "File .*:\r\nclass $demangled\r\n.*$gdb_prompt $" {
! pass "info function for \"$regex\""
}
-re ".*$gdb_prompt $" {
! fail "info function for \"$regex\""
}
timeout {
! fail "info function for \"$regex\" (timeout)"
}
}
}
#
! # Run print &'$arg' on the input arg and verify that we can correctly
! # lookup the fully qualified C++ function.
! # We ignore the return type of the function since we are only interested
! # in the rootname and arguments part.
#
! proc print_addr_of { arg } {
global gdb_prompt
global hex
! set pattern [string_to_regexp $arg]
! send_gdb "print &'$arg'\n"
gdb_expect {
! -re ".* = .* $hex <$pattern>\r\n$gdb_prompt $" { pass "print &'$arg'" }
-re ".*$gdb_prompt $" {
! fail "print &'$arg'"
}
timeout {
! fail "print &'$arg' (timeout)"
}
}
}
#
# Test name demangling for operators.
#
# The '(' at the end of each regex input pattern is so that we match only
# the one we are looking for. I.E. "operator&" would match both
# "operator&(foo &)" and "operator&&(foo &)".
#
proc test_lookup_operator_functions {} {
# These tests don't work for COFF targets; don't even try them
if [istarget "a29k-*-udi"] then {
--- 39,309 ----
}
#
! # g++ changed its ABI between 2.95 and 3.0. gdb has two demanglers
! # for the two different styles. The two demanglers have some subtle
! # discrepancies in their output.
#
+ # I probe for the forms in use.
+ # The defaults are for the v3 demangler.
+ #
+
+ set dm_operator_comma ","
+ set dm_type_char_star "char*"
+ set dm_type_foo_ref "foo&"
+ set dm_type_int_star "int*"
+ set dm_type_long_star "long*"
+ set dm_type_unsigned_int "unsigned"
+ set dm_type_void ""
+ set dm_type_void_star "void*"
! proc probe_demangler { } {
global gdb_prompt
+ global dm_operator_comma
+ global dm_type_char_star
+ global dm_type_foo_ref
+ global dm_type_int_star
+ global dm_type_long_star
+ global dm_type_unsigned_int
+ global dm_type_void
+ global dm_type_void_star
+
+ send_gdb "print &'foo::operator,(foo&)'\n"
+ gdb_expect {
+ -re ".*foo::operator, \\(.*foo.*&.*\\).*\r\n$gdb_prompt $" {
+ # v2 demangler
+ set dm_operator_comma ", "
+ pass "detect dm_operator_comma"
+ }
+ -re ".*foo::operator,\\(.*foo.*&.*\\).*\r\n$gdb_prompt $" {
+ # v3 demangler
+ pass "detect dm_operator_comma"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "detect dm_operator_comma"
+ }
+ timeout {
+ fail "detect dm_operator_comma"
+ }
+ }
+
+ send_gdb "print &'dm_type_char_star'\n"
+ gdb_expect {
+ -re ".*dm_type_char_star\\(char \\*\\).*\r\n$gdb_prompt $" {
+ # v2 demangler
+ set dm_type_char_star "char *"
+ pass "detect dm_type_char_star"
+ }
+ -re ".*dm_type_char_star\\(char\\*\\).*\r\n$gdb_prompt $" {
+ # v3 demangler
+ pass "detect dm_type_char_star"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "detect dm_type_char_star"
+ }
+ timeout {
+ fail "detect dm_type_char_star (timeout)"
+ }
+ }
! send_gdb "print &'dm_type_foo_ref'\n"
gdb_expect {
! -re ".*dm_type_foo_ref\\(foo &\\).*\r\n$gdb_prompt $" {
! # v2 demangler
! set dm_type_foo_ref "foo &"
! pass "detect dm_type_foo_ref"
}
! -re ".*dm_type_foo_ref\\(foo&\\).*\r\n$gdb_prompt $" {
! # v3 demangler
! pass "detect dm_type_foo_ref"
}
-re ".*$gdb_prompt $" {
! fail "detect dm_type_foo_ref"
}
timeout {
! fail "detect dm_type_foo_ref (timeout)"
}
}
+
+ send_gdb "print &'dm_type_int_star'\n"
+ gdb_expect {
+ -re ".*dm_type_int_star\\(int \\*\\).*\r\n$gdb_prompt $" {
+ # v2 demangler
+ set dm_type_int_star "int *"
+ pass "detect dm_type_int_star"
+ }
+ -re ".*dm_type_int_star\\(int\\*\\).*\r\n$gdb_prompt $" {
+ # v3 demangler
+ pass "detect dm_type_int_star"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "detect dm_type_int_star"
+ }
+ timeout {
+ fail "detect dm_type_int_star (timeout)"
+ }
+ }
+
+ send_gdb "print &'dm_type_long_star'\n"
+ gdb_expect {
+ -re ".*dm_type_long_star\\(long \\*\\).*\r\n$gdb_prompt $" {
+ # v2 demangler
+ set dm_type_long_star "long *"
+ pass "detect dm_type_long_star"
+ }
+ -re ".*dm_type_long_star\\(long\\*\\).*\r\n$gdb_prompt $" {
+ # v3 demangler
+ pass "detect dm_type_long_star"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "detect dm_type_long_star"
+ }
+ timeout {
+ fail "detect dm_type_long_star (timeout)"
+ }
+ }
+
+ send_gdb "print &'dm_type_unsigned_int'\n"
+ gdb_expect {
+ -re ".*dm_type_unsigned_int\\(unsigned int\\).*\r\n$gdb_prompt $" {
+ # v2 demangler
+ set dm_type_unsigned_int "unsigned int"
+ pass "detect dm_type_unsigned_int"
+ }
+ -re ".*dm_type_unsigned_int\\(unsigned\\).*\r\n$gdb_prompt $" {
+ # v3 demangler
+ pass "detect dm_type_unsigned_int"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "detect dm_type_unsigned_int"
+ }
+ timeout {
+ fail "detect dm_unsigned int (timeout)"
+ }
+ }
+
+ send_gdb "print &'dm_type_void'\n"
+ gdb_expect {
+ -re ".*dm_type_void\\(void\\).*\r\n$gdb_prompt $" {
+ # v2 demangler
+ set dm_type_void "void"
+ pass "detect dm_type_void"
+ }
+ -re ".*dm_type_void\\(\\).*\r\n$gdb_prompt $" {
+ # v3 demangler
+ pass "detect dm_type_void"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "detect dm_type_void"
+ }
+ timeout {
+ fail "detect dm_type_void (timeout)"
+ }
+ }
+
+ send_gdb "print &'dm_type_void_star'\n"
+ gdb_expect {
+ -re ".*dm_type_void_star\\(void \\*\\).*\r\n$gdb_prompt $" {
+ # v2 demangler
+ set dm_type_void_star "void *"
+ pass "detect dm_type_void_star"
+ }
+ -re ".*dm_type_void_star\\(void\\*\\).*\r\n$gdb_prompt $" {
+ # v3 demangler
+ pass "detect dm_type_void_star"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "detect dm_type_void_star"
+ }
+ timeout {
+ fail "detect dm_type_void_star (timeout)"
+ }
+ }
+ }
+
+ #
+ # Lookup a specific C++ function and print the demangled type.
+ # This form accepts the demangled type as a regexp.
+ #
+
+ proc info_func_regexp { name demangled } {
+ global gdb_prompt
+
+ send_gdb "info function $name\n"
+ gdb_expect {
+ -re ".*File .*:\r\n(class |)$demangled\r\n.*$gdb_prompt $" {
+ pass "info function for \"$name\""
+ }
+ -re ".*$gdb_prompt $" {
+ fail "info function for \"$name\""
+ }
+ timeout {
+ fail "info function for \"$name\" (timeout)"
+ }
+ }
}
#
! # Lookup a specific C++ function and print the demangled type.
! # This form accepts the demangled type as a literal string.
#
! proc info_func { name demangled } {
! info_func_regexp "$name" [string_to_regexp "$demangled"]
! }
!
! #
! # Print the address of a function.
! # This checks that I can lookup a fully qualified C++ function.
! # This also checks the argument types on the return string.
! #
!
! proc print_addr_2 { name good } {
global gdb_prompt
global hex
+
+ set good_pattern [string_to_regexp $good]
! send_gdb "print &'$name'\n"
gdb_expect {
! -re ".* = .* $hex <$good_pattern>\r\n$gdb_prompt $" {
! pass "print &'$name'"
! }
-re ".*$gdb_prompt $" {
! fail "print &'$name'"
}
timeout {
! fail "print &'$name' (timeout)"
}
}
}
#
+ # Simple interfaces to print_addr_2.
+ #
+
+ proc print_addr { name } {
+ print_addr_2 "$name" "$name"
+ }
+
+ #
# Test name demangling for operators.
#
# The '(' at the end of each regex input pattern is so that we match only
# the one we are looking for. I.E. "operator&" would match both
# "operator&(foo &)" and "operator&&(foo &)".
#
+ # gdb-gnats bug gdb/18:
+ # "gdb can't parse "info func operator*" or "info func operator\*".
+ # The star in "operator*" is interpreted as a regexp, but the "\*"
+ # in "operator\*" is not a legal operator.
+ #
proc test_lookup_operator_functions {} {
+ global dm_operator_comma
+ global dm_type_char_star
+ global dm_type_foo_ref
+ global dm_type_void
+ global dm_type_void_star
# These tests don't work for COFF targets; don't even try them
if [istarget "a29k-*-udi"] then {
*************** proc test_lookup_operator_functions {} {
*** 103,229 ****
return
}
! info_func "operator&&(" "void foo::operator&&\\(foo &\\);"
! info_func "operator&=(" "void foo::operator&=\\(foo &\\);"
! info_func "operator&(" "void foo::operator&\\(foo &\\);"
! info_func "operator/=(" "void foo::operator/=\\(foo &\\);"
! info_func "operator^=(" "void foo::operator.=\\(foo &\\);"
! info_func "operator<<=(" "void foo::operator<<=\\(foo &\\);"
! info_func "operator%=(" "void foo::operator%=\\(foo &\\);"
! info_func "operator-=(" "void foo::operator-=\\(foo &\\);"
!
! # There doesn't appear to be any way to get GDB to treat '*' as a
! # character to match, rather than as a regex special character.
! setup_xfail "*-*-*"
! info_func "operator\*=(" "void foo::operator\\*=\\(foo &\\);"
!
! info_func "operator|=(" "void foo::operator\\|=\\(foo &\\);"
! info_func "operator+=(" "void foo::operator.=\\(foo &\\);"
! info_func "operator>>=(" "void foo::operator\>\>=\\(foo &\\);"
! info_func "operator=(" "void foo::operator=\\(foo &\\);"
! info_func "operator()(" "void foo::operator\\(\\)\\(foo &\\);"
!
! # The function should be "operator," not "operator, ". (note space)
! # This test will work; I've commented it out because it should not
! # count as a pass, since it is incorrect. Ian Taylor.
! # info_func "operator, (" "void foo::operator, \\(foo &\\);"
! setup_xfail "*-*-*"
! info_func "operator,(" "void foo::operator,\\(foo &\\);"
!
! info_func "operator~(" "void foo::operator~\\(void\\);"
! info_func "operator delete(" "void foo::operator delete\\(void \\*\\)(| static);"
! info_func "operator/(" "void foo::operator/\\(foo &\\);"
! info_func "operator==(" "void foo::operator==\\(foo &\\);"
! info_func "operator^(" "void foo::operator\\^\\(foo &\\);"
!
! info_func "operator>=(" "void foo::operator>=\\(foo &\\);"
! info_func "operator>(" "void foo::operator>\\(foo &\\);"
! info_func "operator<=(" "void foo::operator<=\\(foo &\\);"
! info_func "operator<<(" "void foo::operator<<\\(foo &\\);"
! info_func "operator<(" "void foo::operator<\\(foo &\\);"
! info_func "operator%(" "void foo::operator%\\(foo &\\);"
! info_func "operator-(" "void foo::operator-\\(foo &\\);"
!
! # There doesn't appear to be anyway to get '*' treated as a character
! # to match, rather than as a regex special character.
! setup_xfail "*-*-*"
! info_func "operator\*(" "void foo::operator\\*\\(foo &\\);"
!
! info_func "operator--(" "void foo::operator--\\(int\\);"
! info_func "operator!=(" "void foo::operator!=\\(foo &\\);"
! info_func "operator!(" "void foo::operator!\\(void\\);"
! info_func "operator new(" "void \\*foo::operator new\\(.*\\)(| static);"
! info_func "operator||(" "void foo::operator\\|\\|\\(foo &\\);"
! info_func "operator char \\*(" "char \\*foo::operator char \\*\\(void\\);"
! info_func "operator int(" "int foo::operator int\\(void\\);"
! info_func "operator|(" "void foo::operator\\|\\(foo &\\);"
! info_func "operator+(" "void foo::operator\\+\\(foo &\\);"
! info_func "operator++(" "void foo::operator\\+\\+\\(int\\);"
! info_func "operator->(" "foo \\*foo::operator->\\(void\\);"
! info_func "operator->\\*(" "void foo::operator->\\*\\(foo &\\);"
! info_func "operator>>(" "void foo::operator\>\>\\(foo &\\);"
!
! # GDB says "`operator \[\](' not supported". I don't know why.
! setup_xfail "*-*-*"
! info_func "operator\\\[\\\](" "void foo::operator\\\[\\\]\\(foo &\\);"
! # But this works, for some reason.
! info_func ".perator\\\[\\\](" "void foo::operator\\\[\\\]\\(foo &\\);"
}
proc test_paddr_operator_functions {} {
global hex
global hp_aCC_compiler
! print_addr_of "foo::operator&&(foo &)"
! print_addr_of "foo::operator&=(foo &)"
! print_addr_of "foo::operator&(foo &)"
! print_addr_of "foo::operator/=(foo &)"
! print_addr_of "foo::operator^=(foo &)"
! print_addr_of "foo::operator<<=(foo &)"
! print_addr_of "foo::operator%=(foo &)"
! print_addr_of "foo::operator-=(foo &)"
! print_addr_of "foo::operator*=(foo &)"
! print_addr_of "foo::operator|=(foo &)"
! print_addr_of "foo::operator+=(foo &)"
! print_addr_of "foo::operator>>=(foo &)"
! print_addr_of "foo::operator=(foo &)"
! print_addr_of "foo::operator()(foo &)"
! print_addr_of "foo::operator, (foo &)"
! print_addr_of "foo::operator~(void)"
if { !$hp_aCC_compiler } {
! print_addr_of "foo::operator delete(void *)"
} else {
! gdb_test "print &'foo::operator delete(void *) static'" \
" = .*(0x\[0-9a-f\]+|) <foo::operator delete.*>"
}
! print_addr_of "foo::operator/(foo &)"
! print_addr_of "foo::operator==(foo &)"
! print_addr_of "foo::operator^(foo &)"
! print_addr_of "foo::operator>=(foo &)"
! print_addr_of "foo::operator>(foo &)"
! print_addr_of "foo::operator<=(foo &)"
! print_addr_of "foo::operator<<(foo &)"
! print_addr_of "foo::operator<(foo &)"
! print_addr_of "foo::operator%(foo &)"
! print_addr_of "foo::operator-(foo &)"
! print_addr_of "foo::operator*(foo &)"
! print_addr_of "foo::operator--(int)"
! print_addr_of "foo::operator!=(foo &)"
! print_addr_of "foo::operator!(void)"
! gdb_test "print &'foo::operator new'" \
! " = .* $hex <foo::operator new\\(.*\\)(| static)>"
! print_addr_of "foo::operator||(foo &)"
! print_addr_of "foo::operator char *(void)"
! print_addr_of "foo::operator int(void)"
! print_addr_of "foo::operator|(foo &)"
! print_addr_of "foo::operator+(foo &)"
! print_addr_of "foo::operator++(int)"
! print_addr_of "foo::operator->(void)"
! print_addr_of "foo::operator->*(foo &)"
! print_addr_of "foo::operator>>(foo &)"
! gdb_test "print &'foo::operator\[\](foo &)'" \
! " = .*0x\[0-9a-f\]+ <foo::operator\\\[\\\]\\(foo &\\)>"
}
#
--- 312,432 ----
return
}
! info_func "operator*(" "void foo::operator*($dm_type_foo_ref);"
! info_func "operator%(" "void foo::operator%($dm_type_foo_ref);"
! info_func "operator-(" "void foo::operator-($dm_type_foo_ref);"
! info_func "operator>>(" "void foo::operator>>($dm_type_foo_ref);"
! info_func "operator!=(" "void foo::operator!=($dm_type_foo_ref);"
! info_func "operator>(" "void foo::operator>($dm_type_foo_ref);"
! info_func "operator>=(" "void foo::operator>=($dm_type_foo_ref);"
! info_func "operator|(" "void foo::operator|($dm_type_foo_ref);"
! info_func "operator&&(" "void foo::operator&&($dm_type_foo_ref);"
! info_func "operator!(" "void foo::operator!($dm_type_void);"
! info_func "operator++(" "void foo::operator++(int);"
! info_func "operator=(" "void foo::operator=($dm_type_foo_ref);"
! info_func "operator+=(" "void foo::operator+=($dm_type_foo_ref);"
! info_func "operator*=(" "void foo::operator*=($dm_type_foo_ref);"
! info_func "operator%=(" "void foo::operator%=($dm_type_foo_ref);"
! info_func "operator>>=(" "void foo::operator>>=($dm_type_foo_ref);"
! info_func "operator|=(" "void foo::operator|=($dm_type_foo_ref);"
! info_func "operator$dm_operator_comma\(" \
! "void foo::operator$dm_operator_comma\($dm_type_foo_ref);"
! info_func "operator/(" "void foo::operator/($dm_type_foo_ref);"
! info_func "operator+(" "void foo::operator+($dm_type_foo_ref);"
! info_func "operator<<(" "void foo::operator<<($dm_type_foo_ref);"
! info_func "operator==(" "void foo::operator==($dm_type_foo_ref);"
! info_func "operator<(" "void foo::operator<($dm_type_foo_ref);"
! info_func "operator<=(" "void foo::operator<=($dm_type_foo_ref);"
! info_func "operator&(" "void foo::operator&($dm_type_foo_ref);"
! info_func "operator^(" "void foo::operator^($dm_type_foo_ref);"
! info_func "operator||(" "void foo::operator||($dm_type_foo_ref);"
! info_func "operator~(" "void foo::operator~($dm_type_void);"
! info_func "operator--(" "void foo::operator--(int);"
! info_func "operator->(" "foo *foo::operator->($dm_type_void);"
! info_func "operator-=(" "void foo::operator-=($dm_type_foo_ref);"
! info_func "operator/=(" "void foo::operator/=($dm_type_foo_ref);"
! info_func "operator<<=(" "void foo::operator<<=($dm_type_foo_ref);"
! info_func "operator&=(" "void foo::operator&=($dm_type_foo_ref);"
! info_func "operator^=(" "void foo::operator^=($dm_type_foo_ref);"
! info_func "operator->*(" "void foo::operator->*($dm_type_foo_ref);"
!
! # operator[] needs backslashes to protect against TCL evaluation.
! info_func "operator\[\](" "void foo::operator\[\]($dm_type_foo_ref);"
!
! # These are gnarly because they might end with 'static'.
! set dm_type_void_star_regexp [string_to_regexp $dm_type_void_star]
! info_func_regexp "operator new(" "void \\*foo::operator new\\(.*\\)(| static);"
! info_func_regexp "operator delete(" "void foo::operator delete\\($dm_type_void_star_regexp\\)(| static);"
!
! info_func "operator int(" "int foo::operator int($dm_type_void);"
! info_func "operator()(" "void foo::operator()($dm_type_foo_ref);"
! info_func "operator $dm_type_char_star\(" \
! "char *foo::operator $dm_type_char_star\($dm_type_void);"
!
}
proc test_paddr_operator_functions {} {
global hex
global hp_aCC_compiler
+ global dm_operator_comma
+ global dm_type_char_star
+ global dm_type_foo_ref
+ global dm_type_long_star
+ global dm_type_unsigned_int
+ global dm_type_void
+ global dm_type_void_star
+
+ print_addr "foo::operator*($dm_type_foo_ref)"
+ print_addr "foo::operator%($dm_type_foo_ref)"
+ print_addr "foo::operator-($dm_type_foo_ref)"
+ print_addr "foo::operator>>($dm_type_foo_ref)"
+ print_addr "foo::operator!=($dm_type_foo_ref)"
+ print_addr "foo::operator>($dm_type_foo_ref)"
+ print_addr "foo::operator>=($dm_type_foo_ref)"
+ print_addr "foo::operator|($dm_type_foo_ref)"
+ print_addr "foo::operator&&($dm_type_foo_ref)"
+ print_addr "foo::operator!($dm_type_void)"
+ print_addr "foo::operator++(int)"
+ print_addr "foo::operator=($dm_type_foo_ref)"
+ print_addr "foo::operator+=($dm_type_foo_ref)"
+ print_addr "foo::operator*=($dm_type_foo_ref)"
+ print_addr "foo::operator%=($dm_type_foo_ref)"
+ print_addr "foo::operator>>=($dm_type_foo_ref)"
+ print_addr "foo::operator|=($dm_type_foo_ref)"
+ print_addr "foo::operator$dm_operator_comma\($dm_type_foo_ref)"
+ print_addr "foo::operator/($dm_type_foo_ref)"
+ print_addr "foo::operator+($dm_type_foo_ref)"
+ print_addr "foo::operator<<($dm_type_foo_ref)"
+ print_addr "foo::operator==($dm_type_foo_ref)"
+ print_addr "foo::operator<($dm_type_foo_ref)"
+ print_addr "foo::operator<=($dm_type_foo_ref)"
+ print_addr "foo::operator&($dm_type_foo_ref)"
+ print_addr "foo::operator^($dm_type_foo_ref)"
+ print_addr "foo::operator||($dm_type_foo_ref)"
+ print_addr "foo::operator~($dm_type_void)"
+ print_addr "foo::operator--(int)"
+ print_addr "foo::operator->($dm_type_void)"
+ print_addr "foo::operator-=($dm_type_foo_ref)"
+ print_addr "foo::operator/=($dm_type_foo_ref)"
+ print_addr "foo::operator<<=($dm_type_foo_ref)"
+ print_addr "foo::operator&=($dm_type_foo_ref)"
+ print_addr "foo::operator^=($dm_type_foo_ref)"
+ print_addr "foo::operator->*($dm_type_foo_ref)"
+ print_addr "foo::operator\[\]($dm_type_foo_ref)"
+ print_addr "foo::operator()($dm_type_foo_ref)"
! gdb_test "print &'foo::operator new'" \
! " = .* $hex <foo::operator new\\(.*\\)(| static)>"
if { !$hp_aCC_compiler } {
! print_addr "foo::operator delete($dm_type_void_star)"
} else {
! gdb_test "print &'foo::operator delete($dm_type_void_star) static'" \
" = .*(0x\[0-9a-f\]+|) <foo::operator delete.*>"
}
!
! print_addr "foo::operator int($dm_type_void)"
! print_addr "foo::operator $dm_type_char_star\($dm_type_void)"
}
#
*************** proc test_paddr_operator_functions {} {
*** 231,269 ****
#
proc test_paddr_overloaded_functions {} {
! print_addr_of "overload1arg(signed char)"
! print_addr_of "overload1arg(unsigned char)"
! print_addr_of "overload1arg(unsigned int)"
! print_addr_of "overload1arg(unsigned long)"
! print_addr_of "overload1arg(unsigned short)"
! print_addr_of "overload1arg(char)"
! print_addr_of "overload1arg(double)"
! print_addr_of "overload1arg(float)"
! print_addr_of "overload1arg(int)"
! print_addr_of "overload1arg(long)"
! print_addr_of "overload1arg(short)"
! print_addr_of "overload1arg(void)"
! print_addr_of "overloadargs(int)"
! print_addr_of "overloadargs(int, int)"
! print_addr_of "overloadargs(int, int, int)"
! print_addr_of "overloadargs(int, int, int, int)"
! print_addr_of "overloadargs(int, int, int, int, int)"
! print_addr_of "overloadargs(int, int, int, int, int, int)"
! print_addr_of "overloadargs(int, int, int, int, int, int, int)"
! print_addr_of "overloadargs(int, int, int, int, int, int, int, int)"
! print_addr_of "overloadargs(int, int, int, int, int, int, int, int, int)"
! print_addr_of "overloadargs(int, int, int, int, int, int, int, int, int, int)"
! print_addr_of "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
}
proc test_paddr_hairy_functions {} {
! print_addr_of "hairyfunc1(int)"
! print_addr_of "hairyfunc2(int (*)(char *))"
! print_addr_of "hairyfunc3(int (*)(short (*)(long *)))"
! print_addr_of "hairyfunc4(int (*)(short (*)(char *)))"
! print_addr_of "hairyfunc5(int (*(*)(char *))(long))"
! print_addr_of "hairyfunc6(int (*(*)(int *))(long))"
! print_addr_of "hairyfunc7(int (*(*)(int (*)(char *)))(long))"
}
proc do_tests {} {
--- 434,485 ----
#
proc test_paddr_overloaded_functions {} {
! global dm_type_unsigned_int
! global dm_type_void
!
! print_addr "overload1arg($dm_type_void)"
! print_addr "overload1arg(char)"
! print_addr "overload1arg(signed char)"
! print_addr "overload1arg(unsigned char)"
! print_addr "overload1arg(short)"
! print_addr "overload1arg(unsigned short)"
! print_addr "overload1arg(int)"
! print_addr "overload1arg($dm_type_unsigned_int)"
! print_addr "overload1arg(long)"
! print_addr "overload1arg(unsigned long)"
! print_addr "overload1arg(float)"
! print_addr "overload1arg(double)"
!
! print_addr "overloadargs(int)"
! print_addr "overloadargs(int, int)"
! print_addr "overloadargs(int, int, int)"
! print_addr "overloadargs(int, int, int, int)"
! print_addr "overloadargs(int, int, int, int, int)"
! print_addr "overloadargs(int, int, int, int, int, int)"
! print_addr "overloadargs(int, int, int, int, int, int, int)"
! print_addr "overloadargs(int, int, int, int, int, int, int, int)"
! print_addr "overloadargs(int, int, int, int, int, int, int, int, int)"
! print_addr "overloadargs(int, int, int, int, int, int, int, int, int, int)"
! print_addr "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
}
proc test_paddr_hairy_functions {} {
! global gdb_prompt
! global hex
! global dm_type_char_star
! global dm_type_int_star
! global dm_type_long_star
!
! print_addr_2 "hairyfunc1" "hairyfunc1(int)"
! print_addr_2 "hairyfunc2" "hairyfunc2(int (*)($dm_type_char_star))"
! print_addr_2 "hairyfunc3" "hairyfunc3(int (*)(short (*)($dm_type_long_star)))"
! print_addr_2 "hairyfunc4" "hairyfunc4(int (*)(short (*)($dm_type_char_star)))"
!
! # gdb-gnats bug gdb/19:
! # "gdb v3 demangler fails on hairyfunc5 hairyfunc6 hairyfunc7"
! print_addr_2 "hairyfunc5" "hairyfunc5(int (*(*)($dm_type_char_star))(long))"
! print_addr_2 "hairyfunc6" "hairyfunc6(int (*(*)($dm_type_int_star))(long))"
! print_addr_2 "hairyfunc7" "hairyfunc7(int (*(*)(int (*)(char *)))(long))"
}
proc do_tests {} {
*************** proc do_tests {} {
*** 303,308 ****
--- 519,525 ----
clear_xfail "*-*-*"
}
+ probe_demangler
test_paddr_overloaded_functions
test_paddr_operator_functions
test_paddr_hairy_functions