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 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 ======================= 23bool v_bool; 24bool v_bool_array[2]; 25 26typedef struct fleep fleep; 27struct fleep { int a; } s; 28 29// ====================== simple class structures ======================= 30 31struct default_public_struct { 32 // defaults to public: 33 int a; 34 int b; 35}; 36 37struct explicit_public_struct { 38 public: 39 int a; 40 int b; 41}; 42 43struct protected_struct { 44 protected: 45 int a; 46 int b; 47}; 48 49struct private_struct { 50 private: 51 int a; 52 int b; 53}; 54 55struct 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 73class public_class { 74 public: 75 int a; 76 int b; 77}; 78 79class protected_class { 80 protected: 81 int a; 82 int b; 83}; 84 85class default_private_class { 86 // defaults to private: 87 int a; 88 int b; 89}; 90 91class explicit_private_class { 92 private: 93 int a; 94 int b; 95}; 96 97class 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 115class const_vol_method_class { 116public: 117 int a; 118 int b; 119 int foo (int &) const; 120 int bar (int &) volatile; 121 int baz (int &) const volatile; 122}; 123 124int const_vol_method_class::foo (int & ir) const 125{ 126 return ir + 3; 127} 128int const_vol_method_class::bar (int & ir) volatile 129{ 130 return ir + 4; 131} 132int const_vol_method_class::baz (int & ir) const volatile 133{ 134 return ir + 5; 135} 136 137// ========================= simple inheritance ========================== 138 139class A { 140 public: 141 int a; 142 int x; 143}; 144 145A g_A; 146 147class B : public A { 148 public: 149 int b; 150 int x; 151}; 152 153B g_B; 154 155class C : public A { 156 public: 157 int c; 158 int x; 159}; 160 161C g_C; 162 163class D : public B, public C { 164 public: 165 int d; 166 int x; 167}; 168 169D g_D; 170 171class E : public D { 172 public: 173 int e; 174 int x; 175}; 176 177E g_E; 178 179class class_with_anon_union 180{ 181 public: 182 int one; 183 union 184 { 185 int a; 186 long b; 187 }; 188}; 189 190class_with_anon_union g_anon_union; 191 192void inheritance2 (void) 193{ 194} 195 196void 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 293class Static { 294public: 295 static void ii(int, int); 296}; 297void Static::ii (int, int) { } 298 299// ======================== virtual base classes========================= 300 301class vA { 302 public: 303 int va; 304 int vx; 305}; 306 307vA g_vA; 308 309class vB : public virtual vA { 310 public: 311 int vb; 312 int vx; 313}; 314 315vB g_vB; 316 317class vC : public virtual vA { 318 public: 319 int vc; 320 int vx; 321}; 322 323vC g_vC; 324 325class vD : public virtual vB, public virtual vC { 326 public: 327 int vd; 328 int vx; 329}; 330 331vD g_vD; 332 333class vE : public virtual vD { 334 public: 335 int ve; 336 int vx; 337}; 338 339vE g_vE; 340 341void inheritance4 (void) 342{ 343} 344 345void 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 399class Base1 { 400 public: 401 int x; 402 Base1(int i) { x = i; } 403}; 404 405class 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 417class 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 423int Foo::operator! () { return !x; } 424 425int Foo::times (int y) { return x * y; } 426 427int Foo::st = 100; 428 429Foo::operator int() { return x; } 430 431Foo foo(10, 11); 432Bar bar(20, 21, 22); 433 434class ClassWithEnum { 435public: 436 enum PrivEnum { red, green, blue, yellow = 42 }; 437 PrivEnum priv_enum; 438 int x; 439}; 440 441void enums2 (void) 442{ 443} 444 445/* classes.exp relies on statement order in this function for testing 446 enumeration fields. */ 447 448void 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 458class ClassParam { 459public: 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 468ClassParam class_param; 469 470class 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 479Contains_static_instance Contains_static_instance::null(0,0); 480Contains_static_instance csi(10,20); 481 482class 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 502Contains_nested_static_instance Contains_nested_static_instance::null(0, 0); 503Contains_nested_static_instance::Nested Contains_nested_static_instance::yy(5); 504Contains_nested_static_instance 505 Contains_nested_static_instance::Nested::xx(1,2); 506Contains_nested_static_instance cnsi(30,40); 507 508typedef struct { 509 int one; 510 int two; 511} tagless_struct; 512tagless_struct v_tagless; 513 514/* Try to get the compiler to allocate a class in a register. */ 515class small { 516 public: 517 int x; 518 int method (); 519}; 520 521int 522small::method () 523{ 524 return x + 5; 525} 526 527void marker_reg1 () {} 528 529int 530register_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 550void dummy() 551{ 552 v_bool = true; 553 v_bool_array[0] = false; 554 v_bool_array[1] = v_bool; 555} 556 557void 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 570int 571main() 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 598default_public_struct default_public_s; 599explicit_public_struct explicit_public_s; 600protected_struct protected_s; 601private_struct private_s; 602mixed_protection_struct mixed_protection_s; 603public_class public_c; 604protected_class protected_c; 605default_private_class default_private_c; 606explicit_private_class explicit_private_c; 607mixed_protection_class mixed_protection_c; 608