1# Copyright 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2# 2004, 2006, 2007 Free Software Foundation, Inc. 3 4# This program is free software; you can redistribute it and/or modify 5# it under the terms of the GNU General Public License as published by 6# the Free Software Foundation; either version 3 of the License, or 7# (at your option) any later version. 8# 9# This program is distributed in the hope that it will be useful, 10# but WITHOUT ANY WARRANTY; without even the implied warranty of 11# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12# GNU General Public License for more details. 13# 14# You should have received a copy of the GNU General Public License 15# along with this program. If not, see <http://www.gnu.org/licenses/>. 16 17# This file was written by Fred Fish. (fnf@cygnus.com) 18# And rewritten by Michael Chastain <mec.gnu@mindspring.com>. 19 20set nl "\[\r\n\]+" 21 22if $tracelevel then { 23 strace $tracelevel 24} 25 26if { [skip_cplus_tests] } { continue } 27 28load_lib "cp-support.exp" 29 30set testfile "classes" 31set srcfile ${testfile}.cc 32set binfile ${objdir}/${subdir}/${testfile} 33 34if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } { 35 untested classes.exp 36 return -1 37} 38 39# Test ptype of class objects. 40 41proc test_ptype_class_objects {} { 42 43 # Simple type. 44 45 cp_test_ptype_class \ 46 "ptype struct default_public_struct" "" "struct" "default_public_struct" \ 47 { 48 { field public "int a;" } 49 { field public "int b;" } 50 } 51 52 # Another simple type. 53 54 cp_test_ptype_class \ 55 "ptype struct explicit_public_struct" "" "struct" "explicit_public_struct" \ 56 { 57 { field public "int a;" } 58 { field public "int b;" } 59 } 60 61 # Another simple type. 62 63 cp_test_ptype_class \ 64 "ptype struct protected_struct" "" "struct" "protected_struct" \ 65 { 66 { field protected "int a;" } 67 { field protected "int b;" } 68 } 69 70 # Another simple type. 71 72 cp_test_ptype_class \ 73 "ptype struct private_struct" "" "struct" "private_struct" \ 74 { 75 { field private "int a;" } 76 { field private "int b;" } 77 } 78 79 # A bigger type. 80 81 cp_test_ptype_class \ 82 "ptype struct mixed_protection_struct" "" "struct" "mixed_protection_struct" \ 83 { 84 { field public "int a;" } 85 { field public "int b;" } 86 { field private "int c;" } 87 { field private "int d;" } 88 { field protected "int e;" } 89 { field protected "int f;" } 90 { field public "int g;" } 91 { field private "int h;" } 92 { field protected "int i;" } 93 } 94 95 # All that again with "class" instead of "struct". 96 # gdb does not care about the difference anyways. 97 98 cp_test_ptype_class \ 99 "ptype class public_class" "" "class" "public_class" \ 100 { 101 { field public "int a;" } 102 { field public "int b;" } 103 } 104 105 # Another simple type. 106 107 cp_test_ptype_class \ 108 "ptype class protected_class" "" "class" "protected_class" \ 109 { 110 { field protected "int a;" } 111 { field protected "int b;" } 112 } 113 114 # Another simple type. 115 116 cp_test_ptype_class \ 117 "ptype class default_private_class" "" "class" "default_private_class" \ 118 { 119 { field private "int a;" } 120 { field private "int b;" } 121 } 122 123 # Another simple type. 124 125 cp_test_ptype_class \ 126 "ptype class explicit_private_class" "" "class" "explicit_private_class" \ 127 { 128 { field private "int a;" } 129 { field private "int b;" } 130 } 131 132 # A bigger type. 133 134 cp_test_ptype_class \ 135 "ptype class mixed_protection_class" "" "class" "mixed_protection_class" \ 136 { 137 138 { field public "int a;" } 139 { field public "int b;" } 140 { field private "int c;" } 141 { field private "int d;" } 142 { field protected "int e;" } 143 { field protected "int f;" } 144 { field public "int g;" } 145 { field private "int h;" } 146 { field protected "int i;" } 147 } 148 149 # Here are some classes with inheritance. 150 151 # Base class. 152 153 cp_test_ptype_class \ 154 "ptype class A" "" "class" "A" \ 155 { 156 { field public "int a;" } 157 { field public "int x;" } 158 } 159 160 # Derived class. 161 162 cp_test_ptype_class \ 163 "ptype class B" "" "class" "B" \ 164 { 165 { base "public A" } 166 { field public "int b;" } 167 { field public "int x;" } 168 } 169 170 # Derived class. 171 172 cp_test_ptype_class \ 173 "ptype class C" "" "class" "C" \ 174 { 175 { base "public A" } 176 { field public "int c;" } 177 { field public "int x;" } 178 } 179 180 # Derived class, multiple inheritance. 181 182 cp_test_ptype_class \ 183 "ptype class D" "" "class" "D" \ 184 { 185 { base "public B" } 186 { base "public C" } 187 { field public "int d;" } 188 { field public "int x;" } 189 } 190 191 # Derived class. 192 193 cp_test_ptype_class \ 194 "ptype class E" "" "class" "E" \ 195 { 196 { base "public D" } 197 { field public "int e;" } 198 { field public "int x;" } 199 } 200 201 # This is a break from inheritance tests. 202 # 203 # gcc 2.X with stabs (stabs or stabs+?) used to have a problem with 204 # static methods whose name is the same as their argument mangling. 205 206 cp_test_ptype_class \ 207 "ptype class Static" "" "class" "Static" \ 208 { 209 { method public "static void ii(int, int);" } 210 } 211 212 # Here are some virtual inheritance tests. 213 214 # A virtual base class. 215 216 cp_test_ptype_class \ 217 "ptype class vA" "" "class" "vA" \ 218 { 219 { field public "int va;" } 220 { field public "int vx;" } 221 } 222 223 # A derived class with a virtual base. 224 225 cp_test_ptype_class \ 226 "ptype class vB" "" "class" "vB" \ 227 { 228 { base "public virtual vA" } 229 { vbase "vA" } 230 { field public "int vb;" } 231 { field public "int vx;" } 232 } 233 234 # Another derived class with a virtual base. 235 236 cp_test_ptype_class \ 237 "ptype class vC" "" "class" "vC" \ 238 { 239 { base "public virtual vA" } 240 { vbase "vA" } 241 { field public "int vc;" } 242 { field public "int vx;" } 243 } 244 245 # A classic diamond class. 246 247 cp_test_ptype_class \ 248 "ptype class vD" "" "class" "vD" \ 249 { 250 { base "public virtual vB" } 251 { base "public virtual vC" } 252 { vbase "vC" } 253 { vbase "vB" } 254 { field public "int vd;" } 255 { field public "int vx;" } 256 } 257 258 # A class derived from a diamond class. 259 260 cp_test_ptype_class \ 261 "ptype class vE" "" "class" "vE" \ 262 { 263 { base "public virtual vD" } 264 { vbase "vD" } 265 { field public "int ve;" } 266 { field public "int vx;" } 267 } 268 269 # Another inheritance series. 270 271 # A base class. 272 273 cp_test_ptype_class \ 274 "ptype class Base1" "" "class" "Base1" \ 275 { 276 { field public "int x;" } 277 { method public "Base1(int);" } 278 } 279 280 # Another base class. 281 282 cp_test_ptype_class \ 283 "ptype class Foo" "" "class" "Foo" \ 284 { 285 { field public "int x;" } 286 { field public "int y;" } 287 { field public "static int st;" } 288 { method public "Foo(int, int);" } 289 { method public "int operator!();" } 290 { method public "operator int();" } 291 { method public "int times(int);" } 292 } \ 293 "" \ 294 { 295 { 296 "operator int();" 297 "int operator int();" 298 { setup_kfail "gdb/1497" "*-*-*" } 299 } 300 { 301 "operator int();" 302 "int operator int(void);" 303 { setup_kfail "gdb/1497" "*-*-*" } 304 } 305 } 306 307 # A multiple inheritance derived class. 308 309 cp_test_ptype_class \ 310 "ptype class Bar" "" "class" "Bar" \ 311 { 312 { base "public Base1" } 313 { base "public Foo" } 314 { field public "int z;" } 315 { method public "Bar(int, int, int);" } 316 } 317 318} 319 320# Test simple access to class members. 321 322proc test_non_inherited_member_access {} { 323 324 # Print non-inherited members of g_A. 325 gdb_test "print g_A.a" ".* = 1" 326 gdb_test "print g_A.x" ".* = 2" 327 328 # Print non-inherited members of g_B. 329 gdb_test "print g_B.b" ".* = 5" 330 gdb_test "print g_B.x" ".* = 6" 331 332 # Print non-inherited members of g_C. 333 gdb_test "print g_C.c" ".* = 9" 334 gdb_test "print g_C.x" ".* = 10" 335 336 # Print non-inherited members of g_D. 337 gdb_test "print g_D.d" ".* = 19" 338 gdb_test "print g_D.x" ".* = 20" 339 340 # Print non-inherited members of g_E. 341 gdb_test "print g_E.e" ".* = 31" 342 gdb_test "print g_E.x" ".* = 32" 343} 344 345# Test access to members of other classes. 346# gdb should refuse to print them. 347# (I feel old -- I remember when this was legal in C -- chastain). 348 349proc test_wrong_class_members {} { 350 gdb_test "print g_A.b" "There is no member( or method|) named b." 351 gdb_test "print g_B.c" "There is no member( or method|) named c." 352 gdb_test "print g_B.d" "There is no member( or method|) named d." 353 gdb_test "print g_C.b" "There is no member( or method|) named b." 354 gdb_test "print g_C.d" "There is no member( or method|) named d." 355 gdb_test "print g_D.e" "There is no member( or method|) named e." 356} 357 358# Test access to names that are not members of any class. 359 360proc test_nonexistent_members {} { 361 gdb_test "print g_A.y" "There is no member( or method|) named y." 362 gdb_test "print g_B.z" "There is no member( or method|) named z." 363 gdb_test "print g_C.q" "There is no member( or method|) named q." 364 gdb_test "print g_D.p" "There is no member( or method|) named p." 365} 366 367# Call a method that expects a base class parameter with base, inherited, 368# and unrelated class arguments. 369 370proc test_method_param_class {} { 371 gdb_test "call class_param.Aptr_a (&g_A)" ".* = 1" 372 gdb_test "call class_param.Aptr_x (&g_A)" ".* = 2" 373 gdb_test "call class_param.Aptr_a (&g_B)" ".* = 3" 374 gdb_test "call class_param.Aptr_x (&g_B)" ".* = 4" 375 gdb_test "call class_param.Aref_a (g_A)" ".* = 1" 376 gdb_test "call class_param.Aref_x (g_A)" ".* = 2" 377 gdb_test "call class_param.Aref_a (g_B)" ".* = 3" 378 gdb_test "call class_param.Aref_x (g_B)" ".* = 4" 379 gdb_test "call class_param.Aval_a (g_A)" ".* = 1" 380 gdb_test "call class_param.Aval_x (g_A)" ".* = 2" 381 gdb_test "call class_param.Aval_a (g_B)" ".* = 3" 382 gdb_test "call class_param.Aval_x (g_B)" ".* = 4" 383 384 gdb_test "call class_param.Aptr_a (&foo)" "Cannot resolve .*" "unrelated class *param" 385 gdb_test "call class_param.Aref_a (foo)" "Cannot resolve .*" "unrelated class ¶m" 386 gdb_test "call class_param.Aval_a (foo)" "Cannot resolve .*" "unrelated class param" 387} 388 389# Examine a class with an enum field. 390 391proc test_enums {} { 392 global gdb_prompt 393 global nl 394 395 # print the object 396 397 gdb_test "print obj_with_enum" \ 398 "\\$\[0-9\]+ = \{priv_enum = red, x = 0\}" \ 399 "print obj_with_enum (1)" 400 401 # advance one line 402 403 gdb_test "next" "" 404 405 # print the object again 406 407 gdb_test "print obj_with_enum" \ 408 "\\$\[0-9\]+ = \{priv_enum = green, x = 0\}" \ 409 "print obj_with_enum (2)" 410 411 # print the enum member 412 413 gdb_test "print obj_with_enum.priv_enum" "\\$\[0-9\]+ = green" 414 415 # ptype on the enum member 416 417 gdb_test_multiple "ptype obj_with_enum.priv_enum" "ptype obj_with_enum.priv_enum" { 418 -re "type = enum ClassWithEnum::PrivEnum \{ ?red, green, blue, yellow = 42 ?\}$nl$gdb_prompt $" { 419 pass "ptype obj_with_enum.priv_enum" 420 } 421 -re "type = enum PrivEnum \{ ?red, green, blue, yellow = 42 ?\}$nl$gdb_prompt $" { 422 # gcc 2.95.3 -gdwarf-2 423 # gcc 3.3.2 -gdwarf-2 424 pass "ptype obj_with_enum.priv_enum" 425 } 426 -re "type = enum \{ ?red, green, blue, yellow = 42 ?\}$nl$gdb_prompt $" { 427 # This case case is a little dubious, but it's not clear what 428 # ought to be required of a ptype on a private enum... 429 # -sts 19990324 430 # 431 # It bugs me that this happens with gcc 3. 432 # -- chastain 2003-12-30 433 # 434 # gcc 2.95.3 -gstabs+ 435 # gcc 3.3.2 -gstabs+ 436 # gcc HEAD 2003-12-28 21:08:30 UTC -gstabs+ 437 pass "ptype obj_with_enum.priv_enum" 438 } 439 } 440 441 # ptype on the object 442 443 # NOTE: carlton/2003-02-28: One could certainly argue that plain 444 # "PrivEnum" 445 # is acceptable: PrivEnum is a member of ClassWithEnum, so 446 # there's no need to explicitly qualify its name with 447 # "ClassWithEnum::". The truth, though, is that GDB is simply 448 # forgetting that PrivEnum is a member of ClassWithEnum, so we do 449 # that output for a bad reason instead of a good reason. Under 450 # stabs, we probably can't get this right; under DWARF-2, we can. 451 452 cp_test_ptype_class \ 453 "ptype obj_with_enum" "" "class" "ClassWithEnum" \ 454 { 455 { field public "ClassWithEnum::PrivEnum priv_enum;" } 456 { field public "int x;" } 457 } \ 458 "" \ 459 { 460 { 461 "ClassWithEnum::PrivEnum priv_enum;" 462 "PrivEnum priv_enum;" 463 { setup_kfail "gdb/57" "*-*-*" } 464 } 465 } 466 467 # I'll do this test two different ways, because of a parser bug. 468 # See PR gdb/1588. 469 470 gdb_test_multiple "print (ClassWithEnum::PrivEnum) 42" "print (ClassWithEnum::PrivEnum) 42" { 471 -re "\\$\[0-9\]+ = yellow$nl$gdb_prompt $" { 472 pass "print (ClassWithEnum::PrivEnum) 42" 473 } 474 -re "A (parse|syntax) error in expression, near `42'.$nl$gdb_prompt $" { 475 # "parse error" is bison 1.35. 476 # "syntax error" is bison 1.875. 477 kfail "gdb/1588" "print (ClassWithEnum::PrivEnum) 42" 478 } 479 } 480 481 gdb_test_multiple "print ('ClassWithEnum::PrivEnum') 42" "print ('ClassWithEnum::PrivEnum') 42" { 482 -re "\\$\[0-9\]+ = yellow$nl$gdb_prompt $" { 483 # gcc 3.3.2 -gstabs+ 484 # gcc HEAD 2003-12-28 21:08:30 UTC -gstabs+ 485 pass "print ('ClassWithEnum::PrivEnum') 42" 486 } 487 -re "No symbol \"ClassWithEnum::PrivEnum\" in current context.$nl$gdb_prompt $" { 488 # gcc 2.95.3 -gdwarf-2 489 # gcc 3.3.2 -gdwarf-2 490 # gcc HEAD 2003-12-28 21:08:30 UTC -gdwarf-2 491 # gcc 2.95.3 -gstabs+ 492 kfail "gdb/57" "print ('ClassWithEnum::PrivEnum') 42" 493 } 494 } 495} 496 497# Pointers to class members 498 499proc test_pointers_to_class_members {} { 500 gdb_test "print Bar::z" "Cannot reference non-static field \"z\"" 501 gdb_test "print &Foo::x" "\\$\[0-9\]+ = &Foo::x" 502 gdb_test "print (int)&Foo::x" "\\$\[0-9\]+ = 0" 503 gdb_test "print (int)&Bar::y == 2*sizeof(int)" "\\$\[0-9\]+ = true" 504 505 gdb_test "ptype Bar::z" "type = int" 506 gdb_test "ptype &Bar::z" "type = int Bar::\\*" 507 508 # TODO: this is a bogus test. It's looking at a variable that 509 # has not even been declared yet, so it's accessing random junk 510 # on the stack and comparing that it's NOT equal to a specific 511 # value. It's been like this since gdb 4.10 in 1993! 512 # -- chastain 2004-01-01 513 gdb_test "print (int)pmi == sizeof(int)" ".* = false" 514} 515 516# Test static members. 517 518proc test_static_members {} { 519 global hex 520 521 gdb_test "print Foo::st" "\\$\[0-9\]+ = 100" 522 gdb_test "set foo.st = 200" "" "" 523 gdb_test "print bar.st" "\\$\[0-9\]+ = 200" 524 gdb_test "print &foo.st" "\\$\[0-9\]+ = \\(int ?\\*\\) $hex" 525 gdb_test "print &Bar::st" "\\$\[0-9\]+ = \\(int ?\\*\\) $hex" 526 gdb_test "print *\$" "\\$\[0-9\]+ = 200" 527 528 gdb_test "set print static-members off" "" 529 gdb_test "print csi" \ 530 "{x = 10, y = 20}" \ 531 "print csi without static members" 532 gdb_test "print cnsi" \ 533 "{x = 30, y = 40}" \ 534 "print cnsi without static members" 535 536 gdb_test "set print static-members on" "" 537 gdb_test "print csi" \ 538 "{x = 10, y = 20, static null = {x = 0, y = 0, static null = <same as static member of an already seen type>}}" \ 539 "print csi with static members" 540 gdb_test "print cnsi" \ 541 "{x = 30, y = 40, static null = {x = 0, y = 0, static null = <same as static member of an already seen type>, static yy = {z = 5, static xx = {x = 1, y = 2, static null = <same as static member of an already seen type>, static yy = <same as static member of an already seen type>}}}, static yy = <same as static member of an already seen type>}" \ 542 "print cnsi with static members" 543} 544 545proc do_tests {} { 546 global prms_id 547 global bug_id 548 global subdir 549 global objdir 550 global srcdir 551 global binfile 552 global gdb_prompt 553 global nl 554 555 set prms_id 0 556 set bug_id 0 557 558 # Start with a fresh gdb. 559 560 gdb_exit 561 gdb_start 562 gdb_reinitialize_dir $srcdir/$subdir 563 gdb_load $binfile 564 565 gdb_test "set language c++" "" "" 566 gdb_test "set width 0" "" "" 567 568 if ![runto_main ] then { 569 perror "couldn't run to breakpoint" 570 return 571 } 572 573 gdb_breakpoint inheritance2 574 gdb_test "continue" ".*Breakpoint .* inheritance2.*" "" 575 576 test_ptype_class_objects 577 test_non_inherited_member_access 578 test_wrong_class_members 579 test_nonexistent_members 580 test_method_param_class 581 582 gdb_breakpoint enums2 583 gdb_test "continue" ".*Breakpoint .* enums2.*" "continue to enums2(\\(\\)|)" 584 gdb_test "finish" "" "" 585 test_enums 586 587 gdb_test "finish" "" "" 588 test_pointers_to_class_members 589 test_static_members 590 591 # Now some random tests that were just thrown in here. 592 593 gdb_breakpoint marker_reg1 594 gdb_test "continue" ".*Breakpoint .* marker_reg1.*" "" 595 gdb_test "finish" "Run till exit from.*" "finish from marker_reg1" 596 597 # This class is so small that an instance of it can fit in a register. 598 # When gdb tries to call a method, it gets embarrassed about taking 599 # the address of a register. 600 # 601 # TODO: I think that message should be a PASS, not an XFAIL. 602 # gdb prints an informative message and declines to do something 603 # impossible. 604 # 605 # The method call actually succeeds if the compiler allocates very 606 # small classes in memory instead of registers. So this test does 607 # not tell us anything interesting if the call succeeds. 608 # 609 # -- chastain 2003-12-31 610 gdb_test_multiple "print v.method ()" "calling method for small class" { 611 -re "\\$\[0-9\]+ = 82$nl$gdb_prompt $" { 612 # gcc 3.3.2 -gdwarf-2 613 # gcc HEAD 2003-12-28 21:08:30 UTC -gdwarf-2 614 # gcc 3.3.2 -gstabs+ 615 # gcc HEAD 2003-12-28 21:08:30 UTC -gstabs+ 616 pass "calling method for small class" 617 } 618 -re "Address requested for identifier \"v\" which is in register .*$nl$gdb_prompt $" { 619 # gcc 2.95.3 -gdwarf-2 620 # gcc 2.95.3 -gstabs+ 621 setup_xfail "*-*-*" 2972 622 fail "calling method for small class" 623 } 624 } 625} 626 627do_tests 628