Subversion Repositories openrisc_me

const1.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: range-test-2.C =================================================================== --- range-test-2.C (nonexistent) +++ range-test-2.C (revision 154) @@ -0,0 +1,96 @@ +// Test fold-const.c (fold_range_test) optimizations. +// { dg-do run } */ +// { dg-options "-O2" } */ + +#include +#include +#include + +#if (INT_MAX == 2147483647) && (INT_MIN == -2147483648) \ + && (SCHAR_MIN == -128) && (SCHAR_MAX == 127) \ + && (UCHAR_MIN == 0) && (UCHAR_MAX == 255) + +#ifndef T + +enum enum3 +{ + enum3_zero, + enum3_one, + enum3_two, + enum3_three, + enum3_four, + enum3_five, + enum3_six, + enum3_seven +}; + +int var; +void +check () +{ + ++var; +} + +#define T(IDX, TYPE, TEST, YESARR, NOARR) \ +void __attribute__((noinline)) \ +test##IDX (TYPE x) \ +{ \ + if (TEST) \ + check (); \ +} +#include "range-test-2.C" +#undef T + +int +main () +{ + int i, fails = 0; + +#define C , +#define T(IDX, TYPE, TEST, YESARR, NOARR) \ + { \ + static TYPE yesarr##IDX [] = YESARR; \ + static TYPE noarr##IDX [] = NOARR; \ + for (i = 0; i < (int) (sizeof (yesarr##IDX) / sizeof (TYPE)); ++i) \ + { \ + var = 0; \ + test##IDX (yesarr##IDX [i]); \ + if (var != 1) \ + printf ("test" #IDX " failed for yesarr [%u]\n", i), ++fails; \ + } \ + var = 0; \ + for (i = 0; i < (int) (sizeof (noarr##IDX) / sizeof (TYPE)); ++i) \ + { \ + test##IDX (noarr##IDX [i]); \ + if (var != 0) \ + printf ("test" #IDX " failed for noarr [%u]\n", i), ++fails; \ + } \ + } +#include "range-test-2.C" +#undef T + + if (fails) + abort (); + + exit (0); +} + +#else + +/* Use `C' instead of `,' below to separate array entries. */ + +T(26, enum3, x == enum3_one || x == enum3_two || x == enum3_three, + { enum3_one C enum3_two C enum3_three }, { enum3_zero C enum3_four + C enum3_five C enum3_six C enum3_seven }) + +#endif + +#else + +int +main (void) +{ + return 0; +} + +#endif

range-test-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: builtins1.C =================================================================== --- builtins1.C (nonexistent) +++ builtins1.C (revision 154) @@ -0,0 +1,14 @@ +// PR c++/14791 +// Test if builtins with FILE * arguments work +// { dg-options "-O2 -Wformat" } + +typedef struct _FILE FILE; +FILE *stderr; +extern "C" int printf (__const char *__restrict, ...); +extern "C" int fprintf (FILE *__restrict, __const char *__restrict, ...); + +int main () +{ + printf ("%d\n", 1, 1); // { dg-warning "too many arguments for format" } + fprintf (stderr, "%d\n", 1, 1); // { dg-warning "too many arguments for format" } +}

builtins1.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: pr30252.C =================================================================== --- pr30252.C (nonexistent) +++ pr30252.C (revision 154) @@ -0,0 +1,226 @@ +/* { dg-do run } */ +/* { dg-options "-O -fstrict-aliasing" } */ + +extern "C" void abort (void); +namespace sigc { + template + struct type_trait + { + typedef T_type& pass; + typedef const T_type& take; + typedef T_type* pointer; + }; + template + struct is_base_and_derived + { + struct big { + char memory[64]; + }; + static big is_base_class_(...); + static char is_base_class_(typename type_trait::pointer); + static const bool value = + sizeof(is_base_class_(reinterpret_cast::pointer>(0))) == + sizeof(char); + }; + struct nil; + struct functor_base {}; + template ::value> + struct functor_trait + { + }; + template + struct functor_trait + { + typedef typename T_functor::result_type result_type; + typedef T_functor functor_type; + }; + template + class pointer_functor1 : public functor_base + { + typedef T_return (*function_type)(T_arg1); + function_type func_ptr_; + public: + typedef T_return result_type; + explicit pointer_functor1(function_type _A_func): func_ptr_(_A_func) {} + T_return operator()(typename type_trait::take _A_a1) const + { return func_ptr_(_A_a1); } + }; + template + inline pointer_functor1 + ptr_fun1(T_return (*_A_func)(T_arg1)) + { return pointer_functor1(_A_func); } + struct adaptor_base : public functor_base {}; + template ::value> + struct deduce_result_type + { typedef typename functor_trait::result_type type; }; + template + struct adaptor_functor : public adaptor_base + { + template + struct deduce_result_type + { typedef typename sigc::deduce_result_type::type type; }; + typedef typename functor_trait::result_type result_type; + result_type + operator()() const; + template + typename deduce_result_type::type + operator()(T_arg1 _A_arg1) const + { return functor_(_A_arg1); } + explicit adaptor_functor(const T_functor& _A_functor) + : functor_(_A_functor) + {} + mutable T_functor functor_; + }; + template + typename adaptor_functor::result_type + adaptor_functor::operator()() const + { return functor_(); } + template ::value> struct adaptor_trait; + template + struct adaptor_trait + { + typedef T_functor adaptor_type; + }; + template + struct adaptor_trait + { + typedef typename functor_trait::functor_type functor_type; + typedef adaptor_functor adaptor_type; + }; + template + struct adapts : public adaptor_base + { + typedef typename adaptor_trait::adaptor_type adaptor_type; + explicit adapts(const T_functor& _A_functor) + : functor_(_A_functor) + {} + mutable adaptor_type functor_; + }; + template + struct reference_wrapper + { + }; + template + struct unwrap_reference + { + typedef T_type type; + }; + template + class bound_argument + { + public: + bound_argument(const T_type& _A_argument) + : visited_(_A_argument) + {} + inline T_type& invoke() + { return visited_; } + T_type visited_; + }; + template + class bound_argument< reference_wrapper > + { + }; + template + struct bind_functor; + template + struct bind_functor<-1, T_functor, T_type1> : public adapts + { + typedef typename adapts::adaptor_type adaptor_type; + typedef typename adaptor_type::result_type result_type; + result_type + operator()() + { + return this->functor_.template operator()::type>::pass> (bound1_.invoke()); + } + bind_functor(typename type_trait::take _A_func, typename type_trait::take _A_bound1) + : adapts(_A_func), bound1_(_A_bound1) + {} + bound_argument bound1_; + }; + template + inline bind_functor<-1, T_functor, + T_type1> + bind(const T_functor& _A_func, T_type1 _A_b1) + { return bind_functor<-1, T_functor, + T_type1> + (_A_func, _A_b1); + } + namespace internal { + struct slot_rep; + typedef void* (*hook)(slot_rep *); + struct slot_rep + { + hook call_; + }; + } + class slot_base : public functor_base + { + public: + typedef internal::slot_rep rep_type; + explicit slot_base(rep_type* rep) + : rep_(rep) + { + } + mutable rep_type *rep_; + }; + namespace internal { + template + struct typed_slot_rep : public slot_rep + { + typedef typename adaptor_trait::adaptor_type adaptor_type; + adaptor_type functor_; + inline typed_slot_rep(const T_functor& functor) + : functor_(functor) + { + } + }; + template + struct slot_call0 + { + static void *call_it(slot_rep* rep) + { + typedef typed_slot_rep typed_slot; + typed_slot *typed_rep = static_cast(rep); + return (typed_rep->functor_)(); + } + static hook address() + { + return &call_it; + } + }; + } + + class slot0 : public slot_base + { + public: + typedef void * (*call_type)(rep_type*); + inline void *operator()() const + { + return slot_base::rep_->call_ (slot_base::rep_); + } + template + slot0(const T_functor& _A_func) + : slot_base(new internal::typed_slot_rep(_A_func)) + { + slot_base::rep_->call_ = internal::slot_call0::address(); + } + }; +} +struct A +{ + static void *foo (void *p) { return p; } + typedef sigc::slot0 C; + C bar(); +}; +A::C A::bar () +{ + return sigc::bind (sigc::ptr_fun1 (&A::foo), (void*)0); +} +int main (void) +{ + A a; + if (a.bar ()() != 0) + abort (); +}

pr30252.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: eh3.C =================================================================== --- eh3.C (nonexistent) +++ eh3.C (revision 154) @@ -0,0 +1,33 @@ +// PR target/18841 +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort (); + +int r, i1 = 1, i2 = 2, i3 = 3, i4 = 4, i5 = 5; + +struct S +{ + ~S() { r = i1 + i2 + i3 + i4 + i5; } +}; + +void foo() +{ + S s; + throw 1; +} + +void bar() +{ + try { + foo(); + } catch (...) { + } +} + +int main() +{ + bar(); + if (r != 1 + 2 + 3 + 4 + 5) + abort (); +}

eh3.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: pr17724-1.C =================================================================== --- pr17724-1.C (nonexistent) +++ pr17724-1.C (revision 154) @@ -0,0 +1,23 @@ +// PR tree-optimization/17724 +// { dg-do compile } +// { dg-options "-O2" } + +namespace N { char *strcpy (char *, const char *); } +extern "C" char *strcpy (char *, const char *) throw (); +inline char *N::strcpy (char *s, const char *t) { return ::strcpy (s, t); } + +struct S { ~S (); }; +int foo (); + +int +main () +{ + S s; + int a; + char b[64]; + N::strcpy (b, "ABCDEFGHIJKLM"); + while ((a = foo ()) != -1) + if (a) + return -1; + return 0; +}

pr17724-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: anonunion1.C =================================================================== --- anonunion1.C (nonexistent) +++ anonunion1.C (revision 154) @@ -0,0 +1,25 @@ +// PR c++/5748 +// This testcase ICEd because used flag from the anon union variables +// was not propagated back to the anon union itself, causing addressof +// not to be replaced with stack slot. +// { dg-do compile } +// { dg-options "-O2" } + +struct A { + A (); + ~A (); + int foo (); + int bar (void *x, int y); +}; + +int A::foo() +{ + union { + int a; + int b; + }; + + if (bar (&a, sizeof (int)) != 32) + return 16; + return 0; +}

anonunion1.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: pr20991.C =================================================================== --- pr20991.C (nonexistent) +++ pr20991.C (revision 154) @@ -0,0 +1,34 @@ +// PR middle-end/20991 +// { dg-options "-O2" } +// { dg-do compile } + +struct S +{ + virtual inline int foo () const; + virtual inline bool bar () const; + virtual int baz (int) const; +}; + +inline int S::foo () const +{ + return 1; +} + +inline bool S::bar () const +{ + return foo () == 0; +} + +void A () +{ + S s; + if (s.bar ()) + s.foo (); +} + +void B () +{ + S s; + if (s.bar ()) + s.foo (); +}

pr20991.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: pr17724-5.C =================================================================== --- pr17724-5.C (nonexistent) +++ pr17724-5.C (revision 154) @@ -0,0 +1,24 @@ +// PR tree-optimization/17724 +// { dg-do compile } +// { dg-options "-O2" } + +extern char *strcpy (char* d, const char* s) throw (); + +class A { public: A (); ~A (); }; + +inline char * B (char *s, const char *t) +{ return ::strcpy (s, t); } + +class C { int D (void); int E; }; + +int C::D (void) +{ + A a; + try + { + char z[22]; + if (this->E) B (z, ""); + return 0; + } + catch (int &f) { return -1; } +}

pr17724-5.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: nrv3.C =================================================================== --- nrv3.C (nonexistent) +++ nrv3.C (revision 154) @@ -0,0 +1,24 @@ +// PR optimization/6189 +// Bug: we forgot about foo's nrv after writing it out. +// { dg-options -O3 } +// { dg-do run } + +struct A +{ + int i; +}; + + +A foo () +{ + A a; + a.i = 42; + return a; +} + + +int main() +{ + A b = foo(); + return b.i != 42; +}

nrv3.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: ptrmem4.C =================================================================== --- ptrmem4.C (nonexistent) +++ ptrmem4.C (revision 154) @@ -0,0 +1,12 @@ +// { dg-do compile } +// { dg-options "-O3" } + +struct X { void foo (); }; + +template +inline void spawn (void (X::*fun_ptr)()) {} + +void bar () { + void (X::*const comp)() = &X::foo; + spawn (comp); +}

ptrmem4.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: pr26179.C =================================================================== --- pr26179.C (nonexistent) +++ pr26179.C (revision 154) @@ -0,0 +1,22 @@ +/* The problem here is that Load PRE on the tree level + forgot to handle RETURN_DECL which causes us to ICE. */ + +// { dg-do compile } +// { dg-options "-O2" } + +struct a +{ + int i; +}; +void h(struct a&); +void l(void); + +struct a g(void) +{ + struct a fl; + h(fl); + if (fl.i) + l(); + fl.i+=2; + return fl; +}

pr26179.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 154) @@ -0,0 +1,24 @@ +// PR middle-end/22484 +// { dg-do compile } +// { dg-options "-O3" } + +struct A { ~A(); }; +typedef bool B; + +bool foo(); + +bool bar(A&) +{ + B b = true; + + for (int i = 0; i < 2 && b; ++i) + b = foo(); + + return b; +} + +void baz() +{ + A a; + if (bar(a)) foo(); +}

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 Index: nrv7.C =================================================================== --- nrv7.C (nonexistent) +++ nrv7.C (revision 154) @@ -0,0 +1,13 @@ +// PR c++/15461 + +struct A { + int i; +}; + +inline A foo () { + int j = 1; + A a = { j }; + return a; +} + +A tv = foo();

nrv7.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: longbranch1.C =================================================================== --- longbranch1.C (nonexistent) +++ longbranch1.C (revision 154) @@ -0,0 +1,36 @@ +// PR c++/5964 +// This testcase failed to link on sparc -m64 -O0, because instruction +// lengths were incorrectly computed +// { dg-do link } +// { dg-options "-O0" } + +#define makecode for (int i = 1; i < 1000; ++i) i *= 3 +#define muchcode \ + makecode; makecode; makecode; makecode; makecode; makecode; \ + makecode; makecode; makecode; makecode; makecode; makecode; \ + makecode; makecode; makecode; makecode; makecode; makecode; \ + makecode; makecode; makecode; makecode; makecode; makecode + +#define verymuchcode \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode; \ + muchcode; muchcode; muchcode; muchcode; muchcode; muchcode + +int +main (int argc, char **argv) +{ +loop: + verymuchcode; + delete[] argv; + goto loop; +}

longbranch1.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: static1.C =================================================================== --- static1.C (nonexistent) +++ static1.C (revision 154) @@ -0,0 +1,20 @@ +// PR c++/6073 +// This testcase ICEd because finish_struct_bits changed +// A's and const A's TYPE_MODE from QI to BLK, but did +// not change a's DECL_MODE because its mode was not +// TYPE_MAIN_VARIANT. + +struct A +{ + static const A a; + ~A (); +}; + +void bar (A x); +void foo (); + +void +foo () +{ + bar (A::a); +}

static1.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: thunk1.C =================================================================== --- thunk1.C (nonexistent) +++ thunk1.C (revision 154) @@ -0,0 +1,42 @@ +// PR 6788 +// Test that the thunk adjusts the this pointer properly. +// { dg-do run } + +extern "C" void abort (); + +struct A +{ + virtual void foo() = 0; + char large[33*1024]; +}; + +struct B +{ + virtual void foo() = 0; +}; + +struct C : public A, public B +{ + virtual void foo(); +}; + +static C *match; + +void C::foo() +{ + if (this != match) + abort (); +} + +void bar(B *x) +{ + x->foo(); +} + +int main() +{ + C obj; + match = &obj; + bar(&obj); + return 0; +}

thunk1.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: expect2.C =================================================================== --- expect2.C (nonexistent) +++ expect2.C (revision 154) @@ -0,0 +1,11 @@ +// PR c++/13392 +// { dg-do compile } +// { dg-options "-O0" } + +extern "C" void abort (void); +struct X { ~X () throw() {} }; +bool foo (X s = X ()) { return false; } +void bar () +{ + __builtin_expect (foo () && true, 1) ? 0 : (abort (), 0); +}

expect2.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: delay-slot-1.C =================================================================== --- delay-slot-1.C (nonexistent) +++ delay-slot-1.C (revision 154) @@ -0,0 +1,111 @@ +/* PR rtl-optimization/23585 */ +/* Testcase by Matti Rintala */ + +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +template +class const_mem_fun_t +{ +public: + explicit + const_mem_fun_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) {} + + _Ret + operator()(const _Tp* __p) const + { return (__p->*_M_f)(); } +private: + _Ret (_Tp::*_M_f)() const; +}; + +template +class const_mem_fun_ref_t +{ +public: + explicit + const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) {} + + _Ret + operator()(const _Tp& __r) const + { return (__r.*_M_f)(); } +private: + _Ret (_Tp::*_M_f)() const; +}; + +template +class const_mem_fun1_t +{ +public: + explicit + const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) {} + + _Ret + operator()(const _Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } +private: + _Ret (_Tp::*_M_f)(_Arg) const; +}; + + +template +class const_mem_fun1_ref_t +{ +public: + explicit + const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) {} + + _Ret + operator()(const _Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } +private: + _Ret (_Tp::*_M_f)(_Arg) const; +}; + +template +inline const_mem_fun_t<_Ret, _Tp> +mem_fun(_Ret (_Tp::*__f)() const) +{ return const_mem_fun_t<_Ret, _Tp>(__f); } + +template +inline const_mem_fun_ref_t<_Ret, _Tp> +mem_fun_ref(_Ret (_Tp::*__f)() const) +{ return const_mem_fun_ref_t<_Ret, _Tp>(__f); } + +template +inline const_mem_fun1_t<_Ret, _Tp, _Arg> +mem_fun(_Ret (_Tp::*__f)(_Arg) const) +{ return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + +template +inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> +mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) +{ return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + +class Klasse { +public: + void vf0c() const; + void vf1c(const int&) const; +}; + +int main() +{ + Klasse obj; + const Klasse& objc = obj; + + mem_fun(&Klasse::vf0c)(&objc); + mem_fun(&Klasse::vf1c)(&objc, 1); + + mem_fun_ref(&Klasse::vf0c)(objc); + mem_fun_ref(&Klasse::vf1c)(objc, 1); + return 0; +} + +void Klasse::vf0c() const +{} + +void Klasse::vf1c(const int&) const +{}

delay-slot-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: static5.C =================================================================== --- static5.C (nonexistent) +++ static5.C (revision 154) @@ -0,0 +1,29 @@ +// PR c++/31809 +// { dg-do run } +// { dg-options "-O2" } + +struct S +{ + unsigned v; + static inline S f (unsigned a); +}; + +inline S +S::f (unsigned a) +{ + static S t = { a }; + return t; +} + +const static S s = S::f (26); + +extern "C" void abort (void); + +int +main () +{ + S t = s; + if (t.v != 26) + abort (); + return 0; +}

static5.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: alias4.C =================================================================== --- alias4.C (nonexistent) +++ alias4.C (revision 154) @@ -0,0 +1,56 @@ +// PR c++/27768 +// Alias grouping was losing some may_aliases, causing us to think +// the store to w.p was dead. + +// { dg-do run } +// { dg-options "-O2" } + +int N = 1; + +struct VA +{ + int *p, *q, *r; + + VA() : p(), q() {} + VA(const VA&) : p(), q() {} + ~VA() { if (p) --N; } +}; + +inline void foo(VA, VA, VA) {} + +struct VB +{ + VA va; + + VB() {} + + VB(const VB&) + { + va.p = new int(va.q - va.p); + va.r = va.p + (va.q - va.p); + foo(va, va, va); + } +}; + +struct VC : VB { char c; }; +struct V : VC {}; + +struct WA +{ + struct X {}; + X **p, **q, **r; + + WA() : p() {} + ~WA() { if (p) --N; } +}; + +struct W : WA {}; + +int main() +{ + { + V v, u(v); + W w; + } + return N; +}

alias4.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: pr15054.C =================================================================== --- pr15054.C (nonexistent) +++ pr15054.C (revision 154) @@ -0,0 +1,36 @@ +// PR middle-end/15054 +// This used to abort due to overlapping stack temporaries. + +// { dg-do run } +// { dg-options "-O" } + +extern "C" void abort (void); + +struct pointer +{ + void* ptr; + + pointer(void* x = 0) : ptr(x) {} + pointer(const pointer& x) : ptr(x.ptr) {} +}; + +struct element +{ + int canary; + + element() : canary(123) { } + ~element() { pointer(); if (canary != 123) abort (); } +}; + +inline pointer +insert(const element& x) +{ + return pointer(new element(x)); +} + +int +main (void) +{ + insert(element()); + return 0; +}

pr15054.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: pr23056.C =================================================================== --- pr23056.C (nonexistent) +++ pr23056.C (revision 154) @@ -0,0 +1,9 @@ +// PR c++/23056 +// { dg-do compile } + +template struct S { virtual ~S(); }; +void foo () +{ + static_cast("Foo"); +} +S a;

pr23056.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: cfg2.C =================================================================== --- cfg2.C (nonexistent) +++ cfg2.C (revision 154) @@ -0,0 +1,38 @@ +// PR optimization/12215 +// Origin: +// Reduced testcase by Wolfgang Bangerth + +// This used to fail because the CSE pass destroyed the CFG in presence +// of trapping loads, which led to the deletion of basic blocks. + +// { dg-do compile } +// { dg-options "-O2 -fno-gcse -fnon-call-exceptions" } + + +struct B { + ~B() throw() {} +}; + +struct X { + X(const char*, const B&); + ~X() {} +}; + +bool m(); +void f(int &i, float &arg0); + +void g (const char **argv) { + float val; + int i = 1; + + try { + while ( i < 1 ) + { + X arg(argv[i], B()); + if (m()) + throw(0); + + f(i, val); + } + } catch (...) {} +}

cfg2.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: mmx1.C =================================================================== --- mmx1.C (nonexistent) +++ mmx1.C (revision 154) @@ -0,0 +1,65 @@ +// PR optimization/4994 +// This testcase ICEd because movsi was not supporting direct +// mmx -> mmx register moves. +// { dg-do compile } +// { dg-options "-O2" } +// { dg-options "-fno-exceptions -O2 -mmmx -fPIC" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } + +struct A { + unsigned a0; + bool a1 () { return !--a0; } + void a2 (); +}; + +struct B +{ + B (); + B (const B &); + ~B(); + B &operator= (const B &); + B b0 (unsigned long x, int y = 0, int z = 10) const; + +private: + A *b1; + static A *b2; +}; + +inline B::~B() +{ + if (b1->a1 () && b1 == b2) + b1->a2(); +} + +struct C +{ + C *c0; +}; + +struct D +{ + C *d0; + D (); + D (const D &c0) {} + D &operator++ () { + C *x = d0; C *y = x->c0; + while (x == y->c0) + x = y; + d0 = x; + return *this; + } +}; + +B foo (const char *x, const B &y); + +void bar (void) +{ + B *y = 0; + B z; + for (unsigned long l = 0; l < 2147483647L * 2UL + 1; l++) + { + z = y->b0 (l); + *y = foo ("data", z); + } + D d; + ++d; +}

mmx1.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: switch3.C =================================================================== --- switch3.C (nonexistent) +++ switch3.C (revision 154) @@ -0,0 +1,16 @@ +// PR c++/20023 +// { dg-do compile } +// { dg-options "-O2" } + +void f (void); +typedef __SIZE_TYPE__ size_t; +void g (void *a) +{ + size_t b = (size_t) a; + switch (b) + { + case 1: + f (); + break; + } +}

switch3.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: stack1.C =================================================================== --- stack1.C (nonexistent) +++ stack1.C (revision 154) @@ -0,0 +1,135 @@ +// PR optimization/11198 +// Origin: Joerg Walter +// Reduced testcase by: Volker Reichelt +// Wolfgang Bangerth + +// The compiler used to allocate the same stack slot for two aggregates, +// overlooking that assignments to members given the same address on the +// stack may not alias and thus may be reordered by the scheduling passes. + +// { dg-do run } +// { dg-options "-O2 -frename-registers" } + + +double zero_; + +inline const int& +min(const int& a, const int& b) { + if (b < a) return b; return a; +} + +struct barrier { barrier () {} }; + +template struct unbounded_array { + inline unbounded_array (): data_ (new double [9]) {} + inline double& operator [] (int i) { return data_ [i]; } + double* data_; +}; + +inline int element (int i, int j) { + return i + j; +} + +template +struct matrix { + inline matrix () : size2_ (3) {} + + inline unbounded_array<> &data () { return data_; } + + inline double& el (int i, int j) { + int dead1 = j; + int dead2 = 1 + i - j; + if (j < size2_ && i-j < 2) + return data () [element (j,i-j+1)]; + barrier (); + return zero_; + } + + struct iterator2; + + inline iterator2 find () { + return iterator2 (*this); + } + + struct iterator1 { + inline iterator1 (matrix *m): + dead1 (m), i (0) {} + void *dead1; + int i; + int dead2; + }; + + const int size2_; + unbounded_array<> data_; +}; + + +template +struct adaptor { + adaptor (matrix<> &m) : m(&m), upper_ (1) {} + + int size1 () const; + int size2 () const { return 3; } + int lower () const { return 1; } + int upper () const { return upper_; } + matrix<> &data () { return *m; } + + double& el (int i, int j) { + int dead1, dead2; + if (j < size2 () && i-j < 1) + return data ().el (i, j); + + barrier (); + return zero_; + } + + struct a_iterator2; + + struct a_iterator1 { + a_iterator1 (adaptor &a, const matrix<>::iterator1 &it1): + a (&a), dead1 (it1) {} + + a_iterator2 begin () const { + return a_iterator2(*a); + } + adaptor *a; + matrix<>::iterator1 dead1; + }; + + struct a_iterator2 { + a_iterator2 (adaptor &a) : a (&a) {} + + double& f () const { + int i = 0; + int l = a->upper () + i; + int q = a->size2 (); + if (0 < q && + l < a->lower () + 1 + a->upper ()) + return a->m->el(0,0); + + return a->el (i, 0); + } + + adaptor *a; + }; + + matrix<> *m; + int upper_; +}; + +void matrix_swap (adaptor<> &bam1, adaptor<> &bam2) +{ + adaptor<>::a_iterator1 it1 (bam1,matrix<>::iterator1(bam1.m)), + it2 (bam2,matrix<>::iterator1(bam2.m)); + int dead; + double x = it1.begin().f(); + it2.begin().f() = x; +} + +int main () +{ + matrix<> m1,m2; + adaptor<> bam1 (m1), bam2 (m2); + matrix_swap (bam1, bam2); + return 0; +}

stack1.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: pr19317-3.C =================================================================== --- pr19317-3.C (nonexistent) +++ pr19317-3.C (revision 154) @@ -0,0 +1,37 @@ +// PR c++/19317 +// { dg-options "-O2" } +// { dg-do run } + +extern "C" void abort (void); + +struct A { int c; int d; int e; int f; }; + +A +foo (const A *x, const A *r) +{ + A t; + t.c = -1; + t.c += x->c < r->c ? x->c : r->c; + t.d = 0; + t.e = 0; + t.f = 0; + return t; +} + +int +main () +{ + A a; + a.c = 10; + a.d = 0; + a.e = 0; + a.f = 0; + A b; + b.c = 100; + b.d = 0; + b.e = 0; + b.f = 0; + a = foo (&b, &a); + if (a.c != 9) + abort (); +}

pr19317-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: complex2.C =================================================================== --- complex2.C (nonexistent) +++ complex2.C (revision 154) @@ -0,0 +1,24 @@ +// PR 22022 +// { dg-do compile } +// { dg-options "-O2" } + +_Complex float f(); +_Complex float g(); +_Complex float h()throw(); +void i(_Complex float)throw(); + +void j(void) +{ + _Complex float x = h(); + try + { + try + { + x = f(); + }catch (...) + { + x = g(); + } + }catch(...){} + i(x); +}

complex2.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: call1.C =================================================================== --- call1.C (nonexistent) +++ call1.C (revision 154) @@ -0,0 +1,21 @@ +// { dg-options "-O2" } + +void a (void (*f)()) +{ + f(); +} + +struct RunState +{ + static void runcallback() { } + static void wait() + { + a (runcallback); + } +}; + +int main() +{ + RunState::wait(); + return 0; +}

call1.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: complex6.C =================================================================== --- complex6.C (nonexistent) +++ complex6.C (revision 154) @@ -0,0 +1,14 @@ +// PR 30168 +// { dg-do compile } +// { dg-options "-O2" } + +struct aaa +{ + aaa(_Complex float __z) ; + _Complex float _M_value; +}; +aaa::aaa(_Complex float __z) +{ + __z*=2.0f; + _M_value = __z; +}

complex6.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: pr17697-1.C =================================================================== --- pr17697-1.C (nonexistent) +++ pr17697-1.C (revision 154) @@ -0,0 +1,32 @@ +// PR tree-optimization/17697 +// { dg-do run } +// { dg-options "-O2" } + +extern "C" +{ + extern int strcmp (const char *s, const char *t) throw () + __attribute__ ((pure)); +} + +namespace A +{ + extern int strcmp (const char *s, const char *t); +} + +inline int +A::strcmp (const char *s, const char *t) +{ + return ::strcmp (s, t); +} + +int +foo (const char *x) throw () +{ + return A::strcmp ("", x); +} + +int +main () +{ + return foo ("") != 0 || foo ("a") == 0; +}

pr17697-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: inline4.C =================================================================== --- inline4.C (nonexistent) +++ inline4.C (revision 154) @@ -0,0 +1,13 @@ +// { dg-options "-O2 -ftemplate-depth-20000" } + +template +inline void g() { g(); return; } + +template <> +inline void g<0>() { int i; return; } + +void h() { + g<250>(); +} + +// { dg-final { scan-assembler-not "\n_?_Z1gILi\[0-9\]+EEvv\[: \t\n\]" } }

inline4.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: reg-stack4.C =================================================================== --- reg-stack4.C (nonexistent) +++ reg-stack4.C (revision 154) @@ -0,0 +1,29 @@ +// PR target/12900 +// Origin: + +// This used to fail on x86 because the reg-stack pass +// deleted a valid edge. + +// { dg-do compile } +// { dg-options "-mtune=i586 -O2" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } + +struct array { + double data; + virtual ~array(); +}; + +double glob; +double ext1(double); +int nmuons; + +void track_match() +{ + array vecdca; + if (glob < 10) return; + double p = glob*5; + double phi = vecdca.data; + ext1 (vecdca.data-glob); + ext1 (phi*2); + if (1 < p) + ++nmuons; +}

reg-stack4.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: fold1.C =================================================================== --- fold1.C (nonexistent) +++ fold1.C (revision 154) @@ -0,0 +1,17 @@ +// PR middle-end/13696 +// { dg-do compile } +// { dg-options "-O2" } + +extern void x(unsigned long*); + +enum e { red, blue, green }; + +struct s { + unsigned long l; +}; +struct s map[1][256]; + +void +f(int i,e j) { + x(&(map[i][j].l)); +}

fold1.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: inline8.C =================================================================== --- inline8.C (nonexistent) +++ inline8.C (revision 154) @@ -0,0 +1,5 @@ +// PR c++/15871 +// { dg-options "-O2 -fkeep-inline-functions" } +// { dg-final { scan-assembler "foo" } } + +inline void foo(void) { }

inline8.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: emptyunion.C =================================================================== --- emptyunion.C (nonexistent) +++ emptyunion.C (revision 154) @@ -0,0 +1,13 @@ +// PR optimization/11059 +// This testcase ICEd because clear_by_pieces was called with zero length. +// { dg-do compile } +// { dg-options "-O2" } + +union uni {}; + +int main() { + uni *h; + + h = (uni *)new uni(); +} +

emptyunion.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: covariant1.C =================================================================== --- covariant1.C (nonexistent) +++ covariant1.C (revision 154) @@ -0,0 +1,47 @@ +// PR c++/20206 +// { dg-do run } +// { dg-options "-O0" } + +void +bar (int x) +{ + asm ("" : : "g" (x)); +} + +struct S { S () {}; virtual ~S () {}; }; +struct T { virtual T *foo (int) {}; }; +struct V : virtual S, virtual T {}; +struct V v; +struct U : public S, public T +{ + bool a; + U () {} + virtual ~U () {} + virtual V *foo (int x) + { + switch (x) + { + case 12: + break; + case 9: + bar (7); + break; + case 10: + bar (12); + break; + case 4: + bar (18); + break; + case 2: + bar (26); + break; + } + return &v; + } +}; +U u; + +int +main () +{ +}

covariant1.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: const2.C =================================================================== --- const2.C (nonexistent) +++ const2.C (revision 154) @@ -0,0 +1,42 @@ +// PR optimization/6631 + +// { dg-do run } +// { dg-options "-O" } + +extern "C" void abort (void); + +struct QSize +{ + QSize(); + QSize( int w, int h ); + int wd, ht; + friend inline const QSize operator+( const QSize &, const QSize & ); +}; + +inline QSize::QSize() +{ wd = ht = -1; } + +inline QSize::QSize( int w, int h ) +{ wd = w; ht = h; } + +inline const QSize operator+( const QSize & s1, const QSize & s2 ) +{ return QSize(s1.wd+s2.wd, s1.ht+s2.ht); } + +QSize minimumSize() +{ + return QSize (100, 200); +} + +QSize totalMinimumSize() +{ + QSize s = minimumSize(); + return s + QSize( 0, 0 ); +} + +int main() +{ + QSize s = totalMinimumSize(); + if (s.wd != 100 || s.ht != 200) + abort (); +} +

const2.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: conj1.C =================================================================== --- conj1.C (nonexistent) +++ conj1.C (revision 154) @@ -0,0 +1,18 @@ +// PR target/5740 +// This testcase ICEd on SPARC -m64 because emit_group_load tried +// to move a DFmode register into DImode register directly. +// { dg-do compile } +// { dg-options "-O2" } + +struct C +{ + C (double y, double z) { __real__ x = y; __imag__ x = z; } + double r () const { return __real__ x; } + double i () const { return __imag__ x; } + __complex__ double x; +}; + +C conj (const C& z) +{ + return C (z.r (), -z.i ()); +}

conj1.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: pr25005.C =================================================================== --- pr25005.C (nonexistent) +++ pr25005.C (revision 154) @@ -0,0 +1,34 @@ +// PR target/25005 +// { dg-options "-O2 -funroll-loops" } +// { dg-do compile } + +inline void *operator new (__SIZE_TYPE__, void *__p) throw() { return __p; } + +struct M { ~M() { } }; + +struct P +{ + P () { v[0] = 0; v[1] = 0; v[2] = 0; } + P (const P &x) { for (int i = 0; i < 3; ++i) v[i] = x.v[i]; } + double v[3]; +}; + +struct V : public M +{ + V (const P *x, const P *y) + { + P *b = this->a = ::new P[2]; + for (; x != y; ++x, ++b) + ::new (b) P(*x); + } + P *a; +}; + +void bar (const V &); + +void +foo () +{ + const P d[2] = { P(), P() }; + bar (V (&d[0], &d[2])); +}

pr25005.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: pr16372-1.C =================================================================== --- pr16372-1.C (nonexistent) +++ pr16372-1.C (revision 154) @@ -0,0 +1,17 @@ +// PR tree-optimization/16372 +// { dg-do run } +// { dg-options "-O1" } + +extern "C" void abort(); + +enum number {ZERO, ONE, TWO, THREE, FOUR, FIVE}; + +int main() { + number n = FIVE; + + if((n == ONE) || (n == TWO) || (n == THREE)) { + abort (); + } + return 0; +} +

pr16372-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: pr28116.C =================================================================== --- pr28116.C (nonexistent) +++ pr28116.C (revision 154) @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-O3" } */ + +struct QDateTime +{ + QDateTime addSecs( int secs ) const; + int t; +}; +QDateTime gridToDate(long x) +{ + QDateTime date; + date = date.addSecs(1); + return date; +} +void whatsOnAt(long x, long y) +{ + gridToDate(x); +} +

pr28116.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: pr19108.C =================================================================== --- pr19108.C (nonexistent) +++ pr19108.C (revision 154) @@ -0,0 +1,19 @@ +// PR tree-optimization/19108 +// This used to abort due to not handing RANGE_EXPR in SRA. + +// { dg-do compile } +// { dg-options "-O" } + +struct A +{ + int i[6]; + A () : i() {} +}; + +struct B +{ + A a; + B(const A& x) : a(x) {} +}; + +B b=A();

pr19108.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: pr17724-2.C =================================================================== --- pr17724-2.C (nonexistent) +++ pr17724-2.C (revision 154) @@ -0,0 +1,23 @@ +// PR tree-optimization/17724 +// { dg-do compile } +// { dg-options "-O2" } + +namespace N { char *strcpy (char *, const char *); } +extern "C" char *strcpy (char *, const char *); +inline char *N::strcpy (char *s, const char *t) { return ::strcpy (s, t); } + +struct S { ~S (); }; +int foo (); + +int +main () +{ + S s; + int a; + char b[64]; + N::strcpy (b, "ABCDEFGHIJKLM"); + while ((a = foo ()) != -1) + if (a) + return -1; + return 0; +}

pr17724-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: ptrmem1.C =================================================================== --- ptrmem1.C (nonexistent) +++ ptrmem1.C (revision 154) @@ -0,0 +1,12 @@ +// { dg-options "-O2" } + +class QWidget +{ + public: void repaint( bool erase = 1 ); +}; +void f (void) +{ + typedef void (QWidget::*A)(bool); + A b = &QWidget::repaint; +} +

ptrmem1.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: pr17624.C =================================================================== --- pr17624.C (nonexistent) +++ pr17624.C (revision 154) @@ -0,0 +1,23 @@ +// { dg-do compile } +// { dg-options "-O2" } + +extern void foo (void); +int c; +void foo (int n) +{ + int j = 0; + try + { + for(;;) + { + foo (); + if (j ++ == n) + break; + foo (); + } + } + catch (...) + { + c = j; + } +}

pr17624.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: pr20995-1.C =================================================================== --- pr20995-1.C (nonexistent) +++ pr20995-1.C (revision 154) @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +template void foo() +{ + double d = (N ? 0.0 : 0) + 1; +} +

pr20995-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: pr16693-1.C =================================================================== --- pr16693-1.C (nonexistent) +++ pr16693-1.C (revision 154) @@ -0,0 +1,25 @@ +// PR middle-end/16693 +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort(); + +unsigned short ret6666(int) { + return 0x66; +} + +typedef enum { + a = 0x0, b = 0x1, c = 0x2, d = 0x3, e = 0x4, f = 0x5, + g = 0x6, h = 0x7, i = 0x8, j = 0x9, k = 0xa, l = 0xb, + m = 0xc, n = 0xd, o = 0xe, p = 0xf +} Test_Enum; + +int main(void) { + unsigned char r1; + r1 = static_cast(0xf & ret6666(44)); + + if(r1 != 0x6) + abort(); + return 0; +} +

pr16693-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: ptrmem5.C =================================================================== --- ptrmem5.C (nonexistent) +++ ptrmem5.C (revision 154) @@ -0,0 +1,19 @@ +// PR tree-opt/18904 +// { dg-do compile } +// { dg-options "-O3" } + +struct Data; +struct Wrapper { + Data* D; +}; +struct Data { + int X; + void init(Wrapper&); +}; +void Data::init( Wrapper &w ) { + int Data::* res = &Data::X; + w.D = this; + for( int i = 0; i < 4; i++ ) + (w.D->*res) = 0; +} +

ptrmem5.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: nrv4.C =================================================================== --- nrv4.C (nonexistent) +++ nrv4.C (revision 154) @@ -0,0 +1,23 @@ +// PR optimization/7145 +// Bug: The NRV optimization caused us to lose the initializer for 'ret'. +// { dg-options -O } +// { dg-do run } + +struct GdkColor { + long pixel; + short red; + short green; + short blue; +}; + +inline GdkColor mkcolor() { + GdkColor ret={0,1,2,3}; + return ret; +} + +int +main() +{ + GdkColor col=mkcolor(); + return (col.pixel != 0 || col.red != 1 || col.green != 2 || col.blue != 3); +}

nrv4.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: copysign-1.C =================================================================== --- copysign-1.C (nonexistent) +++ copysign-1.C (revision 154) @@ -0,0 +1,10 @@ +// { dg-options "-O2" } +// { dg-do compile } +// PR rtl-opt/27883 +// MIPS used to ICE because local flow update +// was not removing an invalid REG_DEAD. + + +double copysign (double x, double y); +double GetDouble(); +double a = copysign (1.0, GetDouble());

copysign-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: pr17724-6.C =================================================================== --- pr17724-6.C (nonexistent) +++ pr17724-6.C (revision 154) @@ -0,0 +1,24 @@ +// PR tree-optimization/17724 +// { dg-do compile } +// { dg-options "-O2" } + +extern char *strcpy (char* d, const char* s); + +class A { public: A (); ~A (); }; + +inline char * B (char *s, const char *t) +{ return ::strcpy (s, t); } + +class C { int D (void); int E; }; + +int C::D (void) +{ + A a; + try + { + char z[22]; + if (this->E) B (z, ""); + return 0; + } + catch (int &f) { return -1; } +}

pr17724-6.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: pr7503-1.C =================================================================== --- pr7503-1.C (nonexistent) +++ pr7503-1.C (revision 154) @@ -0,0 +1,148 @@ +// PR c++/7503 +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort(); + +void test1a() +{ + int A = 4; + int B = 4; + + (A > B ? A : B) = 1; + if (A != 4 || B != 1) + abort (); +} + +void test1b() +{ + int A = 3; + int B = 5; + + (A > B ? A : B) = 1; + if (A != 3 || B != 1) + abort (); +} + +void test1c() +{ + int A = 5; + int B = 3; + + (A > B ? A : B) = 1; + if (A != 1 || B != 3) + abort (); +} + +void test2a() +{ + int A = 4; + int B = 4; + + (A >= B ? A : B) = 1; + if (A != 1 || B != 4) + abort (); +} + +void test2b() +{ + int A = 3; + int B = 5; + + (A >= B ? A : B) = 1; + if (A != 3 || B != 1) + abort (); +} + +void test2c() +{ + int A = 5; + int B = 3; + + (A >= B ? A : B) = 1; + if (A != 1 || B != 3) + abort (); +} + +void test3a() +{ + int A = 4; + int B = 4; + + (A < B ? A : B) = 1; + if (A != 4 || B != 1) + abort (); +} + +void test3b() +{ + int A = 3; + int B = 5; + + (A < B ? A : B) = 1; + if (A != 1 || B != 5) + abort (); +} + +void test3c() +{ + int A = 5; + int B = 3; + + (A < B ? A : B) = 1; + if (A != 5 || B != 1) + abort (); +} + +void test4a() +{ + int A = 4; + int B = 4; + + (A <= B ? A : B) = 1; + if (A != 1 || B != 4) + abort (); +} + +void test4b() +{ + int A = 3; + int B = 5; + + (A <= B ? A : B) = 1; + if (A != 1 || B != 5) + abort (); +} + +void test4c() +{ + int A = 5; + int B = 3; + + (A <= B ? A : B) = 1; + if (A != 5 || B != 1) + abort (); +} + + +int main() +{ + test1a(); + test1b(); + test1c(); + + test2a(); + test2b(); + test2c(); + + test3a(); + test3b(); + test3c(); + + test4a(); + test4b(); + test4c(); + + return 0; +} +

pr7503-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: longbranch2.C =================================================================== --- longbranch2.C (nonexistent) +++ longbranch2.C (revision 154) @@ -0,0 +1,63 @@ +// PR target/11689 +// Originator: thor@math.tu-berlin.de + +// { dg-do compile } +// { dg-options "-O3 -funroll-loops -mtune=k6 -fomit-frame-pointer" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } + + +// This used to fail to assemble because of an out-of-range 'loop' instructions. + + +class JKeeper { +public: + unsigned long a0; +}; + +class EBCOTLut : public JKeeper { + unsigned char a1[1<<8]; + unsigned char a2[1<<8]; + unsigned char a3[1<<8]; + long a4[1<<9]; +public: + EBCOTLut(void); +}; + +EBCOTLut::EBCOTLut(void) +{ + unsigned char inter[36]; // intermediate lookup table; + unsigned long i; + for(i=0;i<36;i++) { + inter[i] = 0; + } + for(i=1;i<16;i++) { + a1[i | (1<<7)] = 8<<1; + a1[i | (1<<6)] = 8<<1; + } + for(i=0;i < ((1<<9)-1);i++) { + int ds = (i>>0) & 0x01; // significance of DOWN + int us = (i>>1) & 0x01; // significance of UP + int rs = (i>>2) & 0x01; // significance of RIGHT + int ls = (i>>3) & 0x01; // significance of LEFT + int dn = (i>>5) & 0x01; // sign of DOWN + int un = (i>>6) & 0x01; // sign of UP + int rn = (i>>7) & 0x01; // sign of RIGHT + int ln = (i>>8) & 0x01; // sign of LEFT + int h,v; // h and v as in the VM description + + h = ls*(1-ln*2) + rs*(1-2*rn); + v = us*(1-un*2) + ds*(1-2*dn); + h = (h >= -1)?(h):(-1); + v = (v >= -1)?(v):(-1); + h = (h <= 1)?(h):(1); + v = (v <= 1)?(v):(1); + a2[i] = inter[((h+1)<<3) | (v+1)]; + a3[i] = inter[((h+1)<<3) | (v+1)] & (unsigned char)(~1); + } + for(i=0;i< 1<<9; i++) { + a4[i] = 2*(i-(1<<(9-1)))*(i-(1<<(9-1))) - + ((i< (1<<(9-1)))? + (2*(i-(1<<(9-2)))*(i-(1<<(9-2)))): + (2*(i-(3<<(9-2)))*(i-(3<<(9-2))))); + + } +}

longbranch2.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: life1.C =================================================================== --- life1.C (nonexistent) +++ life1.C (revision 154) @@ -0,0 +1,18 @@ +// This testcase did not set up the pic register on IA-32 due +// to bug in calculate_global_regs_live EH edge handling. +// { dg-do compile { target i?86-*-linux* x86_64-*-linux* } } +// { dg-require-effective-target ilp32 } +// { dg-require-effective-target fpic } +// { dg-options "-O2 -fPIC" } + +struct A { }; + +void foo (A (*fn)()) +{ + try { + A a = fn (); + } catch (...) { + } +} + +// { dg-final { scan-assembler "GLOBAL_OFFSET_TABLE" } }

life1.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: interface1-a.cc =================================================================== --- interface1-a.cc (nonexistent) +++ interface1-a.cc (revision 154) @@ -0,0 +1,9 @@ +struct Test { + void f(); +}; + +Test t; + +void g() { + t.f(); +} Index: pr6713.C =================================================================== --- pr6713.C (nonexistent) +++ pr6713.C (revision 154) @@ -0,0 +1,117 @@ +// PR optimization/6713 +// This testcase segfaulted on x86 because a dangling REG_EQUAL note +// resulted in incorrect substitutions later. +// { dg-do run } +// { dg-options "-O2" } + +template class basic_iterator +{ + public: + basic_iterator(_CharT* _p) : _M_current(_p) {} + basic_iterator& operator++() { ++_M_current; return *this; } + _CharT& operator*() const { return *_M_current; } + bool operator!=(basic_iterator &_rhs) { return _M_current != _rhs._M_current; } + + private: + _CharT* _M_current; +}; + +template class basic_string +{ + public: + typedef unsigned int size_type; + typedef basic_iterator<_CharT> iterator; + + private: + struct _Rep + { + size_type _M_length; + size_type _M_capacity; + int _M_references; + + bool _M_is_leaked() const { return _M_references < 0; } + bool _M_is_shared() const { return _M_references > 0; } + void _M_set_leaked() { _M_references = -1; } + void _M_set_sharable() { _M_references = 0; } + }; + + struct _Rep _M_rep; + + struct _Alloc_hider + { + _CharT _raw[16]; + _CharT* _M_p; + }; + + mutable _Alloc_hider _M_dataplus; + + _CharT* _M_data() const { return _M_dataplus._M_p; } + + void _M_leak() { if (!_M_rep._M_is_leaked()) _M_leak_hard(); } + + static int count; + + static void _M_leak_hard(); + + public: + explicit basic_string(const _CharT* __s); + + iterator begin() { _M_leak(); return iterator(_M_data()); } + + iterator end() { _M_leak(); return iterator(_M_data() + this->size()); } + + size_type size() const { return _M_rep._M_length; } +}; + +template basic_string<_CharT>:: +basic_string(const _CharT* __s) +{ + int i; + + for (i=0; i<15; i++) { + if (!__s[i]) + break; + + _M_dataplus._raw[i] = __s[i]; + } + + _M_dataplus._raw[i] = 0; + _M_dataplus._M_p = _M_dataplus._raw; + + _M_rep._M_length = i; + _M_rep._M_capacity = i; + _M_rep._M_references = 1; +} + +template int basic_string<_CharT>::count = 0; + +template void basic_string<_CharT>:: +_M_leak_hard() +{ + count++; +} + +typedef basic_string string; + +template int basic_string::count; + +int isspa(int ch) +{ + return 0; +} + +void foo(string& str) +{ + string::iterator it = str.begin(); + string::iterator stop = str.end(); + + for (; it != stop; ++it) + if (isspa(*it)) + break; +} + +int main() +{ + string str("test"); + foo(str); +}

pr6713.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: rtti1.C =================================================================== --- rtti1.C (nonexistent) +++ rtti1.C (revision 154) @@ -0,0 +1,20 @@ +// Test that typeid sees through references even when optimizing. +// { dg-do run } +// { dg-options "-O2" } + +#include + +struct A +{ + virtual ~A() { } +}; + +class B : public A { }; + +int main () +{ + B b; + A &aref = b; + + return typeid (aref) != typeid (b); +}

rtti1.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: placeholder1.C =================================================================== --- placeholder1.C (nonexistent) +++ placeholder1.C (revision 154) @@ -0,0 +1,10 @@ +// PR rtl-optimization/15159 +// { dg-options "-O2" } +struct S { S (); }; +struct P { P (S *); }; +void foo (const P &); +void bar () +{ + P p = new S; + foo (p); +}

placeholder1.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 154) @@ -0,0 +1,34 @@ +// PR middle-end/21492 +// { dg-do compile } +// { dg-options "-Os" } +// { dg-options "-Os -fPIC" { target fpic } } + +extern char *bar (const char *, const char *); +extern char *baz (char *, const char *); +extern unsigned int fn (const char *); +static const struct C { int i; } k = { 0}; + +struct A +{ + ~A (); +}; + +char * +foo (char *x, const char *y) +{ + A a; + char *c = x; + + if (bar (y, "foo")) + { + baz (c, "foo"); + c += fn ("foo"); + } + else if (bar (y, "bar")) + { + baz (c, "bar"); + c += fn ("bar"); + } + + return x; +}

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: static2.C =================================================================== --- static2.C (nonexistent) +++ static2.C (revision 154) @@ -0,0 +1,13 @@ +// Origin: reichelt@igpm.rwth-aachen.de +// PR 5571 +// { dg-options "-O2" } + +template struct A {}; + +struct B +{ + static A a; + void f() { a; } +}; + +A B::a = A();

static2.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: nrv13.C =================================================================== --- nrv13.C (nonexistent) +++ nrv13.C (revision 154) @@ -0,0 +1,42 @@ +// PR tree-optimization/32353 +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort (); + +struct A +{ + int f; + A (int x) : f (x) {} +}; + +A +foo (const A &x, const A &y) +{ + A r (0); + r = x.f == -111 ? y : (y.f == -111 || x.f > y.f) ? x : y; + A s (0); + r = r.f == -111 ? s : (r.f > s.f) ? r : s; + return r; +} + +int +main () +{ + if (foo (A (0), A (1)).f != 1) + abort (); + if (foo (A (1), A (9)).f != 9) + abort (); + if (foo (A (9), A (1)).f != 9) + abort (); + if (foo (A (-4), A (-5)).f != 0) + abort (); + if (foo (A (-111), A (-111)).f != 0) + abort (); + if (foo (A (2), A (-111)).f != 2) + abort (); + if (foo (A (-111), A (6)).f != 6) + abort (); + if (foo (A (-111), A (-4)).f != 0) + abort (); +}

nrv13.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 154) @@ -0,0 +1,25 @@ +// Test that type punning using an anonymous union works with strict aliasing. +// { dg-do run } +// { dg-options "-O2 -fstrict-aliasing" } + +extern "C" void abort (); + +void f (long i) +{ + union + { + long ui; + float uf[20]; + }; + + ui = i; + if (uf[0] != 42.0) + abort (); +} + +int main () +{ + union U { long i; float f[20]; } u; + u.f[0] = 42.0; + f (u.i); +}

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: thunk2.C =================================================================== --- thunk2.C (nonexistent) +++ thunk2.C (revision 154) @@ -0,0 +1,44 @@ +// PR c++/20206 +// { dg-do run } +// { dg-options "-O0" } + +void +bar (int x) +{ + asm ("" : : "g" (x)); +} + +struct S { S () {}; virtual ~S () {}; }; +struct T { virtual void foo (int) = 0; }; +struct U : public S, public T +{ + bool a; + U () {} + virtual ~U () {} + virtual void foo (int x) + { + switch (x) + { + case 12: + break; + case 9: + bar (7); + break; + case 10: + bar (12); + break; + case 4: + bar (18); + break; + case 2: + bar (26); + break; + } + } +}; +U u; + +int +main () +{ +}

thunk2.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: pr23454-2.C =================================================================== --- pr23454-2.C (nonexistent) +++ pr23454-2.C (revision 154) @@ -0,0 +1,106 @@ +/* PR rtl-optimization/23454 */ +/* Submitted by Matthias Klose */ + +/* { dg-do compile } */ +/* { dg-options "-O3" } */ + +typedef unsigned long long int ulonglong; +typedef long long int longlong; +typedef unsigned int uint32; +typedef unsigned int uint; +typedef unsigned long int ulong; + +class Item { +public: + bool null_value; + virtual longlong val_int()=0; +}; + +typedef struct st_tree_element { + struct st_tree_element *left,*right; + uint32 count; +} TREE_ELEMENT; + +typedef struct st_tree { + uint offset_to_key,elements_in_tree,size_of_element,memory_limit,allocated; + void *custom_arg; + bool with_delete; + uint flag; +} TREE; + +class field_info +{ +public: + ulong treemem, tree_elements, empty, nulls, min_length, max_length; + uint room_in_tree; + bool found; + TREE tree; + Item *item; +}; + +class field_ulonglong: public field_info +{ + ulonglong min_arg, max_arg; + ulonglong sum, sum_sqr; + void add(); +}; + +extern char *longlong10_to_str(longlong val,char *dst,int radix); +extern void delete_tree(TREE*); +extern TREE_ELEMENT *tree_insert(TREE *tree,void *custom_arg); + +static int compare_ulonglong(const ulonglong *s, const ulonglong *t) +{ + return ((*s < *t) ? -1 : *s > *t ? 1 : 0); +} + +void field_ulonglong::add() +{ + char buff[(255*3 +1)]; + longlong num = item->val_int(); + uint length = (uint) (longlong10_to_str(num, buff, 10) - buff); + TREE_ELEMENT *element; + + if (item->null_value) + { + nulls++; + return; + } + if (num == 0) + empty++; + + if (room_in_tree) + { + if (!(element = tree_insert(&tree, tree.custom_arg))) + { + room_in_tree = 0; + delete_tree(&tree); + } + else if (element->count == 1) + { + room_in_tree = 0; + delete_tree(&tree); + } + } + + if (!found) + { + found = 1; + min_arg = max_arg = sum = num; + sum_sqr = num * num; + min_length = max_length = length; + } + else if (num != 0) + { + sum += num; + sum_sqr += num * num; + if (length < min_length) + min_length = length; + if (length > max_length) + max_length = length; + if (compare_ulonglong((ulonglong*) &num, &min_arg) < 0) + min_arg = num; + if (compare_ulonglong((ulonglong*) &num, &max_arg) > 0) + max_arg = num; + } +}

pr23454-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: cfg3.C =================================================================== --- cfg3.C (nonexistent) +++ cfg3.C (revision 154) @@ -0,0 +1,61 @@ +// PR optimization/11646 +// Origin: + +// This used to fail because the compiler inadvertently cleared +// the EDGE_ABNORMAL flag on a EDGE_EH edge and didn't delete +// unreachable blocks after CSE. + +// { dg-do compile } +// { dg-options "-O -fgcse -fnon-call-exceptions" } + +struct C +{ + int i; +}; + +struct allocator +{ + ~allocator() throw() {} +}; + +struct _Vector_alloc_base +{ + _Vector_alloc_base(const allocator& __a) {} + allocator _M_data_allocator; + struct C *_M_start, *_M_end_of_storage; + void _M_deallocate(struct C* __p, unsigned int __n) {} +}; + +struct _Vector_base : _Vector_alloc_base +{ + _Vector_base(const allocator& __a) : _Vector_alloc_base(__a) { } + ~_Vector_base() { _M_deallocate(0, _M_end_of_storage - _M_start); } +}; + +struct vector : _Vector_base +{ + vector(const allocator& __a = allocator()) : _Vector_base(__a) {} + struct C& operator[](unsigned int __n) { return *_M_start; } +}; + +struct A +{ + float l() const; + A operator-(const A &) const; + const A& operator=(float) const; +}; + +struct B +{ + float d(); +}; + +float f(const A& a, B& b) +{ + vector vc; + int index = vc[0].i; + A aa; + float d = (aa - a).l(); + if (d > b.d()) aa = 0; + return b.d(); +}

cfg3.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: mmx2.C =================================================================== --- mmx2.C (nonexistent) +++ mmx2.C (revision 154) @@ -0,0 +1,23 @@ +// { dg-do link { target i?86-*-* x86_64-*-* } } +// { dg-options "-O2 -mmmx" } + +#include + +static union u { __m64 m; long long l; } u; +extern "C" void abort (void); + +__attribute__((noinline)) +void bar (__m64 x) +{ + u.m = x; +} + +int +main () +{ + bar (_mm_set_pi32 (0x000000FF,0xFFFF00FF)); + _mm_empty (); + if (u.l != 0xffffff00ffLL) + abort (); + return 0; +}

mmx2.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: pr18084-1.C =================================================================== --- pr18084-1.C (nonexistent) +++ pr18084-1.C (revision 154) @@ -0,0 +1,32 @@ +// { dg-do run } +// { dg-options "-O3" } + +extern "C" void abort (void); + +struct X { + bool init; + void foo() { if (!init) init = true; } + void bar() { foo(); } + +}; + +typedef unsigned long long int uint64_t; +uint64_t mask1, mask2; + +uint64_t calc() { + return mask1 & mask2; +} + +int main() +{ + mask1 = 0x00000000FFFFFFFFull; + mask2 = 0x000000000000FFFFull; + uint64_t value = calc(); + + X().bar(); + + if(value != calc()) + abort (); + return 0; +} +

pr18084-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: init1.C =================================================================== --- init1.C (nonexistent) +++ init1.C (revision 154) @@ -0,0 +1,4 @@ +// PR c++/23171 +// { dg-options "-O" } + +int *p = (int*)(int[1]){0};

init1.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: switch4.C =================================================================== --- switch4.C (nonexistent) +++ switch4.C (revision 154) @@ -0,0 +1,30 @@ +// { dg-do compile } + +// PR c++/20008 + +// We failed to compile this because CFG cleanup left the switch +// statement intact, whereas expand_case expected at least one +// in-range case to remain. + +typedef enum _SECStatus { + SECWouldBlock = -2, + SECFailure = -1, + SECSuccess = 0 +} SECStatus; + +typedef enum { + SEC_ERROR_BAD_SIGNATURE = (-0x2000) + 10 +} SECErrorCodes; + +void g(void); +void f(SECStatus status) +{ + switch( status ) + { + case SEC_ERROR_BAD_SIGNATURE : + // This case can be optimized away in C++ (but apparently not in + // C), because the enum type is defined with a narrow range. + g(); + break ; + } +}

switch4.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: reload1.C =================================================================== --- reload1.C (nonexistent) +++ reload1.C (revision 154) @@ -0,0 +1,43 @@ +// PR 7944 +// { dg-do compile } +// { dg-options -O2 } + +struct B +{ + B & operator << (short s) + { + int j; + if (j) + return operator << (s); + else + return operator << (s); + } +}; + +struct A +{ + int i; + static void bar (); + static int quux () + { + bar (); + return 0; + } + + A ():i (quux ()) + { + } + ~A () + { + } +}; + +void +foo () +{ + short s[4] = { 0, 0, 0, 1 }; + A a[2] = { A (), A () }; + + B b; + b << s[0] << s[2]; +}

reload1.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: pr18683-1.C =================================================================== --- pr18683-1.C (nonexistent) +++ pr18683-1.C (revision 154) @@ -0,0 +1,29 @@ +// PR middle-end/18683 +// { dg-do compile } +// { dg-options "-O0" } + +template +struct basic_ostream +{ + basic_ostream& operator<<(int __n); +}; + +extern basic_ostream cout; + +template struct linear_congruential +{ + template + friend basic_ostream& + operator<<(basic_ostream& os, + const linear_congruential& lcg) + { + return os << 1; + } +}; + +void instantiate_all() +{ + linear_congruential<0> lcf; + cout << lcf; +} +

pr18683-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: pr23478.C =================================================================== --- pr23478.C (nonexistent) +++ pr23478.C (revision 154) @@ -0,0 +1,211 @@ +// PR rtl-optimization/23478 +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort (); +bool tthrow; +struct C3 { int i; }; +class C14 {}; +struct C7 +{ + virtual ~C7 (); +}; + +C7::~C7 () +{ + asm volatile ("" : : : "memory"); +} +class C2 : public C7 {}; + +template class C13 +{ + bool ma; + X *mb; +public: + explicit C13 (X *p = 0) throw () : ma (p != 0), mb (p) {} + ~C13 (); +}; + +template +C13::~C13 () +{ + asm volatile ("" : : "r" (ma), "r" (mb) : "memory"); +} + +struct C1 +{ + C1 (const C3 &, const C3 &, const C3 &, const C3 *&); +}; + +C1::C1 (const C3 &, const C3 &, const C3 &, const C3 *&) +{ + if (!tthrow) + throw 24; +} + +struct C8 +{ + struct C15 {}; + typedef C15 *C9; + virtual void f1 (C2 &, long *, void *, C3 &, void *, bool) = 0; + virtual C13 f3 () const = 0; + virtual ~C8 () {} +}; + +bool +xx14 () +{ + bool b = false; + if (tthrow) + throw 6; + asm volatile ("" : : "r" (&b) : "memory"); + return b; +} + +bool +xx2 () +{ + bool b = false; + if (tthrow) + throw 6; + asm volatile ("" : : "r" (&b) : "memory"); + return b; +} + +C13 +xx9 () +{ + return C13(); +} + +C2 & +xx10 () +{ + static C2 c2; + return c2; +} + +C3 & +xx12 () +{ + static C3 c3 = { 1 }; + return c3; +} + +const C3 & +xx5 () +{ + static const C3 c3 = { 2 }; + return c3; +} + +const C3 *& +xx4 () +{ + static const C3 *p; + if (tthrow) + throw 6; + return p; +} + +long ll13; + +long +xx13 () +{ + long ret; + asm volatile ("" : "=r" (ret) : "r" (ll13)); + return ret; +} + +void +xx15 (C3 &x, C13 &y) +{ + asm volatile ("" : : "r" (&x), "r" (&y) : "memory"); +} + +long +xx16 (const void *x) +{ + long ret; + asm volatile ("" : "=r" (ret) : "0" (1), "r" (x) : "memory"); + return ret; +} + +void +xx1 (C13 x) +{ + asm volatile ("" : : "r" (&x) : "memory"); + if (tthrow) + throw 6; +} + +void +xx3 (const C7 *x) +{ + if (x) + abort (); +} + +void +xx7 () +{ + asm volatile ("" : : : "memory"); +} + +struct C5 +{ + C13 f2 (C3 &v1, const void *v2, C8 *v6); + C7 *m2[2]; + long m1[2]; +}; + +C13 +C5::f2 (C3 &v1, const void *v2, C8 *v6) +{ + C13 v13 = xx9 (); + C2 &v9 = xx10 (); + for (long i = 1; i < 2; i++) + xx3 (m2[i]); + const C3 &ld = xx5 (); + xx7 (); + if (xx2 ()) + throw ""; + xx4 (); + C3 &si = xx12 (); + for (long i = 0; i < xx16 (v2); ++i) + { + C13 sk (new C1 (xx5 (), ld, xx5 (), xx4 ())); + xx15 (si, sk); + } + long v4 = xx13 (); + for (long i = v4 - 1; i >= 0; --i) + m1[i] = i; + bool v8 = xx2 (); + for (long i = 0; i < 2 && !xx14 (); i++) + { + v6[i].f1 (v9, 0, __null, v1, __null, v8); + if (v8) + xx1 (v6[i].f3 ()); + } + return v13; +} + +int +main (void) +{ + C5 c5 = { { __null, __null }, { 0, 0 } }; + bool seen = false; + try + { + c5.f2 (xx12 (), __null, __null); + } + catch (int n) + { + if (n != 24) + abort (); + seen = true; + } + if (!seen) + abort (); +}

pr23478.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: pr23299.C =================================================================== --- pr23299.C (nonexistent) +++ pr23299.C (revision 154) @@ -0,0 +1,63 @@ +// PR rtl-optimization/23299 +// { dg-do run } +// { dg-options "-Os" } + +extern "C" void abort (); + +struct A +{ + virtual int a () {} +}; +struct B : public A +{ + virtual int b () {} +}; +struct C : public A +{ + virtual int c () {} +}; +struct D +{ + D () { d = 64; } + ~D (); + int d; +}; + +int x; +D::~D () +{ + x |= 1; + if (d != 64) + abort (); +} + +struct E : public B, public C +{ + E () {} + virtual int c (); + ~E (); + D dv; +}; + +E::~E () +{ + int r = c (); +} + +int +E::c () +{ + if (x > 10) + throw 1; + x |= 2; +} + +int +main (void) +{ + { + E e; + } + if (x != 3) + abort (); +}

pr23299.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: complex3.C =================================================================== --- complex3.C (nonexistent) +++ complex3.C (revision 154) @@ -0,0 +1,24 @@ +// PR 22022 +// { dg-do compile } +// { dg-options "-O2" } + +_Complex float f(); +_Complex float g(); +_Complex float h()throw(); +void i(float)throw(); + +float j(void) +{ + _Complex float x = h(); + try + { + try + { + x = f(); + }catch (...) + { + x += g(); + } + }catch(...){} + i(__builtin_crealf(x)+__builtin_cimagf(x)); +}

complex3.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: 20050511-1.C =================================================================== --- 20050511-1.C (nonexistent) +++ 20050511-1.C (revision 154) @@ -0,0 +1,65 @@ +/* { dg-do run } */ +/* { dg-options "-w" } */ +/* { dg-options "-O3 -w" { target powerpc*-*-* } } */ +#include +#include + +typedef signed short SINT16 ; +typedef unsigned long UINT32 ; +typedef unsigned int UINT ; + +class A +{ +public: + union + { + SINT16 xy[2]; + UINT32 abXY; + }; + bool operator==(const A& other) const {return abXY == other.abXY;} + bool operator!=(const A& other) const {return abXY != other.abXY;} +}; + +template struct pArray { unsigned char u08[16*(((size*1)+15)/16)] __attribute__ ((aligned(16))); }; + +struct B +{ + union { + A mvL[2]; + pArray<1> xyz; + }; +} ; + +typedef struct +{ + UINT w; + B b; + +}C; + + +UINT32 bar (const C * sPtr) +{ + UINT w = sPtr->w; + A a; + + a.xy[0] = sPtr->b.mvL[w].xy[0]<<2; + a.xy[1] = sPtr->b.mvL[w].xy[1]<<2; + + if (a.xy[0] != ((SINT16) 0xffff << 2)) + abort (); +} + +int main() +{ + A a; + C c; + a.xy[0] = 0xffff; + a.xy[1] = 0xffff; + c.w=0; + c.b.mvL[0].xy[0] = a.xy[0]; + c.b.mvL[0].xy[1] = a.xy[1]; + + bar (&c); +} +

20050511-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: unroll1.C =================================================================== --- unroll1.C (nonexistent) +++ unroll1.C (revision 154) @@ -0,0 +1,420 @@ +// PR optimization/12340 +// Origin: Richard Guenther +// Testcase by Eric Botcazou + +// This used to segfault on x86 because the loop optimizer wrongly +// interpreted a double assignment to a biv as a double increment, +// which subsequently fooled the unroller. + +// { dg-do run } +// { dg-options "-O2 -fno-exceptions -funroll-loops" } + +typedef __SIZE_TYPE__ size_t; + +inline void* operator new(size_t, void* __p) throw() { return __p; } +inline void operator delete (void*, void*) throw() { }; + +class Loc; +class Interval; + +template +class DomainBase +{ +public: + typedef typename DT::Domain_t Domain_t; + typedef typename DT::Storage_t Storage_t; + + Domain_t &unwrap() { return *static_cast(this); } + + const Domain_t &unwrap() const { + return *static_cast(const_cast *>(this)); + } + +protected: + Storage_t domain_m; +}; + +template +class Domain : public DomainBase

+{ + typedef DomainBase

Base_t; + +public: + typedef typename DT::Size_t Size_t; + typedef typename DT::Element_t Element_t; + typedef typename Base_t::Domain_t Domain_t; + typedef typename Base_t::Storage_t Storage_t; + + Domain_t &operator[](int) { return this->unwrap(); } + + const Domain_t &operator[](int) const { return this->unwrap(); } + + template + void setDomain(const T &newdom) { + DT::setDomain(this->domain_m, newdom); + } + + Element_t first() const { return DT::first(this->domain_m); } + + Size_t length() const { return DT::length(this->domain_m); } + + Size_t size() const { return length(); } +}; + +template +struct DomainTraits; + +template<> +struct DomainTraits +{ + typedef int Size_t; + typedef int Element_t; + typedef Interval Domain_t; + typedef Interval OneDomain_t; + typedef Loc AskDomain_t; + typedef int Storage_t[2]; + enum { dimensions = 1 }; + enum { wildcard = false }; + + static int first(const Storage_t &d) { return d[0]; } + + static int length(const Storage_t &d) { return d[1]; } + + static OneDomain_t &getDomain(Domain_t &d, int) { return d; } + + static const OneDomain_t &getDomain(const Domain_t &d, int) { return d; } + + template + static void setDomain(Storage_t &dom, const T &newdom) { + dom[0] = newdom.first(); + dom[1] = newdom.length(); + } + + template + static void setDomain(Storage_t &dom, const T1 &begval, const T2 &endval) { + dom[0] = begval; + dom[1] = (endval - begval + 1); + } + +}; + +class Interval : public Domain > +{ +public: + Interval(const Interval &a) : Domain >() { + for (int i=0; i < DomainTraits::dimensions; ++i) + DomainTraits::getDomain(*this, i).setDomain( + DomainTraits::getDomain(a, i)); + } + + Interval(int a) : Domain >() + { + DomainTraits::setDomain(domain_m, 0, a - 1); + } +}; + +template<> +struct DomainTraits +{ + typedef int Size_t; + typedef int Element_t; + typedef Loc Domain_t; + typedef Loc AskDomain_t; + typedef Loc MultResult_t; + typedef int Storage_t; + + static int first(int d) { return d; } + + template + static void setDomain(int &dom, const T &newdom) { + dom = DomainTraits::getFirst(newdom); + } +}; + +template<> +struct DomainTraits + { + enum { dimensions = 1 }; + enum { wildcard = false }; + + static int getPointDomain(int d, int) { return d; } + + static int getFirst(const int &d) { return d; } +}; + +class Loc : public Domain > +{ +public: + explicit Loc(const int &a) : Domain >() { + for (int i=0; i < 1; ++i) + (*this)[i].setDomain(DomainTraits::getPointDomain(a, 0)); + } +}; + +struct ElementProperties +{ + enum { hasTrivialDefaultConstructor = false }; + enum { hasTrivialDestructor = false }; + + static void construct(double* addr) + { + new (addr) double(); + } + + static void construct(double* addr, const double& model) + { + new (addr) double(model); + } + + static void destruct(double *addr) {} +}; + +class RefCounted +{ +public: + RefCounted() : count_m(0) {} + + void addReference() { ++count_m; } + bool removeRefAndCheckGarbage() + { + return (--count_m == 0); + } + +private: + int count_m; +}; + +class RefBlockController : public RefCounted +{ +public: + explicit RefBlockController(unsigned int size) + : pBegin_m(0), pEnd_m(0), pEndOfStorage_m(0), dealloc_m(false) + { + reallocateStorage(size, false); + + if (!ElementProperties::hasTrivialDefaultConstructor) + { + for (double * pt = begin(); pt != end(); ++pt) + ElementProperties::construct(pt); + } + } + + ~RefBlockController() + { + deleteStorage(); + } + + double *begin() const + { + return pBegin_m; + } + + double *end() const + { + return pEnd_m; + } + + bool isMine() const + { + return dealloc_m; + } + +private: + void deleteStorage() + { + if (isMine() && pBegin_m != 0) + { + if (!ElementProperties::hasTrivialDestructor) + for (double *pt = begin(); pt != end(); ++pt) + ElementProperties::destruct(pt); + + char *tmp = reinterpret_cast(pBegin_m); + delete [] tmp; + } + } + + void reallocateStorage(unsigned int newsize, bool copyold = false) + { + double *pBeginNew = 0; + double *pEndNew = 0; + double *pEndOfStorageNew = 0; + + if (newsize > 0) + { + int nsize = newsize * sizeof(double); + char *tmp = new char[nsize]; + pBeginNew = reinterpret_cast(tmp); + pEndNew = pBeginNew + newsize; + pEndOfStorageNew = pBeginNew + (nsize / sizeof(double)); + + if (copyold) + { + double * pOld = begin(); + double * pNew = pBeginNew; + while (pOld != end() && pNew != pEndNew) + ElementProperties::construct(pNew++,*pOld++); + } + } + + deleteStorage(); + + pBegin_m = pBeginNew; + pEnd_m = pEndNew; + pEndOfStorage_m = pEndOfStorageNew; + dealloc_m = true; + } + + double *pBegin_m; + double *pEnd_m; + double *pEndOfStorage_m; + bool dealloc_m; +}; + +class DataBlockController : public RefBlockController +{ +public: + explicit + DataBlockController(unsigned int size) + : RefBlockController(size), dataObjectPtr_m(new char), owned_m(true) {} + + ~DataBlockController() + { + if (owned_m) delete dataObjectPtr_m; + } + +private: + mutable char *dataObjectPtr_m; + bool owned_m; +}; + +class RefCountedPtr +{ +public: + RefCountedPtr(DataBlockController * const pT) : ptr_m(pT) + { if (isValid()) ptr_m->addReference(); } + + ~RefCountedPtr() { invalidate(); } + + DataBlockController* operator->() const { return ptr_m; } + void invalidate(); + bool isValid() const { return ptr_m != 0; } + +private: + friend class RefCountedBlockPtr; + DataBlockController * ptr_m; +}; + +inline void RefCountedPtr::invalidate() +{ + if ( isValid() && ptr_m->removeRefAndCheckGarbage() ) + delete ptr_m; + ptr_m = 0; +} + +class RefCountedBlockPtr +{ +public: + explicit RefCountedBlockPtr(unsigned int size) + : offset_m(0), + blockControllerPtr_m(new DataBlockController(size)) {} + + int offset() const + { + return offset_m; + } + + double *beginPointer() const + { + return blockControllerPtr_m->begin(); + } + + double *currentPointer() const + { + return beginPointer() + offset(); + } + +protected: + int offset_m; + RefCountedPtr blockControllerPtr_m; +}; + +class DataBlockPtr : public RefCountedBlockPtr +{ +public: + explicit DataBlockPtr(unsigned int size) : RefCountedBlockPtr(size) {} +}; + +class Node +{ +public: + Node(const Interval &owned, const Interval &allocated) + : domain_m(owned), allocated_m(allocated) {} + + const Interval &allocated() const { return allocated_m; } + +private: + Interval domain_m; + Interval allocated_m; +}; + +class DomainLayout +{ +public: + explicit DomainLayout(const Interval &dom) : node_m(0, dom) {} + + const Interval &domain() const + { + return node_m.allocated(); + } + +private: + Node node_m; +}; + +class BrickBase +{ +public: + explicit BrickBase(const Interval &domain); + + int offset(const Loc &dom) const { return off_m + dom[0].first(); } + +protected: + DomainLayout layout_m; + int firsts_m; + int off_m; +}; + +BrickBase::BrickBase(const Interval &dom) + : layout_m(dom) +{ + firsts_m = layout_m.domain()[0].first(); + off_m = -firsts_m; +} + +class Engine : public BrickBase +{ +public: + explicit Engine(const Interval &dom) + : BrickBase(dom), dataBlock_m(dom.size()), data_m(dataBlock_m.currentPointer()) {} + + double& operator()(const Loc &loc) const + { + return data_m[this->offset(loc)]; + } + +private: + DataBlockPtr dataBlock_m; + double *data_m; +}; + + +int main() +{ + Interval I(10); + Engine A(I); + + for (int i = 0; i < 10; i++) + A(Loc(i)) = 2.0 + i - i*i; + + return 0; +}

unroll1.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: pr17697-2.C =================================================================== --- pr17697-2.C (nonexistent) +++ pr17697-2.C (revision 154) @@ -0,0 +1,32 @@ +// PR tree-optimization/17697 +// { dg-do run } +// { dg-options "-O2" } + +extern "C" +{ + extern int strcmp (const char *s, const char *t) throw () + __attribute__ ((pure)); +} + +namespace A +{ + extern int strcmp (const char *s, const char *t) throw (); +} + +inline int +A::strcmp (const char *s, const char *t) throw () +{ + return ::strcmp (s, t); +} + +int +foo (const char *x) throw () +{ + return A::strcmp ("", x); +} + +int +main () +{ + return foo ("") != 0 || foo ("a") == 0; +}

pr17697-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: inline1.C =================================================================== --- inline1.C (nonexistent) +++ inline1.C (revision 154) @@ -0,0 +1,43 @@ +// PR c++/6316 +// This testcase ICEd because when deferred bar()::F::F() was being +// expanded, containing bar() was still deferred and had DECL_EXTERNAL set +// (and DECL_NOT_REALLY_EXTERN too). +// { dg-do compile } +// { dg-options "-O3" } + +struct A { ~A() throw() {} }; +template struct B { U a; B(const T *); }; +typedef B C; +struct D { D(); }; +struct E { virtual ~E(); }; + +E *bar (); + +void +foo () +{ + E *a = bar (); +} + +extern char *z []; + +E * +bar () +{ + struct F : public E + { + F () + { + for (int i = 0; i < 2; i++) + C e = z[i]; + } + D x, y; + }; + return new F (); +} + +int +main () +{ + foo (); +}

inline1.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: asm1.C =================================================================== --- asm1.C (nonexistent) +++ asm1.C (revision 154) @@ -0,0 +1,9 @@ +// PR c++/6747 +// { dg-do compile } +// { dg-options "-O" } + +void foo() +{ + union { double d; char c[sizeof(double)]; } tmp; + __asm__ ("" : "=m" (tmp.d)); // { dg-bogus "not directly addressable" "double sized union element should be addressible" { xfail xstormy16-*-* } } +}

asm1.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: inline5.C =================================================================== --- inline5.C (nonexistent) +++ inline5.C (revision 154) @@ -0,0 +1,20 @@ +// PR c++/12519 + +// { dg-do compile } +// { dg-options "-O" } + +struct A +{ + ~A(); +}; + +inline const A foo() +{ + A a; + return a; +} + +A bar() +{ + return foo(); +}

inline5.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: strength-reduce.C =================================================================== --- strength-reduce.C (nonexistent) +++ strength-reduce.C (revision 154) @@ -0,0 +1,51 @@ +// This testcase was miscompiled on s390x, because strength-reduction +// did not see biv in C::foo as used after loop, but it was used +// in a REG_EQUAL note. +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort (void); + +struct C +{ + int foo (char ch, int offset = __INT_MAX__) const; + int bar (int offset, char c) const; + const char *a; +}; + +int C::bar (int offset, char c) const +{ + char ch = a[offset]; + if (ch < c) + return -1; + if (ch > c) + return 1; + return 0; +} + +int C::foo (char ch, int offset) const +{ + int len = __builtin_strlen (a); + if (len == 0) + return __INT_MAX__; + if (offset >= len) + offset = len - 1; + + while (bar (offset, ch) != 0) + { + if (offset == 0) + return __INT_MAX__; + offset--; + } + + return offset; +} + +int main (void) +{ + C c; + c.a = "/some/dir/file.ext"; + if (c.foo ('/') != 9) + abort (); + return 0; +}

strength-reduce.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: fold2.C =================================================================== --- fold2.C (nonexistent) +++ fold2.C (revision 154) @@ -0,0 +1,19 @@ +// PR optimization/14669 +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort (void); +extern "C" void exit (int); + +enum ActionType { EE=-1, E0=0, E1, E2 }; + +int main(void) +{ + ActionType t = E0; + + if (E1 <= t && t <= E2) + abort (); + + exit (0); +} +

fold2.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: inline9.C =================================================================== --- inline9.C (nonexistent) +++ inline9.C (revision 154) @@ -0,0 +1,29 @@ +// PR c++/17972 +// Origin: Michal Ostrowski +// Testcase by Alan Modra +// { dg-do run } +// { dg-options "-O" } +// { dg-options "-O -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } + +struct thread_info +{ + short preempt_count; +} x; + +static inline struct thread_info *cti (void) __attribute__ ((const)); +static inline struct thread_info *cti (void) +{ + return &x; +} + +void fn (void) __attribute__ ((noinline)); +void fn (void) +{ + ++cti()->preempt_count; +} + +int main (void) +{ + fn (); + return 0; +}

inline9.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: const3.C =================================================================== --- const3.C (nonexistent) +++ const3.C (revision 154) @@ -0,0 +1,44 @@ +// PR optimization/12926 +// This failed on SPARC64 because the assignments to the bit-fields +// were wrongly swapped in the constructor. + +// { dg-do run } +// { dg-options "-O2" } + +extern "C" void abort(void); + +typedef __SIZE_TYPE__ size_t; + +void *my_out; + +struct A +{ + enum Type {P, U, S}; + + int foo1(void *, const char *); + int foo2(int, const Type); + + A (const size_t size, const Type type): mSize(size), mType(type) + { + foo2(foo1(my_out, "type = "), type); + foo2(foo1(my_out, "mType = "), mType); + } + + const size_t mSize : 8*sizeof(size_t) - 3; + Type mType : 2; +}; + +int i; + +int A::foo1(void *ios, const char *str) { } +int A::foo2(int v, const Type t) { i=0; } + +int main() +{ + A testa(2, A::S); + + if (testa.mType != A::S) + abort(); + + return 0; +}

const3.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: noreturn-1.C =================================================================== --- noreturn-1.C (nonexistent) +++ noreturn-1.C (revision 154) @@ -0,0 +1,87 @@ +// PR optimization/12965 +// Origin: +// Reduced testcase: Falk Hueffner + +// This ICEd on Alpha because the reload pass emitted save/restore +// insns around a no-return call. + +// { dg-do compile } +// { dg-options "-O2" } + +template class allocator; +template struct char_traits; +template , + typename _Alloc = allocator<_CharT> > +class basic_string; +typedef basic_string string; + +static inline int __exchange_and_add(volatile int * __mem, int __val) { + int __result; + asm("" : "=&r"(__result)); + return __result; +} + +template struct allocator { + allocator() throw() { } + allocator(const allocator &) throw() {} +}; + +template +struct basic_string { + typedef _Alloc allocator_type; + struct _Rep { + int _M_references; + void _M_dispose(const _Alloc & __a) { + if (__exchange_and_add(&_M_references, -1) <= 0) + _M_destroy(__a); + } void _M_destroy(const _Alloc &) throw(); + }; + struct _Alloc_hider : _Alloc { + _CharT *_M_p; + }; + mutable _Alloc_hider _M_dataplus; + _CharT *_M_data() const { return _M_dataplus._M_p; } + _Rep *_M_rep() const { + return &((reinterpret_cast<_Rep *>(_M_data()))[-1]); + } + basic_string(); + basic_string(const _CharT * __s, const _Alloc & __a = _Alloc()); + ~basic_string() { + _M_rep()->_M_dispose(this->get_allocator()); + } + allocator_type get_allocator() const { return _M_dataplus; } +}; + +struct Egeneric { + void stack(const string & passage, const string & message = "") { } +}; + +struct infinint { + void detruit() throw(Egeneric); + template void infinint_from(T a) throw(Egeneric); + infinint(long a = 0) throw(Egeneric) { + try { + infinint_from(a); + } catch(Egeneric& e) { + e.stack("infinint::infinint", "long"); + } + } + ~infinint() throw(Egeneric) { + try { + detruit(); + } catch(Egeneric& e) { } + } +}; + +struct inode { + string x; + infinint a, c; + infinint ea_offset; + inode(); +}; + +inode::inode() +{ + ea_offset = 0; +}

noreturn-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: conj2.C =================================================================== --- conj2.C (nonexistent) +++ conj2.C (revision 154) @@ -0,0 +1,23 @@ +// PR target/6043 +// This testcase ICEd on IA-64 because emit_group_store +// did not handle loading CONCAT from register group +// { dg-do compile } + +struct C +{ + C (double y, double z) { __real__ x = y; __imag__ x = z; } + double r () const { return __real__ x; } + double i () const { return __imag__ x; } + __complex__ double x; +}; + +inline C conj (const C& x) +{ + return C (x.r (), - x.i ()); +} + +void foo (void) +{ + C x (1.0, 1.0); + conj (x); +}

conj2.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: eh1.C =================================================================== --- eh1.C (nonexistent) +++ eh1.C (revision 154) @@ -0,0 +1,21 @@ +// PR middle-end/14477 +// { dg-do compile } +// { dg-options "-O2 -fno-default-inline" } + +struct A +{ + A(); +}; + +struct B +{ + B(const A*); +}; + +struct C +{ + B b; + C(int) : b(new A) {} +}; + +C c(0);

eh1.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: interface1.C =================================================================== --- interface1.C (nonexistent) +++ interface1.C (revision 154) @@ -0,0 +1,13 @@ +// { dg-do run } +// { dg-options "-O2" } +// { dg-additional-sources "interface1-a.cc" } + +#pragma implementation "interface1.h" + +#include "interface1.h" + +extern void g(); + +int main () { + g(); +}

interface1.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 154) @@ -0,0 +1,14 @@ +// PR opt/13681 +// Here we have an out-of-range array index. We should not abort +// trying to resolve the indirection back to an object. + +struct X { + double values[1]; + double & foo (const unsigned int index) { return values[index]; } +}; + +void foo() { + double d; + X h1; + h1.foo(1) = d; +}

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: tmp1.C =================================================================== --- tmp1.C (nonexistent) +++ tmp1.C (revision 154) @@ -0,0 +1,48 @@ +// { dg-do run } + + +// Copyright (C) 2003 Free Software Foundation, Inc. +// Contributed by Nathan Sidwell 30 Jul 2003 + +// compound exprs were causing additional temporaries. + +extern "C" int printf (char const *, ...); +extern "C" void abort (); + + +static unsigned order[] = +{ + 1, 2, 502, 102, 101, + 0 +}; + +static unsigned point; + +static void Check (unsigned t, unsigned i, void const *ptr, char const *name) +{ + printf ("%d %d %p %s\n", t, i, ptr, name); + + if (order[point++] != i + t) + abort (); + +} + +template struct A +{ + A () { Check (0, I, this, __PRETTY_FUNCTION__); } + ~A () { Check (100, I, this, __PRETTY_FUNCTION__); } + A (A const &) { Check (200, I, this, __PRETTY_FUNCTION__); } + A &operator= (A const &) { Check (300, I, this, __PRETTY_FUNCTION__); } + void Foo () const { Check (400, I, this, __PRETTY_FUNCTION__); } +}; + +template void Foo (A a) +{ + Check (500, I, &a, __PRETTY_FUNCTION__); +} + +int main () +{ + Foo ((A<1> (), A<2> ())); + Check (0, 0, 0, "end"); +}