5ea360e4d06
[binutils-gdb.git] /
1 /* This testcase is part of GDB, the GNU debugger.
2
3 Copyright 1993-2020 Free Software Foundation, Inc.
4
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.
9
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.
14
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/>. */
17
18 // Test various -*- C++ -*- things.
19
20 // ====================== basic C++ types =======================
21 bool v_bool;
22 bool v_bool_array[2];
23
24 typedef struct fleep fleep;
25 struct fleep { int a; } s;
26
27 // ====================== simple class structures =======================
28
29 struct default_public_struct {
30 // defaults to public:
31 int a;
32 int b;
33 };
34
35 struct explicit_public_struct {
36 public:
37 int a;
38 int b;
39 };
40
41 struct protected_struct {
42 protected:
43 int a;
44 int b;
45 };
46
47 struct private_struct {
48 private:
49 int a;
50 int b;
51 };
52
53 struct mixed_protection_struct {
54 public:
55 int a;
56 int b;
57 private:
58 int c;
59 int d;
60 protected:
61 int e;
62 int f;
63 public:
64 int g;
65 private:
66 int h;
67 protected:
68 int i;
69 };
70
71 class public_class {
72 public:
73 int a;
74 int b;
75 };
76
77 class protected_class {
78 protected:
79 int a;
80 int b;
81 };
82
83 class default_private_class {
84 // defaults to private:
85 int a;
86 int b;
87 };
88
89 class explicit_private_class {
90 private:
91 int a;
92 int b;
93 };
94
95 class mixed_protection_class {
96 public:
97 int a;
98 int b;
99 private:
100 int c;
101 int d;
102 protected:
103 int e;
104 int f;
105 public:
106 int g;
107 private:
108 int h;
109 protected:
110 int i;
111 };
112
113 class const_vol_method_class {
114 public:
115 int a;
116 int b;
117 int foo (int &) const;
118 int bar (int &) volatile;
119 int baz (int &) const volatile;
120 };
121
122 int const_vol_method_class::foo (int & ir) const
123 {
124 return ir + 3;
125 }
126 int const_vol_method_class::bar (int & ir) volatile
127 {
128 return ir + 4;
129 }
130 int const_vol_method_class::baz (int & ir) const volatile
131 {
132 return ir + 5;
133 }
134
135 // ========================= simple inheritance ==========================
136
137 class A {
138 public:
139 int a;
140 int x;
141 };
142
143 A g_A;
144
145 class B : public A {
146 public:
147 int b;
148 int x;
149 };
150
151 B g_B;
152
153 class C : public A {
154 public:
155 int c;
156 int x;
157 };
158
159 C g_C;
160
161 class D : public B, public C {
162 public:
163 int d;
164 int x;
165 };
166
167 D g_D;
168
169 class E : public D {
170 public:
171 int e;
172 int x;
173 };
174
175 E g_E;
176
177 class class_with_anon_union
178 {
179 public:
180 int one;
181 union
182 {
183 int a;
184 long b;
185 };
186 };
187
188 class_with_anon_union g_anon_union;
189
190 void inheritance2 (void)
191 {
192 }
193
194 void inheritance1 (void)
195 {
196 int ival;
197 int *intp;
198
199 // {A::a, A::x}
200
201 g_A.A::a = 1;
202 g_A.A::x = 2;
203
204 // {{A::a,A::x},B::b,B::x}
205
206 g_B.A::a = 3;
207 g_B.A::x = 4;
208 g_B.B::b = 5;
209 g_B.B::x = 6;
210
211 // {{A::a,A::x},C::c,C::x}
212
213 g_C.A::a = 7;
214 g_C.A::x = 8;
215 g_C.C::c = 9;
216 g_C.C::x = 10;
217
218 // {{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}
219
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.
223
224 for (intp = (int *) &g_D, ival = 11;
225 intp < ((int *) &g_D + sizeof (g_D) / sizeof (int));
226 intp++, ival++)
227 {
228 *intp = ival;
229 }
230
231 // Overlay the nonportable initialization with legal initialization.
232
233 // ????? = 11; (g_D.A::a = 11; is ambiguous)
234 // ????? = 12; (g_D.A::x = 12; is ambiguous)
235 /* djb 6-3-2000
236
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.
240 */
241 g_D.C::a = 15;
242 g_D.C::x = 12;
243 g_D.B::a = 11;
244 g_D.B::x = 12;
245 g_D.B::b = 13;
246 g_D.B::x = 14;
247 // ????? = 15;
248 // ????? = 16;
249 g_D.C::c = 17;
250 g_D.C::x = 18;
251 g_D.D::d = 19;
252 g_D.D::x = 20;
253
254
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}
256
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.
260
261 for (intp = (int *) &g_E, ival = 21;
262 intp < ((int *) &g_E + sizeof (g_E) / sizeof (int));
263 intp++, ival++)
264 {
265 *intp = ival;
266 }
267
268 // Overlay the nonportable initialization with legal initialization.
269
270 // ????? = 21; (g_E.A::a = 21; is ambiguous)
271 // ????? = 22; (g_E.A::x = 22; is ambiguous)
272 g_E.B::b = 23;
273 g_E.B::x = 24;
274 // ????? = 25;
275 // ????? = 26;
276 g_E.C::c = 27;
277 g_E.C::x = 28;
278 g_E.D::d = 29;
279 g_E.D::x = 30;
280 g_E.E::e = 31;
281 g_E.E::x = 32;
282
283 g_anon_union.one = 1;
284 g_anon_union.a = 2;
285
286 inheritance2 ();
287 }
288
289 // ======================== static member functions =====================
290
291 class Static {
292 public:
293 static void ii(int, int);
294 };
295 void Static::ii (int, int) { }
296
297 // ======================== virtual base classes=========================
298
299 class vA {
300 public:
301 int va;
302 int vx;
303 };
304
305 vA g_vA;
306
307 class vB : public virtual vA {
308 public:
309 int vb;
310 int vx;
311 };
312
313 vB g_vB;
314
315 class vC : public virtual vA {
316 public:
317 int vc;
318 int vx;
319 };
320
321 vC g_vC;
322
323 class vD : public virtual vB, public virtual vC {
324 public:
325 int vd;
326 int vx;
327 };
328
329 vD g_vD;
330
331 class vE : public virtual vD {
332 public:
333 int ve;
334 int vx;
335 };
336
337 vE g_vE;
338
339 void inheritance4 (void)
340 {
341 }
342
343 void inheritance3 (void)
344 {
345 int ival;
346 int *intp;
347
348 // {vA::va, vA::vx}
349
350 g_vA.vA::va = 1;
351 g_vA.vA::vx = 2;
352
353 // {{vA::va, vA::vx}, vB::vb, vB::vx}
354
355 g_vB.vA::va = 3;
356 g_vB.vA::vx = 4;
357 g_vB.vB::vb = 5;
358 g_vB.vB::vx = 6;
359
360 // {{vA::va, vA::vx}, vC::vc, vC::vx}
361
362 g_vC.vA::va = 7;
363 g_vC.vA::vx = 8;
364 g_vC.vC::vc = 9;
365 g_vC.vC::vx = 10;
366
367 // {{{{vA::va, vA::vx}, vB::vb, vB::vx}, vC::vc, vC::vx}, vD::vd,vD::vx}
368
369 g_vD.vA::va = 11;
370 g_vD.vA::vx = 12;
371 g_vD.vB::vb = 13;
372 g_vD.vB::vx = 14;
373 g_vD.vC::vc = 15;
374 g_vD.vC::vx = 16;
375 g_vD.vD::vd = 17;
376 g_vD.vD::vx = 18;
377
378
379 // {{{{{vA::va,vA::vx},vB::vb,vB::vx},vC::vc,vC::vx},vD::vd,vD::vx},vE::ve,vE::vx}
380
381 g_vD.vA::va = 19;
382 g_vD.vA::vx = 20;
383 g_vD.vB::vb = 21;
384 g_vD.vB::vx = 22;
385 g_vD.vC::vc = 23;
386 g_vD.vC::vx = 24;
387 g_vD.vD::vd = 25;
388 g_vD.vD::vx = 26;
389 g_vE.vE::ve = 27;
390 g_vE.vE::vx = 28;
391
392 inheritance4 ();
393 }
394
395 // ======================================================================
396
397 class Base1 {
398 public:
399 int x;
400 Base1(int i) { x = i; }
401 ~Base1 () { }
402 };
403
404 typedef Base1 base1;
405
406 class Foo
407 {
408 public:
409 int x;
410 int y;
411 static int st;
412 Foo (int i, int j) { x = i; y = j; }
413 int operator! ();
414 operator int ();
415 int times (int y);
416 };
417
418 typedef Foo ByAnyOtherName;
419
420 class Bar : public Base1, public Foo {
421 public:
422 int z;
423 Bar (int i, int j, int k) : Base1 (10*k), Foo (i, j) { z = k; }
424 };
425
426 int Foo::operator! () { return !x; }
427
428 int Foo::times (int y) { return x * y; }
429
430 int Foo::st = 100;
431
432 Foo::operator int() { return x; }
433
434 ByAnyOtherName foo(10, 11);
435 Bar bar(20, 21, 22);
436
437 /* Use a typedef for the baseclass to exercise gnu-v3-abi.c:gnuv3_dynamic_class
438 recursion. It's important that the class itself have no name to make sure
439 the typedef makes it through to the recursive call. */
440 typedef class {
441 public:
442 int x;
443 virtual int get_x () { return x; }
444 } DynamicBase2;
445
446 class DynamicBar : public DynamicBase2
447 {
448 public:
449 DynamicBar (int i, int j) { x = i; y = j; }
450 int y;
451 };
452
453 DynamicBar dynbar (23, 24);
454
455 class ClassWithEnum {
456 public:
457 enum PrivEnum { red, green, blue, yellow = 42 };
458 PrivEnum priv_enum;
459 int x;
460 };
461
462 void enums2 (void)
463 {
464 }
465
466 /* classes.exp relies on statement order in this function for testing
467 enumeration fields. */
468
469 void enums1 ()
470 {
471 ClassWithEnum obj_with_enum;
472 obj_with_enum.priv_enum = ClassWithEnum::red;
473 obj_with_enum.x = 0;
474 enums2 ();
475 obj_with_enum.priv_enum = ClassWithEnum::green;
476 obj_with_enum.x = 1;
477 }
478
479 class ClassParam {
480 public:
481 int Aptr_a (A *a) { return a->a; }
482 int Aptr_x (A *a) { return a->x; }
483 int Aref_a (A &a) { return a.a; }
484 int Aref_x (A &a) { return a.x; }
485 int Aval_a (A a) { return a.a; }
486 int Aval_x (A a) { return a.x; }
487 };
488
489 ClassParam class_param;
490
491 class Contains_static_instance
492 {
493 public:
494 int x;
495 int y;
496 Contains_static_instance (int i, int j) { x = i; y = j; }
497 static Contains_static_instance null;
498 };
499
500 Contains_static_instance Contains_static_instance::null(0,0);
501 Contains_static_instance csi(10,20);
502
503 class Contains_nested_static_instance
504 {
505 public:
506 class Nested
507 {
508 public:
509 Nested(int i) : z(i) {}
510 int z;
511 static Contains_nested_static_instance xx;
512 };
513
514 Contains_nested_static_instance(int i, int j) : x(i), y(j) {}
515
516 int x;
517 int y;
518
519 static Contains_nested_static_instance null;
520 static Nested yy;
521 };
522
523 Contains_nested_static_instance Contains_nested_static_instance::null(0, 0);
524 Contains_nested_static_instance::Nested Contains_nested_static_instance::yy(5);
525 Contains_nested_static_instance
526 Contains_nested_static_instance::Nested::xx(1,2);
527 Contains_nested_static_instance cnsi(30,40);
528
529 typedef struct {
530 int one;
531 int two;
532 } tagless_struct;
533 tagless_struct v_tagless;
534
535 /* Try to get the compiler to allocate a class in a register. */
536 class small {
537 public:
538 int x;
539 int method ();
540 };
541
542 int
543 small::method ()
544 {
545 return x + 5;
546 }
547
548 class class_with_typedefs
549 {
550 public:
551 typedef int public_int;
552 protected:
553 typedef int protected_int;
554 private:
555 typedef int private_int;
556
557 public:
558 class_with_typedefs ()
559 : public_int_ (1), protected_int_ (2), private_int_ (3) {}
560 public_int add_public (public_int a) { return a + public_int_; }
561 public_int add_all (int a)
562 { return add_public (a) + add_protected (a) + add_private (a); }
563
564 protected:
565 protected_int add_protected (protected_int a) { return a + protected_int_; }
566
567 private:
568 private_int add_private (private_int a) { return a + private_int_; }
569
570 protected:
571 public_int public_int_;
572 protected_int protected_int_;
573 private_int private_int_;
574 };
575
576 class class_with_public_typedef
577 {
578 int a;
579 public:
580 typedef int INT;
581 INT b;
582 };
583
584 class class_with_protected_typedef
585 {
586 int a;
587 protected:
588 typedef int INT;
589 INT b;
590 };
591
592 class class_with_private_typedef
593 {
594 int a;
595 private:
596 typedef int INT;
597 INT b;
598 };
599
600 struct struct_with_public_typedef
601 {
602 int a;
603 public:
604 typedef int INT;
605 INT b;
606 };
607
608 struct struct_with_protected_typedef
609 {
610 int a;
611 protected:
612 typedef int INT;
613 INT b;
614 };
615
616 struct struct_with_private_typedef
617 {
618 int a;
619 private:
620 typedef int INT;
621 INT b;
622 };
623
624 void marker_reg1 () {}
625
626 int
627 register_class ()
628 {
629 /* We don't call any methods for v, so gcc version cygnus-2.3.3-930220
630 might put this variable in a register. This is a lose, though, because
631 it means that GDB can't call any methods for that variable. */
632 register small v;
633
634 int i;
635
636 /* Perform a computation sufficiently complicated that optimizing compilers
637 won't optimized out the variable. If some compiler constant-folds this
638 whole loop, maybe using a parameter to this function here would help. */
639 v.x = 0;
640 for (i = 0; i < 13; ++i)
641 v.x += i;
642 --v.x; /* v.x is now 77 */
643 marker_reg1 ();
644 return v.x + 5;
645 }
646
647 void dummy()
648 {
649 v_bool = true;
650 v_bool_array[0] = false;
651 v_bool_array[1] = v_bool;
652 }
653
654 void use_methods ()
655 {
656 /* Refer to methods so that they don't get optimized away. */
657 int i;
658 i = class_param.Aptr_a (&g_A);
659 i = class_param.Aptr_x (&g_A);
660 i = class_param.Aref_a (g_A);
661 i = class_param.Aref_x (g_A);
662 i = class_param.Aval_a (g_A);
663 i = class_param.Aval_x (g_A);
664
665 base1 b (3);
666 }
667
668 struct Inner
669 {
670 static Inner instance;
671 };
672
673 struct Outer
674 {
675 Inner inner;
676 static Outer instance;
677 };
678
679 Inner Inner::instance;
680 Outer Outer::instance;
681
682 int
683 main()
684 {
685 dummy();
686 inheritance1 ();
687 inheritance3 ();
688 enums1 ();
689 register_class ();
690
691 /* FIXME: pmi gets optimized out. Need to do some more computation with
692 it or something. (No one notices, because the test is xfail'd anyway,
693 but that probably won't always be true...). */
694 int Foo::* pmi = &Foo::y;
695
696 /* Make sure the AIX linker doesn't remove the variable. */
697 v_tagless.one = 5;
698
699 use_methods ();
700
701 return foo.*pmi;
702 }
703
704 /* Create an instance for some classes, otherwise they get optimized away. */
705
706 default_public_struct default_public_s;
707 explicit_public_struct explicit_public_s;
708 protected_struct protected_s;
709 private_struct private_s;
710 mixed_protection_struct mixed_protection_s;
711 public_class public_c;
712 protected_class protected_c;
713 default_private_class default_private_c;
714 explicit_private_class explicit_private_c;
715 mixed_protection_class mixed_protection_c;
716 class_with_typedefs class_with_typedefs_c;
717 class_with_public_typedef class_with_public_typedef_c;
718 class_with_protected_typedef class_with_protected_typedef_c;
719 class_with_private_typedef class_with_private_typedef_c;
720 struct_with_public_typedef struct_with_public_typedef_s;
721 struct_with_protected_typedef struct_with_protected_typedef_s;
722 struct_with_private_typedef struct_with_private_typedef_s;