OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.cp/] [classes.cc] - Blame information for rev 258

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* 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;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.