gdb/testsuite/gdb.cp/classes.exp

   1 # Copyright 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   2 # 2004, 2006, 2007, 2008, 2009 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
  20 set nl "\[\r\n\]+"
  21
  22 if $tracelevel then {
  23     strace $tracelevel
  24 }
  25
  26 if { [skip_cplus_tests] } { continue }
  27
  28 load_lib "cp-support.exp"
  29
  30 set testfile "classes"
  31 set srcfile ${testfile}.cc
  32 set binfile ${objdir}/${subdir}/${testfile}
  33
  34 if  { [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
  41 proc 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
 322 proc 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
 349 proc 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
 360 proc 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
 370 proc 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 &param"
 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
 391 proc test_enums {} {
 392     global gdb_prompt
 393     global nl
 394
 395     # print the object
 396
 397     # We match the enum values with and without qualifiers.  As of
 398     # 2008-08-21 we can output the qualifiers for DWARF-2.
 399
 400     gdb_test "print obj_with_enum" \
 401         "\\$\[0-9\]+ = \{priv_enum = (ClassWithEnum::)?red, x = 0\}" \
 402         "print obj_with_enum (1)"
 403
 404     # advance one line
 405
 406     gdb_test "next" ""
 407
 408     # print the object again
 409
 410     gdb_test "print obj_with_enum" \
 411         "\\$\[0-9\]+ = \{priv_enum = (ClassWithEnum::)?green, x = 0\}" \
 412         "print obj_with_enum (2)"
 413
 414     # print the enum member
 415
 416     gdb_test "print obj_with_enum.priv_enum" "\\$\[0-9\]+ = (ClassWithEnum::)?green"
 417
 418     # ptype on the enum member
 419
 420     gdb_test_multiple "ptype obj_with_enum.priv_enum" "ptype obj_with_enum.priv_enum" {
 421         -re "type = enum ClassWithEnum::PrivEnum \{ ?(ClassWithEnum::)?red, (ClassWithEnum::)?green, (ClassWithEnum::)?blue, (ClassWithEnum::)?yellow = 42 ?\}$nl$gdb_prompt $" {
 422             pass "ptype obj_with_enum.priv_enum"
 423         }
 424         -re "type = enum PrivEnum \{ ?(ClassWithEnum::)?red, (ClassWithEnum::)?green, (ClassWithEnum::)?blue, (ClassWithEnum::)?yellow = 42 ?\}$nl$gdb_prompt $" {
 425             # gcc 2.95.3 -gdwarf-2
 426             # gcc 3.3.2 -gdwarf-2
 427             pass "ptype obj_with_enum.priv_enum"
 428         }
 429         -re "type = enum \{ ?red, green, blue, yellow = 42 ?\}$nl$gdb_prompt $" {
 430             # This case case is a little dubious, but it's not clear what
 431             # ought to be required of a ptype on a private enum...
 432             # -sts 19990324
 433             #
 434             # It bugs me that this happens with gcc 3.
 435             # -- chastain 2003-12-30
 436             #
 437             # gcc 2.95.3 -gstabs+
 438             # gcc 3.3.2 -gstabs+
 439             # gcc HEAD 2003-12-28 21:08:30 UTC -gstabs+
 440             pass "ptype obj_with_enum.priv_enum"
 441         }
 442     }
 443
 444     # ptype on the object
 445
 446     # NOTE: carlton/2003-02-28: One could certainly argue that plain
 447     # "PrivEnum"
 448     # is acceptable: PrivEnum is a member of ClassWithEnum, so
 449     # there's no need to explicitly qualify its name with
 450     # "ClassWithEnum::".  The truth, though, is that GDB is simply
 451     # forgetting that PrivEnum is a member of ClassWithEnum, so we do
 452     # that output for a bad reason instead of a good reason.  Under
 453     # stabs, we probably can't get this right; under DWARF-2, we can.
 454
 455     cp_test_ptype_class \
 456         "ptype obj_with_enum" "" "class" "ClassWithEnum" \
 457         {
 458             { field public "ClassWithEnum::PrivEnum priv_enum;" }
 459             { field public "int x;" }
 460         } \
 461         "" \
 462         {
 463             {
 464                 "ClassWithEnum::PrivEnum priv_enum;"
 465                 "PrivEnum priv_enum;"
 466                 { setup_kfail "gdb/57" "*-*-*" }
 467             }
 468         }
 469
 470     # I'll do this test two different ways, because of a parser bug.
 471     # See PR gdb/1588.
 472
 473     gdb_test_multiple "print (ClassWithEnum::PrivEnum) 42" "print (ClassWithEnum::PrivEnum) 42" {
 474         -re "\\$\[0-9\]+ = (ClassWithEnum::)?yellow$nl$gdb_prompt $" {
 475             pass "print (ClassWithEnum::PrivEnum) 42"
 476         }
 477         -re "A (parse|syntax) error in expression, near `42'.$nl$gdb_prompt $" {
 478             # "parse error" is bison 1.35.
 479             # "syntax error" is bison 1.875.
 480             kfail "gdb/1588" "print (ClassWithEnum::PrivEnum) 42"
 481         }
 482     }
 483
 484     gdb_test_multiple "print ('ClassWithEnum::PrivEnum') 42" "print ('ClassWithEnum::PrivEnum') 42" {
 485         -re "\\$\[0-9\]+ = (ClassWithEnum::)?yellow$nl$gdb_prompt $" {
 486             # gcc 3.3.2 -gstabs+
 487             # gcc HEAD 2003-12-28 21:08:30 UTC -gstabs+
 488             pass "print ('ClassWithEnum::PrivEnum') 42"
 489         }
 490         -re "No symbol \"ClassWithEnum::PrivEnum\" in current context.$nl$gdb_prompt $" {
 491             # gcc 2.95.3 -gdwarf-2
 492             # gcc 3.3.2 -gdwarf-2
 493             # gcc HEAD 2003-12-28 21:08:30 UTC -gdwarf-2
 494             # gcc 2.95.3 -gstabs+
 495             kfail "gdb/57" "print ('ClassWithEnum::PrivEnum') 42"
 496         }
 497     }
 498 }
 499
 500 # Pointers to class members
 501
 502 proc test_pointers_to_class_members {} {
 503     gdb_test "print Bar::z" "Cannot reference non-static field \"z\""
 504     gdb_test "print &Foo::x" "\\$\[0-9\]+ = &Foo::x"
 505     gdb_test "print (int)&Foo::x" "\\$\[0-9\]+ = 0"
 506     gdb_test "print (int)&Bar::y == 2*sizeof(int)" "\\$\[0-9\]+ = true"
 507
 508     gdb_test "ptype Bar::z" "type = int"
 509     gdb_test "ptype &Bar::z" "type = int Bar::\\*"
 510
 511     # TODO: this is a bogus test.  It's looking at a variable that
 512     # has not even been declared yet, so it's accessing random junk
 513     # on the stack and comparing that it's NOT equal to a specific
 514     # value.  It's been like this since gdb 4.10 in 1993!
 515     # -- chastain 2004-01-01
 516     gdb_test "print (int)pmi == sizeof(int)" ".* = false"
 517 }
 518
 519 # Test static members.
 520
 521 proc test_static_members {} {
 522     global hex
 523
 524     gdb_test "print Foo::st" "\\$\[0-9\]+ = 100"
 525     gdb_test "set foo.st = 200" "" ""
 526     gdb_test "print bar.st" "\\$\[0-9\]+ = 200"
 527     gdb_test "print &foo.st" "\\$\[0-9\]+ = \\(int ?\\*\\) $hex"
 528     gdb_test "print &Bar::st" "\\$\[0-9\]+ = \\(int ?\\*\\) $hex"
 529     gdb_test "print *\$" "\\$\[0-9\]+ = 200"
 530
 531     gdb_test "set print static-members off" ""
 532     gdb_test "print csi" \
 533         "{x = 10, y = 20}" \
 534         "print csi without static members"
 535     gdb_test "print cnsi" \
 536         "{x = 30, y = 40}" \
 537         "print cnsi without static members"
 538
 539     gdb_test "set print static-members on" ""
 540     gdb_test "print csi" \
 541         "{x = 10, y = 20, static null = {x = 0, y = 0, static null = <same as static member of an already seen type>}}" \
 542         "print csi with static members"
 543     gdb_test "print cnsi" \
 544         "{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>}" \
 545         "print cnsi with static members"
 546 }
 547
 548 proc do_tests {} {
 549     global prms_id
 550     global bug_id
 551     global subdir
 552     global objdir
 553     global srcdir
 554     global binfile
 555     global gdb_prompt
 556     global nl
 557
 558     set prms_id 0
 559     set bug_id 0
 560
 561     # Start with a fresh gdb.
 562
 563     gdb_exit
 564     gdb_start
 565     gdb_reinitialize_dir $srcdir/$subdir
 566     gdb_load $binfile
 567
 568     gdb_test "set language c++" "" ""
 569     gdb_test "set width 0" "" ""
 570
 571     if ![runto_main ] then {
 572         perror "couldn't run to breakpoint"
 573         return
 574     }
 575
 576     gdb_breakpoint inheritance2
 577     gdb_test "continue" ".*Breakpoint .* inheritance2.*" ""
 578
 579     test_ptype_class_objects
 580     test_non_inherited_member_access
 581     test_wrong_class_members
 582     test_nonexistent_members
 583     test_method_param_class
 584
 585     gdb_breakpoint enums2
 586     gdb_test "continue" ".*Breakpoint .* enums2.*" "continue to enums2(\\(\\)|)"
 587     # Leave enums2.  Make sure we reach the next line, in case there
 588     # are any more instructions to finish the function call.
 589     gdb_test_multiple "finish" "" {
 590         -re "enums2 \\(\\);.*$gdb_prompt $" {
 591             gdb_test "next" "" ""
 592         }
 593         -re "$gdb_prompt $" { }
 594     }
 595     test_enums
 596
 597     gdb_test "finish" "" ""
 598     test_pointers_to_class_members
 599     test_static_members
 600
 601     # Now some random tests that were just thrown in here.
 602
 603     gdb_breakpoint marker_reg1
 604     gdb_test "continue" ".*Breakpoint .* marker_reg1.*" ""
 605     gdb_test "finish" "Run till exit from.*" "finish from marker_reg1"
 606
 607     # This class is so small that an instance of it can fit in a register.
 608     # When gdb tries to call a method, it gets embarrassed about taking
 609     # the address of a register.
 610     #
 611     # TODO: I think that message should be a PASS, not an XFAIL.
 612     # gdb prints an informative message and declines to do something
 613     # impossible.
 614     #
 615     # The method call actually succeeds if the compiler allocates very
 616     # small classes in memory instead of registers.  So this test does
 617     # not tell us anything interesting if the call succeeds.
 618     #
 619     # -- chastain 2003-12-31
 620     gdb_test_multiple "print v.method ()" "calling method for small class" {
 621         -re "\\$\[0-9\]+ = 82$nl$gdb_prompt $" {
 622             # gcc 3.3.2 -gdwarf-2
 623             # gcc HEAD 2003-12-28 21:08:30 UTC -gdwarf-2
 624             # gcc 3.3.2 -gstabs+
 625             # gcc HEAD 2003-12-28 21:08:30 UTC -gstabs+
 626             pass "calling method for small class"
 627         }
 628         -re "Address requested for identifier \"v\" which is in register .*$nl$gdb_prompt $" {
 629             # gcc 2.95.3 -gdwarf-2
 630             # gcc 2.95.3 -gstabs+
 631             setup_xfail "*-*-*" 2972
 632             fail "calling method for small class"
 633         }
 634     }
 635 }
 636
 637 do_tests