1 /* This testcase is part of GDB, the GNU debugger.
3 Copyright 1993-2014 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
18 // Test various -*- C++ -*- things.
20 // ====================== basic C++ types =======================
24 typedef struct fleep fleep;
25 struct fleep { int a; } s;
27 // ====================== simple class structures =======================
29 struct default_public_struct {
30 // defaults to public:
35 struct explicit_public_struct {
41 struct protected_struct {
47 struct private_struct {
53 struct mixed_protection_struct {
77 class protected_class {
83 class default_private_class {
84 // defaults to private:
89 class explicit_private_class {
95 class mixed_protection_class {
113 class const_vol_method_class {
117 int foo (int &) const;
118 int bar (int &) volatile;
119 int baz (int &) const volatile;
122 int const_vol_method_class::foo (int & ir) const
126 int const_vol_method_class::bar (int & ir) volatile
130 int const_vol_method_class::baz (int & ir) const volatile
135 // ========================= simple inheritance ==========================
161 class D : public B, public C {
177 class class_with_anon_union
188 class_with_anon_union g_anon_union;
190 void inheritance2 (void)
194 void inheritance1 (void)
204 // {{A::a,A::x},B::b,B::x}
211 // {{A::a,A::x},C::c,C::x}
218 // {{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}
220 // The following initialization code is non-portable, but allows us
221 // to initialize all members of g_D until we can fill in the missing
222 // initialization code with legal C++ code.
224 for (intp = (int *) &g_D, ival = 11;
225 intp < ((int *) &g_D + sizeof (g_D) / sizeof (int));
231 // Overlay the nonportable initialization with legal initialization.
233 // ????? = 11; (g_D.A::a = 11; is ambiguous)
234 // ????? = 12; (g_D.A::x = 12; is ambiguous)
237 This should take care of it. Rather than try to initialize using an ambiguous
238 construct, use 2 unambiguous ones for each. Since the ambiguous a/x member is
239 coming from C, and B, initialize D's C::a, and B::a, and D's C::x and B::x.
255 // {{{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}},E::e,E::x}
257 // The following initialization code is non-portable, but allows us
258 // to initialize all members of g_D until we can fill in the missing
259 // initialization code with legal C++ code.
261 for (intp = (int *) &g_E, ival = 21;
262 intp < ((int *) &g_E + sizeof (g_E) / sizeof (int));
268 // Overlay the nonportable initialization with legal initialization.
270 // ????? = 21; (g_E.A::a = 21; is ambiguous)
271 // ????? = 22; (g_E.A::x = 22; is ambiguous)
283 g_anon_union.one = 1;
289 // ======================== static member functions =====================
293 static void ii(int, int);
295 void Static::ii (int, int) { }
297 // ======================== virtual base classes=========================
307 class vB : public virtual vA {
315 class vC : public virtual vA {
323 class vD : public virtual vB, public virtual vC {
331 class vE : public virtual vD {
339 void inheritance4 (void)
343 void inheritance3 (void)
353 // {{vA::va, vA::vx}, vB::vb, vB::vx}
360 // {{vA::va, vA::vx}, vC::vc, vC::vx}
367 // {{{{vA::va, vA::vx}, vB::vb, vB::vx}, vC::vc, vC::vx}, vD::vd,vD::vx}
379 // {{{{{vA::va,vA::vx},vB::vb,vB::vx},vC::vc,vC::vx},vD::vd,vD::vx},vE::ve,vE::vx}
395 // ======================================================================
400 Base1(int i) { x = i; }
412 Foo (int i, int j) { x = i; y = j; }
418 typedef Foo ByAnyOtherName;
420 class Bar : public Base1, public Foo {
423 Bar (int i, int j, int k) : Base1 (10*k), Foo (i, j) { z = k; }
426 int Foo::operator! () { return !x; }
428 int Foo::times (int y) { return x * y; }
432 Foo::operator int() { return x; }
434 ByAnyOtherName foo(10, 11);
437 class ClassWithEnum {
439 enum PrivEnum { red, green, blue, yellow = 42 };
448 /* classes.exp relies on statement order in this function for testing
449 enumeration fields. */
453 ClassWithEnum obj_with_enum;
454 obj_with_enum.priv_enum = ClassWithEnum::red;
457 obj_with_enum.priv_enum = ClassWithEnum::green;
463 int Aptr_a (A *a) { return a->a; }
464 int Aptr_x (A *a) { return a->x; }
465 int Aref_a (A &a) { return a.a; }
466 int Aref_x (A &a) { return a.x; }
467 int Aval_a (A a) { return a.a; }
468 int Aval_x (A a) { return a.x; }
471 ClassParam class_param;
473 class Contains_static_instance
478 Contains_static_instance (int i, int j) { x = i; y = j; }
479 static Contains_static_instance null;
482 Contains_static_instance Contains_static_instance::null(0,0);
483 Contains_static_instance csi(10,20);
485 class Contains_nested_static_instance
491 Nested(int i) : z(i) {}
493 static Contains_nested_static_instance xx;
496 Contains_nested_static_instance(int i, int j) : x(i), y(j) {}
501 static Contains_nested_static_instance null;
505 Contains_nested_static_instance Contains_nested_static_instance::null(0, 0);
506 Contains_nested_static_instance::Nested Contains_nested_static_instance::yy(5);
507 Contains_nested_static_instance
508 Contains_nested_static_instance::Nested::xx(1,2);
509 Contains_nested_static_instance cnsi(30,40);
515 tagless_struct v_tagless;
517 /* Try to get the compiler to allocate a class in a register. */
530 void marker_reg1 () {}
535 /* We don't call any methods for v, so gcc version cygnus-2.3.3-930220
536 might put this variable in a register. This is a lose, though, because
537 it means that GDB can't call any methods for that variable. */
542 /* Perform a computation sufficiently complicated that optimizing compilers
543 won't optimized out the variable. If some compiler constant-folds this
544 whole loop, maybe using a parameter to this function here would help. */
546 for (i = 0; i < 13; ++i)
548 --v.x; /* v.x is now 77 */
556 v_bool_array[0] = false;
557 v_bool_array[1] = v_bool;
562 /* Refer to methods so that they don't get optimized away. */
564 i = class_param.Aptr_a (&g_A);
565 i = class_param.Aptr_x (&g_A);
566 i = class_param.Aref_a (g_A);
567 i = class_param.Aref_x (g_A);
568 i = class_param.Aval_a (g_A);
569 i = class_param.Aval_x (g_A);
584 /* FIXME: pmi gets optimized out. Need to do some more computation with
585 it or something. (No one notices, because the test is xfail'd anyway,
586 but that probably won't always be true...). */
587 int Foo::* pmi = &Foo::y;
589 /* Make sure the AIX linker doesn't remove the variable. */
597 /* Create an instance for some classes, otherwise they get optimized away. */
599 default_public_struct default_public_s;
600 explicit_public_struct explicit_public_s;
601 protected_struct protected_s;
602 private_struct private_s;
603 mixed_protection_struct mixed_protection_s;
604 public_class public_c;
605 protected_class protected_c;
606 default_private_class default_private_c;
607 explicit_private_class explicit_private_c;
608 mixed_protection_class mixed_protection_c;