gdb/testsuite/gdb.cp/classes.exp

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