gdb/testsuite/gdb.cp/classes.cc

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2004, 2007,
   4    2008 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18    */
  19
  20 // Test various -*- C++ -*- things.
  21
  22 // ====================== basic C++ types  =======================
  23 bool            v_bool;
  24 bool            v_bool_array[2];
  25
  26 typedef struct fleep fleep;
  27 struct fleep { int a; } s;
  28
  29 // ====================== simple class structures  =======================
  30
  31 struct default_public_struct {
  32  // defaults to public:
  33   int a;
  34   int b;
  35 };
  36
  37 struct explicit_public_struct {
  38  public:
  39   int a;
  40   int b;
  41 };
  42
  43 struct protected_struct {
  44  protected:
  45   int a;
  46   int b;
  47 };
  48
  49 struct private_struct {
  50  private:
  51   int a;
  52   int b;
  53 };
  54
  55 struct mixed_protection_struct {
  56  public:
  57   int a;
  58   int b;
  59  private:
  60   int c;
  61   int d;
  62  protected:
  63   int e;
  64   int f;
  65  public:
  66   int g;
  67  private:
  68   int h;
  69  protected:
  70   int i;
  71 };
  72
  73 class public_class {
  74  public:
  75   int a;
  76   int b;
  77 };
  78
  79 class protected_class {
  80  protected:
  81   int a;
  82   int b;
  83 };
  84
  85 class default_private_class {
  86  // defaults to private:
  87   int a;
  88   int b;
  89 };
  90
  91 class explicit_private_class {
  92  private:
  93   int a;
  94   int b;
  95 };
  96
  97 class mixed_protection_class {
  98  public:
  99   int a;
 100   int b;
 101  private:
 102   int c;
 103   int d;
 104  protected:
 105   int e;
 106   int f;
 107  public:
 108   int g;
 109  private:
 110   int h;
 111  protected:
 112   int i;
 113 };
 114
 115 class const_vol_method_class {
 116 public:
 117   int a;
 118   int b;
 119   int foo (int &) const;
 120   int bar (int &) volatile;
 121   int baz (int &) const volatile;
 122 };
 123
 124 int const_vol_method_class::foo (int & ir) const
 125 {
 126   return ir + 3;
 127 }
 128 int const_vol_method_class::bar (int & ir) volatile
 129 {
 130   return ir + 4;
 131 }
 132 int const_vol_method_class::baz (int & ir) const volatile
 133 {
 134   return ir + 5;
 135 }
 136
 137 // ========================= simple inheritance ==========================
 138
 139 class A {
 140  public:
 141   int a;
 142   int x;
 143 };
 144
 145 A g_A;
 146
 147 class B : public A {
 148  public:
 149   int b;
 150   int x;
 151 };
 152
 153 B g_B;
 154
 155 class C : public A {
 156  public:
 157   int c;
 158   int x;
 159 };
 160
 161 C g_C;
 162
 163 class D : public B, public C {
 164  public:
 165   int d;
 166   int x;
 167 };
 168
 169 D g_D;
 170
 171 class E : public D {
 172  public:
 173   int e;
 174   int x;
 175 };
 176
 177 E g_E;
 178
 179 class class_with_anon_union
 180 {
 181  public:
 182   int one;
 183   union
 184   {
 185     int a;
 186     long b;
 187   };
 188 };
 189
 190 class_with_anon_union g_anon_union;
 191
 192 void inheritance2 (void)
 193 {
 194 }
 195
 196 void inheritance1 (void)
 197 {
 198   int ival;
 199   int *intp;
 200
 201   // {A::a, A::x}
 202
 203   g_A.A::a = 1;
 204   g_A.A::x = 2;
 205
 206   // {{A::a,A::x},B::b,B::x}
 207
 208   g_B.A::a = 3;
 209   g_B.A::x = 4;
 210   g_B.B::b = 5;
 211   g_B.B::x = 6;
 212
 213   // {{A::a,A::x},C::c,C::x}
 214
 215   g_C.A::a = 7;
 216   g_C.A::x = 8;
 217   g_C.C::c = 9;
 218   g_C.C::x = 10;
 219
 220   // {{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}
 221
 222   // The following initialization code is non-portable, but allows us
 223   // to initialize all members of g_D until we can fill in the missing
 224   // initialization code with legal C++ code.
 225
 226   for (intp = (int *) &g_D, ival = 11;
 227        intp < ((int *) &g_D + sizeof (g_D) / sizeof (int));
 228        intp++, ival++)
 229     {
 230       *intp = ival;
 231     }
 232
 233   // Overlay the nonportable initialization with legal initialization.
 234
 235   // ????? = 11;  (g_D.A::a = 11; is ambiguous)
 236   // ????? = 12;  (g_D.A::x = 12; is ambiguous)
 237 /* djb 6-3-2000
 238
 239         This should take care of it. Rather than try to initialize using an ambiguous
 240         construct, use 2 unambiguous ones for each. Since the ambiguous a/x member is
 241         coming from C, and B, initialize D's C::a, and B::a, and D's C::x and B::x.
 242  */
 243   g_D.C::a = 15;
 244   g_D.C::x = 12;
 245   g_D.B::a = 11;
 246   g_D.B::x = 12;
 247   g_D.B::b = 13;
 248   g_D.B::x = 14;
 249   // ????? = 15;
 250   // ????? = 16;
 251   g_D.C::c = 17;
 252   g_D.C::x = 18;
 253   g_D.D::d = 19;
 254   g_D.D::x = 20;
 255
 256
 257   // {{{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}},E::e,E::x}
 258
 259   // The following initialization code is non-portable, but allows us
 260   // to initialize all members of g_D until we can fill in the missing
 261   // initialization code with legal C++ code.
 262
 263   for (intp = (int *) &g_E, ival = 21;
 264        intp < ((int *) &g_E + sizeof (g_E) / sizeof (int));
 265        intp++, ival++)
 266   {
 267     *intp = ival;
 268   }
 269
 270   // Overlay the nonportable initialization with legal initialization.
 271
 272   // ????? = 21;  (g_E.A::a = 21; is ambiguous)
 273   // ????? = 22;  (g_E.A::x = 22; is ambiguous)
 274   g_E.B::b = 23;
 275   g_E.B::x = 24;
 276   // ????? = 25;
 277   // ????? = 26;
 278   g_E.C::c = 27;
 279   g_E.C::x = 28;
 280   g_E.D::d = 29;
 281   g_E.D::x = 30;
 282   g_E.E::e = 31;
 283   g_E.E::x = 32;
 284
 285   g_anon_union.one = 1;
 286   g_anon_union.a = 2;
 287
 288   inheritance2 ();
 289 }
 290
 291 // ======================== static member functions =====================
 292
 293 class Static {
 294 public:
 295   static void ii(int, int);
 296 };
 297 void Static::ii (int, int) { }
 298
 299 // ======================== virtual base classes=========================
 300
 301 class vA {
 302  public:
 303   int va;
 304   int vx;
 305 };
 306
 307 vA g_vA;
 308
 309 class vB : public virtual vA {
 310  public:
 311   int vb;
 312   int vx;
 313 };
 314
 315 vB g_vB;
 316
 317 class vC : public virtual vA {
 318  public:
 319   int vc;
 320   int vx;
 321 };
 322
 323 vC g_vC;
 324
 325 class vD : public virtual vB, public virtual vC {
 326  public:
 327   int vd;
 328   int vx;
 329 };
 330
 331 vD g_vD;
 332
 333 class vE : public virtual vD {
 334  public:
 335   int ve;
 336   int vx;
 337 };
 338
 339 vE g_vE;
 340
 341 void inheritance4 (void)
 342 {
 343 }
 344
 345 void inheritance3 (void)
 346 {
 347   int ival;
 348   int *intp;
 349
 350   // {vA::va, vA::vx}
 351
 352   g_vA.vA::va = 1;
 353   g_vA.vA::vx = 2;
 354
 355   // {{vA::va, vA::vx}, vB::vb, vB::vx}
 356
 357   g_vB.vA::va = 3;
 358   g_vB.vA::vx = 4;
 359   g_vB.vB::vb = 5;
 360   g_vB.vB::vx = 6;
 361
 362   // {{vA::va, vA::vx}, vC::vc, vC::vx}
 363
 364   g_vC.vA::va = 7;
 365   g_vC.vA::vx = 8;
 366   g_vC.vC::vc = 9;
 367   g_vC.vC::vx = 10;
 368
 369   // {{{{vA::va, vA::vx}, vB::vb, vB::vx}, vC::vc, vC::vx}, vD::vd,vD::vx}
 370
 371   g_vD.vA::va = 11;
 372   g_vD.vA::vx = 12;
 373   g_vD.vB::vb = 13;
 374   g_vD.vB::vx = 14;
 375   g_vD.vC::vc = 15;
 376   g_vD.vC::vx = 16;
 377   g_vD.vD::vd = 17;
 378   g_vD.vD::vx = 18;
 379
 380
 381   // {{{{{vA::va,vA::vx},vB::vb,vB::vx},vC::vc,vC::vx},vD::vd,vD::vx},vE::ve,vE::vx}
 382
 383   g_vD.vA::va = 19;
 384   g_vD.vA::vx = 20;
 385   g_vD.vB::vb = 21;
 386   g_vD.vB::vx = 22;
 387   g_vD.vC::vc = 23;
 388   g_vD.vC::vx = 24;
 389   g_vD.vD::vd = 25;
 390   g_vD.vD::vx = 26;
 391   g_vE.vE::ve = 27;
 392   g_vE.vE::vx = 28;
 393
 394   inheritance4 ();
 395 }
 396
 397 // ======================================================================
 398
 399 class Base1 {
 400  public:
 401   int x;
 402   Base1(int i) { x = i; }
 403 };
 404
 405 class Foo
 406 {
 407  public:
 408   int x;
 409   int y;
 410   static int st;
 411   Foo (int i, int j) { x = i; y = j; }
 412   int operator! ();
 413   operator int ();
 414   int times (int y);
 415 };
 416
 417 class Bar : public Base1, public Foo {
 418  public:
 419   int z;
 420   Bar (int i, int j, int k) : Base1 (10*k), Foo (i, j) { z = k; }
 421 };
 422
 423 int Foo::operator! () { return !x; }
 424
 425 int Foo::times (int y) { return x * y; }
 426
 427 int Foo::st = 100;
 428
 429 Foo::operator int() { return x; }
 430
 431 Foo foo(10, 11);
 432 Bar bar(20, 21, 22);
 433
 434 class ClassWithEnum {
 435 public:
 436   enum PrivEnum { red, green, blue, yellow = 42 };
 437   PrivEnum priv_enum;
 438   int x;
 439 };
 440
 441 void enums2 (void)
 442 {
 443 }
 444
 445 /* classes.exp relies on statement order in this function for testing
 446    enumeration fields.  */
 447
 448 void enums1 ()
 449 {
 450   ClassWithEnum obj_with_enum;
 451   obj_with_enum.priv_enum = ClassWithEnum::red;
 452   obj_with_enum.x = 0;
 453   enums2 ();
 454   obj_with_enum.priv_enum = ClassWithEnum::green;
 455   obj_with_enum.x = 1;
 456 }
 457
 458 class ClassParam {
 459 public:
 460   int Aptr_a (A *a) { return a->a; }
 461   int Aptr_x (A *a) { return a->x; }
 462   int Aref_a (A &a) { return a.a; }
 463   int Aref_x (A &a) { return a.x; }
 464   int Aval_a (A a) { return a.a; }
 465   int Aval_x (A a) { return a.x; }
 466 };
 467
 468 ClassParam class_param;
 469
 470 class Contains_static_instance
 471 {
 472  public:
 473   int x;
 474   int y;
 475   Contains_static_instance (int i, int j) { x = i; y = j; }
 476   static Contains_static_instance null;
 477 };
 478
 479 Contains_static_instance Contains_static_instance::null(0,0);
 480 Contains_static_instance csi(10,20);
 481
 482 class Contains_nested_static_instance
 483 {
 484  public:
 485   class Nested
 486   {
 487    public:
 488     Nested(int i) : z(i) {}
 489     int z;
 490     static Contains_nested_static_instance xx;
 491   };
 492
 493   Contains_nested_static_instance(int i, int j) : x(i), y(j) {}
 494
 495   int x;
 496   int y;
 497
 498   static Contains_nested_static_instance null;
 499   static Nested yy;
 500 };
 501
 502 Contains_nested_static_instance Contains_nested_static_instance::null(0, 0);
 503 Contains_nested_static_instance::Nested Contains_nested_static_instance::yy(5);
 504 Contains_nested_static_instance
 505   Contains_nested_static_instance::Nested::xx(1,2);
 506 Contains_nested_static_instance cnsi(30,40);
 507
 508 typedef struct {
 509   int one;
 510   int two;
 511 } tagless_struct;
 512 tagless_struct v_tagless;
 513
 514 /* Try to get the compiler to allocate a class in a register.  */
 515 class small {
 516  public:
 517   int x;
 518   int method ();
 519 };
 520
 521 int
 522 small::method ()
 523 {
 524   return x + 5;
 525 }
 526
 527 void marker_reg1 () {}
 528
 529 int
 530 register_class ()
 531 {
 532   /* We don't call any methods for v, so gcc version cygnus-2.3.3-930220
 533      might put this variable in a register.  This is a lose, though, because
 534      it means that GDB can't call any methods for that variable.  */
 535   register small v;
 536
 537   int i;
 538
 539   /* Perform a computation sufficiently complicated that optimizing compilers
 540      won't optimized out the variable.  If some compiler constant-folds this
 541      whole loop, maybe using a parameter to this function here would help.  */
 542   v.x = 0;
 543   for (i = 0; i < 13; ++i)
 544     v.x += i;
 545   --v.x; /* v.x is now 77 */
 546   marker_reg1 ();
 547   return v.x + 5;
 548 }
 549
 550 void dummy()
 551 {
 552   v_bool = true;
 553   v_bool_array[0] = false;
 554   v_bool_array[1] = v_bool;
 555 }
 556
 557 void use_methods ()
 558 {
 559   /* Refer to methods so that they don't get optimized away. */
 560   int i;
 561   i = class_param.Aptr_a (&g_A);
 562   i = class_param.Aptr_x (&g_A);
 563   i = class_param.Aref_a (g_A);
 564   i = class_param.Aref_x (g_A);
 565   i = class_param.Aval_a (g_A);
 566   i = class_param.Aval_x (g_A);
 567 }
 568
 569
 570 int
 571 main()
 572 {
 573 #ifdef usestubs
 574   set_debug_traps();
 575   breakpoint();
 576 #endif
 577   dummy();
 578   inheritance1 ();
 579   inheritance3 ();
 580   enums1 ();
 581   register_class ();
 582
 583   /* FIXME: pmi gets optimized out.  Need to do some more computation with
 584      it or something.  (No one notices, because the test is xfail'd anyway,
 585      but that probably won't always be true...).  */
 586   int Foo::* pmi = &Foo::y;
 587
 588   /* Make sure the AIX linker doesn't remove the variable.  */
 589   v_tagless.one = 5;
 590
 591   use_methods ();
 592
 593   return foo.*pmi;
 594 }
 595
 596 /* Create an instance for some classes, otherwise they get optimized away.  */
 597
 598 default_public_struct default_public_s;
 599 explicit_public_struct explicit_public_s;
 600 protected_struct protected_s;
 601 private_struct private_s;
 602 mixed_protection_struct mixed_protection_s;
 603 public_class public_c;
 604 protected_class protected_c;
 605 default_private_class default_private_c;
 606 explicit_private_class explicit_private_c;
 607 mixed_protection_class mixed_protection_c;