From 99f78f560a6f6c670c802274baea31f846378e08 Mon Sep 17 00:00:00 2001 From: Michael Chastain Date: Wed, 14 Feb 2001 19:54:04 +0000 Subject: [PATCH] 2001-02-11 Michael Chastain * 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. Add reference to gdb/19 for related tests. (do_tests): Call probe_demangler. --- gdb/testsuite/ChangeLog | 28 ++ gdb/testsuite/gdb.c++/cplusfuncs.cc | 11 + gdb/testsuite/gdb.c++/cplusfuncs.exp | 550 +++++++++++++++++++++++++---------- 3 files changed, 428 insertions(+), 161 deletions(-) diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 365b7c8..06e5576 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,31 @@ +2001-02-11 Michael Chastain + + * 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. + Add reference to gdb/19 for related tests. + (do_tests): Call probe_demangler. + 2001-01-30 Kevin Buettner * gdb.c++/templates.cc (printf): Remove unused function definition. diff --git a/gdb/testsuite/gdb.c++/cplusfuncs.cc b/gdb/testsuite/gdb.c++/cplusfuncs.cc index 0c835eb..ed555aa 100644 --- a/gdb/testsuite/gdb.c++/cplusfuncs.cc +++ b/gdb/testsuite/gdb.c++/cplusfuncs.cc @@ -183,3 +183,14 @@ int hairyfunc4 (PFPFPc_s_i arg) { arg = 0; return 0; } 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; } diff --git a/gdb/testsuite/gdb.c++/cplusfuncs.exp b/gdb/testsuite/gdb.c++/cplusfuncs.exp index d3783a3..c2ed85c 100644 --- a/gdb/testsuite/gdb.c++/cplusfuncs.exp +++ b/gdb/testsuite/gdb.c++/cplusfuncs.exp @@ -1,4 +1,4 @@ -# Copyright (C) 1992, 1997, 1999 Free Software Foundation, Inc. +# 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,6 +18,7 @@ # 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 @@ -38,63 +39,282 @@ if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {deb } # -# Cause gdb to lookup a specific C++ function and print the demangled -# form. +# 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. +# +# old demangler new demangler +# --- --------- --- --------- +# "operator, " "operator," +# "char *" "char*" +# "int *" "int*" +# "long *" "long*" +# "void *" "void*" +# "foo &" "foo&" +# "unsigned int" "unsigned" +# "void" "" +# +# I probe for the forms in use. +# The defaults are for the v3 demangler (as of 2001-02-13). # -proc info_func { regex demangled } { +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 "info function $regex\n" + send_gdb "print &'dm_type_void'\n" gdb_expect { - -re "File .*:\r\n$demangled\r\n.*$gdb_prompt $" { - pass "info function for \"$regex\"" + -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 "File .*:\r\nclass $demangled\r\n.*$gdb_prompt $" { - pass "info function for \"$regex\"" + -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 \"$regex\"" + fail "info function for \"$name\"" } timeout { - fail "info function for \"$regex\" (timeout)" + fail "info function for \"$name\" (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. +# Lookup a specific C++ function and print the demangled type. +# This form accepts the demangled type as a literal string. # -proc print_addr_of { arg } { +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 pattern [string_to_regexp $arg] - send_gdb "print &'$arg'\n" + set good_pattern [string_to_regexp $good] + + send_gdb "print &'$name'\n" gdb_expect { - -re ".* = .* $hex <$pattern>\r\n$gdb_prompt $" { pass "print &'$arg'" } + -re ".* = .* $hex <$good_pattern>\r\n$gdb_prompt $" { + pass "print &'$name'" + } -re ".*$gdb_prompt $" { - fail "print &'$arg'" + fail "print &'$name'" } timeout { - fail "print &'$arg' (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 { @@ -103,127 +323,121 @@ proc test_lookup_operator_functions {} { 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 &\\);" + 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)" - 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)" + gdb_test "print &'foo::operator new'" \ + " = .* $hex " if { !$hp_aCC_compiler } { - print_addr_of "foo::operator delete(void *)" + print_addr "foo::operator delete($dm_type_void_star)" } else { - gdb_test "print &'foo::operator delete(void *) static'" \ + gdb_test "print &'foo::operator delete($dm_type_void_star) static'" \ " = .*(0x\[0-9a-f\]+|) " } - 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 " - 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\]+ " + + print_addr "foo::operator int($dm_type_void)" + print_addr "foo::operator $dm_type_char_star\($dm_type_void)" } # @@ -231,39 +445,52 @@ proc test_paddr_operator_functions {} { # 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)" + 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 {} { - 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))" + 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 (*)($dm_type_char_star)))(long))" } proc do_tests {} { @@ -303,6 +530,7 @@ proc do_tests {} { clear_xfail "*-*-*" } + probe_demangler test_paddr_overloaded_functions test_paddr_operator_functions test_paddr_hairy_functions -- 2.7.4