1d506c26d9
This commit is the result of the following actions:
- Running gdb/copyright.py to update all of the copyright headers to
include 2024,
- Manually updating a few files the copyright.py script told me to
update, these files had copyright headers embedded within the
file,
- Regenerating gdbsupport/Makefile.in to refresh it's copyright
date,
- Using grep to find other files that still mentioned 2023. If
these files were updated last year from 2022 to 2023 then I've
updated them this year to 2024.
I'm sure I've probably missed some dates. Feel free to fix them up as
you spot them.
596 lines
20 KiB
Text
596 lines
20 KiB
Text
# Copyright 1992-2024 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)
|
|
|
|
require allow_cplus_tests
|
|
|
|
standard_testfile .cc
|
|
|
|
if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
|
|
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
|
|
|
|
gdb_test_multiple "print &foo::operator,(foo&)" \
|
|
"detect dm_operator_comma" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &foo::operator char*($dm_type_void)" \
|
|
"detect dm_operator_char_star" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_char_star" \
|
|
"detect dm_type_char_star" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_foo_ref" \
|
|
"detect dm_type_foo_ref" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_int_star" \
|
|
"detect dm_type_int_star" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_long_star" \
|
|
"detect dm_type_long_star" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_unsigned_int" \
|
|
"detect dm_type_unsigned_int" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_void" \
|
|
"detect dm_type_void" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_void_star" \
|
|
"detect dm_type_void_star" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_short" \
|
|
"detect dm_type_short" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_unsigned_short" \
|
|
"detect dm_type_unsigned_short" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_long" \
|
|
"detect dm_type_long" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_unsigned_long" \
|
|
"detect dm_type_unsigned_long" {
|
|
-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"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "print &dm_type_typedef" \
|
|
"detect dm_type_typedef" {
|
|
-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"
|
|
}
|
|
}
|
|
}
|
|
|
|
#
|
|
# 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 srcfile decimal
|
|
|
|
regsub {\\\(void\\\)} $demangled {\(\)} demangled
|
|
|
|
set file_re "File .*[string_to_regexp $srcfile]:"
|
|
|
|
gdb_test_lines "info function $name" "info function for \"$name\"" \
|
|
[multi_line \
|
|
"$file_re" \
|
|
"$decimal:\t(class|)${demangled}.*"]
|
|
}
|
|
|
|
#
|
|
# 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]
|
|
|
|
gdb_test "print &$name" \
|
|
".* = .* $hex <$good_pattern>"
|
|
}
|
|
|
|
# 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]
|
|
|
|
gdb_test_multiple "print &$name" "print &$name" {
|
|
-re ".* = .* $hex <$good_pattern>\r\n$gdb_prompt $" {
|
|
pass "print &$name"
|
|
}
|
|
-re ".* = .* $hex <$bad_pattern>\r\n$gdb_prompt $" {
|
|
kfail $bugid "print &$name"
|
|
}
|
|
}
|
|
}
|
|
|
|
#
|
|
# 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 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)>"
|
|
|
|
print_addr "foo::operator delete($dm_type_void_star)"
|
|
print_addr "foo::operator delete\[\]($dm_type_void_star)"
|
|
|
|
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 binfile
|
|
global dm_type_int_star
|
|
|
|
gdb_test_no_output "set width 0"
|
|
|
|
runto_main
|
|
|
|
gdb_test_no_output "set language c++"
|
|
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" \
|
|
"Function \"foo::operator [string_to_regexp $dm_type_int_star]\" not defined\\."
|
|
}
|
|
|
|
do_tests
|