cec808ecec
* gdb.cp/cplusfuncs.cc (dm_type_short): New function.
(dm_type_long): New function.
(dm_type_unsigned_short): New function.
(dm_type_unsigned_long): New function.
(myint): New typedef.
* gdb.cp/cplusfuncs.exp (probe_demangler): Add tests for short,
long, unsigned shor and long, operator char*, and typedef.
(test_lookup_operator_functions): Add operator char* test.
(test_paddr_operator_functions): Likewise.
(test_paddr_overloaded_functions): Use probe values for
short, long, and unsigned short and long.
(test_paddr_hairy_functions): If the demangler probe detected
gdb type printers, "expect" them. Otherwise "expect" the v2 or v3
demangler.
* gdb.cp/expand-sals.exp: Backtrace may contain class names.
* gdb.cp/member-ptr.exp: Refine expected result for "print pmf"
and "print null_pmf".
Add test "ptype a.*pmf".
* gdb.cp/overload.exp: Allow optional "int" to appear with
"short" and "long".
* gdb.cp/ovldbreak.exp: Use append to construct super-duper
long expect value for men_overload1arg.
Allow "int" to appear with "short" and "long".
When testing "info break", add argument for main (void).
Also allow "int" to appear with "short" and "long".
Ditto with "unsigned" and "long long".
* gdb.java/jmain.exp: Do not enclose methods names in single
quotes.
* gdb.java/jmisc.exp: Likewise.
* gdb.java/jprint.exp: Likewise.
* gdb.python/py-symbol.exp: Update expected "linkage_name" value.
From Jan Kratochvil <jan.kratochvil@redhat.com>:
* gdb.cp/exception.exp (backtrace after first throw)
(backtrace after second throw): Allow a namespace before __cxa_throw.
(backtrace after first catch, backtrace after second catch): Allow
a namespace before __cxa_begin_catch.
* gdb.cp/cpexprs.exp: New file.
* gdb.cp/cpexprs.cc: New file.
From Daniel Jacobowitz <dan@codesourcery.com>
* gdb.cp/cpexprs.exp (escape): Delete. Change all callers
to use string_to_regexp.
(ctor, dtor): New functions. Use them to match constructor
and destructor function types.
(Top level): Use runto_main.
737 lines
23 KiB
Text
737 lines
23 KiB
Text
# Copyright 1992, 1997, 1999, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010
|
|
# 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 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 { [skip_cplus_tests] } { continue }
|
|
|
|
set testfile "cplusfuncs"
|
|
set srcfile ${testfile}.cc
|
|
set binfile ${objdir}/${subdir}/${testfile}
|
|
|
|
if { [get_compiler_info $binfile "c++"] } {
|
|
return -1
|
|
}
|
|
|
|
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
|
|
untested cplusfuncs.exp
|
|
return -1
|
|
}
|
|
|
|
#
|
|
# 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).
|
|
#
|
|
|
|
set dm_operator_comma ","
|
|
set dm_type_char_star "char*"
|
|
set dm_type_char_star_quoted "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 "void"
|
|
set dm_type_void_star "void*"
|
|
|
|
# Some other vagaries of GDB's type printing machinery. The integer types
|
|
# may have unsigned before or after their length, and may have "int"
|
|
# appended. The char* conversion operator may have name "char*" even if
|
|
# the type is "char *", because the name comes from the debug information
|
|
# and the type from GDB. Function types may not see through typedefs.
|
|
|
|
set dm_type_short "short"
|
|
set dm_type_long "long"
|
|
set dm_type_unsigned_short "unsigned short"
|
|
set dm_type_unsigned_long "unsigned long"
|
|
set dm_operator_char_star "char*"
|
|
set dm_operator_char_star_quoted "char\\*"
|
|
set dm_type_typedef 0
|
|
|
|
proc probe_demangler { } {
|
|
global gdb_prompt
|
|
global dm_operator_comma
|
|
global dm_operator_char_star
|
|
global dm_operator_char_star_quoted
|
|
global dm_type_char_star
|
|
global dm_type_char_star_quoted
|
|
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
|
|
global dm_type_short
|
|
global dm_type_unsigned_short
|
|
global dm_type_long
|
|
global dm_type_unsigned_long
|
|
global dm_type_typedef
|
|
|
|
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 &foo::operator char*($dm_type_void)\n"
|
|
gdb_expect {
|
|
-re ".*foo::operator char \\*\\(void\\).*\r\n$gdb_prompt $" {
|
|
# v2 demangler or GDB type printer
|
|
set dm_operator_char_star "char *"
|
|
set dm_operator_char_star_quoted "char \\*"
|
|
pass "detect dm_operator_char_star"
|
|
}
|
|
-re ".*foo::operator char\\*\\(\\).*\r\n$gdb_prompt $" {
|
|
# v3 demangler
|
|
pass "detect dm_operator_char_star"
|
|
}
|
|
-re ".*$gdb_prompt $" {
|
|
fail "detect dm_operator_char_star"
|
|
}
|
|
timeout {
|
|
fail "detect dm_operator_char_star"
|
|
}
|
|
}
|
|
|
|
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 *"
|
|
set dm_type_char_star_quoted "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 ".*dm_type_long_star\\(long int \\*\\).*\r\n$gdb_prompt $" {
|
|
# GCC v3 and GDB's type printer
|
|
set dm_type_long_star "long int *"
|
|
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)"
|
|
}
|
|
}
|
|
|
|
send_gdb "print &dm_type_short\n"
|
|
gdb_expect {
|
|
-re ".*dm_type_short\\(short\\).*\r\n$gdb_prompt $" {
|
|
# v2 and v3 demanglers
|
|
pass "detect dm_type_short"
|
|
}
|
|
-re ".*dm_type_short\\(short int\\).*\r\n$gdb_prompt $" {
|
|
# GDB type printer
|
|
set dm_type_short "short int"
|
|
pass "detect dm_type_short"
|
|
}
|
|
-re ".*$gdb_prompt $" {
|
|
fail "detect dm_type_short"
|
|
}
|
|
timeout {
|
|
fail "detect dm_type_short (timeout)"
|
|
}
|
|
}
|
|
|
|
send_gdb "print &dm_type_unsigned_short\n"
|
|
gdb_expect {
|
|
-re ".*dm_type_unsigned_short\\(unsigned short\\).*\r\n$gdb_prompt $" {
|
|
# v2 and v3 demanglers
|
|
pass "detect dm_type_unsigned_short"
|
|
}
|
|
-re ".*dm_type_unsigned_short\\(short unsigned int\\).*\r\n$gdb_prompt $" {
|
|
# GDB type printer
|
|
set dm_type_unsigned_short "short unsigned int"
|
|
pass "detect dm_type_unsigned_short"
|
|
}
|
|
-re ".*$gdb_prompt $" {
|
|
fail "detect dm_type_unsigned_short"
|
|
}
|
|
timeout {
|
|
fail "detect dm_type_unsigned_short (timeout)"
|
|
}
|
|
}
|
|
|
|
send_gdb "print &dm_type_long\n"
|
|
gdb_expect {
|
|
-re ".*dm_type_long\\(long\\).*\r\n$gdb_prompt $" {
|
|
# v2 and v3 demanglers
|
|
pass "detect dm_type_long"
|
|
}
|
|
-re ".*dm_type_long\\(long int\\).*\r\n$gdb_prompt $" {
|
|
# GDB type printer
|
|
set dm_type_long "long int"
|
|
pass "detect dm_type_long"
|
|
}
|
|
-re ".*$gdb_prompt $" {
|
|
fail "detect dm_type_long"
|
|
}
|
|
timeout {
|
|
fail "detect dm_type_long (timeout)"
|
|
}
|
|
}
|
|
|
|
send_gdb "print &dm_type_unsigned_long\n"
|
|
gdb_expect {
|
|
-re ".*dm_type_unsigned_long\\(unsigned long\\).*\r\n$gdb_prompt $" {
|
|
# v2 and v3 demanglers
|
|
pass "detect dm_type_unsigned_long"
|
|
}
|
|
-re ".*dm_type_unsigned_long\\(long unsigned int\\).*\r\n$gdb_prompt $" {
|
|
# GDB type printer
|
|
set dm_type_unsigned_long "long unsigned int"
|
|
pass "detect dm_type_unsigned_long"
|
|
}
|
|
-re ".*$gdb_prompt $" {
|
|
fail "detect dm_type_unsigned_long"
|
|
}
|
|
timeout {
|
|
fail "detect dm_type_unsigned_long (timeout)"
|
|
}
|
|
}
|
|
|
|
send_gdb "print &dm_type_typedef\n"
|
|
gdb_expect {
|
|
-re ".*dm_type_typedef\\(int\\).*\r\n$gdb_prompt $" {
|
|
# v2 and v3 demanglers
|
|
pass "detect dm_type_typedef"
|
|
}
|
|
-re ".*dm_type_typedef\\(myint\\).*\r\n$gdb_prompt $" {
|
|
# GDB type printer
|
|
set dm_type_typedef 1
|
|
pass "detect dm_type_typedef"
|
|
}
|
|
-re ".*$gdb_prompt $" {
|
|
fail "detect dm_type_typedef"
|
|
}
|
|
timeout {
|
|
fail "detect dm_type_typedef (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"
|
|
regsub {\\\(void\\\)} $demangled {\(\)} demangled
|
|
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.
|
|
|
|
# Note: carlton/2003-01-16: If you modify this, make a corresponding
|
|
# modification to print_addr_2_kfail.
|
|
|
|
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)"
|
|
}
|
|
}
|
|
}
|
|
|
|
# NOTE: carlton/2003-01-16: hairyfunc5-6 fail on GCC 3.x (for at least
|
|
# x=1 and x=2.1). So I'm modifying print_addr_2 to accept a failure
|
|
# condition. FIXME: It would be nice if the failure condition were
|
|
# conditional on the compiler version, but I'm not sufficiently
|
|
# motivated. I did hardwire in the versions of char * and int *,
|
|
# which will give some compiler-specificity to the failure.
|
|
|
|
proc print_addr_2_kfail { name good bad bugid } {
|
|
global gdb_prompt
|
|
global hex
|
|
|
|
set good_pattern [string_to_regexp $good]
|
|
set bad_pattern [string_to_regexp $bad]
|
|
|
|
send_gdb "print &$name\n"
|
|
gdb_expect {
|
|
-re ".* = .* $hex <$good_pattern>\r\n$gdb_prompt $" {
|
|
pass "print &$name"
|
|
}
|
|
-re ".* = .* $hex <$bad_pattern>\r\n$gdb_prompt $" {
|
|
kfail $bugid "print &$name"
|
|
}
|
|
-re ".*$gdb_prompt $" {
|
|
fail "print &$name"
|
|
}
|
|
timeout {
|
|
fail "print &$name (timeout)"
|
|
}
|
|
}
|
|
}
|
|
|
|
#
|
|
# Simple interfaces to print_addr_2.
|
|
#
|
|
|
|
proc print_addr { name } {
|
|
regsub {\(void\)} $name {()} expected
|
|
if {[string first "::" $name] == -1} {
|
|
# C function -- must be qutoed
|
|
set name "'$name'"
|
|
}
|
|
print_addr_2 "$name" $expected
|
|
}
|
|
|
|
#
|
|
# 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_operator_char_star
|
|
global dm_type_char_star
|
|
global dm_operator_char_star_quoted
|
|
global dm_type_foo_ref
|
|
global dm_type_void
|
|
global dm_type_void_star
|
|
|
|
# operator* requires quoting so that GDB does not treat it as a regexp.
|
|
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);"
|
|
# operator*= requires quoting so that GDB does not treat it as a regexp.
|
|
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);"
|
|
# operator->* requires quoting so that GDB does not treat it as a regexp.
|
|
info_func "operator->\\*(" "void foo::operator->*($dm_type_foo_ref);"
|
|
|
|
# operator[] needs double backslashes, so that a single backslash
|
|
# will be sent to GDB, preventing the square brackets from being
|
|
# evaluated as a regular expression.
|
|
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_operator_char_star_quoted\(" \
|
|
"char *foo::operator $dm_operator_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
|
|
global dm_operator_char_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)>"
|
|
gdb_test "print &foo::operator new\[\]" \
|
|
" = .* $hex <foo::operator new\\\[\\\]\\(.*\\)(| static)>"
|
|
if { !$hp_aCC_compiler } {
|
|
print_addr "foo::operator delete($dm_type_void_star)"
|
|
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_operator_char_star\($dm_type_void)"
|
|
}
|
|
|
|
#
|
|
# Test overloaded functions (1 arg).
|
|
#
|
|
|
|
proc test_paddr_overloaded_functions {} {
|
|
global dm_type_unsigned_int
|
|
global dm_type_void
|
|
global dm_type_short
|
|
global dm_type_unsigned_short
|
|
global dm_type_long
|
|
global dm_type_unsigned_long
|
|
|
|
print_addr "overload1arg($dm_type_void)"
|
|
print_addr "overload1arg(char)"
|
|
print_addr "overload1arg(signed char)"
|
|
print_addr "overload1arg(unsigned char)"
|
|
print_addr "overload1arg($dm_type_short)"
|
|
print_addr "overload1arg($dm_type_unsigned_short)"
|
|
print_addr "overload1arg(int)"
|
|
print_addr "overload1arg($dm_type_unsigned_int)"
|
|
print_addr "overload1arg($dm_type_long)"
|
|
print_addr "overload1arg($dm_type_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
|
|
global dm_type_typedef
|
|
|
|
print_addr_2 "hairyfunc1" "hairyfunc1(int)"
|
|
|
|
if {$dm_type_typedef == 0} {
|
|
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_kfail "hairyfunc5" "hairyfunc5(int (*(*)($dm_type_char_star))(long))" "hairyfunc5(int (*)(long) (*)(char*))" "gdb/19"
|
|
print_addr_2_kfail "hairyfunc6" "hairyfunc6(int (*(*)($dm_type_int_star))(long))" "hairyfunc6(int (*)(long) (*)(int*))" "gdb/19"
|
|
print_addr_2_kfail "hairyfunc7" "hairyfunc7(int (*(*)(int (*)($dm_type_char_star)))(long))" "hairyfunc7(int (*)(long) (*)(int (*)(char*)))" "gdb/19"
|
|
} else {
|
|
print_addr_2 "hairyfunc2" "hairyfunc2(PFPc_i)"
|
|
print_addr_2 "hairyfunc3" "hairyfunc3(PFPFPl_s_i)"
|
|
print_addr_2 "hairyfunc4" "hairyfunc4(PFPFPc_s_i)"
|
|
|
|
# gdb-gnats bug gdb/19:
|
|
# "gdb v3 demangler fails on hairyfunc5 hairyfunc6 hairyfunc7"
|
|
print_addr_2 "hairyfunc5" "hairyfunc5(PFPc_PFl_i)"
|
|
print_addr_2 "hairyfunc6" "hairyfunc6(PFPi_PFl_i)"
|
|
print_addr_2 "hairyfunc7" "hairyfunc7(PFPFPc_i_PFl_i)"
|
|
}
|
|
}
|
|
|
|
proc do_tests {} {
|
|
global prms_id
|
|
global bug_id
|
|
global subdir
|
|
global objdir
|
|
global srcdir
|
|
global binfile
|
|
global gdb_prompt
|
|
global dm_type_int_star
|
|
|
|
set prms_id 0
|
|
set bug_id 0
|
|
|
|
# Start with a fresh gdb.
|
|
|
|
gdb_exit
|
|
gdb_start
|
|
gdb_reinitialize_dir $srcdir/$subdir
|
|
gdb_load $binfile
|
|
|
|
send_gdb "set language c++\n"
|
|
gdb_expect -re "$gdb_prompt $"
|
|
send_gdb "set width 0\n"
|
|
gdb_expect -re "$gdb_prompt $"
|
|
|
|
runto_main
|
|
|
|
probe_demangler
|
|
test_paddr_overloaded_functions
|
|
test_paddr_operator_functions
|
|
test_paddr_hairy_functions
|
|
test_lookup_operator_functions
|
|
|
|
# A regression test on errors involving operators
|
|
gdb_test "list foo::operator $dm_type_int_star" \
|
|
".*the class foo does not have any method named operator $dm_type_int_star.*"
|
|
}
|
|
|
|
do_tests
|