[thirdparty/binutils-gdb.git] / gdb / testsuite / gdb.cp / classes.cc

/* This testcase is part of GDB, the GNU debugger.

   Copyright 1993-2014 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

// Test various -*- C++ -*- things.

// ====================== basic C++ types  =======================
bool            v_bool;
bool            v_bool_array[2];

typedef struct fleep fleep;
struct fleep { int a; } s;

// ====================== simple class structures  =======================

struct default_public_struct {
 // defaults to public:
  int a;
  int b;
};

struct explicit_public_struct {
 public:
  int a;
  int b;
};

struct protected_struct {
 protected:
  int a;
  int b;
};

struct private_struct {
 private:
  int a;
  int b;
};

struct mixed_protection_struct {
 public:
  int a;
  int b;
 private:
  int c;
  int d;
 protected:
  int e;
  int f;
 public:
  int g;
 private:
  int h;
 protected:
  int i;
};

class public_class {
 public:
  int a;
  int b;
};

class protected_class {
 protected:
  int a;
  int b;
};

class default_private_class {
 // defaults to private:
  int a;
  int b;
};

class explicit_private_class {
 private:
  int a;
  int b;
};

class mixed_protection_class {
 public:
  int a;
  int b;
 private:
  int c;
  int d;
 protected:
  int e;
  int f;
 public:
  int g;
 private:
  int h;
 protected:
  int i;
};

class const_vol_method_class {
public:
  int a;
  int b;
  int foo (int &) const;
  int bar (int &) volatile;
  int baz (int &) const volatile;
};

int const_vol_method_class::foo (int & ir) const
{
  return ir + 3;
}
int const_vol_method_class::bar (int & ir) volatile
{
  return ir + 4;
}
int const_vol_method_class::baz (int & ir) const volatile
{
  return ir + 5;
}

// ========================= simple inheritance ==========================

class A {
 public:
  int a;
  int x;
};

A g_A;

class B : public A {
 public:
  int b;
  int x;
};

B g_B;

class C : public A {
 public:
  int c;
  int x;
};

C g_C;

class D : public B, public C {
 public:
  int d;
  int x;
};

D g_D;

class E : public D {
 public:
  int e;
  int x;
};

E g_E;

class class_with_anon_union
{
 public:
  int one;
  union
  {
    int a;
    long b;
  };
};

class_with_anon_union g_anon_union;

void inheritance2 (void)
{
}

void inheritance1 (void)
{
  int ival;
  int *intp;

  // {A::a, A::x}

  g_A.A::a = 1;
  g_A.A::x = 2;

  // {{A::a,A::x},B::b,B::x}

  g_B.A::a = 3;
  g_B.A::x = 4;
  g_B.B::b = 5;
  g_B.B::x = 6;

  // {{A::a,A::x},C::c,C::x}

  g_C.A::a = 7;
  g_C.A::x = 8;
  g_C.C::c = 9;
  g_C.C::x = 10;

  // {{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}

  // The following initialization code is non-portable, but allows us
  // to initialize all members of g_D until we can fill in the missing
  // initialization code with legal C++ code.

  for (intp = (int *) &g_D, ival = 11;
       intp < ((int *) &g_D + sizeof (g_D) / sizeof (int));
       intp++, ival++)
    {
      *intp = ival;
    }

  // Overlay the nonportable initialization with legal initialization.

  // ????? = 11;  (g_D.A::a = 11; is ambiguous)
  // ????? = 12;  (g_D.A::x = 12; is ambiguous)
/* djb 6-3-2000

	This should take care of it. Rather than try to initialize using an ambiguous
	construct, use 2 unambiguous ones for each. Since the ambiguous a/x member is
	coming from C, and B, initialize D's C::a, and B::a, and D's C::x and B::x.
 */
  g_D.C::a = 15;
  g_D.C::x = 12;
  g_D.B::a = 11;
  g_D.B::x = 12;
  g_D.B::b = 13;
  g_D.B::x = 14;
  // ????? = 15;
  // ????? = 16;
  g_D.C::c = 17;
  g_D.C::x = 18;
  g_D.D::d = 19;
  g_D.D::x = 20;


  // {{{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}},E::e,E::x}

  // The following initialization code is non-portable, but allows us
  // to initialize all members of g_D until we can fill in the missing
  // initialization code with legal C++ code.

  for (intp = (int *) &g_E, ival = 21;
       intp < ((int *) &g_E + sizeof (g_E) / sizeof (int));
       intp++, ival++)
  {
    *intp = ival;
  }

  // Overlay the nonportable initialization with legal initialization.

  // ????? = 21;  (g_E.A::a = 21; is ambiguous)
  // ????? = 22;  (g_E.A::x = 22; is ambiguous)
  g_E.B::b = 23;
  g_E.B::x = 24;
  // ????? = 25;
  // ????? = 26;
  g_E.C::c = 27;
  g_E.C::x = 28;
  g_E.D::d = 29;
  g_E.D::x = 30;
  g_E.E::e = 31;
  g_E.E::x = 32;

  g_anon_union.one = 1;
  g_anon_union.a = 2;

  inheritance2 ();	
}

// ======================== static member functions =====================

class Static {
public:
  static void ii(int, int);
};
void Static::ii (int, int) { }

// ======================== virtual base classes=========================

class vA {
 public:
  int va;
  int vx;
};

vA g_vA;

class vB : public virtual vA {
 public:
  int vb;
  int vx;
};

vB g_vB;

class vC : public virtual vA {
 public:
  int vc;
  int vx;
};

vC g_vC;

class vD : public virtual vB, public virtual vC {
 public:
  int vd;
  int vx;
};

vD g_vD;

class vE : public virtual vD {
 public:
  int ve;
  int vx;
};

vE g_vE;

void inheritance4 (void)
{
}

void inheritance3 (void)
{
  int ival;
  int *intp;

  // {vA::va, vA::vx}

  g_vA.vA::va = 1;
  g_vA.vA::vx = 2;

  // {{vA::va, vA::vx}, vB::vb, vB::vx}

  g_vB.vA::va = 3;
  g_vB.vA::vx = 4;
  g_vB.vB::vb = 5;
  g_vB.vB::vx = 6;

  // {{vA::va, vA::vx}, vC::vc, vC::vx}

  g_vC.vA::va = 7;
  g_vC.vA::vx = 8;
  g_vC.vC::vc = 9;
  g_vC.vC::vx = 10;

  // {{{{vA::va, vA::vx}, vB::vb, vB::vx}, vC::vc, vC::vx}, vD::vd,vD::vx}

  g_vD.vA::va = 11;
  g_vD.vA::vx = 12;
  g_vD.vB::vb = 13;
  g_vD.vB::vx = 14;
  g_vD.vC::vc = 15;
  g_vD.vC::vx = 16;
  g_vD.vD::vd = 17;
  g_vD.vD::vx = 18;


  // {{{{{vA::va,vA::vx},vB::vb,vB::vx},vC::vc,vC::vx},vD::vd,vD::vx},vE::ve,vE::vx}

  g_vD.vA::va = 19;
  g_vD.vA::vx = 20;
  g_vD.vB::vb = 21;
  g_vD.vB::vx = 22;
  g_vD.vC::vc = 23;
  g_vD.vC::vx = 24;
  g_vD.vD::vd = 25;
  g_vD.vD::vx = 26;
  g_vE.vE::ve = 27;
  g_vE.vE::vx = 28;

  inheritance4 ();	
}

// ======================================================================

class Base1 {
 public:
  int x;
  Base1(int i) { x = i; }
  ~Base1 () { }
};

typedef Base1 base1;

class Foo
{
 public:
  int x;
  int y;
  static int st;
  Foo (int i, int j) { x = i; y = j; }
  int operator! ();
  operator int ();
  int times (int y);
};

typedef Foo ByAnyOtherName;

class Bar : public Base1, public Foo {
 public:
  int z;
  Bar (int i, int j, int k) : Base1 (10*k), Foo (i, j) { z = k; }
};

int Foo::operator! () { return !x; }

int Foo::times (int y) { return x * y; }

int Foo::st = 100;

Foo::operator int() { return x; }

ByAnyOtherName foo(10, 11);
Bar bar(20, 21, 22);

class ClassWithEnum {
public:
  enum PrivEnum { red, green, blue, yellow = 42 };
  PrivEnum priv_enum;
  int x;
};

void enums2 (void)
{
}

/* classes.exp relies on statement order in this function for testing
   enumeration fields.  */

void enums1 ()
{
  ClassWithEnum obj_with_enum;
  obj_with_enum.priv_enum = ClassWithEnum::red;
  obj_with_enum.x = 0;
  enums2 ();
  obj_with_enum.priv_enum = ClassWithEnum::green;
  obj_with_enum.x = 1;
}

class ClassParam {
public:
  int Aptr_a (A *a) { return a->a; }
  int Aptr_x (A *a) { return a->x; }
  int Aref_a (A &a) { return a.a; }
  int Aref_x (A &a) { return a.x; }
  int Aval_a (A a) { return a.a; }
  int Aval_x (A a) { return a.x; }
};

ClassParam class_param;

class Contains_static_instance
{
 public:
  int x;
  int y;
  Contains_static_instance (int i, int j) { x = i; y = j; }
  static Contains_static_instance null;
};

Contains_static_instance Contains_static_instance::null(0,0);
Contains_static_instance csi(10,20);

class Contains_nested_static_instance
{
 public:
  class Nested
  {
   public:
    Nested(int i) : z(i) {}
    int z;
    static Contains_nested_static_instance xx;
  };

  Contains_nested_static_instance(int i, int j) : x(i), y(j) {}

  int x;
  int y;

  static Contains_nested_static_instance null;
  static Nested yy;
};

Contains_nested_static_instance Contains_nested_static_instance::null(0, 0);
Contains_nested_static_instance::Nested Contains_nested_static_instance::yy(5);
Contains_nested_static_instance
  Contains_nested_static_instance::Nested::xx(1,2);
Contains_nested_static_instance cnsi(30,40);

typedef struct {
  int one;
  int two;
} tagless_struct;
tagless_struct v_tagless;

/* Try to get the compiler to allocate a class in a register.  */
class small {
 public:
  int x;
  int method ();
};

int
small::method ()
{
  return x + 5;
}

void marker_reg1 () {}

int
register_class ()
{
  /* We don't call any methods for v, so gcc version cygnus-2.3.3-930220
     might put this variable in a register.  This is a lose, though, because
     it means that GDB can't call any methods for that variable.  */
  register small v;

  int i;

  /* Perform a computation sufficiently complicated that optimizing compilers
     won't optimized out the variable.  If some compiler constant-folds this
     whole loop, maybe using a parameter to this function here would help.  */
  v.x = 0;
  for (i = 0; i < 13; ++i)
    v.x += i;
  --v.x; /* v.x is now 77 */
  marker_reg1 ();
  return v.x + 5;
}

void dummy()
{
  v_bool = true;
  v_bool_array[0] = false;
  v_bool_array[1] = v_bool;
}

void use_methods ()
{
  /* Refer to methods so that they don't get optimized away. */
  int i;
  i = class_param.Aptr_a (&g_A);
  i = class_param.Aptr_x (&g_A);
  i = class_param.Aref_a (g_A);
  i = class_param.Aref_x (g_A);
  i = class_param.Aval_a (g_A);
  i = class_param.Aval_x (g_A);

  base1 b (3);
}


int
main()
{
  dummy();
  inheritance1 ();
  inheritance3 ();
  enums1 ();
  register_class ();

  /* FIXME: pmi gets optimized out.  Need to do some more computation with
     it or something.  (No one notices, because the test is xfail'd anyway,
     but that probably won't always be true...).  */
  int Foo::* pmi = &Foo::y;

  /* Make sure the AIX linker doesn't remove the variable.  */
  v_tagless.one = 5;

  use_methods ();

  return foo.*pmi;
}

/* Create an instance for some classes, otherwise they get optimized away.  */

default_public_struct default_public_s;
explicit_public_struct explicit_public_s;
protected_struct protected_s;
private_struct private_s;
mixed_protection_struct mixed_protection_s;
public_class public_c;
protected_class protected_c;
default_private_class default_private_c;
explicit_private_class explicit_private_c;
mixed_protection_class mixed_protection_c;
Commit	Line	Data
ed69573c MC	1	/* This testcase is part of GDB, the GNU debugger.
ed69573c MC	2
ecd75fc8	3	Copyright 1993-2014 Free Software Foundation, Inc.
ed69573c MC	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
a9762ec7	7	the Free Software Foundation; either version 3 of the License, or
ed69573c MC	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.
a9762ec7	14
ed69573c	15	You should have received a copy of the GNU General Public License
47d48711	16	along with this program. If not, see <http://www.gnu.org/licenses/>. */
ed69573c MC	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; }
3fe8f3b3	401	~Base1 () { }
ed69573c MC	402	};
ed69573c MC	403
3fe8f3b3 KS	404	typedef Base1 base1;
3fe8f3b3 KS	405
ed69573c MC	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
40f0318e KS	418	typedef Foo ByAnyOtherName;
40f0318e KS	419
ed69573c MC	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
40f0318e	434	ByAnyOtherName foo(10, 11);
ed69573c MC	435	Bar bar(20, 21, 22);
	436
	437	class ClassWithEnum {
	438	public:
	439	enum PrivEnum { red, green, blue, yellow = 42 };
	440	PrivEnum priv_enum;
	441	int x;
	442	};
	443
	444	void enums2 (void)
	445	{
	446	}
	447
	448	/* classes.exp relies on statement order in this function for testing
	449	enumeration fields. */
	450
	451	void enums1 ()
	452	{
	453	ClassWithEnum obj_with_enum;
	454	obj_with_enum.priv_enum = ClassWithEnum::red;
	455	obj_with_enum.x = 0;
	456	enums2 ();
	457	obj_with_enum.priv_enum = ClassWithEnum::green;
c7414a01	458	obj_with_enum.x = 1;
ed69573c MC	459	}
	460
	461	class ClassParam {
	462	public:
	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; }
	469	};
	470
	471	ClassParam class_param;
	472
	473	class Contains_static_instance
	474	{
	475	public:
	476	int x;
	477	int y;
	478	Contains_static_instance (int i, int j) { x = i; y = j; }
	479	static Contains_static_instance null;
	480	};
	481
	482	Contains_static_instance Contains_static_instance::null(0,0);
	483	Contains_static_instance csi(10,20);
	484
	485	class Contains_nested_static_instance
	486	{
	487	public:
	488	class Nested
	489	{
	490	public:
	491	Nested(int i) : z(i) {}
	492	int z;
	493	static Contains_nested_static_instance xx;
	494	};
	495
	496	Contains_nested_static_instance(int i, int j) : x(i), y(j) {}
	497
	498	int x;
	499	int y;
	500
	501	static Contains_nested_static_instance null;
	502	static Nested yy;
	503	};
	504
	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);
	510
	511	typedef struct {
	512	int one;
	513	int two;
	514	} tagless_struct;
	515	tagless_struct v_tagless;
	516
	517	/* Try to get the compiler to allocate a class in a register. */
	518	class small {
	519	public:
	520	int x;
	521	int method ();
	522	};
523
524	int
525	small::method ()
526	{
527	return x + 5;
528	}
529
530	void marker_reg1 () {}
531
532	int
533	register_class ()
534	{
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. */
538	register small v;
539
540	int i;
541
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. */
545	v.x = 0;
546	for (i = 0; i < 13; ++i)
547	v.x += i;
548	--v.x; /* v.x is now 77 */
549	marker_reg1 ();
550	return v.x + 5;
551	}
552
553	void dummy()
554	{
555	v_bool = true;
556	v_bool_array[0] = false;
557	v_bool_array[1] = v_bool;
558	}
559
560	void use_methods ()
561	{
562	/* Refer to methods so that they don't get optimized away. */
563	int i;
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);
3fe8f3b3 KS	570
3fe8f3b3 KS	571	base1 b (3);
ed69573c MC	572	}
	573
	574
	575	int
	576	main()
	577	{
ed69573c MC	578	dummy();
	579	inheritance1 ();
	580	inheritance3 ();
	581	enums1 ();
	582	register_class ();
	583
	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;
	588
	589	/* Make sure the AIX linker doesn't remove the variable. */
	590	v_tagless.one = 5;
	591
	592	use_methods ();
	593
	594	return foo.*pmi;
	595	}
	596
	597	/* Create an instance for some classes, otherwise they get optimized away. */
	598
	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;