URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.cp/] [misc.cc] - Rev 841
Go to most recent revision | Compare with Previous | Blame | View Log
/* This testcase is part of GDB, the GNU debugger. Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2007, 2008 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; } }; 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); }; 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; } Foo 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; } 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); } int main() { #ifdef usestubs set_debug_traps(); breakpoint(); #endif 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;
Go to most recent revision | Compare with Previous | Blame | View Log