derivation.exp revision 1.10
1# Copyright 1998-2023 Free Software Foundation, Inc. 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 5# the Free Software Foundation; either version 3 of the License, or 6# (at your option) any later version. 7# 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. 12# 13# You should have received a copy of the GNU General Public License 14# along with this program. If not, see <http://www.gnu.org/licenses/>. 15 16# This file was written by Elena Zannoni (ezannoni@cygnus.com) 17# And rewritten by Michael Chastain <mec.gnu@mindspring.com> 18 19# This file is part of the gdb testsuite 20 21# tests for inheritance, with several derivations types combinations 22# (private, public, protected) 23# classes have simple members and member functions. 24 25set ws "\[\r\n\t \]+" 26set nl "\[\r\n\]+" 27 28# Start program. 29 30 31if { [skip_cplus_tests] } { return } 32 33load_lib "cp-support.exp" 34 35standard_testfile derivation.cc derivation2.cc 36 37if {[prepare_for_testing "failed to prepare" $testfile \ 38 [list $srcfile $srcfile2] {debug c++}]} { 39 return -1 40} 41 42# Check inheritance of typedefs. 43with_test_prefix "before run" { 44 foreach klass {"A" "D" "E" "F" "A2" "D2"} { 45 gdb_test "ptype ${klass}::value_type" "type = int" 46 gdb_test "whatis ${klass}::value_type" "type = int" 47 gdb_test "p (${klass}::value_type) 0" " = 0" 48 } 49 foreach klass {"Z" "ZZ"} { 50 gdb_test "ptype ${klass}::value_type" "type = float" 51 gdb_test "whatis ${klass}::value_type" "type = float" 52 gdb_test "p (${klass}::value_type) 0" " = 0" 53 } 54} 55 56# Set it up at a breakpoint so we can play with the variable values. 57 58if {![runto 'marker1']} { 59 return 60} 61 62# Check inheritance of typedefs again, but this time with an active block. 63with_test_prefix "at marker1" { 64 foreach klass {"A" "D" "A2" "D2"} { 65 gdb_test "ptype ${klass}::value_type" "type = int" 66 gdb_test "whatis ${klass}::value_type" "type = int" 67 gdb_test "p (${klass}::value_type) 0" " = 0" 68 } 69} 70 71gdb_test "up" ".*main.*" "up from marker1" 72 73# Print class types and values. 74 75# class A 76 77gdb_test "print a_instance" "\\$\[0-9\]+ = \{a = 1, aa = 2\}" "print value of a_instance" 78 79# Clang does not add accessibility information for typedefs inside classes. 80if {[test_compiler_info {clang*} c++]} { 81 setup_xfail "clang 57608" *-*-* 82} 83cp_test_ptype_class \ 84 "a_instance" "" "class" "A" \ 85 { 86 { field public "A::value_type a;" } 87 { field public "A::value_type aa;" } 88 { method public "A();" } 89 { method public "A::value_type afoo();" } 90 { method public "A::value_type foo();" } 91 { typedef public "typedef int value_type;" } 92 } 93 94# class D 95 96gdb_test_multiple "print d_instance" "print value of d_instance" { 97 -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, d = 7, dd = 8\}$nl$gdb_prompt $" { 98 pass "print value of d_instance" 99 } 100} 101 102cp_test_ptype_class \ 103 "d_instance" "" "class" "D" \ 104 { 105 { base "private A" } 106 { base "public B" } 107 { base "protected C" } 108 { field public "A::value_type d;" } 109 { field public "A::value_type dd;" } 110 { method public "D();" } 111 { method public "A::value_type dfoo();" } 112 { method public "A::value_type foo();" } 113 } \ 114 "" \ 115 { 116 { "protected C" "private C" { setup_xfail "*-*-*" "gcc/13539" } } 117 } 118 119# class E 120 121gdb_test_multiple "print e_instance" "print value of e_instance" { 122 -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, e = 9, ee = 10\}$nl$gdb_prompt $" { 123 pass "print value of e_instance" 124 } 125} 126 127cp_test_ptype_class \ 128 "e_instance" "" "class" "E" \ 129 { 130 { base "public A" } 131 { base "private B" } 132 { base "protected C" } 133 { field public "A::value_type e;" } 134 { field public "A::value_type ee;" } 135 { method public "E();" } 136 { method public "A::value_type efoo();" } 137 { method public "A::value_type foo();" } 138 } \ 139 "" \ 140 { 141 { "protected C" "private C" { setup_xfail "*-*-*" "gcc/13539" } } 142 } 143 144# class F 145 146gdb_test_multiple "print f_instance" "print value of f_instance" { 147 -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, f = 11, ff = 12\}$nl$gdb_prompt $" { 148 pass "print value of f_instance" 149 } 150} 151 152cp_test_ptype_class \ 153 "f_instance" "" "class" "F" \ 154 { 155 { base "private A" } 156 { base "public B" } 157 { base "private C" } 158 { field public "A::value_type f;" } 159 { field public "A::value_type ff;" } 160 { method public "F();" } 161 { method public "A::value_type ffoo();" } 162 { method public "A::value_type foo();" } 163 } 164 165# class G 166cp_test_ptype_class \ 167 "g_instance" "" "class" "G" \ 168 { 169 { base "private A" } 170 { base "public B" } 171 { base "protected C" } 172 { field public "int g;" } 173 { field public "int gg;" } 174 { field public "int a;" } 175 { field public "int b;" } 176 { field public "int c;" } 177 { method public "int gfoo();" } 178 { method public "int foo();" } 179 } 180 181# Print individual fields. 182 183gdb_test "print d_instance.a" "\\$\[0-9\]+ = 1" "print value of d_instance.a" 184gdb_test "print d_instance.aa" "\\$\[0-9\]+ = 2" "print value of d_instance.aa" 185gdb_test "print d_instance.b" "\\$\[0-9\]+ = 3" "print value of d_instance.b" 186gdb_test "print d_instance.bb" "\\$\[0-9\]+ = 4" "print value of d_instance.bb" 187gdb_test "print d_instance.c" "\\$\[0-9\]+ = 5" "print value of d_instance.c" 188gdb_test "print d_instance.cc" "\\$\[0-9\]+ = 6" "print value of d_instance.cc" 189gdb_test "print d_instance.d" "\\$\[0-9\]+ = 7" "print value of d_instance.d" 190gdb_test "print d_instance.dd" "\\$\[0-9\]+ = 8" "print value of d_instance.dd" 191 192# Print some fields which are defined in the top of class G 193# and in its base classes. This is not be ambiguous. 194 195gdb_test "print g_instance.a" "\\$\[0-9\]+ = 15" "print value of g_instance.a" 196gdb_test "print g_instance.b" "\\$\[0-9\]+ = 16" "print value of g_instance.b" 197gdb_test "print g_instance.c" "\\$\[0-9\]+ = 17" "print value of g_instance.c" 198 199# Print a function call. 200 201gdb_test "print g_instance.afoo()" "\\$\[0-9\]+ = 1" "print value of g_instance.afoo()" 202 203# If GDB fails to restore the selected frame properly after the 204# inferior function call above (see GDB PR 1155 for an explanation of 205# why this might happen), all the subsequent tests will fail. We 206# should detect report that failure, but let the marker call finish so 207# that the rest of the tests can run undisturbed. 208 209gdb_test_multiple "frame" "re-selected 'main' frame after inferior call" { 210 -re "#0 marker1.*$gdb_prompt $" { 211 setup_kfail "gdb/1155" s390-*-linux-gnu 212 fail "re-selected 'main' frame after inferior call" 213 gdb_test "finish" ".*main.*at .*derivation.cc:.*// marker1-returns-here.*" \ 214 "finish call to marker1" 215 } 216 -re "#1 ($hex in )?main.*$gdb_prompt $" { 217 pass "re-selected 'main' frame after inferior call" 218 } 219} 220 221gdb_test "print g_instance.bfoo()" "\\$\[0-9\]+ = 2" "print value of g_instance.bfoo()" 222gdb_test "print g_instance.cfoo()" "\\$\[0-9\]+ = 3" "print value of g_instance.cfoo()" 223 224# Check typedefs of fields 225foreach Klass {"C" "G"} { 226 set klass [string tolower $Klass] 227 set instance "${klass}_instance" 228 set var "${instance}.$klass" 229 gdb_test "whatis $var" "int" 230 gdb_test "ptype $var" "int" 231} 232 233foreach Klass {"A" "B" "D" "E" "F"} { 234 set klass [string tolower $Klass] 235 set instance "${klass}_instance" 236 set var "${instance}.$klass" 237 gdb_test "whatis $var" "A::value_type" 238 gdb_test "ptype $var" "int" 239 if {![string equal $Klass "B"]} { 240 gdb_test "p (${Klass}::value_type) 0" " = 0" 241 } 242} 243 244foreach Klass {"Z" "ZZ"} { 245 set klass [string tolower $Klass] 246 set instance "${klass}_instance" 247 set var "${instance}.$klass" 248 gdb_test "whatis $var" "Z::value_type" 249 gdb_test "ptype $var" "float" 250 gdb_test "p (${Klass}::value_type) 0" " = 0" 251} 252 253# This is a regression test for a bug that caused a crash when trying 254# to print the vtbl pointer. We don't care about the output so much 255# here (it is tested elsewhere), just that gdb doesn't crash. We test 256# "ptype" first because, before the gdb fix, that was the only code 257# path calling get_vptr_fieldno. 258gdb_test "ptype vderived" "type = .*" 259gdb_test "print vderived" " = {.* inter = 0.*x = 0}" 260 261# Test whether inheritance of typedefs is properly 262# reported when stopped. 263gdb_test "ptype N::value_type" "type = double" 264gdb_test "ptype N::Derived::value_type" "type = int" 265 266# Now run to N::Derived::doit and get the type of "value_type" 267if {![runto "N::Derived::doit"]} { 268 return 269} 270 271gdb_test "ptype value_type" "type = int" 272