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

Subversion Repositories openrisc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk/gnu-old/gcc-4.2.2/gcc/testsuite/g++.dg/eh
    from Rev 154 to Rev 816
    ↔ Reverse comparison
  •

Rev 154 → Rev 816

/uncaught1.C
0,0 → 1,84
// PR libstdc++/10606
// { dg-do run }
// { dg-options "-fuse-cxa-get-exception-ptr" { target powerpc*-*-darwin* } }
 
#include <exception>
#include <cstdlib>
 
 
struct Check {
int obj1, obj2;
bool state;
};
 
static Check const data[] = {
{ 0, 0, false }, // construct [0]
{ 1, 0, true }, // [1] = [0]
{ 0, 0, true }, // destruct [0]
{ 2, 1, true }, // [2] = [1]
{ 2, 2, true }, // destruct [2]
{ 3, 1, true }, // [3] = [1]
{ 3, 3, false }, // destruct [3]
{ 1, 1, false }, // destruct [1]
{ 9, 9, false } // end-of-data
};
 
static int pos = 0;
 
static void test(int obj1, int obj2, bool state)
{
if (obj1 != data[pos].obj1) abort ();
if (obj2 != data[pos].obj2) abort ();
if (state != data[pos].state) abort ();
pos++;
}
 
 
struct S {
int id;
S ();
S (const S &);
~S ();
};
 
static int next_id = 0;
 
S::S()
: id (next_id++)
{
test (id, id, std::uncaught_exception ());
}
 
S::S(const S &x)
: id (next_id++)
{
test (id, x.id, std::uncaught_exception ());
}
 
S::~S()
{
test (id, id, std::uncaught_exception ());
}
 
extern void foo (S *);
 
int main()
{
try
{
try
{
S s0;
throw s0; // s1 is the exception object
}
catch (S s2)
{
throw;
}
}
catch (S s3)
{
}
return 0;
}
uncaught1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: uncaught3.C =================================================================== --- uncaught3.C (nonexistent) +++ uncaught3.C (revision 816) @@ -0,0 +1,84 @@ +// { dg-do compile { target powerpc*-*-darwin* } } +// { dg-final { scan-assembler-not "__cxa_get_exception" } } +// { dg-options "-mmacosx-version-min=10.4" } + +#include +#include + + +struct Check { + int obj1, obj2; + bool state; +}; + +static Check const data[] = { + { 0, 0, false }, // construct [0] + { 1, 0, true }, // [1] = [0] + { 0, 0, true }, // destruct [0] + { 2, 1, true }, // [2] = [1] + { 2, 2, true }, // destruct [2] + { 3, 1, true }, // [3] = [1] + { 3, 3, false }, // destruct [3] + { 1, 1, false }, // destruct [1] + { 9, 9, false } // end-of-data +}; + +static int pos = 0; + +static void test(int obj1, int obj2, bool state) +{ + if (obj1 != data[pos].obj1) abort (); + if (obj2 != data[pos].obj2) abort (); + if (state != data[pos].state) abort (); + pos++; +} + + +struct S { + int id; + S (); + S (const S &); + ~S (); +}; + +static int next_id = 0; + +S::S() + : id (next_id++) +{ + test (id, id, std::uncaught_exception ()); +} + +S::S(const S &x) + : id (next_id++) +{ + test (id, x.id, std::uncaught_exception ()); +} + +S::~S() +{ + test (id, id, std::uncaught_exception ()); +} + +extern void foo (S *); + +int main() +{ + try + { + try + { + S s0; + throw s0; // s1 is the exception object + } + catch (S s2) + { + throw; + } + } + catch (S s3) + { + } + + return 0; +}
uncaught3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ia64-2.C =================================================================== --- ia64-2.C (nonexistent) +++ ia64-2.C (revision 816) @@ -0,0 +1,57 @@ +// PR target/30230 +// This testcase failed on IA-64, where end of an EH region ended +// in the middle of a bundle (with br.call insn in first or second +// slot of .bbb/.mbb bundles and EH region end right after it). +// But br.call returns to the start of the next bundlem so during +// unwinding the call was considered to be outside of the EH region +// while it should have been inside. +// { dg-options "-O2" } +// { dg-do run } + +struct A {}; +struct B { virtual ~B(); }; +B::~B () {} +struct C { void foo (short &, B &); }; +struct D { void *d1; C *d2; virtual void virt (void) {} }; +struct E { D *e1; B *e2; }; +struct F { void bar (void *, B &); }; +F *p __attribute__((weak)); +volatile int r; + +void C::foo (short &x, B &) +{ + if (r) + throw A (); + x = 1; +} + +void F::bar (void *, B &) +{ + throw A (); +} + +void baz (E &x) +{ + short g = 0; + B b = *x.e2; + x.e1->d2->foo (g, b); + if (g) + p->bar(x.e1->d1, b); +} + +int main () +{ + F g; + D s; + E h; + p = &g; + h.e1 = &s; + try + { + baz (h); + } + catch (A &) + { + } + return 0; +}
ia64-2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: elide1.C =================================================================== --- elide1.C (nonexistent) +++ elide1.C (revision 816) @@ -0,0 +1,30 @@ +// PR c++/13944 + +// Bug: When eliding the copy from the A temporary into the exception +// object, we extended the throw prohibition to the constructor for the +// temporary. This is wrong; the throw from A() should propagate normally +// regardless of the elision of the temporary. + +// { dg-do run } + +struct A +{ + A() { throw 0; } +}; + +int main() +{ + try + { + throw A(); + } + catch(int i) + { + return i; + } + catch (...) + { + return 2; + } + return 3; +}
elide1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: catch1.C =================================================================== --- catch1.C (nonexistent) +++ catch1.C (revision 816) @@ -0,0 +1,8 @@ +// PR c++/28250 +// { dg-do compile } + +template void foo() +{ + try {} + catch (int(0)) {} // { dg-error "before" } +}
catch1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spbp.C =================================================================== --- spbp.C (nonexistent) +++ spbp.C (revision 816) @@ -0,0 +1,27 @@ +/* { dg-do run } */ +/* { dg-options "-gdwarf-2" } */ +/* { dg-skip-if "No Dwarf" { { *-*-aix* hppa*-*-hpux* *-*-solaris2.[56]* } && { ! hppa*64*-*-* } } { "*" } { "" } } */ + +/* This was a bug on x86-darwin, where the register numbering for SP + and BP was swapped (it's easy to do because on that port it's + different for eh_frame and debug_frame). */ + +#include + +void f1(int t) +{ + char u[t]; + throw 1; +} + +int main() +{ + bool b = true; + try { + f1(100); + } catch (int x) { + if (b) + exit (0); + } + abort (); +}
spbp.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: catch3.C =================================================================== --- catch3.C (nonexistent) +++ catch3.C (revision 816) @@ -0,0 +1,10 @@ +// PR c++/28250 +// { dg-do compile } + +template void foo() +{ + try {} + catch () {} // { dg-error "type-specifier" } +} + +template void foo<0>();
catch3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: shadow1.C =================================================================== --- shadow1.C (nonexistent) +++ shadow1.C (revision 816) @@ -0,0 +1,32 @@ +// Copyright (C) 2004 Free Software Foundation, Inc. +// Contributed by Nathan Sidwell 15 Oct 2004 + +// We forgot to ignore current context and friends when determing +// which exceptions shadowed eachother. + +struct E; + +struct B {}; + +struct D : private B +{ + friend class E; + + static B *baz (D *); + virtual void V () throw (B); // { dg-error "overriding" "" } +}; + +struct E : public D +{ + virtual void V () throw (D); // { dg-error "looser throw" "" } +}; + +B* foo (D *); + +B *D::baz (D *p) +{ + try {foo (p);} + catch (B const &b) {} + catch (D const &d) {} + return p; +}
shadow1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: filter2.C =================================================================== --- filter2.C (nonexistent) +++ filter2.C (revision 816) @@ -0,0 +1,59 @@ +// Test that terminate gets run when a catch filter fails to match while +// running destructors. Original bug depended on a::~a being inlined. +// { dg-do run } +// { dg-options -O } + +#include +#include + +struct e1 {}; +struct e2 {}; + +struct a +{ + a () { } + + ~a () + { + try + { + throw e1(); + } + catch (e2 &) + { + } + } +}; + +void +ex_test () +{ + a aa; + try + { + throw e1 (); + } + catch (e2 &) + { + } +} + +void my_terminate () +{ + std::exit (0); +} + +int +main () +{ + std::set_terminate (my_terminate); + + try + { + ex_test (); + } + catch (...) + { + } + abort (); +}
filter2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cleanup2.C =================================================================== --- cleanup2.C (nonexistent) +++ cleanup2.C (revision 816) @@ -0,0 +1,46 @@ +// PR c++/12491 +// { dg-do compile } +// { dg-options "-O2" } + +// The return statements are necessary to trigger this bug. + +class Object +{ +public: + virtual ~Object (void) { return; } +}; + +class AutoPtr +{ +public: + ~AutoPtr (void) { delete m_rep; return; } +private: + const Object *m_rep; +}; + +class Handle +{ +public: + ~Handle (void) { return; } +private: + AutoPtr m_rep; +}; + +class HandleOf:public Handle +{ +public: + ~HandleOf (void) { return; } +}; + +class Error +{ +public: + ~Error (void); +private: + HandleOf m_hndl; +}; + +Error::~Error (void) +{ + return; +}
cleanup2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cleanup4.C =================================================================== --- cleanup4.C (nonexistent) +++ cleanup4.C (revision 816) @@ -0,0 +1,17 @@ +// PR 16254 +// { dg-do compile } +// We lost a CLEANUP_POINT_EXPR, leading to a crash destroying temp of A. + +struct A +{ + ~A (); + A (int); +}; + +int bar (const A &); + +void +foo (int i) +{ + int format[1] = { bar (A (i)) }; +}
cleanup4.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: forced1.C =================================================================== --- forced1.C (nonexistent) +++ forced1.C (revision 816) @@ -0,0 +1,82 @@ +// HP-UX libunwind.so doesn't provide _UA_END_OF_STACK. +// { dg-do run { xfail "ia64-hp-hpux11.*" } } + +// Test that forced unwinding runs all cleanups. Also tests that +// rethrowing doesn't call the exception object destructor. + +#include +#include +#include + +static int test = 0; + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + { + if (test != 15) + abort (); + exit (0); + } + + return _URC_NO_REASON; +} + +static void +force_unwind_cleanup (_Unwind_Reason_Code, struct _Unwind_Exception *) +{ + abort (); +} + +static void force_unwind () +{ + _Unwind_Exception *exc = new _Unwind_Exception; + // exception_class might not be a scalar. + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = force_unwind_cleanup; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +struct S +{ + int bit; + S(int b) : bit(b) { } + ~S() { test |= bit; } +}; + +static __attribute__ ((noinline)) void doit () +{ + try { + S four(4); + + try { + S one(1); + force_unwind (); + } catch(...) { + test |= 2; + throw; + } + + } catch(...) { + test |= 8; + throw; + } +} + +int main() +{ + doit (); + abort (); +}
forced1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: forced3.C =================================================================== --- forced3.C (nonexistent) +++ forced3.C (revision 816) @@ -0,0 +1,58 @@ +// HP-UX libunwind.so doesn't provide _UA_END_OF_STACK. +// { dg-do run { xfail "ia64-hp-hpux11.*" } } + +// Test that forced unwinding calls std::unexpected going +// throw a nothrow function. + +#include +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void __attribute__((noreturn)) +force_unwind () +{ + _Unwind_Exception *exc = new _Unwind_Exception; + // exception_class might not be a scalar. + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = 0; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +static void +handle_unexpected () +{ + exit (0); +} + +static void +doit () throw() +{ + force_unwind (); +} + +int main() +{ + std::set_unexpected (handle_unexpected); + doit (); + abort (); +}
forced3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: table.C =================================================================== --- table.C (nonexistent) +++ table.C (revision 816) @@ -0,0 +1,33 @@ +// { dg-do compile { target *-*-darwin* } } +// { dg-final { scan-assembler "GCC_except_table0" } } +void needed(); +void unneeded(); + +class Bar +{ +public: + Bar() {} + virtual ~Bar() {} + + void unneeded(); +}; + +void needed() +{ + Bar b; +} + +//#if 0 +void unneeded() +{ + Bar b; + b.unneeded(); +} +//#endif + +int main() +{ + needed(); + + return 0; +}
table.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ctor2.C =================================================================== --- ctor2.C (nonexistent) +++ ctor2.C (revision 816) @@ -0,0 +1,42 @@ +// PR c++/4460 +// Test that the cleanup for fully-constructed subobjects when a +// constructor throws gets the right address for a virtual base. + +// { dg-do run } + +int r; +void *p; + +struct VBase +{ + virtual void f () {} + VBase() { p = this; } + ~VBase() { if (p != this) r = 1; } +}; + +struct StreamBase +{ + virtual ~StreamBase() {} +}; + +struct Stream : public virtual VBase, public StreamBase +{ + Stream() {} + virtual ~Stream() {} +}; + +struct DerivedStream : public Stream +{ + DerivedStream() { throw 1; } +}; + +int main() { + + try + { + DerivedStream str; + } + catch (...) { } + + return r; +}
ctor2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: goto1.C =================================================================== --- goto1.C (nonexistent) +++ goto1.C (revision 816) @@ -0,0 +1,34 @@ +extern "C" void abort (); + +static int count; + +struct S { + S() { ++count; } + ~S() { --count; } +}; + +int foo(int p) +{ + S s1; + { + S s2; + if (p) + goto L; + else + return 1; + } + foo (p); + L: + return 0; +} + +int main() +{ + foo(0); + if (count != 0) + abort (); + foo(1); + if (count != 0) + abort (); + return 0; +}
goto1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dtor1.C =================================================================== --- dtor1.C (nonexistent) +++ dtor1.C (revision 816) @@ -0,0 +1,35 @@ +// PR c++/411 + +// Test that a fully-constructed base is destroyed before transferring +// control to the handler of a function-try-block. + +// { dg-do run } + +int ad; +int r; + +struct A { + ~A() { ++ad; } +}; + +struct B: public A { + ~B(); +}; + +B::~B () +try + { + throw 1; + } +catch (...) + { + if (!ad) + r = 1; + return; + } + +int main () +{ + { B b; } + return r; +}
dtor1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: simd-2.C =================================================================== --- simd-2.C (nonexistent) +++ simd-2.C (revision 816) @@ -0,0 +1,55 @@ +// Test EH when V4SI SIMD registers are involved. +// Contributed by Aldy Hernandez (aldy@quesejoda.com). +// { dg-options "-O" } +// { dg-options "-O -w" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } +// { dg-options "-O -w" { target powerpc*-*-* } } +// { dg-options "-O -w -maltivec" { target { powerpc*-*-linux* && powerpc_altivec_ok } } } +// { dg-options "-O -w -maltivec" { target { powerpc*-*-darwin* && powerpc_altivec_ok } } } +// { dg-xfail-if "" { "powerpc-*-eabispe*" "powerpc-ibm-aix*" } { "*" } { "" } } +// { dg-do run } + +#include "check-vect.h" + +typedef int __attribute__((vector_size (16))) vecint; + +vecint vecfunc (vecint beachbum) +{ + return beachbum; +} + +void f3 (void) +{ + vecint foobar = (vecint) {0, 0}; + foobar = vecfunc (foobar); + + throw int(); +} + +void f2 (void) +{ + vecint foobar = (vecint) {0, 0}; + foobar = vecfunc (foobar); + + f3 (); +} + +void f1 (void) +{ + int i; + try + { + f2 (); + } + catch (int) + { + i = 9; + } +} + +int main () +{ + /* Exit with zero if the hardware does not support AltiVec instructions. */ + check_vect (); + f1 (); + return 0; +}
simd-2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: template1.C =================================================================== --- template1.C (nonexistent) +++ template1.C (revision 816) @@ -0,0 +1,38 @@ +// Test whether exception specifier dependent on template parameter +// is accepted during template decl processing. +// { dg-do run } + +extern "C" void abort(); + +class A {}; + +template +struct B +{ + typedef A E; +}; + +template +struct C +{ + typedef B D; + typedef typename D::E E; + void f() throw(E) { throw E(); } +}; + +int main() +{ + int caught = 0; + try + { + C x; + x.f(); + } + catch (A) + { + ++caught; + } + if (caught != 1) + abort (); + return 0; +}
template1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: simd-4.C =================================================================== --- simd-4.C (nonexistent) +++ simd-4.C (revision 816) @@ -0,0 +1,70 @@ +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fexceptions -fnon-call-exceptions -O -maltivec" } */ + +#include +#include +#include + +typedef int __attribute__((vector_size(16))) v; + +v vv[32]; +volatile v vt = { 1, 2, 3, 4 }; + +void clobber_vrs(void) { }; + +void (*volatile fp)() = clobber_vrs; + +void thrower(int sig) +{ + v v00 = vv[ 0]; + v v01 = vv[ 1]; + v v02 = vv[ 2]; + v v03 = vv[ 3]; + v v04 = vv[ 4]; + v v05 = vv[ 5]; + v v06 = vv[ 6]; + v v07 = vv[ 7]; + v v08 = vv[ 8]; + v v09 = vv[ 9]; + v v10 = vv[10]; + v v11 = vv[11]; + v v12 = vv[12]; + + fp(); + + vv[ 0] = v00; + vv[ 1] = v01; + vv[ 2] = v02; + vv[ 3] = v03; + vv[ 4] = v04; + vv[ 5] = v05; + vv[ 6] = v06; + vv[ 7] = v07; + vv[ 8] = v08; + vv[ 9] = v09; + vv[10] = v10; + vv[11] = v11; + vv[12] = v12; + + throw 3; +} + +v v2; + +int main(void) +{ + v v1 = vt; + if (signal (SIGBUS, thrower) == SIG_ERR) + abort (); + if (signal (SIGSEGV, thrower) == SIG_ERR) + abort (); + try { + *(volatile int *)0 = 0; + abort (); + } catch (int x) { + } + v2 = v1; + if (memcmp (&v2, (v *)&vt, sizeof (v2)) != 0) + abort (); + return 0; +}
simd-4.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cond2.C =================================================================== --- cond2.C (nonexistent) +++ cond2.C (revision 816) @@ -0,0 +1,19 @@ +// PR c++/14083 + +struct A { + A() throw() { } + A(const A&) throw() { } +}; + +struct X { + A a; + X(); + X& operator=(const X& __str); +}; + +bool operator==(const X& __lhs, const char* __rhs); + +int main() { + X x; + x=="" ? x : throw 1; +}
cond2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spec1.C =================================================================== --- spec1.C (nonexistent) +++ spec1.C (revision 816) @@ -0,0 +1,5 @@ +// Check that we allow an exception specification on a reference-to-function. +// { dg-do compile } + +void f () throw (); +void (&fp)() throw () = f;
spec1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cast1.C =================================================================== --- cast1.C (nonexistent) +++ cast1.C (revision 816) @@ -0,0 +1,10 @@ +// PR c++/28523 + +class A {}; +class B : public A {}; + +int main() +{ + throw (A) B(); + return 0; +}
cast1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spec3.C =================================================================== --- spec3.C (nonexistent) +++ spec3.C (revision 816) @@ -0,0 +1,24 @@ +// PR c++/4381 +// Test that exception-specs work properly for classes with virtual bases. + +// { dg-do run } + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +void func() throw (B,A) +{ + throw A(); +} + +int main(void) +{ + try { func(); } + catch (A& a) { } +}
spec3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: omit-frame-pointer.C =================================================================== --- omit-frame-pointer.C (nonexistent) +++ omit-frame-pointer.C (revision 816) @@ -0,0 +1,25 @@ +// { dg-do run } +// { dg-options -fomit-frame-pointer } + +#include + +class Bug +{ +}; + +int throw_bug() +{ + throw Bug(); + + return 0; +} + +int main() +{ + try { + std::cout << throw_bug(); + } catch (Bug bug) { + }; + + return 0; +}
omit-frame-pointer.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spec5.C =================================================================== --- spec5.C (nonexistent) +++ spec5.C (revision 816) @@ -0,0 +1,22 @@ +// Test for extension to allow incomplete types in an +// exception-specification for a declaration. + +// { dg-do run } +// { dg-options "-fpermissive -w" } + +struct A; + +struct B +{ + void f () throw (A); +}; + +struct A {}; + +void B::f () throw (A) {} + +int main () +{ + B b; + b.f(); +}
spec5.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spec7.C =================================================================== --- spec7.C (nonexistent) +++ spec7.C (revision 816) @@ -0,0 +1,35 @@ +// PR 14535 +// { dg-do run } +// { dg-options "-O -finline" } +// +// Original test case failure required that Raiser constructor be inlined. + +extern "C" void abort(); +bool destructor_called = false; + +struct B { + virtual void Run(){}; +}; + +struct D : public B { + virtual void Run() + { + struct O { + ~O() { destructor_called = true; }; + } o; + + struct Raiser { + Raiser() throw( int ) {throw 1;}; + } raiser; + }; +}; + +int main() { + try { + D d; + static_cast(d).Run(); + } catch (...) {} + + if (!destructor_called) + abort (); +}
spec7.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: check-vect.h =================================================================== --- check-vect.h (nonexistent) +++ check-vect.h (revision 816) @@ -0,0 +1,26 @@ +/* Check if system supports SIMD. Copied from gcc.dg/vect/tree-vect.h. */ +#include + +extern "C" void abort (void); +extern "C" void exit (int); + +void +sig_ill_handler (int sig) +{ + exit(0); +} + +void check_vect (void) +{ + signal(SIGILL, sig_ill_handler); +#if defined(__ppc__) || defined(__ppc64__) || defined(__powerpc__) || defined(powerpc) + /* Altivec instruction, 'vor %v0,%v0,%v0'. */ + asm volatile (".long 0x10000484"); +#elif defined(__i386__) || defined(__x86_64__) + /* SSE2 instruction: movsd %xmm0,%xmm0 */ + asm volatile (".byte 0xf2,0x0f,0x10,0xc0"); +#elif defined(__sparc__) + asm volatile (".word\t0x81b007c0"); +#endif + signal (SIGILL, SIG_DFL); +}
check-vect.h Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: throw1.C =================================================================== --- throw1.C (nonexistent) +++ throw1.C (revision 816) @@ -0,0 +1,9 @@ +class S +{ +public: + S(){} +}; + +int foo(char* m1) { + throw (m1 ? S() : S()); +}
throw1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: stabilize.C =================================================================== --- stabilize.C (nonexistent) +++ stabilize.C (revision 816) @@ -0,0 +1,26 @@ +// PR c++/8186 + +// Bug: In f, convert_for_arg_passing wrapped the A TARGET_EXPR in an +// ADDR_EXPR for passing by invisible ref. stabilize_throw_expr copied the +// resulting pointer into a temporary. cp_convert_parm_for_inlining then +// dereferences it and tries to initialize B::am with the INDIRECT_REF, +// which calls for a bitwise copy. Which is broken. + +// { dg-options "-O" } + +struct A +{ + A(); + A(const A&); + A& operator=(const A&); +}; + +struct B { + A am; + B(A a) { am = a; } +}; + +void f () +{ + throw B(A()); +}
stabilize.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: throw3.C =================================================================== --- throw3.C (nonexistent) +++ throw3.C (revision 816) @@ -0,0 +1,8 @@ +// PR c++/19312 + +struct A {}; + +void foo(A a) +{ + throw (A)a; +}
throw3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: synth2.C =================================================================== --- synth2.C (nonexistent) +++ synth2.C (revision 816) @@ -0,0 +1,24 @@ +// PR c++/24580 +// { dg-do run } + +struct vbase {}; + +struct foo : virtual vbase +{ + foo() + { + throw "exception in foo ctor"; + } +}; + +struct bar : public foo {}; + +int main() +{ + try + { + bar a; + } + catch ( ... ) { } + return 0; +}
synth2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: registers1.C =================================================================== --- registers1.C (nonexistent) +++ registers1.C (revision 816) @@ -0,0 +1,138 @@ +// Try to check that registers are preserved when the stack is unwound. +// { dg-do run } +// { dg-options -O2 } + +extern "C" void exit(int); +extern "C" void abort(); + +// This test case triggers up to DEPTH recursive calls to function +// foo(), These calls are numbered so that 0 is the innermost, 1 the +// second innermost, and so on. Each call caches NUM_VARS elements of +// both DOUBLE_SRC and INT_SRC and applies a trivial operation to each +// cached value. The innermost foo() call will throw an integer call +// number. The specified call should store its cached values in +// DOUBLE_DEST and INT_DEST, which main() will check. +const int num_vars = 16; +const int depth = 3; + +float float_src[num_vars * depth]; +float float_dest[num_vars]; + +int int_src[num_vars * depth]; +int int_dest[num_vars]; + +void foo (int level, int throw_to) +{ + float *fsrc = &float_src[level * num_vars]; + float f00 = *fsrc++ + 1.0f; + float f01 = *fsrc++ + 1.0f; + float f02 = *fsrc++ + 1.0f; + float f03 = *fsrc++ + 1.0f; + float f04 = *fsrc++ + 1.0f; + float f05 = *fsrc++ + 1.0f; + float f06 = *fsrc++ + 1.0f; + float f07 = *fsrc++ + 1.0f; + float f08 = *fsrc++ + 1.0f; + float f09 = *fsrc++ + 1.0f; + float f10 = *fsrc++ + 1.0f; + float f11 = *fsrc++ + 1.0f; + float f12 = *fsrc++ + 1.0f; + float f13 = *fsrc++ + 1.0f; + float f14 = *fsrc++ + 1.0f; + float f15 = *fsrc++ + 1.0f; + + int *isrc = &int_src[level * num_vars]; + int i00 = *isrc++ + 1; + int i01 = *isrc++ + 1; + int i02 = *isrc++ + 1; + int i03 = *isrc++ + 1; + int i04 = *isrc++ + 1; + int i05 = *isrc++ + 1; + int i06 = *isrc++ + 1; + int i07 = *isrc++ + 1; + int i08 = *isrc++ + 1; + int i09 = *isrc++ + 1; + int i10 = *isrc++ + 1; + int i11 = *isrc++ + 1; + int i12 = *isrc++ + 1; + int i13 = *isrc++ + 1; + int i14 = *isrc++ + 1; + int i15 = *isrc++ + 1; + + try + { + if (level == 0) + throw throw_to; + else + foo (level - 1, throw_to); + } + catch (int i) + { + if (i == level) + { + float *fdest = float_dest; + *fdest++ = f00; + *fdest++ = f01; + *fdest++ = f02; + *fdest++ = f03; + *fdest++ = f04; + *fdest++ = f05; + *fdest++ = f06; + *fdest++ = f07; + *fdest++ = f08; + *fdest++ = f09; + *fdest++ = f10; + *fdest++ = f11; + *fdest++ = f12; + *fdest++ = f13; + *fdest++ = f14; + *fdest++ = f15; + + int *idest = int_dest; + *idest++ = i00; + *idest++ = i01; + *idest++ = i02; + *idest++ = i03; + *idest++ = i04; + *idest++ = i05; + *idest++ = i06; + *idest++ = i07; + *idest++ = i08; + *idest++ = i09; + *idest++ = i10; + *idest++ = i11; + *idest++ = i12; + *idest++ = i13; + *idest++ = i14; + *idest++ = i15; + } + else + { + throw; + } + } +} + +int main () +{ + for (int i = 0; i < depth * num_vars; i++) + { + int_src[i] = i * i; + float_src[i] = i * 2.0f; + } + for (int level = 0; level < depth; level++) + for (int throw_to = 0; throw_to <= level; throw_to++) + { + foo (level, throw_to); + float *fsrc = &float_src[throw_to * num_vars]; + int *isrc = &int_src[throw_to * num_vars]; + for (int i = 0; i < num_vars; i++) + { + if (int_dest[i] != isrc[i] + 1) + abort (); + if (float_dest[i] != fsrc[i] + 1.0f) + abort (); + } + } + exit (0); +}
registers1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: weak1-a.cc =================================================================== --- weak1-a.cc (nonexistent) +++ weak1-a.cc (revision 816) @@ -0,0 +1,3 @@ +extern void f() { + throw 7; +} Index: pr29166.C =================================================================== --- pr29166.C (nonexistent) +++ pr29166.C (revision 816) @@ -0,0 +1,197 @@ +// PR 29166: r4-r7 corrupted when unwinding. +// { dg-do run } + +class Ex +{ +public: + int val; + + Ex( int v ) + : val( v ) + { } + +}; + +void doIt() +{ + int OFF( 1000 ); + register int v1=OFF+1,v2=OFF+2,v3=OFF+3,v4=OFF+4,v5=OFF+5,v6=OFF+6,v7=OFF+7,v8=OFF+8,v9=OFF+9,v10=OFF+10; + register int v11=OFF+11,v12=OFF+12,v13=OFF+13,v14=OFF+14,v15=OFF+15,v16=OFF+16,v17=OFF+17,v18=OFF+18,v19=OFF+19,v20=OFF+20; + register int v21=OFF+21,v22=OFF+22,v23=OFF+23,v24=OFF+24,v25=OFF+25,v26=OFF+26,v27=OFF+27,v28=OFF+28,v29=OFF+29,v30=OFF+30; + register int v31=OFF+31,v32=OFF+32,v33=OFF+33,v34=OFF+34,v35=OFF+35,v36=OFF+36,v37=OFF+37,v38=OFF+38,v39=OFF+39,v40=OFF+40; + register int v41=OFF+41,v42=OFF+42,v43=OFF+43,v44=OFF+44,v45=OFF+45,v46=OFF+46,v47=OFF+47,v48=OFF+48,v49=OFF+49,v50=OFF+50; + register int v51=OFF+51,v52=OFF+52,v53=OFF+53,v54=OFF+54,v55=OFF+55,v56=OFF+56,v57=OFF+57,v58=OFF+58,v59=OFF+59,v60=OFF+60; + register int v61=OFF+61,v62=OFF+62,v63=OFF+63,v64=OFF+64,v65=OFF+65,v66=OFF+66,v67=OFF+67,v68=OFF+68,v69=OFF+69,v70=OFF+70; + register int v71=OFF+71,v72=OFF+72,v73=OFF+73,v74=OFF+74,v75=OFF+75,v76=OFF+76,v77=OFF+77,v78=OFF+78,v79=OFF+79,v80=OFF+80; + register int v81=OFF+81,v82=OFF+82,v83=OFF+83,v84=OFF+84,v85=OFF+85,v86=OFF+86,v87=OFF+87,v88=OFF+88,v89=OFF+89,v90=OFF+90; + register int v91=OFF+91,v92=OFF+92,v93=OFF+93,v94=OFF+94,v95=OFF+95,v96=OFF+96,v97=OFF+97,v98=OFF+98,v99=OFF+99,v100=OFF+100; + register int v101=OFF+101,v102=OFF+102,v103=OFF+103,v104=OFF+104,v105=OFF+105,v106=OFF+106,v107=OFF+107,v108=OFF+108,v109=OFF+109,v110=OFF+110; + register int v111=OFF+111,v112=OFF+112,v113=OFF+113,v114=OFF+114,v115=OFF+115,v116=OFF+116,v117=OFF+117,v118=OFF+118,v119=OFF+119,v120=OFF+120; + register int v121=OFF+121,v122=OFF+122,v123=OFF+123,v124=OFF+124,v125=OFF+125,v126=OFF+126,v127=OFF+127,v128=OFF+128,v129=OFF+129,v130=OFF+130; + register int v131=OFF+131,v132=OFF+132,v133=OFF+133,v134=OFF+134,v135=OFF+135,v136=OFF+136,v137=OFF+137,v138=OFF+138,v139=OFF+139,v140=OFF+140; + register int v141=OFF+141,v142=OFF+142,v143=OFF+143,v144=OFF+144,v145=OFF+145,v146=OFF+146,v147=OFF+147,v148=OFF+148,v149=OFF+149,v150=OFF+150; + register int v151=OFF+151,v152=OFF+152,v153=OFF+153,v154=OFF+154,v155=OFF+155,v156=OFF+156,v157=OFF+157,v158=OFF+158,v159=OFF+159,v160=OFF+160; + register int v161=OFF+161,v162=OFF+162,v163=OFF+163,v164=OFF+164,v165=OFF+165,v166=OFF+166,v167=OFF+167,v168=OFF+168,v169=OFF+169,v170=OFF+170; + register int v171=OFF+171,v172=OFF+172,v173=OFF+173,v174=OFF+174,v175=OFF+175,v176=OFF+176,v177=OFF+177,v178=OFF+178,v179=OFF+179,v180=OFF+180; + register int v181=OFF+181,v182=OFF+182,v183=OFF+183,v184=OFF+184,v185=OFF+185,v186=OFF+186,v187=OFF+187,v188=OFF+188,v189=OFF+189,v190=OFF+190; + register int v191=OFF+191,v192=OFF+192,v193=OFF+193,v194=OFF+194,v195=OFF+195,v196=OFF+196,v197=OFF+197,v198=OFF+198,v199=OFF+199,v200=OFF+200; + register int v201=OFF+201,v202=OFF+202,v203=OFF+203,v204=OFF+204,v205=OFF+205,v206=OFF+206,v207=OFF+207,v208=OFF+208,v209=OFF+209,v210=OFF+210; + register int v211=OFF+211,v212=OFF+212,v213=OFF+213,v214=OFF+214,v215=OFF+215,v216=OFF+216,v217=OFF+217,v218=OFF+218,v219=OFF+219,v220=OFF+220; + register int v231=OFF+231,v232=OFF+232,v233=OFF+233,v234=OFF+234,v235=OFF+235,v236=OFF+236,v237=OFF+237,v238=OFF+238,v239=OFF+239,v240=OFF+240; + register int v241=OFF+241,v242=OFF+242,v243=OFF+243,v244=OFF+244,v245=OFF+245,v246=OFF+246,v247=OFF+247,v248=OFF+248,v249=OFF+249,v250=OFF+250; + register int v251=OFF+251,v252=OFF+252,v253=OFF+253,v254=OFF+254,v255=OFF+255,v256=OFF+256,v257=OFF+257,v258=OFF+258,v259=OFF+259,v260=OFF+260; + register int v261=OFF+261,v262=OFF+262,v263=OFF+263,v264=OFF+264,v265=OFF+265,v266=OFF+266,v267=OFF+267,v268=OFF+268,v269=OFF+269,v270=OFF+270; + register int v271=OFF+271,v272=OFF+272,v273=OFF+273,v274=OFF+274,v275=OFF+275,v276=OFF+276,v277=OFF+277,v278=OFF+278,v279=OFF+279,v280=OFF+280; + register int v281=OFF+281,v282=OFF+282,v283=OFF+283,v284=OFF+284,v285=OFF+285,v286=OFF+286,v287=OFF+287,v288=OFF+288,v289=OFF+289,v290=OFF+290; + register int v291=OFF+291,v292=OFF+292,v293=OFF+293,v294=OFF+294,v295=OFF+295,v296=OFF+296,v297=OFF+297,v298=OFF+298,v299=OFF+299,v300=OFF+300; + + register int sum = 0; + sum +=v1+v2+v3+v4+v5+v6+v7+v8+v9+v10; + sum +=v11+v12+v13+v14+v15+v16+v17+v18+v19+v20; + sum +=v21+v22+v23+v24+v25+v26+v27+v28+v29+v30; + sum +=v31+v32+v33+v34+v35+v36+v37+v38+v39+v40; + sum +=v41+v42+v43+v44+v45+v46+v47+v48+v49+v50; + sum +=v51+v52+v53+v54+v55+v56+v57+v58+v59+v60; + sum +=v61+v62+v63+v64+v65+v66+v67+v68+v69+v70; + sum +=v71+v72+v73+v74+v75+v76+v77+v78+v79+v80; + sum +=v81+v82+v83+v84+v85+v86+v87+v88+v89+v90; + sum +=v91+v92+v93+v94+v95+v96+v97+v98+v99+v100; + sum +=v101+v102+v103+v104+v105+v106+v107+v108+v109+v110; + sum +=v111+v112+v113+v114+v115+v116+v117+v118+v119+v120; + sum +=v121+v122+v123+v124+v125+v126+v127+v128+v129+v130; + sum +=v131+v132+v133+v134+v135+v136+v137+v138+v139+v140; + sum +=v141+v142+v143+v144+v145+v146+v147+v148+v149+v150; + sum +=v151+v152+v153+v154+v155+v156+v157+v158+v159+v160; + sum +=v161+v162+v163+v164+v165+v166+v167+v168+v169+v170; + sum +=v171+v172+v173+v174+v175+v176+v177+v178+v179+v180; + sum +=v181+v182+v183+v184+v185+v186+v187+v188+v189+v190; + sum +=v191+v192+v193+v194+v195+v196+v197+v198+v199+v200; + sum +=v201+v202+v203+v204+v205+v206+v207+v208+v209+v210; + sum +=v211+v212+v213+v214+v215+v216+v217+v218+v219+v220; + sum +=v231+v232+v233+v234+v235+v236+v237+v238+v239+v240; + sum +=v241+v242+v243+v244+v245+v246+v247+v248+v249+v250; + sum +=v251+v252+v253+v254+v255+v256+v257+v258+v259+v260; + sum +=v261+v262+v263+v264+v265+v266+v267+v268+v269+v270; + sum +=v271+v272+v273+v274+v275+v276+v277+v278+v279+v280; + sum +=v281+v282+v283+v284+v285+v286+v287+v288+v289+v290; + sum +=v291+v292+v293+v294+v295+v296+v297+v298+v299+v300; + + throw Ex( sum ); +} + +void test() +{ + try { + doIt(); + } catch( Ex& ) { } +} + +int main(int argc, char** argv) +{ + int OFF(0); + register int v1=OFF+1,v2=OFF+2,v3=OFF+3,v4=OFF+4,v5=OFF+5,v6=OFF+6,v7=OFF+7,v8=OFF+8,v9=OFF+9,v10=OFF+10; + register int v11=OFF+11,v12=OFF+12,v13=OFF+13,v14=OFF+14,v15=OFF+15,v16=OFF+16,v17=OFF+17,v18=OFF+18,v19=OFF+19,v20=OFF+20; + register int v21=OFF+21,v22=OFF+22,v23=OFF+23,v24=OFF+24,v25=OFF+25,v26=OFF+26,v27=OFF+27,v28=OFF+28,v29=OFF+29,v30=OFF+30; + register int v31=OFF+31,v32=OFF+32,v33=OFF+33,v34=OFF+34,v35=OFF+35,v36=OFF+36,v37=OFF+37,v38=OFF+38,v39=OFF+39,v40=OFF+40; + register int v41=OFF+41,v42=OFF+42,v43=OFF+43,v44=OFF+44,v45=OFF+45,v46=OFF+46,v47=OFF+47,v48=OFF+48,v49=OFF+49,v50=OFF+50; + register int v51=OFF+51,v52=OFF+52,v53=OFF+53,v54=OFF+54,v55=OFF+55,v56=OFF+56,v57=OFF+57,v58=OFF+58,v59=OFF+59,v60=OFF+60; + register int v61=OFF+61,v62=OFF+62,v63=OFF+63,v64=OFF+64,v65=OFF+65,v66=OFF+66,v67=OFF+67,v68=OFF+68,v69=OFF+69,v70=OFF+70; + register int v71=OFF+71,v72=OFF+72,v73=OFF+73,v74=OFF+74,v75=OFF+75,v76=OFF+76,v77=OFF+77,v78=OFF+78,v79=OFF+79,v80=OFF+80; + register int v81=OFF+81,v82=OFF+82,v83=OFF+83,v84=OFF+84,v85=OFF+85,v86=OFF+86,v87=OFF+87,v88=OFF+88,v89=OFF+89,v90=OFF+90; + register int v91=OFF+91,v92=OFF+92,v93=OFF+93,v94=OFF+94,v95=OFF+95,v96=OFF+96,v97=OFF+97,v98=OFF+98,v99=OFF+99,v100=OFF+100; + register int v101=OFF+101,v102=OFF+102,v103=OFF+103,v104=OFF+104,v105=OFF+105,v106=OFF+106,v107=OFF+107,v108=OFF+108,v109=OFF+109,v110=OFF+110; + register int v111=OFF+111,v112=OFF+112,v113=OFF+113,v114=OFF+114,v115=OFF+115,v116=OFF+116,v117=OFF+117,v118=OFF+118,v119=OFF+119,v120=OFF+120; + register int v121=OFF+121,v122=OFF+122,v123=OFF+123,v124=OFF+124,v125=OFF+125,v126=OFF+126,v127=OFF+127,v128=OFF+128,v129=OFF+129,v130=OFF+130; + register int v131=OFF+131,v132=OFF+132,v133=OFF+133,v134=OFF+134,v135=OFF+135,v136=OFF+136,v137=OFF+137,v138=OFF+138,v139=OFF+139,v140=OFF+140; + register int v141=OFF+141,v142=OFF+142,v143=OFF+143,v144=OFF+144,v145=OFF+145,v146=OFF+146,v147=OFF+147,v148=OFF+148,v149=OFF+149,v150=OFF+150; + register int v151=OFF+151,v152=OFF+152,v153=OFF+153,v154=OFF+154,v155=OFF+155,v156=OFF+156,v157=OFF+157,v158=OFF+158,v159=OFF+159,v160=OFF+160; + register int v161=OFF+161,v162=OFF+162,v163=OFF+163,v164=OFF+164,v165=OFF+165,v166=OFF+166,v167=OFF+167,v168=OFF+168,v169=OFF+169,v170=OFF+170; + register int v171=OFF+171,v172=OFF+172,v173=OFF+173,v174=OFF+174,v175=OFF+175,v176=OFF+176,v177=OFF+177,v178=OFF+178,v179=OFF+179,v180=OFF+180; + register int v181=OFF+181,v182=OFF+182,v183=OFF+183,v184=OFF+184,v185=OFF+185,v186=OFF+186,v187=OFF+187,v188=OFF+188,v189=OFF+189,v190=OFF+190; + register int v191=OFF+191,v192=OFF+192,v193=OFF+193,v194=OFF+194,v195=OFF+195,v196=OFF+196,v197=OFF+197,v198=OFF+198,v199=OFF+199,v200=OFF+200; + register int v201=OFF+201,v202=OFF+202,v203=OFF+203,v204=OFF+204,v205=OFF+205,v206=OFF+206,v207=OFF+207,v208=OFF+208,v209=OFF+209,v210=OFF+210; + register int v211=OFF+211,v212=OFF+212,v213=OFF+213,v214=OFF+214,v215=OFF+215,v216=OFF+216,v217=OFF+217,v218=OFF+218,v219=OFF+219,v220=OFF+220; + register int v231=OFF+231,v232=OFF+232,v233=OFF+233,v234=OFF+234,v235=OFF+235,v236=OFF+236,v237=OFF+237,v238=OFF+238,v239=OFF+239,v240=OFF+240; + register int v241=OFF+241,v242=OFF+242,v243=OFF+243,v244=OFF+244,v245=OFF+245,v246=OFF+246,v247=OFF+247,v248=OFF+248,v249=OFF+249,v250=OFF+250; + register int v251=OFF+251,v252=OFF+252,v253=OFF+253,v254=OFF+254,v255=OFF+255,v256=OFF+256,v257=OFF+257,v258=OFF+258,v259=OFF+259,v260=OFF+260; + register int v261=OFF+261,v262=OFF+262,v263=OFF+263,v264=OFF+264,v265=OFF+265,v266=OFF+266,v267=OFF+267,v268=OFF+268,v269=OFF+269,v270=OFF+270; + register int v271=OFF+271,v272=OFF+272,v273=OFF+273,v274=OFF+274,v275=OFF+275,v276=OFF+276,v277=OFF+277,v278=OFF+278,v279=OFF+279,v280=OFF+280; + register int v281=OFF+281,v282=OFF+282,v283=OFF+283,v284=OFF+284,v285=OFF+285,v286=OFF+286,v287=OFF+287,v288=OFF+288,v289=OFF+289,v290=OFF+290; + register int v291=OFF+291,v292=OFF+292,v293=OFF+293,v294=OFF+294,v295=OFF+295,v296=OFF+296,v297=OFF+297,v298=OFF+298,v299=OFF+299,v300=OFF+300; + + int sum_before, sum_after; + + { + int sum( 0 ); + sum +=v1+v2+v3+v4+v5+v6+v7+v8+v9+v10; + sum +=v11+v12+v13+v14+v15+v16+v17+v18+v19+v20; + sum +=v21+v22+v23+v24+v25+v26+v27+v28+v29+v30; + sum +=v31+v32+v33+v34+v35+v36+v37+v38+v39+v40; + sum +=v41+v42+v43+v44+v45+v46+v47+v48+v49+v50; + sum +=v51+v52+v53+v54+v55+v56+v57+v58+v59+v60; + sum +=v61+v62+v63+v64+v65+v66+v67+v68+v69+v70; + sum +=v71+v72+v73+v74+v75+v76+v77+v78+v79+v80; + sum +=v81+v82+v83+v84+v85+v86+v87+v88+v89+v90; + sum +=v91+v92+v93+v94+v95+v96+v97+v98+v99+v100; + sum +=v101+v102+v103+v104+v105+v106+v107+v108+v109+v110; + sum +=v111+v112+v113+v114+v115+v116+v117+v118+v119+v120; + sum +=v121+v122+v123+v124+v125+v126+v127+v128+v129+v130; + sum +=v131+v132+v133+v134+v135+v136+v137+v138+v139+v140; + sum +=v141+v142+v143+v144+v145+v146+v147+v148+v149+v150; + sum +=v151+v152+v153+v154+v155+v156+v157+v158+v159+v160; + sum +=v161+v162+v163+v164+v165+v166+v167+v168+v169+v170; + sum +=v171+v172+v173+v174+v175+v176+v177+v178+v179+v180; + sum +=v181+v182+v183+v184+v185+v186+v187+v188+v189+v190; + sum +=v191+v192+v193+v194+v195+v196+v197+v198+v199+v200; + sum +=v201+v202+v203+v204+v205+v206+v207+v208+v209+v210; + sum +=v211+v212+v213+v214+v215+v216+v217+v218+v219+v220; + sum +=v231+v232+v233+v234+v235+v236+v237+v238+v239+v240; + sum +=v241+v242+v243+v244+v245+v246+v247+v248+v249+v250; + sum +=v251+v252+v253+v254+v255+v256+v257+v258+v259+v260; + sum +=v261+v262+v263+v264+v265+v266+v267+v268+v269+v270; + sum +=v271+v272+v273+v274+v275+v276+v277+v278+v279+v280; + sum +=v281+v282+v283+v284+v285+v286+v287+v288+v289+v290; + sum +=v291+v292+v293+v294+v295+v296+v297+v298+v299+v300; + + sum_before = sum; + } + + test(); + + { + int sum( 0 ); + sum +=v1+v2+v3+v4+v5+v6+v7+v8+v9+v10; + sum +=v11+v12+v13+v14+v15+v16+v17+v18+v19+v20; + sum +=v21+v22+v23+v24+v25+v26+v27+v28+v29+v30; + sum +=v31+v32+v33+v34+v35+v36+v37+v38+v39+v40; + sum +=v41+v42+v43+v44+v45+v46+v47+v48+v49+v50; + sum +=v51+v52+v53+v54+v55+v56+v57+v58+v59+v60; + sum +=v61+v62+v63+v64+v65+v66+v67+v68+v69+v70; + sum +=v71+v72+v73+v74+v75+v76+v77+v78+v79+v80; + sum +=v81+v82+v83+v84+v85+v86+v87+v88+v89+v90; + sum +=v91+v92+v93+v94+v95+v96+v97+v98+v99+v100; + sum +=v101+v102+v103+v104+v105+v106+v107+v108+v109+v110; + sum +=v111+v112+v113+v114+v115+v116+v117+v118+v119+v120; + sum +=v121+v122+v123+v124+v125+v126+v127+v128+v129+v130; + sum +=v131+v132+v133+v134+v135+v136+v137+v138+v139+v140; + sum +=v141+v142+v143+v144+v145+v146+v147+v148+v149+v150; + sum +=v151+v152+v153+v154+v155+v156+v157+v158+v159+v160; + sum +=v161+v162+v163+v164+v165+v166+v167+v168+v169+v170; + sum +=v171+v172+v173+v174+v175+v176+v177+v178+v179+v180; + sum +=v181+v182+v183+v184+v185+v186+v187+v188+v189+v190; + sum +=v191+v192+v193+v194+v195+v196+v197+v198+v199+v200; + sum +=v201+v202+v203+v204+v205+v206+v207+v208+v209+v210; + sum +=v211+v212+v213+v214+v215+v216+v217+v218+v219+v220; + sum +=v231+v232+v233+v234+v235+v236+v237+v238+v239+v240; + sum +=v241+v242+v243+v244+v245+v246+v247+v248+v249+v250; + sum +=v251+v252+v253+v254+v255+v256+v257+v258+v259+v260; + sum +=v261+v262+v263+v264+v265+v266+v267+v268+v269+v270; + sum +=v271+v272+v273+v274+v275+v276+v277+v278+v279+v280; + sum +=v281+v282+v283+v284+v285+v286+v287+v288+v289+v290; + sum +=v291+v292+v293+v294+v295+v296+v297+v298+v299+v300; + + sum_after = sum; + } + + return sum_before != sum_after; +}
pr29166.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: loop1.C =================================================================== --- loop1.C (nonexistent) +++ loop1.C (revision 816) @@ -0,0 +1,30 @@ +// Verify that loop optimization takes into account the exception edge +// and does not increment I before the call. +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort(); +static void bar(char *); + +static void foo(unsigned long element_count, char *ptr) +{ + unsigned long i; + try { + for (i = 0; i != element_count; i++, ptr += 8) + bar (ptr); + } + catch (...) { + if (i) + abort (); + } +} + +static void bar(char *) +{ + throw 1; +} + +int main() +{ + foo(2, 0); +}
loop1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: uncaught2.C =================================================================== --- uncaught2.C (nonexistent) +++ uncaught2.C (revision 816) @@ -0,0 +1,84 @@ +// { dg-do compile } +// { dg-final { scan-assembler-not "__cxa_get_exception" } } +// { dg-options "-fno-use-cxa-get-exception-ptr" } + +#include +#include + + +struct Check { + int obj1, obj2; + bool state; +}; + +static Check const data[] = { + { 0, 0, false }, // construct [0] + { 1, 0, true }, // [1] = [0] + { 0, 0, true }, // destruct [0] + { 2, 1, true }, // [2] = [1] + { 2, 2, true }, // destruct [2] + { 3, 1, true }, // [3] = [1] + { 3, 3, false }, // destruct [3] + { 1, 1, false }, // destruct [1] + { 9, 9, false } // end-of-data +}; + +static int pos = 0; + +static void test(int obj1, int obj2, bool state) +{ + if (obj1 != data[pos].obj1) abort (); + if (obj2 != data[pos].obj2) abort (); + if (state != data[pos].state) abort (); + pos++; +} + + +struct S { + int id; + S (); + S (const S &); + ~S (); +}; + +static int next_id = 0; + +S::S() + : id (next_id++) +{ + test (id, id, std::uncaught_exception ()); +} + +S::S(const S &x) + : id (next_id++) +{ + test (id, x.id, std::uncaught_exception ()); +} + +S::~S() +{ + test (id, id, std::uncaught_exception ()); +} + +extern void foo (S *); + +int main() +{ + try + { + try + { + S s0; + throw s0; // s1 is the exception object + } + catch (S s2) + { + throw; + } + } + catch (S s3) + { + } + + return 0; +}
uncaught2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: omit-frame-pointer2.C =================================================================== --- omit-frame-pointer2.C (nonexistent) +++ omit-frame-pointer2.C (revision 816) @@ -0,0 +1,34 @@ +// Reduced from PR c++/5246, PR c++/2447 +// { dg-options "-O -fomit-frame-pointer" } +// { dg-do run } + +void step (int) +{ + void *sp = __builtin_alloca (0); +} + +void f2 (void) +{ + step (2); + throw int(); +} + +void f1 (void) +{ + try + { + step (1); + f2 (); + step (-1); + } + catch (int) + { + step (3); + } +} + +int main () +{ + f1 (); + return 0; +}
omit-frame-pointer2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ia64-1.C =================================================================== --- ia64-1.C (nonexistent) +++ ia64-1.C (revision 816) @@ -0,0 +1,59 @@ +// Test whether call saved float and branch regs are restored properly +// We can't do this test for branch regs in ILP32 mode. +// { dg-do run { target ia64-*-* } } +// { dg-options "-O2" } + +extern "C" void abort (void); + +#ifdef __LP64__ +char buf[128]; +#endif + +void __attribute__((noinline)) +bar (void) +{ + throw 1; +} + +void __attribute__((noinline)) +foo (void) +{ + bar (); + bar (); +} + +int +main (void) +{ + register double f2 __asm ("f2"); + register double f3 __asm ("f3"); + register double f4 __asm ("f4"); + register double f5 __asm ("f5"); + register double f16 __asm ("f16"); + register double f17 __asm ("f17"); +#ifdef __LP64__ + register void *b1 __asm ("b1"); + register void *b2 __asm ("b2"); + register void *b3 __asm ("b3"); + register void *b4 __asm ("b4"); + register void *b5 __asm ("b5"); +#endif + f2 = 12.0; f3 = 13.0; f4 = 14.0; f5 = 15.0; f16 = 16.0; f17 = 17.0; +#ifdef __LP64__ + b1 = &buf[1]; b2 = &buf[2]; b3 = &buf[3]; b4 = &buf[4]; b5 = &buf[5]; +#endif + try + { + foo (); + } + catch (...) {} + if (f2 != 12.0 || f3 != 13.0 || f4 != 14.0 + || f5 != 15.0 || f16 != 16.0 || f17 != 17.0) + abort (); +#ifdef __LP64__ + if (b1 != &buf[1] || b2 != &buf[2] || b3 != &buf[3] + || b4 != &buf[4] || b5 != &buf[5]) + abort (); +#endif + return 0; +}
ia64-1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: fp-regs.C =================================================================== --- fp-regs.C (nonexistent) +++ fp-regs.C (revision 816) @@ -0,0 +1,94 @@ +// PR 20670: f29 corrupted when unwind stack. This tries to test that FP +// registers are properly saved and restored by defining 20 different FP +// local variables. +// { dg-do run } +// { dg-options "-O" } +#include + +double zero = 0.0; +double another_zero = 0.0; + +int +sub (void) +{ + throw (0); +} + +int +main (void) +{ + double a, b, c, d, e, f, g, h, i, j; + double a1, b1, c1, d1, e1, f1, g1, h1, i1, j1; + + a = zero; + b = a + 1; + c = b + 1; + d = c + 1; + e = d + 1; + f = e + 1; + g = f + 1; + h = g + 1; + i = h + 1; + j = i + 1; + + a1 = another_zero; + b1 = a1 + 1; + c1 = b1 + 1; + d1 = c1 + 1; + e1 = d1 + 1; + f1 = e1 + 1; + g1 = f1 + 1; + h1 = g1 + 1; + i1 = h1 + 1; + j1 = i1 + 1; + + try + { + sub (); + } + catch (...) + { + if (a != 0.0) + abort (); + if (b != 1.0) + abort (); + if (c != 2.0) + abort (); + if (d != 3.0) + abort (); + if (e != 4.0) + abort (); + if (f != 5.0) + abort (); + if (g != 6.0) + abort (); + if (h != 7.0) + abort (); + if (i != 8.0) + abort (); + if (j != 9.0) + abort (); + + if (a1 != 0.0) + abort (); + if (b1 != 1.0) + abort (); + if (c1 != 2.0) + abort (); + if (d1 != 3.0) + abort (); + if (e1 != 4.0) + abort (); + if (f1 != 5.0) + abort (); + if (g1 != 6.0) + abort (); + if (h1 != 7.0) + abort (); + if (i1 != 8.0) + abort (); + if (j1 != 9.0) + abort (); + } + return 0; +}
fp-regs.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: elide2.C =================================================================== --- elide2.C (nonexistent) +++ elide2.C (revision 816) @@ -0,0 +1,34 @@ +// PR c++/13944 + +// Verify that we still call terminate() if we do run the copy constructor, +// and it throws. + +// { dg-do run } + +#include +#include + +struct A +{ + A() { } + A(const A&) { throw 1; } +}; + +A a; + +void +good_terminate() { std::exit (0); } + +int main() +{ + std::set_terminate (good_terminate); + try + { + throw a; + } + catch (...) + { + return 2; + } + return 3; +}
elide2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: catch2.C =================================================================== --- catch2.C (nonexistent) +++ catch2.C (revision 816) @@ -0,0 +1,9 @@ +// PR c++/28250 +// { dg-do compile } + +void foo() +{ + try {} + catch () {} // { dg-error "before" } + catch (...) {} +}
catch2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: filter1.C =================================================================== --- filter1.C (nonexistent) +++ filter1.C (revision 816) @@ -0,0 +1,43 @@ +// Test that cleanups get run when a catch filter fails to match. +// { dg-do run } + +extern "C" void exit(int); +extern "C" void abort(); + +struct a +{ + a(); + ~a(); +}; + +struct e1 {}; +struct e2 {}; + +void +ex_test () +{ + a aa; + try + { + throw e1 (); + } + catch (e2 &) + { + } +} + +int +main () +{ + try + { + ex_test (); + } + catch (...) + { + } + abort (); +} + +a::a() { } +a::~a() { exit (0); }
filter1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: crossjump1.C =================================================================== --- crossjump1.C (nonexistent) +++ crossjump1.C (revision 816) @@ -0,0 +1,31 @@ +// This testcase failed on s390, because cross-jumping merged 2 calls, +// one with REG_EH_REGION note with no handlers (ie. termination) +// and one without REG_EH_REGION note. +// { dg-do run } +// { dg-options "-O2" } + +#include +#include + +struct E : public std::exception +{ + std::string m; + E () : m ("test") { } + ~E () throw() { } +}; + +struct C : public E { }; + +void foo () +{ + throw C (); +} + +int main () +{ + try + { + foo (); + } + catch (...) { } +}
crossjump1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: catch4.C =================================================================== --- catch4.C (nonexistent) +++ catch4.C (revision 816) @@ -0,0 +1,8 @@ +// PR c++/28250 +// { dg-do compile } + +void foo() +{ + try { throw; } + catch () {} // { dg-error "type-specifier" } +}
catch4.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: weak1.C =================================================================== --- weak1.C (nonexistent) +++ weak1.C (revision 816) @@ -0,0 +1,23 @@ +// PR target/29487 +// { dg-require-weak "" } +// { dg-do run { xfail "hppa*-hp-hpux11.*" } } +// { dg-additional-sources "weak1-a.cc" } +// { dg-options "-O2" } + +extern __attribute__((weak)) +void f() { +} + +int main () { + try { + f(); + return 1; + } catch (int i) { + /* Although the implementation of f in this file does not throw + any exceptions, it is weak, and may therefore be replaced at + link time. Therefore, the compiler must not optimize away this + catch clause. */ + if (i != 7) + return 2; + } +}
weak1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cleanup1.C =================================================================== --- cleanup1.C (nonexistent) +++ cleanup1.C (revision 816) @@ -0,0 +1,417 @@ +struct vector { ~vector(); }; +struct C { C(); + vector x; }; + +struct A { + A(); + + typedef C T; + + T a0000; T a0001; T a0002; T a0003; T a0004; T a0005; T a0006; T a0007; T a0008; T a0009; + T a0010; T a0011; T a0012; T a0013; T a0014; T a0015; T a0016; T a0017; T a0018; T a0019; + T a0020; T a0021; T a0022; T a0023; T a0024; T a0025; T a0026; T a0027; T a0028; T a0029; + T a0030; T a0031; T a0032; T a0033; T a0034; T a0035; T a0036; T a0037; T a0038; T a0039; + T a0040; T a0041; T a0042; T a0043; T a0044; T a0045; T a0046; T a0047; T a0048; T a0049; + T a0050; T a0051; T a0052; T a0053; T a0054; T a0055; T a0056; T a0057; T a0058; T a0059; + T a0060; T a0061; T a0062; T a0063; T a0064; T a0065; T a0066; T a0067; T a0068; T a0069; + T a0070; T a0071; T a0072; T a0073; T a0074; T a0075; T a0076; T a0077; T a0078; T a0079; + T a0080; T a0081; T a0082; T a0083; T a0084; T a0085; T a0086; T a0087; T a0088; T a0089; + T a0090; T a0091; T a0092; T a0093; T a0094; T a0095; T a0096; T a0097; T a0098; T a0099; + T a0100; T a0101; T a0102; T a0103; T a0104; T a0105; T a0106; T a0107; T a0108; T a0109; + T a0110; T a0111; T a0112; T a0113; T a0114; T a0115; T a0116; T a0117; T a0118; T a0119; + T a0120; T a0121; T a0122; T a0123; T a0124; T a0125; T a0126; T a0127; T a0128; T a0129; + T a0130; T a0131; T a0132; T a0133; T a0134; T a0135; T a0136; T a0137; T a0138; T a0139; + T a0140; T a0141; T a0142; T a0143; T a0144; T a0145; T a0146; T a0147; T a0148; T a0149; + T a0150; T a0151; T a0152; T a0153; T a0154; T a0155; T a0156; T a0157; T a0158; T a0159; + T a0160; T a0161; T a0162; T a0163; T a0164; T a0165; T a0166; T a0167; T a0168; T a0169; + T a0170; T a0171; T a0172; T a0173; T a0174; T a0175; T a0176; T a0177; T a0178; T a0179; + T a0180; T a0181; T a0182; T a0183; T a0184; T a0185; T a0186; T a0187; T a0188; T a0189; + T a0190; T a0191; T a0192; T a0193; T a0194; T a0195; T a0196; T a0197; T a0198; T a0199; + T a0200; T a0201; T a0202; T a0203; T a0204; T a0205; T a0206; T a0207; T a0208; T a0209; + T a0210; T a0211; T a0212; T a0213; T a0214; T a0215; T a0216; T a0217; T a0218; T a0219; + T a0220; T a0221; T a0222; T a0223; T a0224; T a0225; T a0226; T a0227; T a0228; T a0229; + T a0230; T a0231; T a0232; T a0233; T a0234; T a0235; T a0236; T a0237; T a0238; T a0239; + T a0240; T a0241; T a0242; T a0243; T a0244; T a0245; T a0246; T a0247; T a0248; T a0249; + T a0250; T a0251; T a0252; T a0253; T a0254; T a0255; T a0256; T a0257; T a0258; T a0259; + T a0260; T a0261; T a0262; T a0263; T a0264; T a0265; T a0266; T a0267; T a0268; T a0269; + T a0270; T a0271; T a0272; T a0273; T a0274; T a0275; T a0276; T a0277; T a0278; T a0279; + T a0280; T a0281; T a0282; T a0283; T a0284; T a0285; T a0286; T a0287; T a0288; T a0289; + T a0290; T a0291; T a0292; T a0293; T a0294; T a0295; T a0296; T a0297; T a0298; T a0299; + T a0300; T a0301; T a0302; T a0303; T a0304; T a0305; T a0306; T a0307; T a0308; T a0309; + T a0310; T a0311; T a0312; T a0313; T a0314; T a0315; T a0316; T a0317; T a0318; T a0319; + T a0320; T a0321; T a0322; T a0323; T a0324; T a0325; T a0326; T a0327; T a0328; T a0329; + T a0330; T a0331; T a0332; T a0333; T a0334; T a0335; T a0336; T a0337; T a0338; T a0339; + T a0340; T a0341; T a0342; T a0343; T a0344; T a0345; T a0346; T a0347; T a0348; T a0349; + T a0350; T a0351; T a0352; T a0353; T a0354; T a0355; T a0356; T a0357; T a0358; T a0359; + T a0360; T a0361; T a0362; T a0363; T a0364; T a0365; T a0366; T a0367; T a0368; T a0369; + T a0370; T a0371; T a0372; T a0373; T a0374; T a0375; T a0376; T a0377; T a0378; T a0379; + T a0380; T a0381; T a0382; T a0383; T a0384; T a0385; T a0386; T a0387; T a0388; T a0389; + T a0390; T a0391; T a0392; T a0393; T a0394; T a0395; T a0396; T a0397; T a0398; T a0399; + T a0400; T a0401; T a0402; T a0403; T a0404; T a0405; T a0406; T a0407; T a0408; T a0409; + T a0410; T a0411; T a0412; T a0413; T a0414; T a0415; T a0416; T a0417; T a0418; T a0419; + T a0420; T a0421; T a0422; T a0423; T a0424; T a0425; T a0426; T a0427; T a0428; T a0429; + T a0430; T a0431; T a0432; T a0433; T a0434; T a0435; T a0436; T a0437; T a0438; T a0439; + T a0440; T a0441; T a0442; T a0443; T a0444; T a0445; T a0446; T a0447; T a0448; T a0449; + T a0450; T a0451; T a0452; T a0453; T a0454; T a0455; T a0456; T a0457; T a0458; T a0459; + T a0460; T a0461; T a0462; T a0463; T a0464; T a0465; T a0466; T a0467; T a0468; T a0469; + T a0470; T a0471; T a0472; T a0473; T a0474; T a0475; T a0476; T a0477; T a0478; T a0479; + T a0480; T a0481; T a0482; T a0483; T a0484; T a0485; T a0486; T a0487; T a0488; T a0489; + T a0490; T a0491; T a0492; T a0493; T a0494; T a0495; T a0496; T a0497; T a0498; T a0499; + + T a0500; T a0501; T a0502; T a0503; T a0504; T a0505; T a0506; T a0507; T a0508; T a0509; + T a0510; T a0511; T a0512; T a0513; T a0514; T a0515; T a0516; T a0517; T a0518; T a0519; + T a0520; T a0521; T a0522; T a0523; T a0524; T a0525; T a0526; T a0527; T a0528; T a0529; + T a0530; T a0531; T a0532; T a0533; T a0534; T a0535; T a0536; T a0537; T a0538; T a0539; + T a0540; T a0541; T a0542; T a0543; T a0544; T a0545; T a0546; T a0547; T a0548; T a0549; + T a0550; T a0551; T a0552; T a0553; T a0554; T a0555; T a0556; T a0557; T a0558; T a0559; + T a0560; T a0561; T a0562; T a0563; T a0564; T a0565; T a0566; T a0567; T a0568; T a0569; + T a0570; T a0571; T a0572; T a0573; T a0574; T a0575; T a0576; T a0577; T a0578; T a0579; + T a0580; T a0581; T a0582; T a0583; T a0584; T a0585; T a0586; T a0587; T a0588; T a0589; + T a0590; T a0591; T a0592; T a0593; T a0594; T a0595; T a0596; T a0597; T a0598; T a0599; + T a0600; T a0601; T a0602; T a0603; T a0604; T a0605; T a0606; T a0607; T a0608; T a0609; + T a0610; T a0611; T a0612; T a0613; T a0614; T a0615; T a0616; T a0617; T a0618; T a0619; + T a0620; T a0621; T a0622; T a0623; T a0624; T a0625; T a0626; T a0627; T a0628; T a0629; + T a0630; T a0631; T a0632; T a0633; T a0634; T a0635; T a0636; T a0637; T a0638; T a0639; + T a0640; T a0641; T a0642; T a0643; T a0644; T a0645; T a0646; T a0647; T a0648; T a0649; + T a0650; T a0651; T a0652; T a0653; T a0654; T a0655; T a0656; T a0657; T a0658; T a0659; + T a0660; T a0661; T a0662; T a0663; T a0664; T a0665; T a0666; T a0667; T a0668; T a0669; + T a0670; T a0671; T a0672; T a0673; T a0674; T a0675; T a0676; T a0677; T a0678; T a0679; + T a0680; T a0681; T a0682; T a0683; T a0684; T a0685; T a0686; T a0687; T a0688; T a0689; + T a0690; T a0691; T a0692; T a0693; T a0694; T a0695; T a0696; T a0697; T a0698; T a0699; + T a0700; T a0701; T a0702; T a0703; T a0704; T a0705; T a0706; T a0707; T a0708; T a0709; + T a0710; T a0711; T a0712; T a0713; T a0714; T a0715; T a0716; T a0717; T a0718; T a0719; + T a0720; T a0721; T a0722; T a0723; T a0724; T a0725; T a0726; T a0727; T a0728; T a0729; + T a0730; T a0731; T a0732; T a0733; T a0734; T a0735; T a0736; T a0737; T a0738; T a0739; + T a0740; T a0741; T a0742; T a0743; T a0744; T a0745; T a0746; T a0747; T a0748; T a0749; + T a0750; T a0751; T a0752; T a0753; T a0754; T a0755; T a0756; T a0757; T a0758; T a0759; + T a0760; T a0761; T a0762; T a0763; T a0764; T a0765; T a0766; T a0767; T a0768; T a0769; + T a0770; T a0771; T a0772; T a0773; T a0774; T a0775; T a0776; T a0777; T a0778; T a0779; + T a0780; T a0781; T a0782; T a0783; T a0784; T a0785; T a0786; T a0787; T a0788; T a0789; + T a0790; T a0791; T a0792; T a0793; T a0794; T a0795; T a0796; T a0797; T a0798; T a0799; + T a0800; T a0801; T a0802; T a0803; T a0804; T a0805; T a0806; T a0807; T a0808; T a0809; + T a0810; T a0811; T a0812; T a0813; T a0814; T a0815; T a0816; T a0817; T a0818; T a0819; + T a0820; T a0821; T a0822; T a0823; T a0824; T a0825; T a0826; T a0827; T a0828; T a0829; + T a0830; T a0831; T a0832; T a0833; T a0834; T a0835; T a0836; T a0837; T a0838; T a0839; + T a0840; T a0841; T a0842; T a0843; T a0844; T a0845; T a0846; T a0847; T a0848; T a0849; + T a0850; T a0851; T a0852; T a0853; T a0854; T a0855; T a0856; T a0857; T a0858; T a0859; + T a0860; T a0861; T a0862; T a0863; T a0864; T a0865; T a0866; T a0867; T a0868; T a0869; + T a0870; T a0871; T a0872; T a0873; T a0874; T a0875; T a0876; T a0877; T a0878; T a0879; + T a0880; T a0881; T a0882; T a0883; T a0884; T a0885; T a0886; T a0887; T a0888; T a0889; + T a0890; T a0891; T a0892; T a0893; T a0894; T a0895; T a0896; T a0897; T a0898; T a0899; + T a0900; T a0901; T a0902; T a0903; T a0904; T a0905; T a0906; T a0907; T a0908; T a0909; + T a0910; T a0911; T a0912; T a0913; T a0914; T a0915; T a0916; T a0917; T a0918; T a0919; + T a0920; T a0921; T a0922; T a0923; T a0924; T a0925; T a0926; T a0927; T a0928; T a0929; + T a0930; T a0931; T a0932; T a0933; T a0934; T a0935; T a0936; T a0937; T a0938; T a0939; + T a0940; T a0941; T a0942; T a0943; T a0944; T a0945; T a0946; T a0947; T a0948; T a0949; + T a0950; T a0951; T a0952; T a0953; T a0954; T a0955; T a0956; T a0957; T a0958; T a0959; + T a0960; T a0961; T a0962; T a0963; T a0964; T a0965; T a0966; T a0967; T a0968; T a0969; + T a0970; T a0971; T a0972; T a0973; T a0974; T a0975; T a0976; T a0977; T a0978; T a0979; + T a0980; T a0981; T a0982; T a0983; T a0984; T a0985; T a0986; T a0987; T a0988; T a0989; + T a0990; T a0991; T a0992; T a0993; T a0994; T a0995; T a0996; T a0997; T a0998; T a0999; + T a1000; T a1001; T a1002; T a1003; T a1004; T a1005; T a1006; T a1007; T a1008; T a1009; + T a1010; T a1011; T a1012; T a1013; T a1014; T a1015; T a1016; T a1017; T a1018; T a1019; + T a1020; T a1021; T a1022; T a1023; T a1024; T a1025; T a1026; T a1027; T a1028; T a1029; + T a1030; T a1031; T a1032; T a1033; T a1034; T a1035; T a1036; T a1037; T a1038; T a1039; + T a1040; T a1041; T a1042; T a1043; T a1044; T a1045; T a1046; T a1047; T a1048; T a1049; + T a1050; T a1051; T a1052; T a1053; T a1054; T a1055; T a1056; T a1057; T a1058; T a1059; + T a1060; T a1061; T a1062; T a1063; T a1064; T a1065; T a1066; T a1067; T a1068; T a1069; + T a1070; T a1071; T a1072; T a1073; T a1074; T a1075; T a1076; T a1077; T a1078; T a1079; + T a1080; T a1081; T a1082; T a1083; T a1084; T a1085; T a1086; T a1087; T a1088; T a1089; + T a1090; T a1091; T a1092; T a1093; T a1094; T a1095; T a1096; T a1097; T a1098; T a1099; + T a1100; T a1101; T a1102; T a1103; T a1104; T a1105; T a1106; T a1107; T a1108; T a1109; + T a1110; T a1111; T a1112; T a1113; T a1114; T a1115; T a1116; T a1117; T a1118; T a1119; + T a1120; T a1121; T a1122; T a1123; T a1124; T a1125; T a1126; T a1127; T a1128; T a1129; + T a1130; T a1131; T a1132; T a1133; T a1134; T a1135; T a1136; T a1137; T a1138; T a1139; + T a1140; T a1141; T a1142; T a1143; T a1144; T a1145; T a1146; T a1147; T a1148; T a1149; + T a1150; T a1151; T a1152; T a1153; T a1154; T a1155; T a1156; T a1157; T a1158; T a1159; + T a1160; T a1161; T a1162; T a1163; T a1164; T a1165; T a1166; T a1167; T a1168; T a1169; + T a1170; T a1171; T a1172; T a1173; T a1174; T a1175; T a1176; T a1177; T a1178; T a1179; + T a1180; T a1181; T a1182; T a1183; T a1184; T a1185; T a1186; T a1187; T a1188; T a1189; + T a1190; T a1191; T a1192; T a1193; T a1194; T a1195; T a1196; T a1197; T a1198; T a1199; + T a1200; T a1201; T a1202; T a1203; T a1204; T a1205; T a1206; T a1207; T a1208; T a1209; + T a1210; T a1211; T a1212; T a1213; T a1214; T a1215; T a1216; T a1217; T a1218; T a1219; + T a1220; T a1221; T a1222; T a1223; T a1224; T a1225; T a1226; T a1227; T a1228; T a1229; + T a1230; T a1231; T a1232; T a1233; T a1234; T a1235; T a1236; T a1237; T a1238; T a1239; + T a1240; T a1241; T a1242; T a1243; T a1244; T a1245; T a1246; T a1247; T a1248; T a1249; + T a1250; T a1251; T a1252; T a1253; T a1254; T a1255; T a1256; T a1257; T a1258; T a1259; + T a1260; T a1261; T a1262; T a1263; T a1264; T a1265; T a1266; T a1267; T a1268; T a1269; + T a1270; T a1271; T a1272; T a1273; T a1274; T a1275; T a1276; T a1277; T a1278; T a1279; + T a1280; T a1281; T a1282; T a1283; T a1284; T a1285; T a1286; T a1287; T a1288; T a1289; + T a1290; T a1291; T a1292; T a1293; T a1294; T a1295; T a1296; T a1297; T a1298; T a1299; + T a1300; T a1301; T a1302; T a1303; T a1304; T a1305; T a1306; T a1307; T a1308; T a1309; + T a1310; T a1311; T a1312; T a1313; T a1314; T a1315; T a1316; T a1317; T a1318; T a1319; + T a1320; T a1321; T a1322; T a1323; T a1324; T a1325; T a1326; T a1327; T a1328; T a1329; + T a1330; T a1331; T a1332; T a1333; T a1334; T a1335; T a1336; T a1337; T a1338; T a1339; + T a1340; T a1341; T a1342; T a1343; T a1344; T a1345; T a1346; T a1347; T a1348; T a1349; + T a1350; T a1351; T a1352; T a1353; T a1354; T a1355; T a1356; T a1357; T a1358; T a1359; + T a1360; T a1361; T a1362; T a1363; T a1364; T a1365; T a1366; T a1367; T a1368; T a1369; + T a1370; T a1371; T a1372; T a1373; T a1374; T a1375; T a1376; T a1377; T a1378; T a1379; + T a1380; T a1381; T a1382; T a1383; T a1384; T a1385; T a1386; T a1387; T a1388; T a1389; + T a1390; T a1391; T a1392; T a1393; T a1394; T a1395; T a1396; T a1397; T a1398; T a1399; + T a1400; T a1401; T a1402; T a1403; T a1404; T a1405; T a1406; T a1407; T a1408; T a1409; + T a1410; T a1411; T a1412; T a1413; T a1414; T a1415; T a1416; T a1417; T a1418; T a1419; + T a1420; T a1421; T a1422; T a1423; T a1424; T a1425; T a1426; T a1427; T a1428; T a1429; + T a1430; T a1431; T a1432; T a1433; T a1434; T a1435; T a1436; T a1437; T a1438; T a1439; + T a1440; T a1441; T a1442; T a1443; T a1444; T a1445; T a1446; T a1447; T a1448; T a1449; + T a1450; T a1451; T a1452; T a1453; T a1454; T a1455; T a1456; T a1457; T a1458; T a1459; + T a1460; T a1461; T a1462; T a1463; T a1464; T a1465; T a1466; T a1467; T a1468; T a1469; + T a1470; T a1471; T a1472; T a1473; T a1474; T a1475; T a1476; T a1477; T a1478; T a1479; + T a1480; T a1481; T a1482; T a1483; T a1484; T a1485; T a1486; T a1487; T a1488; T a1489; + T a1490; T a1491; T a1492; T a1493; T a1494; T a1495; T a1496; T a1497; T a1498; T a1499; + T a1500; T a1501; T a1502; T a1503; T a1504; T a1505; T a1506; T a1507; T a1508; T a1509; + T a1510; T a1511; T a1512; T a1513; T a1514; T a1515; T a1516; T a1517; T a1518; T a1519; + T a1520; T a1521; T a1522; T a1523; T a1524; T a1525; T a1526; T a1527; T a1528; T a1529; + T a1530; T a1531; T a1532; T a1533; T a1534; T a1535; T a1536; T a1537; T a1538; T a1539; + T a1540; T a1541; T a1542; T a1543; T a1544; T a1545; T a1546; T a1547; T a1548; T a1549; + T a1550; T a1551; T a1552; T a1553; T a1554; T a1555; T a1556; T a1557; T a1558; T a1559; + T a1560; T a1561; T a1562; T a1563; T a1564; T a1565; T a1566; T a1567; T a1568; T a1569; + T a1570; T a1571; T a1572; T a1573; T a1574; T a1575; T a1576; T a1577; T a1578; T a1579; + T a1580; T a1581; T a1582; T a1583; T a1584; T a1585; T a1586; T a1587; T a1588; T a1589; + T a1590; T a1591; T a1592; T a1593; T a1594; T a1595; T a1596; T a1597; T a1598; T a1599; + T a1600; T a1601; T a1602; T a1603; T a1604; T a1605; T a1606; T a1607; T a1608; T a1609; + T a1610; T a1611; T a1612; T a1613; T a1614; T a1615; T a1616; T a1617; T a1618; T a1619; + T a1620; T a1621; T a1622; T a1623; T a1624; T a1625; T a1626; T a1627; T a1628; T a1629; + T a1630; T a1631; T a1632; T a1633; T a1634; T a1635; T a1636; T a1637; T a1638; T a1639; + T a1640; T a1641; T a1642; T a1643; T a1644; T a1645; T a1646; T a1647; T a1648; T a1649; + T a1650; T a1651; T a1652; T a1653; T a1654; T a1655; T a1656; T a1657; T a1658; T a1659; + T a1660; T a1661; T a1662; T a1663; T a1664; T a1665; T a1666; T a1667; T a1668; T a1669; + T a1670; T a1671; T a1672; T a1673; T a1674; T a1675; T a1676; T a1677; T a1678; T a1679; + T a1680; T a1681; T a1682; T a1683; T a1684; T a1685; T a1686; T a1687; T a1688; T a1689; + T a1690; T a1691; T a1692; T a1693; T a1694; T a1695; T a1696; T a1697; T a1698; T a1699; + T a1700; T a1701; T a1702; T a1703; T a1704; T a1705; T a1706; T a1707; T a1708; T a1709; + T a1710; T a1711; T a1712; T a1713; T a1714; T a1715; T a1716; T a1717; T a1718; T a1719; + T a1720; T a1721; T a1722; T a1723; T a1724; T a1725; T a1726; T a1727; T a1728; T a1729; + T a1730; T a1731; T a1732; T a1733; T a1734; T a1735; T a1736; T a1737; T a1738; T a1739; + T a1740; T a1741; T a1742; T a1743; T a1744; T a1745; T a1746; T a1747; T a1748; T a1749; + T a1750; T a1751; T a1752; T a1753; T a1754; T a1755; T a1756; T a1757; T a1758; T a1759; + T a1760; T a1761; T a1762; T a1763; T a1764; T a1765; T a1766; T a1767; T a1768; T a1769; + T a1770; T a1771; T a1772; T a1773; T a1774; T a1775; T a1776; T a1777; T a1778; T a1779; + T a1780; T a1781; T a1782; T a1783; T a1784; T a1785; T a1786; T a1787; T a1788; T a1789; + T a1790; T a1791; T a1792; T a1793; T a1794; T a1795; T a1796; T a1797; T a1798; T a1799; + T a1800; T a1801; T a1802; T a1803; T a1804; T a1805; T a1806; T a1807; T a1808; T a1809; + T a1810; T a1811; T a1812; T a1813; T a1814; T a1815; T a1816; T a1817; T a1818; T a1819; + T a1820; T a1821; T a1822; T a1823; T a1824; T a1825; T a1826; T a1827; T a1828; T a1829; + T a1830; T a1831; T a1832; T a1833; T a1834; T a1835; T a1836; T a1837; T a1838; T a1839; + T a1840; T a1841; T a1842; T a1843; T a1844; T a1845; T a1846; T a1847; T a1848; T a1849; + T a1850; T a1851; T a1852; T a1853; T a1854; T a1855; T a1856; T a1857; T a1858; T a1859; + T a1860; T a1861; T a1862; T a1863; T a1864; T a1865; T a1866; T a1867; T a1868; T a1869; + T a1870; T a1871; T a1872; T a1873; T a1874; T a1875; T a1876; T a1877; T a1878; T a1879; + T a1880; T a1881; T a1882; T a1883; T a1884; T a1885; T a1886; T a1887; T a1888; T a1889; + T a1890; T a1891; T a1892; T a1893; T a1894; T a1895; T a1896; T a1897; T a1898; T a1899; + T a1900; T a1901; T a1902; T a1903; T a1904; T a1905; T a1906; T a1907; T a1908; T a1909; + T a1910; T a1911; T a1912; T a1913; T a1914; T a1915; T a1916; T a1917; T a1918; T a1919; + T a1920; T a1921; T a1922; T a1923; T a1924; T a1925; T a1926; T a1927; T a1928; T a1929; + T a1930; T a1931; T a1932; T a1933; T a1934; T a1935; T a1936; T a1937; T a1938; T a1939; + T a1940; T a1941; T a1942; T a1943; T a1944; T a1945; T a1946; T a1947; T a1948; T a1949; + T a1950; T a1951; T a1952; T a1953; T a1954; T a1955; T a1956; T a1957; T a1958; T a1959; + T a1960; T a1961; T a1962; T a1963; T a1964; T a1965; T a1966; T a1967; T a1968; T a1969; + T a1970; T a1971; T a1972; T a1973; T a1974; T a1975; T a1976; T a1977; T a1978; T a1979; + T a1980; T a1981; T a1982; T a1983; T a1984; T a1985; T a1986; T a1987; T a1988; T a1989; + T a1990; T a1991; T a1992; T a1993; T a1994; T a1995; T a1996; T a1997; T a1998; T a1999; + + + T a2000; T a2001; T a2002; T a2003; T a2004; T a2005; T a2006; T a2007; T a2008; T a2009; + T a2010; T a2011; T a2012; T a2013; T a2014; T a2015; T a2016; T a2017; T a2018; T a2019; + T a2020; T a2021; T a2022; T a2023; T a2024; T a2025; T a2026; T a2027; T a2028; T a2029; + T a2030; T a2031; T a2032; T a2033; T a2034; T a2035; T a2036; T a2037; T a2038; T a2039; + T a2040; T a2041; T a2042; T a2043; T a2044; T a2045; T a2046; T a2047; T a2048; T a2049; + T a2050; T a2051; T a2052; T a2053; T a2054; T a2055; T a2056; T a2057; T a2058; T a2059; + T a2060; T a2061; T a2062; T a2063; T a2064; T a2065; T a2066; T a2067; T a2068; T a2069; + T a2070; T a2071; T a2072; T a2073; T a2074; T a2075; T a2076; T a2077; T a2078; T a2079; + T a2080; T a2081; T a2082; T a2083; T a2084; T a2085; T a2086; T a2087; T a2088; T a2089; + T a2090; T a2091; T a2092; T a2093; T a2094; T a2095; T a2096; T a2097; T a2098; T a2099; + T a2100; T a2101; T a2102; T a2103; T a2104; T a2105; T a2106; T a2107; T a2108; T a2109; + T a2110; T a2111; T a2112; T a2113; T a2114; T a2115; T a2116; T a2117; T a2118; T a2119; + T a2120; T a2121; T a2122; T a2123; T a2124; T a2125; T a2126; T a2127; T a2128; T a2129; + T a2130; T a2131; T a2132; T a2133; T a2134; T a2135; T a2136; T a2137; T a2138; T a2139; + T a2140; T a2141; T a2142; T a2143; T a2144; T a2145; T a2146; T a2147; T a2148; T a2149; + T a2150; T a2151; T a2152; T a2153; T a2154; T a2155; T a2156; T a2157; T a2158; T a2159; + T a2160; T a2161; T a2162; T a2163; T a2164; T a2165; T a2166; T a2167; T a2168; T a2169; + T a2170; T a2171; T a2172; T a2173; T a2174; T a2175; T a2176; T a2177; T a2178; T a2179; + T a2180; T a2181; T a2182; T a2183; T a2184; T a2185; T a2186; T a2187; T a2188; T a2189; + T a2190; T a2191; T a2192; T a2193; T a2194; T a2195; T a2196; T a2197; T a2198; T a2199; + T a2200; T a2201; T a2202; T a2203; T a2204; T a2205; T a2206; T a2207; T a2208; T a2209; + T a2210; T a2211; T a2212; T a2213; T a2214; T a2215; T a2216; T a2217; T a2218; T a2219; + T a2220; T a2221; T a2222; T a2223; T a2224; T a2225; T a2226; T a2227; T a2228; T a2229; + T a2230; T a2231; T a2232; T a2233; T a2234; T a2235; T a2236; T a2237; T a2238; T a2239; + T a2240; T a2241; T a2242; T a2243; T a2244; T a2245; T a2246; T a2247; T a2248; T a2249; + T a2250; T a2251; T a2252; T a2253; T a2254; T a2255; T a2256; T a2257; T a2258; T a2259; + T a2260; T a2261; T a2262; T a2263; T a2264; T a2265; T a2266; T a2267; T a2268; T a2269; + T a2270; T a2271; T a2272; T a2273; T a2274; T a2275; T a2276; T a2277; T a2278; T a2279; + T a2280; T a2281; T a2282; T a2283; T a2284; T a2285; T a2286; T a2287; T a2288; T a2289; + T a2290; T a2291; T a2292; T a2293; T a2294; T a2295; T a2296; T a2297; T a2298; T a2299; + T a2300; T a2301; T a2302; T a2303; T a2304; T a2305; T a2306; T a2307; T a2308; T a2309; + T a2310; T a2311; T a2312; T a2313; T a2314; T a2315; T a2316; T a2317; T a2318; T a2319; + T a2320; T a2321; T a2322; T a2323; T a2324; T a2325; T a2326; T a2327; T a2328; T a2329; + T a2330; T a2331; T a2332; T a2333; T a2334; T a2335; T a2336; T a2337; T a2338; T a2339; + T a2340; T a2341; T a2342; T a2343; T a2344; T a2345; T a2346; T a2347; T a2348; T a2349; + T a2350; T a2351; T a2352; T a2353; T a2354; T a2355; T a2356; T a2357; T a2358; T a2359; + T a2360; T a2361; T a2362; T a2363; T a2364; T a2365; T a2366; T a2367; T a2368; T a2369; + T a2370; T a2371; T a2372; T a2373; T a2374; T a2375; T a2376; T a2377; T a2378; T a2379; + T a2380; T a2381; T a2382; T a2383; T a2384; T a2385; T a2386; T a2387; T a2388; T a2389; + T a2390; T a2391; T a2392; T a2393; T a2394; T a2395; T a2396; T a2397; T a2398; T a2399; + T a2400; T a2401; T a2402; T a2403; T a2404; T a2405; T a2406; T a2407; T a2408; T a2409; + T a2410; T a2411; T a2412; T a2413; T a2414; T a2415; T a2416; T a2417; T a2418; T a2419; + T a2420; T a2421; T a2422; T a2423; T a2424; T a2425; T a2426; T a2427; T a2428; T a2429; + T a2430; T a2431; T a2432; T a2433; T a2434; T a2435; T a2436; T a2437; T a2438; T a2439; + T a2440; T a2441; T a2442; T a2443; T a2444; T a2445; T a2446; T a2447; T a2448; T a2449; + T a2450; T a2451; T a2452; T a2453; T a2454; T a2455; T a2456; T a2457; T a2458; T a2459; + T a2460; T a2461; T a2462; T a2463; T a2464; T a2465; T a2466; T a2467; T a2468; T a2469; + T a2470; T a2471; T a2472; T a2473; T a2474; T a2475; T a2476; T a2477; T a2478; T a2479; + T a2480; T a2481; T a2482; T a2483; T a2484; T a2485; T a2486; T a2487; T a2488; T a2489; + T a2490; T a2491; T a2492; T a2493; T a2494; T a2495; T a2496; T a2497; T a2498; T a2499; + T a2500; T a2501; T a2502; T a2503; T a2504; T a2505; T a2506; T a2507; T a2508; T a2509; + T a2510; T a2511; T a2512; T a2513; T a2514; T a2515; T a2516; T a2517; T a2518; T a2519; + T a2520; T a2521; T a2522; T a2523; T a2524; T a2525; T a2526; T a2527; T a2528; T a2529; + T a2530; T a2531; T a2532; T a2533; T a2534; T a2535; T a2536; T a2537; T a2538; T a2539; + T a2540; T a2541; T a2542; T a2543; T a2544; T a2545; T a2546; T a2547; T a2548; T a2549; + T a2550; T a2551; T a2552; T a2553; T a2554; T a2555; T a2556; T a2557; T a2558; T a2559; + T a2560; T a2561; T a2562; T a2563; T a2564; T a2565; T a2566; T a2567; T a2568; T a2569; + T a2570; T a2571; T a2572; T a2573; T a2574; T a2575; T a2576; T a2577; T a2578; T a2579; + T a2580; T a2581; T a2582; T a2583; T a2584; T a2585; T a2586; T a2587; T a2588; T a2589; + T a2590; T a2591; T a2592; T a2593; T a2594; T a2595; T a2596; T a2597; T a2598; T a2599; + T a2600; T a2601; T a2602; T a2603; T a2604; T a2605; T a2606; T a2607; T a2608; T a2609; + T a2610; T a2611; T a2612; T a2613; T a2614; T a2615; T a2616; T a2617; T a2618; T a2619; + T a2620; T a2621; T a2622; T a2623; T a2624; T a2625; T a2626; T a2627; T a2628; T a2629; + T a2630; T a2631; T a2632; T a2633; T a2634; T a2635; T a2636; T a2637; T a2638; T a2639; + T a2640; T a2641; T a2642; T a2643; T a2644; T a2645; T a2646; T a2647; T a2648; T a2649; + T a2650; T a2651; T a2652; T a2653; T a2654; T a2655; T a2656; T a2657; T a2658; T a2659; + T a2660; T a2661; T a2662; T a2663; T a2664; T a2665; T a2666; T a2667; T a2668; T a2669; + T a2670; T a2671; T a2672; T a2673; T a2674; T a2675; T a2676; T a2677; T a2678; T a2679; + T a2680; T a2681; T a2682; T a2683; T a2684; T a2685; T a2686; T a2687; T a2688; T a2689; + T a2690; T a2691; T a2692; T a2693; T a2694; T a2695; T a2696; T a2697; T a2698; T a2699; + T a2700; T a2701; T a2702; T a2703; T a2704; T a2705; T a2706; T a2707; T a2708; T a2709; + T a2710; T a2711; T a2712; T a2713; T a2714; T a2715; T a2716; T a2717; T a2718; T a2719; + T a2720; T a2721; T a2722; T a2723; T a2724; T a2725; T a2726; T a2727; T a2728; T a2729; + T a2730; T a2731; T a2732; T a2733; T a2734; T a2735; T a2736; T a2737; T a2738; T a2739; + T a2740; T a2741; T a2742; T a2743; T a2744; T a2745; T a2746; T a2747; T a2748; T a2749; + T a2750; T a2751; T a2752; T a2753; T a2754; T a2755; T a2756; T a2757; T a2758; T a2759; + T a2760; T a2761; T a2762; T a2763; T a2764; T a2765; T a2766; T a2767; T a2768; T a2769; + T a2770; T a2771; T a2772; T a2773; T a2774; T a2775; T a2776; T a2777; T a2778; T a2779; + T a2780; T a2781; T a2782; T a2783; T a2784; T a2785; T a2786; T a2787; T a2788; T a2789; + T a2790; T a2791; T a2792; T a2793; T a2794; T a2795; T a2796; T a2797; T a2798; T a2799; + T a2800; T a2801; T a2802; T a2803; T a2804; T a2805; T a2806; T a2807; T a2808; T a2809; + T a2810; T a2811; T a2812; T a2813; T a2814; T a2815; T a2816; T a2817; T a2818; T a2819; + T a2820; T a2821; T a2822; T a2823; T a2824; T a2825; T a2826; T a2827; T a2828; T a2829; + T a2830; T a2831; T a2832; T a2833; T a2834; T a2835; T a2836; T a2837; T a2838; T a2839; + T a2840; T a2841; T a2842; T a2843; T a2844; T a2845; T a2846; T a2847; T a2848; T a2849; + T a2850; T a2851; T a2852; T a2853; T a2854; T a2855; T a2856; T a2857; T a2858; T a2859; + T a2860; T a2861; T a2862; T a2863; T a2864; T a2865; T a2866; T a2867; T a2868; T a2869; + T a2870; T a2871; T a2872; T a2873; T a2874; T a2875; T a2876; T a2877; T a2878; T a2879; + T a2880; T a2881; T a2882; T a2883; T a2884; T a2885; T a2886; T a2887; T a2888; T a2889; + T a2890; T a2891; T a2892; T a2893; T a2894; T a2895; T a2896; T a2897; T a2898; T a2899; + T a2900; T a2901; T a2902; T a2903; T a2904; T a2905; T a2906; T a2907; T a2908; T a2909; + T a2910; T a2911; T a2912; T a2913; T a2914; T a2915; T a2916; T a2917; T a2918; T a2919; + T a2920; T a2921; T a2922; T a2923; T a2924; T a2925; T a2926; T a2927; T a2928; T a2929; + T a2930; T a2931; T a2932; T a2933; T a2934; T a2935; T a2936; T a2937; T a2938; T a2939; + T a2940; T a2941; T a2942; T a2943; T a2944; T a2945; T a2946; T a2947; T a2948; T a2949; + T a2950; T a2951; T a2952; T a2953; T a2954; T a2955; T a2956; T a2957; T a2958; T a2959; + T a2960; T a2961; T a2962; T a2963; T a2964; T a2965; T a2966; T a2967; T a2968; T a2969; + T a2970; T a2971; T a2972; T a2973; T a2974; T a2975; T a2976; T a2977; T a2978; T a2979; + T a2980; T a2981; T a2982; T a2983; T a2984; T a2985; T a2986; T a2987; T a2988; T a2989; + T a2990; T a2991; T a2992; T a2993; T a2994; T a2995; T a2996; T a2997; T a2998; T a2999; + + + T a3000; T a3001; T a3002; T a3003; T a3004; T a3005; T a3006; T a3007; T a3008; T a3009; + T a3010; T a3011; T a3012; T a3013; T a3014; T a3015; T a3016; T a3017; T a3018; T a3019; + T a3020; T a3021; T a3022; T a3023; T a3024; T a3025; T a3026; T a3027; T a3028; T a3029; + T a3030; T a3031; T a3032; T a3033; T a3034; T a3035; T a3036; T a3037; T a3038; T a3039; + T a3040; T a3041; T a3042; T a3043; T a3044; T a3045; T a3046; T a3047; T a3048; T a3049; + T a3050; T a3051; T a3052; T a3053; T a3054; T a3055; T a3056; T a3057; T a3058; T a3059; + T a3060; T a3061; T a3062; T a3063; T a3064; T a3065; T a3066; T a3067; T a3068; T a3069; + T a3070; T a3071; T a3072; T a3073; T a3074; T a3075; T a3076; T a3077; T a3078; T a3079; + T a3080; T a3081; T a3082; T a3083; T a3084; T a3085; T a3086; T a3087; T a3088; T a3089; + T a3090; T a3091; T a3092; T a3093; T a3094; T a3095; T a3096; T a3097; T a3098; T a3099; + T a3100; T a3101; T a3102; T a3103; T a3104; T a3105; T a3106; T a3107; T a3108; T a3109; + T a3110; T a3111; T a3112; T a3113; T a3114; T a3115; T a3116; T a3117; T a3118; T a3119; + T a3120; T a3121; T a3122; T a3123; T a3124; T a3125; T a3126; T a3127; T a3128; T a3129; + T a3130; T a3131; T a3132; T a3133; T a3134; T a3135; T a3136; T a3137; T a3138; T a3139; + T a3140; T a3141; T a3142; T a3143; T a3144; T a3145; T a3146; T a3147; T a3148; T a3149; + T a3150; T a3151; T a3152; T a3153; T a3154; T a3155; T a3156; T a3157; T a3158; T a3159; + T a3160; T a3161; T a3162; T a3163; T a3164; T a3165; T a3166; T a3167; T a3168; T a3169; + T a3170; T a3171; T a3172; T a3173; T a3174; T a3175; T a3176; T a3177; T a3178; T a3179; + T a3180; T a3181; T a3182; T a3183; T a3184; T a3185; T a3186; T a3187; T a3188; T a3189; + T a3190; T a3191; T a3192; T a3193; T a3194; T a3195; T a3196; T a3197; T a3198; T a3199; + T a3200; T a3201; T a3202; T a3203; T a3204; T a3205; T a3206; T a3207; T a3208; T a3209; + T a3210; T a3211; T a3212; T a3213; T a3214; T a3215; T a3216; T a3217; T a3218; T a3219; + T a3220; T a3221; T a3222; T a3223; T a3224; T a3225; T a3226; T a3227; T a3228; T a3229; + T a3230; T a3231; T a3232; T a3233; T a3234; T a3235; T a3236; T a3237; T a3238; T a3239; + T a3240; T a3241; T a3242; T a3243; T a3244; T a3245; T a3246; T a3247; T a3248; T a3249; + T a3250; T a3251; T a3252; T a3253; T a3254; T a3255; T a3256; T a3257; T a3258; T a3259; + T a3260; T a3261; T a3262; T a3263; T a3264; T a3265; T a3266; T a3267; T a3268; T a3269; + T a3270; T a3271; T a3272; T a3273; T a3274; T a3275; T a3276; T a3277; T a3278; T a3279; + T a3280; T a3281; T a3282; T a3283; T a3284; T a3285; T a3286; T a3287; T a3288; T a3289; + T a3290; T a3291; T a3292; T a3293; T a3294; T a3295; T a3296; T a3297; T a3298; T a3299; + T a3300; T a3301; T a3302; T a3303; T a3304; T a3305; T a3306; T a3307; T a3308; T a3309; + T a3310; T a3311; T a3312; T a3313; T a3314; T a3315; T a3316; T a3317; T a3318; T a3319; + T a3320; T a3321; T a3322; T a3323; T a3324; T a3325; T a3326; T a3327; T a3328; T a3329; + T a3330; T a3331; T a3332; T a3333; T a3334; T a3335; T a3336; T a3337; T a3338; T a3339; + T a3340; T a3341; T a3342; T a3343; T a3344; T a3345; T a3346; T a3347; T a3348; T a3349; + T a3350; T a3351; T a3352; T a3353; T a3354; T a3355; T a3356; T a3357; T a3358; T a3359; + T a3360; T a3361; T a3362; T a3363; T a3364; T a3365; T a3366; T a3367; T a3368; T a3369; + T a3370; T a3371; T a3372; T a3373; T a3374; T a3375; T a3376; T a3377; T a3378; T a3379; + T a3380; T a3381; T a3382; T a3383; T a3384; T a3385; T a3386; T a3387; T a3388; T a3389; + T a3390; T a3391; T a3392; T a3393; T a3394; T a3395; T a3396; T a3397; T a3398; T a3399; + T a3400; T a3401; T a3402; T a3403; T a3404; T a3405; T a3406; T a3407; T a3408; T a3409; + T a3410; T a3411; T a3412; T a3413; T a3414; T a3415; T a3416; T a3417; T a3418; T a3419; + T a3420; T a3421; T a3422; T a3423; T a3424; T a3425; T a3426; T a3427; T a3428; T a3429; + T a3430; T a3431; T a3432; T a3433; T a3434; T a3435; T a3436; T a3437; T a3438; T a3439; + T a3440; T a3441; T a3442; T a3443; T a3444; T a3445; T a3446; T a3447; T a3448; T a3449; + T a3450; T a3451; T a3452; T a3453; T a3454; T a3455; T a3456; T a3457; T a3458; T a3459; + T a3460; T a3461; T a3462; T a3463; T a3464; T a3465; T a3466; T a3467; T a3468; T a3469; + T a3470; T a3471; T a3472; T a3473; T a3474; T a3475; T a3476; T a3477; T a3478; T a3479; + T a3480; T a3481; T a3482; T a3483; T a3484; T a3485; T a3486; T a3487; T a3488; T a3489; + T a3490; T a3491; T a3492; T a3493; T a3494; T a3495; T a3496; T a3497; T a3498; T a3499; + T a3500; T a3501; T a3502; T a3503; T a3504; T a3505; T a3506; T a3507; T a3508; T a3509; + T a3510; T a3511; T a3512; T a3513; T a3514; T a3515; T a3516; T a3517; T a3518; T a3519; + T a3520; T a3521; T a3522; T a3523; T a3524; T a3525; T a3526; T a3527; T a3528; T a3529; + T a3530; T a3531; T a3532; T a3533; T a3534; T a3535; T a3536; T a3537; T a3538; T a3539; + T a3540; T a3541; T a3542; T a3543; T a3544; T a3545; T a3546; T a3547; T a3548; T a3549; + T a3550; T a3551; T a3552; T a3553; T a3554; T a3555; T a3556; T a3557; T a3558; T a3559; + T a3560; T a3561; T a3562; T a3563; T a3564; T a3565; T a3566; T a3567; T a3568; T a3569; + T a3570; T a3571; T a3572; T a3573; T a3574; T a3575; T a3576; T a3577; T a3578; T a3579; + T a3580; T a3581; T a3582; T a3583; T a3584; T a3585; T a3586; T a3587; T a3588; T a3589; + T a3590; T a3591; T a3592; T a3593; T a3594; T a3595; T a3596; T a3597; T a3598; T a3599; + T a3600; T a3601; T a3602; T a3603; T a3604; T a3605; T a3606; T a3607; T a3608; T a3609; + T a3610; T a3611; T a3612; T a3613; T a3614; T a3615; T a3616; T a3617; T a3618; T a3619; + T a3620; T a3621; T a3622; T a3623; T a3624; T a3625; T a3626; T a3627; T a3628; T a3629; + T a3630; T a3631; T a3632; T a3633; T a3634; T a3635; T a3636; T a3637; T a3638; T a3639; + T a3640; T a3641; T a3642; T a3643; T a3644; T a3645; T a3646; T a3647; T a3648; T a3649; + T a3650; T a3651; T a3652; T a3653; T a3654; T a3655; T a3656; T a3657; T a3658; T a3659; + T a3660; T a3661; T a3662; T a3663; T a3664; T a3665; T a3666; T a3667; T a3668; T a3669; + T a3670; T a3671; T a3672; T a3673; T a3674; T a3675; T a3676; T a3677; T a3678; T a3679; + T a3680; T a3681; T a3682; T a3683; T a3684; T a3685; T a3686; T a3687; T a3688; T a3689; + T a3690; T a3691; T a3692; T a3693; T a3694; T a3695; T a3696; T a3697; T a3698; T a3699; + T a3700; T a3701; T a3702; T a3703; T a3704; T a3705; T a3706; T a3707; T a3708; T a3709; + T a3710; T a3711; T a3712; T a3713; T a3714; T a3715; T a3716; T a3717; T a3718; T a3719; + T a3720; T a3721; T a3722; T a3723; T a3724; T a3725; T a3726; T a3727; T a3728; T a3729; + T a3730; T a3731; T a3732; T a3733; T a3734; T a3735; T a3736; T a3737; T a3738; T a3739; + T a3740; T a3741; T a3742; T a3743; T a3744; T a3745; T a3746; T a3747; T a3748; T a3749; + T a3750; T a3751; T a3752; T a3753; T a3754; T a3755; T a3756; T a3757; T a3758; T a3759; + T a3760; T a3761; T a3762; T a3763; T a3764; T a3765; T a3766; T a3767; T a3768; T a3769; + T a3770; T a3771; T a3772; T a3773; T a3774; T a3775; T a3776; T a3777; T a3778; T a3779; + T a3780; T a3781; T a3782; T a3783; T a3784; T a3785; T a3786; T a3787; T a3788; T a3789; + T a3790; T a3791; T a3792; T a3793; T a3794; T a3795; T a3796; T a3797; T a3798; T a3799; + T a3800; T a3801; T a3802; T a3803; T a3804; T a3805; T a3806; T a3807; T a3808; T a3809; + T a3810; T a3811; T a3812; T a3813; T a3814; T a3815; T a3816; T a3817; T a3818; T a3819; + T a3820; T a3821; T a3822; T a3823; T a3824; T a3825; T a3826; T a3827; T a3828; T a3829; + T a3830; T a3831; T a3832; T a3833; T a3834; T a3835; T a3836; T a3837; T a3838; T a3839; + T a3840; T a3841; T a3842; T a3843; T a3844; T a3845; T a3846; T a3847; T a3848; T a3849; + T a3850; T a3851; T a3852; T a3853; T a3854; T a3855; T a3856; T a3857; T a3858; T a3859; + T a3860; T a3861; T a3862; T a3863; T a3864; T a3865; T a3866; T a3867; T a3868; T a3869; + T a3870; T a3871; T a3872; T a3873; T a3874; T a3875; T a3876; T a3877; T a3878; T a3879; + T a3880; T a3881; T a3882; T a3883; T a3884; T a3885; T a3886; T a3887; T a3888; T a3889; + T a3890; T a3891; T a3892; T a3893; T a3894; T a3895; T a3896; T a3897; T a3898; T a3899; + T a3900; T a3901; T a3902; T a3903; T a3904; T a3905; T a3906; T a3907; T a3908; T a3909; + T a3910; T a3911; T a3912; T a3913; T a3914; T a3915; T a3916; T a3917; T a3918; T a3919; + T a3920; T a3921; T a3922; T a3923; T a3924; T a3925; T a3926; T a3927; T a3928; T a3929; + T a3930; T a3931; T a3932; T a3933; T a3934; T a3935; T a3936; T a3937; T a3938; T a3939; + T a3940; T a3941; T a3942; T a3943; T a3944; T a3945; T a3946; T a3947; T a3948; T a3949; + T a3950; T a3951; T a3952; T a3953; T a3954; T a3955; T a3956; T a3957; T a3958; T a3959; + T a3960; T a3961; T a3962; T a3963; T a3964; T a3965; T a3966; T a3967; T a3968; T a3969; + T a3970; T a3971; T a3972; T a3973; T a3974; T a3975; T a3976; T a3977; T a3978; T a3979; + T a3980; T a3981; T a3982; T a3983; T a3984; T a3985; T a3986; T a3987; T a3988; T a3989; + T a3990; T a3991; T a3992; T a3993; T a3994; T a3995; T a3996; T a3997; T a3998; T a3999; +}; + +A::A() {}
cleanup1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: alias1.C =================================================================== --- alias1.C (nonexistent) +++ alias1.C (revision 816) @@ -0,0 +1,42 @@ +// { dg-do run } +// { dg-options "-O3" } +/* PR c++/28139: disjoint alias sets for the store from + expand_start_catch_block than for loading P result in P being loaded + before it is initialized for sh-elf. */ + +extern "C" { +void exit (int) __attribute__ ((noreturn)); +} + +int i_glob = 42; +int *p0 = &i_glob; +typedef int **ipp; + +void +g (int i) +{ + if (!i_glob) + exit ((__SIZE_TYPE__) & i); +} + +static void +h () +{ + throw &p0; +} + +int +main() +{ + g (42); + try + { + h (); + } + catch (const ipp &p) + { + if (**p != 42) + exit (1); + } + return 0; +}
alias1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cleanup3.C =================================================================== --- cleanup3.C (nonexistent) +++ cleanup3.C (revision 816) @@ -0,0 +1,20 @@ +// C++/4794 +// This test used to hang in has_cleanups +// Contributed by: +/* { dg-do compile } */ + +void foo (int a,int b,int c,int d,int e,int f,int g,int h,int i,int j,int k, + int l,int m,int n,int o,int p,int q,int r,int s,int t,int u,int v,int w, + int x,int y,int z,int aa,int ab,int ac) +{ +if (!((((ac != 0) + (d != 0) + (c != 0) + (f != 0) + (x != 0) + (y != 0) + + (z != 0) + (aa != 0) + (ab != 0) + (g != 0) + (b != 0) + (a != 0) + + (h != 0) + (e != 0) + (p != 0) + (q != 0) + (n != 0) + (r != 0) + + (o != 0) + (v != 0) + (w != 0) + (t != 0) + (u != 0) + (s != 0) + + (k != 0) + (l != 0) + (m != 0) + (i != 0) + (j != 0)) <= 1))) + { + return; + } +} + +
cleanup3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: new1.C =================================================================== --- new1.C (nonexistent) +++ new1.C (revision 816) @@ -0,0 +1,40 @@ +// PR c++/5757 +// Test that when a constructor throws in a new-expression, we pass the +// right pointer to operator delete. + +// { dg-do run } + +#include + +int ret = 1; + +void *ptr; +void * operator new[] (size_t s) throw (std::bad_alloc) +{ + ptr = operator new (s); + return ptr; +} + +void operator delete[] (void *p) throw () +{ + if (p == ptr) + ret = 0; + operator delete (p); +} + +struct A +{ + A() { throw 1; } + ~A() {} +}; + +int +main () +{ + try + { + A *p = new A[4]; + } + catch (...) {} + return ret; +}
new1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cleanup5.C =================================================================== --- cleanup5.C (nonexistent) +++ cleanup5.C (revision 816) @@ -0,0 +1,17 @@ +// PR 17907 +// { dg-do compile } +// { dg-options "" } +// We lost a CLEANUP_POINT_EXPR, leading to a crash destroying temp of A. + + +struct String { + ~String(); + int size() const; +}; +struct CodingSystem { + String convertOut() const; +}; +void inputOpened(CodingSystem *outputCodingSystem) +{ + char filePath[outputCodingSystem->convertOut().size()]; +}
cleanup5.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dead1.C =================================================================== --- dead1.C (nonexistent) +++ dead1.C (revision 816) @@ -0,0 +1,20 @@ +// PR 6320 +// Rechained the MUST_NOT_THROW region in the wrong order wrt the +// TRY/CATCH while removing them and got confused. +// { dg-do compile } + +struct S { + ~S(); +}; + +void foo() +{ + try { + return; + } + catch (int) { + } + catch (...) { + S s; + } +}
dead1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: delayslot1.C =================================================================== --- delayslot1.C (nonexistent) +++ delayslot1.C (revision 816) @@ -0,0 +1,47 @@ +// PR target/12301 +// Origin: Colin Hirsch +// Testcase by Christian Ehrhardt + +// This used to fail on SPARC because the reorg pass moved an insn +// across a function call that can throw internally, in order to put +// it in a delay slot. + +// { dg-do run } +// { dg-options "-O" } + +struct S{ + char *c; + char data[100]; + S () : c (data) {}; + S (const S& s) { + c = data; + data[0] = s.c[0]; + } +}; + +S real_cast () +{ + throw 3; +} + +S cast_helper(S& debug) +{ + try { + return real_cast(); + } + catch (int e) { + throw debug; + } +} + +int main() +{ + S tmp; + + try { + cast_helper (tmp); + } + catch (S& e) {} + + return 0; +}
delayslot1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: div.C =================================================================== --- div.C (nonexistent) +++ div.C (revision 816) @@ -0,0 +1,13 @@ +// { dg-do link } +// { dg-options "-Os" } +/* PR target/28014: main references unsigned divide, and the unwinder + references signed divide. + If libgcc contains an object which defines both, and linking is done with + a space-optimized library that defines these functions in separate objects, + you end up with the function for unsigned divide defined twice. */ +int +main (int c, char **argv) + +{ + return 0xffffU/c; +}
div.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: forced2.C =================================================================== --- forced2.C (nonexistent) +++ forced2.C (revision 816) @@ -0,0 +1,53 @@ +// HP-UX libunwind.so doesn't provide _UA_END_OF_STACK. +// { dg-do run { xfail "ia64-hp-hpux11.*" } } + +// Test that leaving the catch block without rethrowing +// does call the exception object destructor. + +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void +force_unwind_cleanup (_Unwind_Reason_Code, struct _Unwind_Exception *) +{ + exit (0); +} + +static void +force_unwind () +{ + _Unwind_Exception *exc = new _Unwind_Exception; + // exception_class might not be a scalar. + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = force_unwind_cleanup; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +int main() +{ + try { + force_unwind (); + } catch (...) { + } + abort (); +}
forced2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: unwind1.C =================================================================== --- unwind1.C (nonexistent) +++ unwind1.C (revision 816) @@ -0,0 +1,25 @@ +// PR middle-end/28493 + +extern "C" void abort (); + +struct Command *ptr; + +struct Command { + Command() { ptr = this; } + virtual ~Command() { if (ptr != this) abort(); } +}; + +void tryfunc() +{ + Command cmd; + throw 1; +} + +int main() +{ + try + { + tryfunc(); + } + catch (int) { } +}
unwind1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: forced4.C =================================================================== --- forced4.C (nonexistent) +++ forced4.C (revision 816) @@ -0,0 +1,52 @@ +// HP-UX libunwind.so doesn't provide _UA_END_OF_STACK. +// { dg-do run { xfail "ia64-hp-hpux11.*" } } + +// Test that forced unwinding does not call std::unexpected going +// throw a function with a non-empty exception spec. + +#include +#include +#include + +static _Unwind_Reason_Code +force_unwind_stop (int version, _Unwind_Action actions, + _Unwind_Exception_Class exc_class, + struct _Unwind_Exception *exc_obj, + struct _Unwind_Context *context, + void *stop_parameter) +{ + if (actions & _UA_END_OF_STACK) + abort (); + return _URC_NO_REASON; +} + +static void __attribute__((noreturn)) +force_unwind () +{ + _Unwind_Exception *exc = new _Unwind_Exception; + // exception_class might not be a scalar. + memset (&exc->exception_class, 0, sizeof (exc->exception_class)); + exc->exception_cleanup = 0; + +#ifndef __USING_SJLJ_EXCEPTIONS__ + _Unwind_ForcedUnwind (exc, force_unwind_stop, 0); +#else + _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0); +#endif + + abort (); +} + +static void +doit () throw(int) +{ + force_unwind (); +} + +int main() +{ + try { + doit (); + } catch (...) { + } +}
forced4.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ctor1.C =================================================================== --- ctor1.C (nonexistent) +++ ctor1.C (revision 816) @@ -0,0 +1,42 @@ +// { dg-do run } + +// Copyright (C) 2001 Free Software Foundation, Inc. +// Contributed by Nathan Sidwell 26 Dec 2001 + +// PR 411 + +bool was_f_in_Bar_destroyed=false; + +struct Foo +{ + ~Foo() + { + was_f_in_Bar_destroyed=true; + } +}; + +struct Bar +{ + ~Bar() + { + throw 1; + } + + Foo f; +}; + +int main() +{ + try + { + Bar f; + } + catch(int i) + { + if(was_f_in_Bar_destroyed) + { + return 0; + } + } + return 1; +}
ctor1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: dtor2.C =================================================================== --- dtor2.C (nonexistent) +++ dtor2.C (revision 816) @@ -0,0 +1,30 @@ +// PR c++/12751 +// tree-ssa eh lowering bug ran a destructor twice for one object +// { dg-do run } + +static int check; + +struct Y { + Y(); + ~Y(); +}; + +void foo() { + Y y1; + Y y2; + switch(0) { + case 1: { + Y y3; + return; + } + } +} + +Y::Y() { ++check; } +Y::~Y() { --check; } + +int main() +{ + foo (); + return check; +}
dtor2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: ctor3.C =================================================================== --- ctor3.C (nonexistent) +++ ctor3.C (revision 816) @@ -0,0 +1,18 @@ +// PR C++/18984 +// We just to ICE as we did not add a +// deference to invisible by reference +// variable + +// { dg-do compile } + + +struct Str +{ + Str(const char *chars); + Str& operator=(const char *chars); + virtual operator char*() const; +}; +Str _localName(Str fullname) +{ + return (char*)fullname; +}
ctor3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: scope1.C =================================================================== --- scope1.C (nonexistent) +++ scope1.C (revision 816) @@ -0,0 +1,71 @@ +// Test that we've scoped the destructor properly for variables declared +// in a conditional. +// { dg-do run } + +extern "C" void abort (); + +class C +{ + bool live; + public: + C(); + C(const C &); + ~C (); + operator bool() const; +}; + +void f1 () +{ + while (C br = C()) abort (); +} + +void f2 () +{ + for (; C br = C(); ) abort (); +} + +void f3 () +{ + if (C br = C()) abort (); +} + +void f4 () +{ + switch (C br = C()) + { + default: + abort (); + case false: + break; + } +} + +int main() +{ + f1(); f2(); f3(); f4(); + return 0; +} + +C::C() +{ + live = true; +} + +C::C(const C &o) +{ + if (!o.live) + abort (); + live = true; +} + +C::~C() +{ + live = false; +} + +C::operator bool() const +{ + if (!live) + abort (); + return false; +}
scope1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: simd-1.C =================================================================== --- simd-1.C (nonexistent) +++ simd-1.C (revision 816) @@ -0,0 +1,50 @@ +// Test EH when V2SI SIMD registers are involved. +// Contributed by Aldy Hernandez (aldy@quesejoda.com). +// { dg-options "-O" } +// { dg-options "-O -w" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } +// { dg-do run } + +typedef int __attribute__((vector_size (8))) vecint; + +vecint vecfunc (vecint beachbum) +{ + return beachbum; +} + +void f3 (void) +{ + /* Force a use of a V2SI register if available. On the PPC/E500, + this will cause the compiler to save the registers in this + function in 64-bits. */ + vecint foobar = (vecint) {0, 0}; + foobar = vecfunc (foobar); + + throw int(); +} + +void f2 (void) +{ + vecint foobar = (vecint) {0, 0}; + foobar = vecfunc (foobar); + + f3 (); +} + +void f1 (void) +{ + int i; + try + { + f2 (); + } + catch (int) + { + i = 9; + } +} + +int main () +{ + f1 (); + return 0; +}
simd-1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: simd-3.C =================================================================== --- simd-3.C (nonexistent) +++ simd-3.C (revision 816) @@ -0,0 +1,65 @@ +// { dg-options "-O" } +// { dg-options "-O -maltivec" { target { powerpc*-*-darwin* && powerpc_altivec_ok } } } +// { dg-do run } + +#include +#include + +typedef int __attribute__((vector_size(16))) v; + +v vv[32]; +volatile v vt = { 1, 2, 3, 4 }; + +void clobber_vrs(void) { }; + +void (*volatile fp)() = clobber_vrs; + +void thrower(void) +{ + v v00 = vv[ 0]; + v v01 = vv[ 1]; + v v02 = vv[ 2]; + v v03 = vv[ 3]; + v v04 = vv[ 4]; + v v05 = vv[ 5]; + v v06 = vv[ 6]; + v v07 = vv[ 7]; + v v08 = vv[ 8]; + v v09 = vv[ 9]; + v v10 = vv[10]; + v v11 = vv[11]; + v v12 = vv[12]; + + fp(); + + vv[ 0] = v00; + vv[ 1] = v01; + vv[ 2] = v02; + vv[ 3] = v03; + vv[ 4] = v04; + vv[ 5] = v05; + vv[ 6] = v06; + vv[ 7] = v07; + vv[ 8] = v08; + vv[ 9] = v09; + vv[10] = v10; + vv[11] = v11; + vv[12] = v12; + + throw 3; +} + +v v2; + +int main(void) +{ + v v1 = vt; + try { + thrower(); + } catch (int x) { + } + v2 = v1; + if (memcmp (&v2, (v *)&vt, sizeof (v2)) != 0) + abort (); + return 0; +}
simd-3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: template2.C =================================================================== --- template2.C (nonexistent) +++ template2.C (revision 816) @@ -0,0 +1,19 @@ +// { dg-do compile } +// { dg-options -O2 } + +template struct O { + O(T *p) : q(p) { } + T *q; +}; +struct W { + virtual ~W(); +}; +struct S : public W { + S (int *); +}; +W *bar(int); +S::S (int *x) +{ + for (int *p = x; *p; p++) + O i (bar (*p)); +}
template2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cond1.C =================================================================== --- cond1.C (nonexistent) +++ cond1.C (revision 816) @@ -0,0 +1,64 @@ +// PR c++/7050 +// { dg-do run } + +extern "C" void abort(void); + +#define CI(stmt) try { stmt; abort(); } catch (int) { } + +struct has_destructor +{ + ~has_destructor() { } +}; + +struct no_destructor +{ +}; + +int PI(int& i) { return i++; } + +int main(int argc, char *argv[]) +{ + (argc+1 ? has_destructor() : throw 0); + CI((argc+1 ? throw 0 : has_destructor())); + CI((0 ? has_destructor() : throw 0)); + CI((1 ? throw 0 : has_destructor())); + (0 ? throw 0 : has_destructor()); + (1 ? has_destructor() : throw 0); + + (argc+1 ? no_destructor() : throw 0); + CI((argc+1 ? throw 0 : no_destructor())); + CI((0 ? no_destructor() : throw 0)); + CI((1 ? throw 0 : no_destructor())); + (0 ? throw 0 : no_destructor()); + (1 ? no_destructor() : throw 0); + + int i = 1; + CI(throw PI(i)); + if (i != 2) abort(); + + (1 ? 0 : throw PI(i)); + if (i != 2) abort(); + + CI(0 ? 0 : throw PI(i)); + if (i != 3) abort(); + + CI(0 ? has_destructor() : throw PI(i)); + if (i != 4) abort(); + (argc+1 ? has_destructor() : throw PI(i)); + if (i != 4) abort(); + + i = 1; + CI(throw i++); + if (i != 2) abort(); + + (1 ? 0 : throw i++); + if (i != 2) abort(); + + CI(0 ? 0 : throw i++); + if (i != 3) abort(); + + CI(0 ? has_destructor() : throw i++); + if (i != 4) abort(); + (argc+1 ? has_destructor() : throw i++); + if (i != 4) abort(); +}
cond1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: cond3.C =================================================================== --- cond3.C (nonexistent) +++ cond3.C (revision 816) @@ -0,0 +1,10 @@ +// PR c++/24996 +// Bug: the cleanup for the A temporary was confusing the gimplifier +// because of the TRY_CATCH_EXPR for the exception object. + +struct A { A(int); ~A(); }; +struct B { B(A); ~B(); }; +void foo(bool b) +{ + throw b ? B(1) : B(1); +}
cond3.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: arm-vfp-unwind.C =================================================================== --- arm-vfp-unwind.C (nonexistent) +++ arm-vfp-unwind.C (revision 816) @@ -0,0 +1,40 @@ +/* { dg-do run } */ +/* { dg-require-effective-target arm32 } */ + +/* Test to catch off-by-one errors in arm/pr-support.c. */ + +#if defined (__VFP_FP__) && !defined (__SOFTFP__) + +#include +#include + +using namespace std; + +static void donkey () +{ + asm volatile ("fcpyd d9, %P0" : : "w" (1.2345) : "d9"); + throw 1; +} + +int main() +{ + try + { + donkey (); + } + catch (int foo) + { + return 0; + } + return 1; +} + +#else + +int main() +{ + return 0; +} + +#endif +
arm-vfp-unwind.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spec2.C =================================================================== --- spec2.C (nonexistent) +++ spec2.C (revision 816) @@ -0,0 +1,10 @@ +// { dg-do compile } + +struct S { void f (void); }; + +typedef void f1 (void) throw (int); // { dg-error "exception" } +typedef void (*f2) (void) throw (int); // { dg-error "exception" } +typedef void (S::*f3) (void) throw (int); // { dg-error "exception" } + +void (*f4) (void) throw (int); +void (S::*f5) (void) throw (int);
spec2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spec4.C =================================================================== --- spec4.C (nonexistent) +++ spec4.C (revision 816) @@ -0,0 +1,17 @@ +// PR c++/5104 +// Test that a function with a throw spec is a valid template argument. + +#include + +typedef void (*HandlerFunction)(); +typedef HandlerFunction (*SetHandlerFunction)(HandlerFunction); + +template +class HandlerStack { +public: + static void defaultHandler(); +}; + +typedef HandlerStack Terminate; + +template<> void Terminate::defaultHandler() {}
spec4.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spec6.C =================================================================== --- spec6.C (nonexistent) +++ spec6.C (revision 816) @@ -0,0 +1,19 @@ +// Test that we don't allow incomplete types in an exception-specification +// for a definition, or at a call site. + +// { dg-options "-fpermissive -w" } + +struct A; // { dg-error "" } + +struct B +{ + void f () throw (A); +}; + +void B::f () throw (A) {} // { dg-error "A" } + +int main () +{ + B b; + b.f(); // { dg-error "A" } +}
spec6.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: crash1.C =================================================================== --- crash1.C (nonexistent) +++ crash1.C (revision 816) @@ -0,0 +1,5 @@ +extern "C" void __cxa_throw (void *, void *, void (*) (void *) ); + +void foo(){ + throw 1; +}
crash1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: spec8.C =================================================================== --- spec8.C (nonexistent) +++ spec8.C (revision 816) @@ -0,0 +1,11 @@ +// PR c++/24817 + +struct exception {}; + +template void foo() throw(exception); // { dg-error "declaration" } +template void foo(); // { dg-error "exceptions" } + +struct bar +{ + template friend void foo(); // { dg-error "exceptions" } +};
spec8.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: throw2.C =================================================================== --- throw2.C (nonexistent) +++ throw2.C (revision 816) @@ -0,0 +1,8 @@ +// PR c++/16851 + +struct A { A(int); }; + +void f(int t) +{ + throw (3,A(t)); +}
throw2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: unexpected1.C =================================================================== --- unexpected1.C (nonexistent) +++ unexpected1.C (revision 816) @@ -0,0 +1,46 @@ +// PR 3719 +// Test that an unexpected handler can rethrow to categorize. +// { dg-do run } + +#include + +extern "C" void abort (); + +struct One { }; +struct Two { }; + +static void +handle_unexpected () +{ + try + { + throw; + } + catch (One &) + { + throw Two (); + } +} + +static void +doit () throw (Two) +{ + throw One (); +} + +int main () +{ + std::set_unexpected (handle_unexpected); + + try + { + doit (); + } + catch (Two &) + { + } + catch (...) + { + abort (); + } +}
unexpected1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: synth1.C =================================================================== --- synth1.C (nonexistent) +++ synth1.C (revision 816) @@ -0,0 +1,27 @@ +// PR c++/6179 + +// Bug: we tried to look at the fields of 'const A' to determine the proper +// exception specification for the synthesized copy constructor, but +// TYPE_FIELDS hadn't been set yet, so we incorrectly got a throw() spec. + +struct B +{ + B () {} + B (const B&) { throw 1; } +}; + +struct A; +void f (const A &) {} +struct A +{ + B b; +}; + +int main () +{ + A a; + try + { A a2 (a); } + catch (...) + { } +}
synth1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: nrv1.C =================================================================== --- nrv1.C (nonexistent) +++ nrv1.C (revision 816) @@ -0,0 +1,25 @@ +// PR c++/5636 +// Bug: the named return value optimization interfered with EH cleanups. + +int c, d; + +struct A +{ + A() { ++c; } + ~A() { ++d; } +}; + +A f() +{ + A nrv; + throw 42; + return nrv; +} + +int main() +{ + try + { A a = f(); } + catch (...) { } + return (d < c); +}
nrv1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: comdat1.C =================================================================== --- comdat1.C (nonexistent) +++ comdat1.C (revision 816) @@ -0,0 +1,42 @@ +// PR target/29487 +// { dg-do link } +// { dg-options "-O2" } + +/* This function is not defined. The compiler should optimize away + all calls to it. */ +extern void undefined () throw (); + +extern void f1(); + +inline void f2() { + f1(); +} + +/* This function will be COMDAT if not inlined. */ +inline void f1() {} + +/* This function will be COMDAT. */ +template +void f3() { + if (false) + throw 3; +} + +inline void f4() { + if (false) + throw 7; +} + +int main () { + try { + f1(); + f2(); + f3(); + f4(); + } catch (...) { + /* The compiler should recognize that none of the functions above + can throw exceptions, and therefore remove this code as + unreachable. */ + undefined (); + } +}
comdat1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: loop2.C =================================================================== --- loop2.C (nonexistent) +++ loop2.C (revision 816) @@ -0,0 +1,11 @@ +// Test that breaking out of a handler works. +// { dg-do run } + +int main () +{ + while (1) + { + try { throw 1; } + catch (...) { break; } + } +}
loop2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property

powered by: WebSVN 2.1.0

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