[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.cp / demangle.exp

# Copyright (C) 1992-2022 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)

if { [skip_cplus_tests] } { continue }

### The demangling style we last sent to GDB.
set current_demangling_style none

### Set GDB's current demangling style to STYLE.  Subsequent calls to
### test_demangle will include STYLE in the test name when reporting
### passes and failures.
proc set_demangling_style {style} {
    global gdb_prompt
    global current_demangling_style

    gdb_test_multiple "set demangle-style $style" \
	"$style: set demangle-style" {
	    -re "set demangle-style $style\[\r\n\]+$gdb_prompt $" {
		pass "$style: set demangle-style"
	    }
	    -re ".*$gdb_prompt $" {
		fail "$style: set demangle-style"
		error "set_demangling_style: set style"
	    }
	    timeout { 
		fail "$style: set demangle-style (timeout)"
		error "set_demangling_style: set style"
	    }
	}

    gdb_test_multiple "show demangle-style" \
	"$style: check demangling style" {
	    -re "The current C\[+\]+ demangling style is \"$style\".\r\n$gdb_prompt $" { 
		pass "$style: check demangling style"
	    }
	    -re ".*$gdb_prompt $" {
		fail "$style: check demangling style"
		error "set_demangling_style: check style"
	    }
	    timeout { 
		fail "$style: check demangling style (timeout)" 
		error "set_demangling_style: check style"
	    }
	}

    set current_demangling_style $style
}


### Utility function for test_demangling and test_demangling_exact.
proc test_demangling_core {tester test result} {
    global current_demangling_style

    if {! [regexp {^([^ ]+): (.+)$} $test dummy style name]} {
      error "bad test name passed to test_demangling"
    }

    if {[string compare $style $current_demangling_style]} {
	with_test_prefix $test {
	    set_demangling_style $style
	}
    }

    $tester "demangle $name" $result $test
}

### Demangle an identifier, and check that the result matches a pattern.
###
### TEST should be of the form "STYLE: NAME", where STYLE is the name
### of a demangling style (like "gnu" or "arm"), and NAME is a mangled
### identifier to demangle.  Pass when the result matches the regular
### expression RESULT.  Report passes and fails using TEST as the name
### of the test.
###
### Why don't we just pass the STYLE and NAME as two separate
### arguments, or let the style be a global variable?  That would be
### cleaner.  However, doing it this way means that:
### 
### 1) the name of the test, as recorded in the summary and log,
### appears verbatim in the script, and
### 
### 2) that test names are unique, even though we try to demangle the same
### identifiers using several different mangling styles.
### 
### This makes it a lot easier for people tracking down failures to
### find the one they care about.

proc test_demangling {test result} {
    test_demangling_core gdb_test $test $result
}

### Like test_demangling, above, except that RESULT is not a regexp,
### but a string that must match exactly.

proc test_demangling_exact {test result} {
    test_demangling_core gdb_test_exact $test $result
}

#
#  Test gnu-v3 style name demangling
#

proc test_gnuv3_style_demangling {} {
    global gdb_prompt

    # Rvalue reference tests
    test_demangling_exact "gnu-v3: _ZN9ArrowLine19ArrowheadIntersectsEP9ArrowheadO6BoxObjP7Graphic" "ArrowLine::ArrowheadIntersects(Arrowhead*, BoxObj&&, Graphic*)"
    test_demangling "gnu-v3: _Z13BitPatterntoaOK10BitPatternccc" \
	"BitPatterntoa\[(\]+(const BitPattern|BitPattern const)&&, char, char, char\[)\]+"
    test_demangling_exact "gnu-v3: _ZN8TextCode14CoreConstDeclsEO7ostream" "TextCode::CoreConstDecls(ostream&&)"
    test_demangling "gnu-v3: _Z31DrawDestinationTransformedImageP7_XImageiiS0_iimjiijmmP4_XGCOK13ivTransformeriiii" \
	"DrawDestinationTransformedImage\[(\]+_XImage\[*\]+, int, int, _XImage\[*\]+, int, int, unsigned long, unsigned int, int, int, unsigned int, unsigned long, unsigned long, _XGC\[*\]+, (const ivTransformer|ivTransformer const)&&, int, int, int, int\[)\]+"
    test_demangling_exact "gnu-v3: _ZN11RelateManip6EffectEO7ivEvent" "RelateManip::Effect(ivEvent&&)"
    test_demangling_exact "gnu-v3: _ZN20DisplayList_IteratorC4EO11DisplayList" "DisplayList_Iterator::DisplayList_Iterator(DisplayList&&)"
    test_demangling_exact "gnu-v3: _ZN3fooC4EOS_" "foo::foo(foo&&)"
    test_demangling_exact "gnu-v3: _ZN3fooC4EiOS_iS0_iS0_" "foo::foo(int, foo&&, int, foo&&, int, foo&&)"
    test_demangling "gnu-v3: _ZN7ivWorldC2EPKcOiPPcPK12ivOptionDescPK14ivPropertyData" \
	"ivWorld::ivWorld\[(\]+(const char|char const)\[*\]+, int&&, char\[*\]+\[*\]+, (const ivOptionDesc|ivOptionDesc const)\[*\]+, (const ivPropertyData|ivPropertyData const)\[*\]+\[)\]+"
    test_demangling "gnu-v3: _Z3argOK7Complex" \
	"arg\[(\]+(const Complex|Complex const)&&\[)\]+"
    test_demangling "gnu-v3: _ZNK9BitString8containsEOK10BitPattern" \
	"BitString::contains\[(\]+(const BitPattern|BitPattern const)&&\[)\]+ const"
    test_demangling "gnu-v3: _ZNK9BitString8containsEOK12BitSubStringi" \
	"BitString::contains\[(\]+(const BitSubString|BitSubString const)&&, int\[)\]+ const"
    test_demangling "gnu-v3: _ZNK9BitString8containsEOKS_" \
	"BitString::contains\[(\]+(const BitString|BitString const)&&\[)\]+ const"
    test_demangling_exact "gnu-v3: _ZN4ListI10VHDLEntityE3PixC4EOKS2_" \
	"List<VHDLEntity>::Pix::Pix(List<VHDLEntity>::Pix const&&)"
    test_demangling_exact "gnu-v3: _ZN4ListI10VHDLEntityE7elementC2EOKS0_PS2_" \
	"List<VHDLEntity>::element::element(VHDLEntity const&&, List<VHDLEntity>::element*)"
    test_demangling_exact "gnu-v3: _ZN4ListI10VHDLEntityE7elementC4EOKS2_" \
	"List<VHDLEntity>::element::element(List<VHDLEntity>::element const&&)"
    test_demangling_exact "gnu-v3: _ZNK4ListI10VHDLEntityEclEOKNS1_3PixE" \
	"List<VHDLEntity>::operator()(List<VHDLEntity>::Pix const&&) const"
    test_demangling_exact "gnu-v3: _ZN4ListI10VHDLEntityEC4EOKS1_" \
	"List<VHDLEntity>::List(List<VHDLEntity> const&&)"
    test_demangling_exact "gnu-v3: _ZN4PixXI11VHDLLibrary14VHDLLibraryRep4ListI10VHDLEntityEEC2EOKS5_" \
	"PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >::PixX(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> > const&&)"
    test_demangling_exact "gnu-v3: _ZNK11VHDLLibrary5nextEEO4PixXIS_14VHDLLibraryRep4ListI10VHDLEntityEE" \
	"VHDLLibrary::nextE(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >&&) const"
    test_demangling_exact "gnu-v3: _ZNK4ListI10VHDLEntityE4nextEONS1_3PixE" \
	"List<VHDLEntity>::next(List<VHDLEntity>::Pix&&) const"
}

proc catch_demangling_errors {command} {
    if {[catch $command result]} {
	puts "ERROR: demangle.exp: while running $command: $result"
    }
}

# Test support for different demangling styles.  Note that this does
# not depend upon running the test program and does not depend upon
# gdb being able to lookup any C++ symbols.  It simply calls the 
# internal demangler with synthesized strings and tests the results.

proc do_tests {} {
    global subdir
    global gdb_prompt


    # Start with a fresh gdb.

    gdb_exit
    gdb_start

    gdb_test_no_output "set language c++"
    gdb_test_no_output "set width 0"

    # Using catch_demangling_errors this way ensures that, if one of
    # the functions raises a Tcl error, then it'll get reported, and
    # the rest of the functions will still run.
    catch_demangling_errors test_gnuv3_style_demangling

    # Verify specifying demangle language.
    gdb_test_no_output "set language unknown"
    set_demangling_style "auto"
    gdb_test_exact "demangle -l c++ -- _ZSt4cout" "std::cout"
    gdb_test_exact "demangle -l c++ _ZSt4cout" "std::cout"
    gdb_test_exact "demangle -l c -- _ZSt4cout" "Can't demangle \"_ZSt4cout\""
    gdb_test_exact "demangle -l garbage xyzdje" "Unknown language \"garbage\""
}

do_tests
Commit	Line	Data
88b9d363	1	# Copyright (C) 1992-2022 Free Software Foundation, Inc.
c906108c SS	2
	3	# This program is free software; you can redistribute it and/or modify
	4	# it under the terms of the GNU General Public License as published by
e22f8b7c	5	# the Free Software Foundation; either version 3 of the License, or
c906108c	6	# (at your option) any later version.
e22f8b7c	7	#
c906108c SS	8	# This program is distributed in the hope that it will be useful,
	9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	# GNU General Public License for more details.
e22f8b7c	12	#
c906108c	13	# You should have received a copy of the GNU General Public License
e22f8b7c	14	# along with this program. If not, see <http://www.gnu.org/licenses/>.
c906108c	15
c906108c SS	16	# This file was written by Fred Fish. (fnf@cygnus.com)
c906108c SS	17
d4f3574e SS	18	if { [skip_cplus_tests] } { continue }
d4f3574e SS	19
7a292a7a SS	20	### The demangling style we last sent to GDB.
7a292a7a SS	21	set current_demangling_style none
c906108c	22
7a292a7a SS	23	### Set GDB's current demangling style to STYLE. Subsequent calls to
	24	### test_demangle will include STYLE in the test name when reporting
	25	### passes and failures.
	26	proc set_demangling_style {style} {
c906108c	27	global gdb_prompt
7a292a7a	28	global current_demangling_style
c906108c	29
f8d3bf8f MS	30	gdb_test_multiple "set demangle-style $style" \
	31	"$style: set demangle-style" {
	32	-re "set demangle-style $style\[\r\n\]+$gdb_prompt $" {
	33	pass "$style: set demangle-style"
	34	}
	35	-re ".*$gdb_prompt $" {
	36	fail "$style: set demangle-style"
	37	error "set_demangling_style: set style"
	38	}
	39	timeout {
	40	fail "$style: set demangle-style (timeout)"
	41	error "set_demangling_style: set style"
	42	}
7a292a7a	43	}
c906108c	44
f8d3bf8f MS	45	gdb_test_multiple "show demangle-style" \
	46	"$style: check demangling style" {
	47	-re "The current C\[+\]+ demangling style is \"$style\".\r\n$gdb_prompt $" {
	48	pass "$style: check demangling style"
	49	}
	50	-re ".*$gdb_prompt $" {
	51	fail "$style: check demangling style"
	52	error "set_demangling_style: check style"
	53	}
	54	timeout {
	55	fail "$style: check demangling style (timeout)"
	56	error "set_demangling_style: check style"
	57	}
7a292a7a	58	}
c906108c	59
7a292a7a SS	60	set current_demangling_style $style
	61	}
	62
	63
	64	### Utility function for test_demangling and test_demangling_exact.
	65	proc test_demangling_core {tester test result} {
	66	global current_demangling_style
	67
	68	if {! [regexp {^([^ ]+): (.+)$} $test dummy style name]} {
	69	error "bad test name passed to test_demangling"
	70	}
	71
	72	if {[string compare $style $current_demangling_style]} {
c0f55cc6 AV	73	with_test_prefix $test {
	74	set_demangling_style $style
	75	}
7a292a7a SS	76	}
7a292a7a SS	77
439250fb	78	$tester "demangle $name" $result $test
7a292a7a SS	79	}
	80
	81	### Demangle an identifier, and check that the result matches a pattern.
	82	###
	83	### TEST should be of the form "STYLE: NAME", where STYLE is the name
	84	### of a demangling style (like "gnu" or "arm"), and NAME is a mangled
	85	### identifier to demangle. Pass when the result matches the regular
	86	### expression RESULT. Report passes and fails using TEST as the name
	87	### of the test.
	88	###
	89	### Why don't we just pass the STYLE and NAME as two separate
	90	### arguments, or let the style be a global variable? That would be
	91	### cleaner. However, doing it this way means that:
	92	###
	93	### 1) the name of the test, as recorded in the summary and log,
	94	### appears verbatim in the script, and
	95	###
	96	### 2) that test names are unique, even though we try to demangle the same
	97	### identifiers using several different mangling styles.
	98	###
	99	### This makes it a lot easier for people tracking down failures to
	100	### find the one they care about.
	101
	102	proc test_demangling {test result} {
	103	test_demangling_core gdb_test $test $result
	104	}
	105
	106	### Like test_demangling, above, except that RESULT is not a regexp,
	107	### but a string that must match exactly.
	108
	109	proc test_demangling_exact {test result} {
	110	test_demangling_core gdb_test_exact $test $result
	111	}
	112
7a292a7a	113	#
041be526	114	# Test gnu-v3 style name demangling
7a292a7a SS	115	#
7a292a7a SS	116
041be526	117	proc test_gnuv3_style_demangling {} {
e017c81f DJ	118	global gdb_prompt
e017c81f DJ	119
c0f55cc6 AV	120	# Rvalue reference tests
	121	test_demangling_exact "gnu-v3: _ZN9ArrowLine19ArrowheadIntersectsEP9ArrowheadO6BoxObjP7Graphic" "ArrowLine::ArrowheadIntersects(Arrowhead, BoxObj&&, Graphic)"
	122	test_demangling "gnu-v3: _Z13BitPatterntoaOK10BitPatternccc" \
	123	"BitPatterntoa\[(\]+(const BitPattern\|BitPattern const)&&, char, char, char\[)\]+"
	124	test_demangling_exact "gnu-v3: _ZN8TextCode14CoreConstDeclsEO7ostream" "TextCode::CoreConstDecls(ostream&&)"
	125	test_demangling "gnu-v3: _Z31DrawDestinationTransformedImageP7_XImageiiS0_iimjiijmmP4_XGCOK13ivTransformeriiii" \
	126	"DrawDestinationTransformedImage\[(\]+_XImage\[\]+, int, int, _XImage\[\]+, int, int, unsigned long, unsigned int, int, int, unsigned int, unsigned long, unsigned long, _XGC\[*\]+, (const ivTransformer\|ivTransformer const)&&, int, int, int, int\[)\]+"
	127	test_demangling_exact "gnu-v3: _ZN11RelateManip6EffectEO7ivEvent" "RelateManip::Effect(ivEvent&&)"
	128	test_demangling_exact "gnu-v3: _ZN20DisplayList_IteratorC4EO11DisplayList" "DisplayList_Iterator::DisplayList_Iterator(DisplayList&&)"
	129	test_demangling_exact "gnu-v3: _ZN3fooC4EOS_" "foo::foo(foo&&)"
	130	test_demangling_exact "gnu-v3: _ZN3fooC4EiOS_iS0_iS0_" "foo::foo(int, foo&&, int, foo&&, int, foo&&)"
	131	test_demangling "gnu-v3: _ZN7ivWorldC2EPKcOiPPcPK12ivOptionDescPK14ivPropertyData" \
	132	"ivWorld::ivWorld\[(\]+(const char\|char const)\[\]+, int&&, char\[\]+\[\]+, (const ivOptionDesc\|ivOptionDesc const)\[\]+, (const ivPropertyData\|ivPropertyData const)\[*\]+\[)\]+"
	133	test_demangling "gnu-v3: _Z3argOK7Complex" \
	134	"arg\[(\]+(const Complex\|Complex const)&&\[)\]+"
	135	test_demangling "gnu-v3: _ZNK9BitString8containsEOK10BitPattern" \
	136	"BitString::contains\[(\]+(const BitPattern\|BitPattern const)&&\[)\]+ const"
	137	test_demangling "gnu-v3: _ZNK9BitString8containsEOK12BitSubStringi" \
	138	"BitString::contains\[(\]+(const BitSubString\|BitSubString const)&&, int\[)\]+ const"
	139	test_demangling "gnu-v3: _ZNK9BitString8containsEOKS_" \
	140	"BitString::contains\[(\]+(const BitString\|BitString const)&&\[)\]+ const"
	141	test_demangling_exact "gnu-v3: _ZN4ListI10VHDLEntityE3PixC4EOKS2_" \
	142	"List<VHDLEntity>::Pix::Pix(List<VHDLEntity>::Pix const&&)"
	143	test_demangling_exact "gnu-v3: _ZN4ListI10VHDLEntityE7elementC2EOKS0_PS2_" \
	144	"List<VHDLEntity>::element::element(VHDLEntity const&&, List<VHDLEntity>::element*)"
	145	test_demangling_exact "gnu-v3: _ZN4ListI10VHDLEntityE7elementC4EOKS2_" \
	146	"List<VHDLEntity>::element::element(List<VHDLEntity>::element const&&)"
	147	test_demangling_exact "gnu-v3: _ZNK4ListI10VHDLEntityEclEOKNS1_3PixE" \
	148	"List<VHDLEntity>::operator()(List<VHDLEntity>::Pix const&&) const"
	149	test_demangling_exact "gnu-v3: _ZN4ListI10VHDLEntityEC4EOKS1_" \
	150	"List<VHDLEntity>::List(List<VHDLEntity> const&&)"
	151	test_demangling_exact "gnu-v3: _ZN4PixXI11VHDLLibrary14VHDLLibraryRep4ListI10VHDLEntityEEC2EOKS5_" \
	152	"PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >::PixX(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> > const&&)"
	153	test_demangling_exact "gnu-v3: _ZNK11VHDLLibrary5nextEEO4PixXIS_14VHDLLibraryRep4ListI10VHDLEntityEE" \
	154	"VHDLLibrary::nextE(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >&&) const"
	155	test_demangling_exact "gnu-v3: _ZNK4ListI10VHDLEntityE4nextEONS1_3PixE" \
	156	"List<VHDLEntity>::next(List<VHDLEntity>::Pix&&) const"
c906108c SS	157	}
c906108c SS	158
7a292a7a SS	159	proc catch_demangling_errors {command} {
	160	if {[catch $command result]} {
	161	puts "ERROR: demangle.exp: while running $command: $result"
	162	}
c906108c	163	}
7a292a7a	164
c906108c SS	165	# Test support for different demangling styles. Note that this does
	166	# not depend upon running the test program and does not depend upon
	167	# gdb being able to lookup any C++ symbols. It simply calls the
	168	# internal demangler with synthesized strings and tests the results.
	169
	170	proc do_tests {} {
c906108c SS	171	global subdir
	172	global gdb_prompt
	173
c906108c SS	174
	175	# Start with a fresh gdb.
	176
	177	gdb_exit
	178	gdb_start
	179
f8d3bf8f MS	180	gdb_test_no_output "set language c++"
f8d3bf8f MS	181	gdb_test_no_output "set width 0"
7a292a7a SS	182
	183	# Using catch_demangling_errors this way ensures that, if one of
	184	# the functions raises a Tcl error, then it'll get reported, and
	185	# the rest of the functions will still run.
041be526	186	catch_demangling_errors test_gnuv3_style_demangling
439250fb DE	187
	188	# Verify specifying demangle language.
	189	gdb_test_no_output "set language unknown"
	190	set_demangling_style "auto"
	191	gdb_test_exact "demangle -l c++ -- _ZSt4cout" "std::cout"
	192	gdb_test_exact "demangle -l c++ _ZSt4cout" "std::cout"
	193	gdb_test_exact "demangle -l c -- _ZSt4cout" "Can't demangle \"_ZSt4cout\""
	194	gdb_test_exact "demangle -l garbage xyzdje" "Unknown language \"garbage\""
c906108c SS	195	}
	196
	197	do_tests