1 /* This testcase is part of GDB, the GNU debugger.
3 Copyright 1993-2020 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
; }
409 Foo (int i
, int j
) { x
= i
; y
= j
; }
415 class Bar
: public Base1
, public Foo
{
418 Bar (int i
, int j
, int k
) : Base1 (10*k
), Foo (i
, j
) { z
= k
; }
421 int Foo::operator! () { return !x
; }
423 int Foo::times (int y
) { return x
* y
; }
427 Foo::operator int() { return x
; }
432 class ClassWithEnum
{
434 enum PrivEnum
{ red
, green
, blue
, yellow
= 42 };
443 /* classes.exp relies on statement order in this function for testing
444 enumeration fields. */
448 ClassWithEnum obj_with_enum
;
449 obj_with_enum
.priv_enum
= ClassWithEnum::red
;
452 obj_with_enum
.priv_enum
= ClassWithEnum::green
;
457 int Aptr_a (A
*a
) { return a
->a
; }
458 int Aptr_x (A
*a
) { return a
->x
; }
459 int Aref_a (A
&a
) { return a
.a
; }
460 int Aref_x (A
&a
) { return a
.x
; }
461 int Aval_a (A a
) { return a
.a
; }
462 int Aval_x (A a
) { return a
.x
; }
465 ClassParam class_param
;
467 class Contains_static_instance
472 Contains_static_instance (int i
, int j
) { x
= i
; y
= j
; }
473 static Contains_static_instance null
;
476 Contains_static_instance
Contains_static_instance::null(0,0);
477 Contains_static_instance
csi(10,20);
479 class Contains_nested_static_instance
485 Nested(int i
) : z(i
) {}
487 static Contains_nested_static_instance xx
;
490 Contains_nested_static_instance(int i
, int j
) : x(i
), y(j
) {}
495 static Contains_nested_static_instance null
;
499 Contains_nested_static_instance
Contains_nested_static_instance::null(0, 0);
500 Contains_nested_static_instance::Nested
Contains_nested_static_instance::yy(5);
501 Contains_nested_static_instance
502 Contains_nested_static_instance::Nested::xx(1,2);
503 Contains_nested_static_instance
cnsi(30,40);
509 tagless_struct v_tagless
;
511 /* Try to get the compiler to allocate a class in a register. */
524 void marker_reg1 () {}
529 /* We don't call any methods for v, so gcc version cygnus-2.3.3-930220
530 might put this variable in a register. This is a lose, though, because
531 it means that GDB can't call any methods for that variable. */
536 /* Perform a computation sufficiently complicated that optimizing compilers
537 won't optimized out the variable. If some compiler constant-folds this
538 whole loop, maybe using a parameter to this function here would help. */
540 for (i
= 0; i
< 13; ++i
)
542 --v
.x
; /* v.x is now 77 */
550 v_bool_array
[0] = false;
551 v_bool_array
[1] = v_bool
;
556 /* Refer to methods so that they don't get optimized away. */
558 i
= class_param
.Aptr_a (&g_A
);
559 i
= class_param
.Aptr_x (&g_A
);
560 i
= class_param
.Aref_a (g_A
);
561 i
= class_param
.Aref_x (g_A
);
562 i
= class_param
.Aval_a (g_A
);
563 i
= class_param
.Aval_x (g_A
);
576 /* FIXME: pmi gets optimized out. Need to do some more computation with
577 it or something. (No one notices, because the test is xfail'd anyway,
578 but that probably won't always be true...). */
579 int Foo::* pmi
= &Foo::y
;
581 /* Make sure the AIX linker doesn't remove the variable. */
589 /* Create an instance for some classes, otherwise they get optimized away. */
591 default_public_struct default_public_s
;
592 explicit_public_struct explicit_public_s
;
593 protected_struct protected_s
;
594 private_struct private_s
;
595 mixed_protection_struct mixed_protection_s
;
596 public_class public_c
;
597 protected_class protected_c
;
598 default_private_class default_private_c
;
599 explicit_private_class explicit_private_c
;
600 mixed_protection_class mixed_protection_c
;