diff options
Diffstat (limited to 'gcc/testsuite/g++.dg/torture')
193 files changed, 9628 insertions, 0 deletions
diff --git a/gcc/testsuite/g++.dg/torture/20070621-1.C b/gcc/testsuite/g++.dg/torture/20070621-1.C new file mode 100644 index 000000000..185314a47 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/20070621-1.C @@ -0,0 +1,116 @@ +/* Reduced from libstdc++-v3/testsuite/25_algorithms/equal/1.cc + +1.2.ii: In function 'void test1()': +1.2.ii:104: error: true/false edge after a non-COND_EXPR in bb 15 +1.2.ii:104: internal compiler error: verify_flow_info failed + +*/ + +__extension__ typedef __PTRDIFF_TYPE__ ptrdiff_t; +namespace std __attribute__ ((__visibility__ ("default"))) { + template<typename, typename> struct __are_same { + enum { + __value = 0 }; + }; + template<typename _Tp> struct __is_integer { + enum { + __value = 0 }; + }; + template<typename _Tp> struct __is_pointer { + enum { + __value = 0 }; + }; + template<typename _Tp> struct __is_normal_iterator { + enum { + __value = 0 }; + }; + struct input_iterator_tag { + }; + template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t, typename _Pointer = _Tp*, typename _Reference = _Tp&> struct iterator { + typedef _Tp value_type; + }; + template<typename _Iterator> struct iterator_traits { + typedef typename _Iterator::value_type value_type; + }; + template<typename _Iterator, bool _BoolType = __is_normal_iterator<_Iterator>::__value> struct __niter_base { + static const _Iterator& __b(const _Iterator& __it) { + return __it; + } + }; + template<bool _BoolType> struct __equal { + template<typename _II1, typename _II2> static bool equal(_II1 __first1, _II1 __last1, _II2 __first2) { + for (; + __first1 != __last1; + ++__first1, ++__first2) if (!(*__first1 == *__first2)) return false; + } + }; + template<typename _II1, typename _II2> inline bool __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = (__is_integer<_ValueType1>::__value && __is_pointer<_II1>::__value && __is_pointer<_II2>::__value && __are_same<_ValueType1, _ValueType2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + template<typename _II1, typename _II2> inline bool equal(_II1 __first1, _II1 __last1, _II2 __first2) { + return std::__equal_aux(__niter_base<_II1>::__b(__first1), __niter_base<_II1>::__b(__last1), __niter_base<_II2>::__b(__first2)); + } + } +extern "C" { + extern void __assert_fail (__const char *__assertion, __const char *__file, unsigned int __line, __const char *__function) throw () __attribute__ ((__noreturn__)); + } +namespace __gnu_test { + template<typename T> struct BoundsContainer { + T* first; + T* last; + BoundsContainer(T* _first, T* _last) : first(_first), last(_last) { + } + }; + template<class T> class input_iterator_wrapper:public std::iterator <std::input_iterator_tag, T, ptrdiff_t, T*, T&> { + public: + typedef BoundsContainer<T> ContainerType; + T* ptr; + ContainerType* SharedInfo; + input_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) : ptr(_ptr), SharedInfo(SharedInfo_in) { + } + bool operator==(const input_iterator_wrapper& in) const { + (static_cast<void> (__builtin_expect (!!(SharedInfo != __null && SharedInfo == in.SharedInfo), 1) ? 0 : (__assert_fail ("SharedInfo != __null && SharedInfo == in.SharedInfo", "/abuild/rguenther/gcc/libstdc++-v3/testsuite/util/testsuite_iterators.h", 201, __PRETTY_FUNCTION__), 0))); + (static_cast<void> (__builtin_expect (!!(ptr>=SharedInfo->first && in.ptr>=SharedInfo->first), 1) ? 0 : (__assert_fail ("ptr>=SharedInfo->first && in.ptr>=SharedInfo->first", "/abuild/rguenther/gcc/libstdc++-v3/testsuite/util/testsuite_iterators.h", 202, __PRETTY_FUNCTION__), 0))); + } + bool operator!=(const input_iterator_wrapper& in) const { + return !(*this == in); + } + T& operator*() const { + (static_cast<void> (__builtin_expect (!!(SharedInfo && ptr < SharedInfo->last), 1) ? 0 : (__assert_fail ("SharedInfo && ptr < SharedInfo->last", "/abuild/rguenther/gcc/libstdc++-v3/testsuite/util/testsuite_iterators.h", 215, __PRETTY_FUNCTION__), 0))); + (static_cast<void> (__builtin_expect (!!(ptr >= SharedInfo->first), 1) ? 0 : (__assert_fail ("ptr >= SharedInfo->first", "/abuild/rguenther/gcc/libstdc++-v3/testsuite/util/testsuite_iterators.h", 216, __PRETTY_FUNCTION__), 0))); + } + input_iterator_wrapper& operator++() { + (static_cast<void> (__builtin_expect (!!(SharedInfo && ptr < SharedInfo->last), 1) ? 0 : (__assert_fail ("SharedInfo && ptr < SharedInfo->last", "/abuild/rguenther/gcc/libstdc++-v3/testsuite/util/testsuite_iterators.h", 237, __PRETTY_FUNCTION__), 0))); + ptr++; + SharedInfo->first=ptr; + } + }; + template <class T, template<class T> class ItType> struct test_container { + typename ItType<T>::ContainerType bounds; + test_container(T* _first, T* _last):bounds(_first, _last) { + } + ItType<T> it(T* pos) { + return ItType<T>(pos, &bounds); + } + ItType<T> begin() { + return it(bounds.first); + } + ItType<T> end() { + } + }; + } +using __gnu_test::test_container; +using __gnu_test::input_iterator_wrapper; +typedef test_container<int, input_iterator_wrapper> Container; +int array1[] = { + 0, 1}; +int array2[] = { + 1, 0}; +void test1() { + Container con1(array1, array1); + Container con2(array2, array2); + (static_cast<void> (__builtin_expect (!!(std::equal(con1.begin(), con1.end(), con2.begin())), 1) ? 0 : (__assert_fail ("std::equal(con1.begin(), con1.end(), con2.begin())", "/abuild/rguenther/gcc/libstdc++-v3/testsuite/25_algorithms/equal/1.cc", 35, __PRETTY_FUNCTION__), 0))); + } diff --git a/gcc/testsuite/g++.dg/torture/20080625-1.C b/gcc/testsuite/g++.dg/torture/20080625-1.C new file mode 100644 index 000000000..b18c28226 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/20080625-1.C @@ -0,0 +1,27 @@ +extern "C" { + typedef unsigned char sal_Bool; + typedef struct _rtl_uString { + } rtl_uString; + void rtl_uString_release( rtl_uString * str ) throw (); +} +class OUString { + rtl_uString * pData; +public: + OUString() {} + ~OUString() { + rtl_uString_release( pData ); + } + sal_Bool equalsIgnoreAsciiCase( const OUString & str ) const; +}; +bool findAndRemove(); +long getAttributeProps() +{ + long nAttrs = 0; + OUString aValue; + if (findAndRemove() + && aValue.equalsIgnoreAsciiCase(OUString())) + ; + else + nAttrs |= 1; + return nAttrs; +} diff --git a/gcc/testsuite/g++.dg/torture/20090329-1.C b/gcc/testsuite/g++.dg/torture/20090329-1.C new file mode 100644 index 000000000..0274a1944 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/20090329-1.C @@ -0,0 +1,59 @@ +/* { dg-do compile } */ + +struct input_iterator_tag { }; +template<typename _Category, typename _Tp, typename _Distance = long, typename _Pointer = _Tp*, typename _Reference = _Tp&> +struct iterator { + typedef _Category iterator_category; +}; +template<typename _Iterator> struct iterator_traits { + typedef typename _Iterator::iterator_category iterator_category; +}; +template<typename, typename> struct __lc_rai { + template<typename _II1, typename _II2> + static _II1 __newlast1(_II1, _II1 __last1, _II2, _II2) { + return __last1; + } + template<typename _II> + static bool __cnd2(_II __first, _II __last) { + return __first != __last; + } +}; +template<typename _II1, typename _II2, typename _Compare> +bool lexicographical_compare(_II1 __first1, _II1 __last1, _II2 __first2, + _II2 __last2, _Compare __comp) { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef __lc_rai<_Category1, _Category2> __rai_type; + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; + __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, ++__first2) { + if (__comp(*__first1, *__first2)) return true; + } +} +void __assert_fail () throw () __attribute__ ((__noreturn__)); +template<typename T> struct BoundsContainer { }; +template<class T> class input_iterator_wrapper : public iterator<input_iterator_tag, T, long, T*, T&> { +public: + typedef BoundsContainer<T> ContainerType; + T* ptr; + ContainerType* SharedInfo; + input_iterator_wrapper(const input_iterator_wrapper& in) : ptr(in.ptr), SharedInfo(in.SharedInfo) { } + bool operator==(const input_iterator_wrapper& in) const { + (static_cast<void> ((SharedInfo != __null + && SharedInfo == in.SharedInfo) + ? 0 : (__assert_fail (), 0))); + } + bool operator!=(const input_iterator_wrapper& in) const { + return !(*this == in); + } + T& operator*() const { } + input_iterator_wrapper& operator++() { } +}; +struct X { }; +bool predicate(const X&, const X&) { + return true; +} +bool test2(input_iterator_wrapper<X>& x) { + return lexicographical_compare(x, x, x, x, predicate); +} diff --git a/gcc/testsuite/g++.dg/torture/20090706-1.C b/gcc/testsuite/g++.dg/torture/20090706-1.C new file mode 100644 index 000000000..43a59f0e6 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/20090706-1.C @@ -0,0 +1,41 @@ +/* { dg-do compile } */ + +namespace std __attribute__ ((__visibility__ ("default"))) { + template<typename _Tp> class new_allocator { }; + template<typename _Tp> class allocator: public new_allocator<_Tp> { }; + template<typename _Tp, typename _Alloc> struct _Vector_base { }; + template<typename _Tp, typename _Alloc = std::allocator<_Tp> > + class vector : protected _Vector_base<_Tp, _Alloc> { }; +}; +template<int Dim> class Vector { }; +enum CenteringType { VertexType, EdgeType, FaceType, CellType }; +enum ContinuityType { XDim = 1, YDim = XDim << 1, ZDim = YDim << 1 }; +template <int Dim> class Centering { +public: + typedef Vector<Dim> Position; + typedef std::vector<Position> Positions; + Centering(const Positions &positions); + Positions positions_m; +}; +template <int Dim> class CanonicalCentering { + CanonicalCentering(); + template <class T> static T combine(const T &op1, const T &op2); + static Centering<Dim>*** centering_table_m; +}; +template <int Dim> CanonicalCentering<Dim>::CanonicalCentering() +{ + typename Centering<Dim>::Positions positions[Dim][2]; + enum { x = 0, y, z }; + int cont = 0; + if (Dim > 1) + { + centering_table_m[EdgeType][cont][YDim] = Centering<Dim>(positions[y][cont]); + centering_table_m[EdgeType][cont][XDim|YDim] = Centering<Dim>(combine(positions[x][cont], positions[y][cont])); + } + if (Dim > 2) + { + centering_table_m[EdgeType][cont][ZDim] = Centering<Dim>(positions[z][cont]); + centering_table_m[EdgeType][cont][XDim|ZDim] = Centering<Dim>(combine(positions[x][cont], positions[z][cont])); + } +} +template class CanonicalCentering<2>; diff --git a/gcc/testsuite/g++.dg/torture/20100702-1.C b/gcc/testsuite/g++.dg/torture/20100702-1.C new file mode 100644 index 000000000..3d223fffb --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/20100702-1.C @@ -0,0 +1,37 @@ +// { dg-do compile } +// { dg-options "-fprefetch-loop-arrays -w" } + +class ggPoint3 { +public: + ggPoint3(); + inline double &x() { + return e[0]; + } + inline double &y() { + return e[1]; + } + ggPoint3(const ggPoint3 &p); + double e[3]; +}; +class ggBox3 { +public: + ggPoint3 min() const; +}; +class ggHAffineMatrix3; +ggPoint3 operator*(const ggHAffineMatrix3 &m, const ggPoint3 &v); +void foo (ggPoint3 *); +void SetMatrix(ggHAffineMatrix3& toworld, ggBox3& box) +{ + ggPoint3 p[2][2][2]; + int i, j, k; + for (i = 0; i < 2; j++) + for (k = 0; k < 2; k++) + { + if (i == 0) + p[i][j][k].x() = box.min().x(); + if (j == 0) + p[i][j][k].y() = box.min().y(); + p[i][j][k] = toworld * p[i][j][k]; + } + foo (&p[0][0][0]); +} diff --git a/gcc/testsuite/g++.dg/torture/20100825.C b/gcc/testsuite/g++.dg/torture/20100825.C new file mode 100644 index 000000000..460c1b608 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/20100825.C @@ -0,0 +1,15 @@ +// { dg-do run } + +typedef enum { zero = 0, one = 1, two = 2, ENUM_MAX = 3 } my_enum; +my_enum e; +extern "C" void abort (void); +int __attribute__((noinline)) foo() { return 10; } +int main() +{ + int r; + r = foo(); + if ((r < 0) || (r >= ENUM_MAX)) + return 0; + e = (my_enum)r; + abort (); +} diff --git a/gcc/testsuite/g++.dg/torture/covariant-1.C b/gcc/testsuite/g++.dg/torture/covariant-1.C new file mode 100644 index 000000000..9f1fd0a52 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/covariant-1.C @@ -0,0 +1,33 @@ +// { dg-do run } + +extern "C" void abort (); + +class A { +public: + virtual A* getThis() { return this; } +}; + +class B { +int a; +public: + virtual B* getThis() { return this; } +}; + +class AB : public A, public B { +public: + virtual AB* getThis() { return this; } +}; + +int main () +{ + AB ab; + + A* a = &ab; + B* b = &ab; + + if (a->getThis() != a + || b->getThis() != b) + abort (); + + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/darwin-cfstring-3.C b/gcc/testsuite/g++.dg/torture/darwin-cfstring-3.C new file mode 100644 index 000000000..2d755ec8d --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/darwin-cfstring-3.C @@ -0,0 +1,30 @@ +/* Test whether the __builtin__CFStringMakeConstantString + "function" generates compile-time objects with the correct layout. */ +/* Developed by Ziemowit Laski <zlaski@apple.com>. */ + +/* { dg-do compile { target *-*-darwin* } } */ +/* { dg-options "-mconstant-cfstrings" } */ + +typedef const struct __CFString *CFStringRef; + +#ifdef __CONSTANT_CFSTRINGS__ +#define CFSTR(STR) ((CFStringRef) __builtin___CFStringMakeConstantString (STR)) +#else +#error __CONSTANT_CFSTRINGS__ not defined +#endif + +extern int cond; +extern const char *func(void); + +CFStringRef s0 = CFSTR("Hello" "there"); + +void foo(void) { + const CFStringRef s1 = CFSTR("Str1"); + + s0 = s1; +} + +/* { dg-final { scan-assembler "\\.long\[ \\t\]+___CFConstantStringClassReference\n\[ \\t\]*\\.long\[ \\t\]+1992\n\[ \\t\]*\\.long\[ \\t\]+LC.*\n\[ \\t\]*\\.long\[ \\t\]+4\n" { target { *-*-darwin* && { ! lp64 } } } } } */ +/* { dg-final { scan-assembler "\\.long\[ \\t\]+___CFConstantStringClassReference\n\[ \\t\]*\\.long\[ \\t\]+1992\n\[ \\t\]*\\.long\[ \\t\]+LC.*\n\[ \\t\]*\\.long\[ \\t\]+10\n" { target { *-*-darwin* && { ! lp64 } } } } } */ +/* { dg-final { scan-assembler ".quad\t___CFConstantStringClassReference\n\t.long\t1992\n\t.space 4\n\t.quad\t.*\n\t.quad\t4\n" { target { *-*-darwin* && { lp64 } } } } } */ +/* { dg-final { scan-assembler ".quad\t___CFConstantStringClassReference\n\t.long\t1992\n\t.space 4\n\t.quad\t.*\n\t.quad\t10\n" { target { *-*-darwin* && { lp64 } } } } } */ diff --git a/gcc/testsuite/g++.dg/torture/dg-torture.exp b/gcc/testsuite/g++.dg/torture/dg-torture.exp new file mode 100644 index 000000000..7525e0408 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/dg-torture.exp @@ -0,0 +1,7 @@ +# This harness is for tests that should be run at all optimisation levels. + +load_lib g++-dg.exp + +dg-init +gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.C $srcdir/c-c++-common/torture/*.c]] "" +dg-finish diff --git a/gcc/testsuite/g++.dg/torture/ipa-cp-1.C b/gcc/testsuite/g++.dg/torture/ipa-cp-1.C new file mode 100644 index 000000000..37c046d87 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/ipa-cp-1.C @@ -0,0 +1,18 @@ +/* { dg-do compile } */ + +// With IPA-CP, this caused a problem on darwin, where +// _M_reset is being cloned, it was still being marked +// as weak and then we had to change the calls to the +// newly marked function for the non throwing behavior. + +int& f(int&); +inline void _M_reset(int &_M_vbp) throw() +{ + f(_M_vbp); +} +extern int _S_last_request; +void _M_allocate_single_object() throw() +{ + _M_reset(_S_last_request); + _M_reset(_S_last_request); +} diff --git a/gcc/testsuite/g++.dg/torture/pr27218.C b/gcc/testsuite/g++.dg/torture/pr27218.C new file mode 100644 index 000000000..b1e18dd33 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr27218.C @@ -0,0 +1,16 @@ +/* { dg-do compile } */ + +struct Vector +{ + double _x, _y; +}; +typedef Vector Point; +Vector d; +static inline Vector f(void) +{ + return d; +} +void add_duck (void) +{ + new Point (f()); +} diff --git a/gcc/testsuite/g++.dg/torture/pr30252.C b/gcc/testsuite/g++.dg/torture/pr30252.C new file mode 100644 index 000000000..aabf88f51 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr30252.C @@ -0,0 +1,226 @@ +/* { dg-do run } */ +/* { dg-options "-fstrict-aliasing" } */ + +extern "C" void abort (void); +namespace sigc { + template <class T_type> + struct type_trait + { + typedef T_type& pass; + typedef const T_type& take; + typedef T_type* pointer; + }; + template <class T_base, class T_derived> + struct is_base_and_derived + { + struct big { + char memory[64]; + }; + static big is_base_class_(...); + static char is_base_class_(typename type_trait<T_base>::pointer); + static const bool value = + sizeof(is_base_class_(reinterpret_cast<typename type_trait<T_derived>::pointer>(0))) == + sizeof(char); + }; + struct nil; + struct functor_base {}; + template <class T_functor, bool I_derives_functor_base=is_base_and_derived<functor_base,T_functor>::value> + struct functor_trait + { + }; + template <class T_functor> + struct functor_trait<T_functor,true> + { + typedef typename T_functor::result_type result_type; + typedef T_functor functor_type; + }; + template <class T_arg1, class T_return> + 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<T_arg1>::take _A_a1) const + { return func_ptr_(_A_a1); } + }; + template <class T_arg1, class T_return> + inline pointer_functor1<T_arg1, T_return> + ptr_fun1(T_return (*_A_func)(T_arg1)) + { return pointer_functor1<T_arg1, T_return>(_A_func); } + struct adaptor_base : public functor_base {}; + template <class T_functor, + class T_arg1=void, + bool I_derives_adaptor_base=is_base_and_derived<adaptor_base,T_functor>::value> + struct deduce_result_type + { typedef typename functor_trait<T_functor>::result_type type; }; + template <class T_functor> + struct adaptor_functor : public adaptor_base + { + template <class T_arg1=void> + struct deduce_result_type + { typedef typename sigc::deduce_result_type<T_functor, T_arg1>::type type; }; + typedef typename functor_trait<T_functor>::result_type result_type; + result_type + operator()() const; + template <class T_arg1> + typename deduce_result_type<T_arg1>::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 <class T_functor> + typename adaptor_functor<T_functor>::result_type + adaptor_functor<T_functor>::operator()() const + { return functor_(); } + template <class T_functor, bool I_isadaptor = is_base_and_derived<adaptor_base, T_functor>::value> struct adaptor_trait; + template <class T_functor> + struct adaptor_trait<T_functor, true> + { + typedef T_functor adaptor_type; + }; + template <class T_functor> + struct adaptor_trait<T_functor, false> + { + typedef typename functor_trait<T_functor>::functor_type functor_type; + typedef adaptor_functor<functor_type> adaptor_type; + }; + template <class T_functor> + struct adapts : public adaptor_base + { + typedef typename adaptor_trait<T_functor>::adaptor_type adaptor_type; + explicit adapts(const T_functor& _A_functor) + : functor_(_A_functor) + {} + mutable adaptor_type functor_; + }; + template <class T_type> + struct reference_wrapper + { + }; + template <class T_type> + struct unwrap_reference + { + typedef T_type type; + }; + template <class T_type> + 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 T_wrapped> + class bound_argument< reference_wrapper<T_wrapped> > + { + }; + template <int I_location, class T_functor, class T_type1=nil> + struct bind_functor; + template <class T_functor, class T_type1> + struct bind_functor<-1, T_functor, T_type1> : public adapts<T_functor> + { + typedef typename adapts<T_functor>::adaptor_type adaptor_type; + typedef typename adaptor_type::result_type result_type; + result_type + operator()() + { + return this->functor_.template operator()<typename type_trait<typename unwrap_reference<T_type1>::type>::pass> (bound1_.invoke()); + } + bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_bound1) + : adapts<T_functor>(_A_func), bound1_(_A_bound1) + {} + bound_argument<T_type1> bound1_; + }; + template <class T_type1, class T_functor> + 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 <class T_functor> + struct typed_slot_rep : public slot_rep + { + typedef typename adaptor_trait<T_functor>::adaptor_type adaptor_type; + adaptor_type functor_; + inline typed_slot_rep(const T_functor& functor) + : functor_(functor) + { + } + }; + template<class T_functor> + struct slot_call0 + { + static void *call_it(slot_rep* rep) + { + typedef typed_slot_rep<T_functor> typed_slot; + typed_slot *typed_rep = static_cast<typed_slot*>(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 <class T_functor> + slot0(const T_functor& _A_func) + : slot_base(new internal::typed_slot_rep<T_functor>(_A_func)) + { + slot_base::rep_->call_ = internal::slot_call0<T_functor>::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 (); +} diff --git a/gcc/testsuite/g++.dg/torture/pr30567.C b/gcc/testsuite/g++.dg/torture/pr30567.C new file mode 100644 index 000000000..389daf357 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr30567.C @@ -0,0 +1,32 @@ +/* { dg-do run } */ + +template <typename T> +struct const_ref +{ + const T* begin; + const_ref(const T* b) : begin(b) {} +}; + +template <typename T> +T sum(const_ref<T> const& a) +{ + T result = 0; + for(unsigned i=0;i<1;i++) result += a.begin[i]; + return result; +} + +struct tiny_plain +{ + int elems[2]; + tiny_plain() { elems[0]=1; } +}; + +struct vec3 : tiny_plain {}; + +struct mat3 +{ + int type() const { return sum(const_ref<int>(vec3().elems)) == 1; } +}; + +int main() { return mat3().type() ? 0 : 1; } + diff --git a/gcc/testsuite/g++.dg/torture/pr31081-1.C b/gcc/testsuite/g++.dg/torture/pr31081-1.C new file mode 100644 index 000000000..cb11b2148 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr31081-1.C @@ -0,0 +1,23 @@ +/* { dg-do compile } */ + +static int get_record (void); +void f(void); +int g(void); +static int get_record (void) +{ + int result; + try + { + result = g(); + f(); + } + catch (const int &) { } + return result; +} +int NAV_get_record ( ) +{ + int result; + for (;;) + if (get_record ()) + return 1; +} diff --git a/gcc/testsuite/g++.dg/torture/pr31081-2.C b/gcc/testsuite/g++.dg/torture/pr31081-2.C new file mode 100644 index 000000000..a14ef3798 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr31081-2.C @@ -0,0 +1,48 @@ +/* { dg-do compile } */ + +class CString +{ +public: + CString(); + ~CString() { operator delete(_rep); } + operator const char*() const { return _rep; } +private: + CString(char* cstr); + char* _rep; +}; + +class String +{ +public: + + String(); + String(const char* str); + ~String(); + CString getCString() const; +}; + +int is_absolute_path(const char *path); + +inline void getAbsolutePath( + const char* path, + const String& filename) +{ + (!is_absolute_path(filename.getCString()) && path); + return; +} + +int foo(int &value); + +int main(int argc, char** argv) +{ + int repeatTestCount = 0; + if (foo(repeatTestCount)) + { + repeatTestCount = 1; + } + for (int numTests = 1; numTests <= repeatTestCount; numTests++) + { + getAbsolutePath("blah", "blah"); + } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr31579.C b/gcc/testsuite/g++.dg/torture/pr31579.C new file mode 100644 index 000000000..131532e63 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr31579.C @@ -0,0 +1,10 @@ +/* { dg-do compile } */ +// middle-end/31579 +// Expand was crashing while expanding the tree for the initializer + +struct Industry { + unsigned char produced_cargo[2]; +}; +unsigned int a = (((__SIZE_TYPE__)&reinterpret_cast<const volatile +char&>((((Industry*)(char*)8)->produced_cargo[0]))) - 8); + diff --git a/gcc/testsuite/g++.dg/torture/pr31863.C b/gcc/testsuite/g++.dg/torture/pr31863.C new file mode 100644 index 000000000..8d8ccc43a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr31863.C @@ -0,0 +1,777 @@ +/* { dg-do link } */ +/* { dg-timeout-factor 2.0 } */ + +namespace Loki +{ + class NullType {}; + template <class T, class U> + struct Typelist + { + typedef T Head; + typedef U Tail; + }; + + + + namespace TL + { + template + < + typename T1 = NullType, typename T2 = NullType, typename T3 = +NullType, + typename T4 = NullType, typename T5 = NullType, typename T6 = +NullType, + typename T7 = NullType, typename T8 = NullType, typename T9 = +NullType, + typename T10 = NullType, typename T11 = NullType, typename T12 += NullType, + typename T13 = NullType, typename T14 = NullType, typename T15 += NullType, + typename T16 = NullType, typename T17 = NullType, typename T18 += NullType, + typename T19 = NullType, typename T20 = NullType, typename T21 += NullType, + typename T22 = NullType, typename T23 = NullType, typename T24 += NullType, + typename T25 = NullType, typename T26 = NullType, typename T27 += NullType, + typename T28 = NullType, typename T29 = NullType, typename T30 += NullType, + typename T31 = NullType, typename T32 = NullType, typename T33 += NullType, + typename T34 = NullType, typename T35 = NullType, typename T36 += NullType, + typename T37 = NullType, typename T38 = NullType, typename T39 += NullType, + typename T40 = NullType + > + struct MakeTypelist + { + private: + typedef typename MakeTypelist + < + T2 , T3 , T4 , + T5 , T6 , T7 , + T8 , T9 , T10, + T11, T12, T13, + T14, T15, T16, + T17, T18, T19, + T20, T21, T22, + T23, T24, T25, + T26, T27, T28, + T29, T30, T31, + T32, T33, T34, + T35, T36, T37, + T38, T39, T40 + > + ::Result TailResult; + + public: + typedef Typelist<T1, TailResult> Result; + }; + + template<> + struct MakeTypelist<> + { + typedef NullType Result; + }; + + } +} +template <class Key> +class Factory; + +template <class Key, bool iW> +struct Context +{ + typedef Key KeyType; + enum + { + isWrite = iW + }; +}; + +namespace detail +{ + +template <class Key, bool isWrite> +class CreatorUnitBaseImpl +{ +public: + typedef Context<Key, isWrite> Context_; +private: + typedef void*(CreatorUnitBaseImpl::*CreateFun)(Context_&, unsigned&, const +Key&); + CreateFun createFun_; + +protected: + virtual void* createUninitialized () = 0; + template <class Value> + void* createImpl (Context_& ctx, unsigned& ver, const Key& k) + { + return createUninitialized(); + } +private: + CreatorUnitBaseImpl(); +public: + template <class Value> + CreatorUnitBaseImpl (Value*) : + createFun_( &CreatorUnitBaseImpl::template createImpl<Value> ) + { + } + + virtual ~CreatorUnitBaseImpl () {} + + CreatorUnitBaseImpl(const CreatorUnitBaseImpl& s) + : createFun_(s.createFun_) + { + } + + CreatorUnitBaseImpl& operator=(const CreatorUnitBaseImpl& s) + { + createFun_ = s.createFun_; + return *this; + } + void* create (Context_& ctx, unsigned& ver, const Key& k) + { + return (this->*createFun_)(ctx, ver, k); + } +}; + +template <class Key> +class Creator : protected CreatorUnitBaseImpl<Key, true>, protected +CreatorUnitBaseImpl<Key, false> +{ +public: + typedef void* (*CreatorFun) (); + +private: + CreatorFun fun_; +protected: + virtual void* createUninitialized () + { + if (fun_) + return (*fun_)(); + return 0; + } +private: + Creator (); +public: + template <class Value> + Creator (CreatorFun f, Value*) : + CreatorUnitBaseImpl<Key, true>((Value*)0), + CreatorUnitBaseImpl<Key, false>((Value*)0), + fun_(f) + { + } + + Creator(const Creator& s) : + CreatorUnitBaseImpl<Key, true>(s), + CreatorUnitBaseImpl<Key, false>(s), + fun_(s.fun_) + { + + } + + Creator& operator=(const Creator& s) + { + CreatorUnitBaseImpl<Key, true>::operator=(s); + CreatorUnitBaseImpl<Key, false>::operator=(s); + fun_ = s.fun_; + return *this; + } + + virtual ~Creator () + { + } + + template <class Context> + void* createObject (Context& ctx, unsigned& ver, const Key& k) + { + void* r = CreatorUnitBaseImpl<Key, Context::isWrite>::create(ctx, ver, +k); + return r; + } +}; + +} + +template <class Key> +class Factory +{ +public: + typedef Key KeyType; + typedef void* (*CreatorFun) (); + typedef detail::Creator<Key> Creator; +public: + Factory () {} + ~Factory () {} + + template <class Value> + bool registerCreator (const Key& k, CreatorFun fun) + { + return true; + } + template <class Context> + void* createObject (const Key& k, Context& ctx, unsigned& ver) + { + return 0; + } +}; + +template <class Key, class Base, Key key> +struct ClassSpec +{ + typedef Key KeyType; + typedef Base BaseType; + enum {KeyValue = key}; +}; + +template <class Key, class T> +class Serializer; + +template <class Key, class Base, Key key> +class Serializer<Key, ClassSpec <Key, Base, key> > + : public virtual Factory<Key> +{ + typedef Key KeyType; + typedef Base BaseType; + enum {KeyValue = key}; + typedef Factory<Key> Inherited; + typedef Serializer<Key, ClassSpec< Key, Base, key > > SelfType; + + static void* create () + { + return (void*) (new BaseType); + } +public: + Serializer() + { + Inherited::template registerCreator<BaseType>( + KeyValue, + &SelfType::create); + } +}; + +template <class Key, class Head> +class Serializer<Key, Loki::Typelist<Head, Loki::NullType> >: + public Serializer<Key, Head> +{ +}; + +template <class Key, class Head, class Tail> +class Serializer<Key, Loki::Typelist<Head, Tail> >: + public virtual Serializer<Key, Head>, + public virtual Serializer<Key, Tail> +{ +}; + +template <class Key> +class Serializer<Key, Loki::NullType> : public virtual Factory<Key> +{ +}; + + + + +typedef unsigned KeyType; + + + +typedef Factory<KeyType> FactoryType; + +typedef KeyType Key; + +struct A001 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 1; } + static const char* className () {return "A001";} +}; + +struct A002 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 2; } + static const char* className () {return "A002";} +}; + +struct A003 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 3; } + static const char* className () {return "A003";} +}; + +struct A004 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 4; } + static const char* className () {return "A004";} +}; + +struct A005 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 5; } + static const char* className () {return "A005";} +}; + +struct A006 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 6; } + static const char* className () {return "A006";} +}; + +struct A007 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 7; } + static const char* className () {return "A007";} +}; + +struct A008 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 8; } + static const char* className () {return "A008";} +}; + +struct A009 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 9; } + static const char* className () {return "A009";} +}; + +struct A010 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 10; } + static const char* className () {return "A010";} +}; + +struct A011 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 11; } + static const char* className () {return "A011";} +}; + +struct A012 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 12; } + static const char* className () {return "A012";} +}; + +struct A013 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 13; } + static const char* className () {return "A013";} +}; + +struct A014 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 14; } + static const char* className () {return "A014";} +}; + +struct A015 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 15; } + static const char* className () {return "A015";} +}; + +struct A016 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 16; } + static const char* className () {return "A016";} +}; + +struct A017 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 17; } + static const char* className () {return "A017";} +}; + +struct A018 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 18; } + static const char* className () {return "A018";} +}; + +struct A019 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 19; } + static const char* className () {return "A019";} +}; + +struct A020 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 20; } + static const char* className () {return "A020";} +}; + +struct A021 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 21; } + static const char* className () {return "A021";} +}; + +struct A022 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 22; } + static const char* className () {return "A022";} +}; + +struct A023 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 23; } + static const char* className () {return "A023";} +}; + +struct A024 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 24; } + static const char* className () {return "A024";} +}; + +struct A025 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 25; } + static const char* className () {return "A025";} +}; + +struct A026 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 26; } + static const char* className () {return "A026";} +}; + +struct A027 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 27; } + static const char* className () {return "A027";} +}; + +struct A028 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 28; } + static const char* className () {return "A028";} +}; + +struct A029 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 29; } + static const char* className () {return "A029";} +}; + +struct A030 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 30; } + static const char* className () {return "A030";} +}; + +struct A031 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 31; } + static const char* className () {return "A031";} +}; + +struct A032 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 32; } + static const char* className () {return "A032";} +}; + +struct A033 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 33; } + static const char* className () {return "A033";} +}; + +struct A034 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 34; } + static const char* className () {return "A034";} +}; + +struct A035 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 35; } + static const char* className () {return "A035";} +}; + +struct A036 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 36; } + static const char* className () {return "A036";} +}; + +struct A037 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 37; } + static const char* className () {return "A037";} +}; + +struct A038 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 38; } + static const char* className () {return "A038";} +}; + +struct A039 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 39; } + static const char* className () {return "A039";} +}; + +struct A040 +{ + template <class Context> + bool serialize(Context& ctx, unsigned& ver) + { + return true; + } + static Key classId() { return 40; } + static const char* className () {return "A040";} +}; + +Factory<Key>& getInstance() +{ + static Serializer<Key, + Loki::TL::MakeTypelist< + ClassSpec<Key, A001, 1>, + ClassSpec<Key, A002, 2>, + ClassSpec<Key, A003, 3>, + ClassSpec<Key, A004, 4>, + ClassSpec<Key, A005, 5>, + ClassSpec<Key, A006, 6>, + ClassSpec<Key, A007, 7>, + ClassSpec<Key, A008, 8>, + ClassSpec<Key, A009, 9>, + ClassSpec<Key, A010, 10>, + ClassSpec<Key, A011, 11>, + ClassSpec<Key, A012, 12>, + ClassSpec<Key, A013, 13>, + ClassSpec<Key, A014, 14>, + ClassSpec<Key, A015, 15>, + ClassSpec<Key, A016, 16>, + ClassSpec<Key, A017, 17>, + ClassSpec<Key, A018, 18>, + ClassSpec<Key, A019, 19>, + ClassSpec<Key, A020, 20>, + ClassSpec<Key, A021, 21>, + ClassSpec<Key, A022, 22>, + ClassSpec<Key, A023, 23>, + ClassSpec<Key, A024, 24>, + ClassSpec<Key, A025, 25>, + ClassSpec<Key, A026, 26>, + ClassSpec<Key, A027, 27>, + ClassSpec<Key, A028, 28>, + ClassSpec<Key, A029, 29>, + ClassSpec<Key, A030, 30>, + ClassSpec<Key, A031, 31>, + ClassSpec<Key, A032, 32>, + ClassSpec<Key, A033, 33>, + ClassSpec<Key, A034, 34>, + ClassSpec<Key, A035, 35>, + ClassSpec<Key, A036, 36>, + ClassSpec<Key, A037, 37>, + ClassSpec<Key, A038, 38>, + ClassSpec<Key, A039, 39>, + ClassSpec<Key, A040, 40> + >::Result + > instance; + return instance; +} + +int main () +{ + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr32304.C b/gcc/testsuite/g++.dg/torture/pr32304.C new file mode 100644 index 000000000..236d00b97 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr32304.C @@ -0,0 +1,9 @@ +// { dg-do compile } + +struct S { + S() {} +}; +S f() { + static S s; + return s; +} diff --git a/gcc/testsuite/g++.dg/torture/pr32563.C b/gcc/testsuite/g++.dg/torture/pr32563.C new file mode 100644 index 000000000..d536b3faa --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr32563.C @@ -0,0 +1,8 @@ +/* { dg-do compile } */ + +struct A +{ + char c[1]; +} a; + +const __SIZE_TYPE__ i = (__SIZE_TYPE__)&a.c[0] - 1; diff --git a/gcc/testsuite/g++.dg/torture/pr32950.C b/gcc/testsuite/g++.dg/torture/pr32950.C new file mode 100644 index 000000000..8d64296e4 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr32950.C @@ -0,0 +1,19 @@ +/* { dg-do compile } */ + +struct A +{ + __complex__ double c; +}; + +struct B +{ + A a; + B(A x) : a(x) {} + void foo(); +}; + +void bar() +{ + B b = A(); + B(b).foo(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr33134.C b/gcc/testsuite/g++.dg/torture/pr33134.C new file mode 100644 index 000000000..43482c7fc --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33134.C @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +/* Used to crash in VRP. */ +/* Testcase by Martin Michlmayr <tbm@cyrius.com> */ + +class FXObject; +class FXStream +{ + public:FXStream (const FXObject *cont = __null); + FXStream & operator<< (const unsigned char &v); +}; + +bool fxsaveGIF (FXStream &store) +{ + int bitsperpixel; + unsigned char c1; + c1 = 0x80; + c1 |= (bitsperpixel - 1) << 4; + store << c1; +} diff --git a/gcc/testsuite/g++.dg/torture/pr33340.C b/gcc/testsuite/g++.dg/torture/pr33340.C new file mode 100644 index 000000000..bac882156 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33340.C @@ -0,0 +1,27 @@ +void* operator new(__SIZE_TYPE__, void* __p) { } + +struct auto_ptr { + int* p; + ~auto_ptr() { delete p; } +}; + +typedef void* T; +struct vector { + void push_back(const T& __x) { + ::new(0) T(__x); + insert(__x); + } + void insert(const T& __x); +} v; + +void g(); +void f() { + auto_ptr ap; + if (ap.p) { + ap.p = new int(); + } + g(); + int* tmp = ap.p; + ap.p = 0; + v.push_back(tmp); +} diff --git a/gcc/testsuite/g++.dg/torture/pr33572.C b/gcc/testsuite/g++.dg/torture/pr33572.C new file mode 100644 index 000000000..91cd073fd --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33572.C @@ -0,0 +1,17 @@ +// { dg-do run } +#include <vector> +#include <memory> + +struct Foo { virtual void f() {} }; + +int main(int argc, char**) +{ + std::auto_ptr<Foo> foo; + if (argc >= 0) { + foo.reset(new Foo()); + } else { + std::vector<int> v; + } + Foo* p = foo.release(); + p->f(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr33589-1.C b/gcc/testsuite/g++.dg/torture/pr33589-1.C new file mode 100644 index 000000000..eea89f421 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33589-1.C @@ -0,0 +1,22 @@ +// { dg-do compile } +struct base { void somemethod() {} }; +struct derived : public base { }; + +struct smartpointer +{ + ~smartpointer() { } + operator derived*() const + { + return 0; + } +}; +typedef void ( derived::* methodptr_type )(); +methodptr_type getmemberptr() +{ + return &derived::somemethod; +} +void somefunction() +{ + smartpointer pObj; + ( pObj->*getmemberptr() )(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr33589-2.C b/gcc/testsuite/g++.dg/torture/pr33589-2.C new file mode 100644 index 000000000..325892bc6 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33589-2.C @@ -0,0 +1,13 @@ +// { dg-do compile } + +void f(void*) throw(); + +void somefunction() +{ +try { + void (*g)(void*) = (void (*)(void*))f; + void (*g2)(int*) = (void (*)(int*))g; + g2(0); +} catch (...) +{throw;} +} diff --git a/gcc/testsuite/g++.dg/torture/pr33627.C b/gcc/testsuite/g++.dg/torture/pr33627.C new file mode 100644 index 000000000..a14e34551 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33627.C @@ -0,0 +1,57 @@ +/* { dg-do compile } */ + +typedef unsigned int UT_uint32; +typedef UT_uint32 PT_DocPosition; +typedef UT_uint32 PT_BlockOffset; +typedef enum _PTStruxType { PTX_Block } PTStruxType; +typedef UT_uint32 PL_ListenerId; +typedef const void * PL_StruxFmtHandle; +class PX_ChangeRecord; +class pf_Frag { + public: + typedef enum _PFType { PFT_Object } PFType; + inline PFType getType(void) const { } + inline pf_Frag * getNext(void) const { } + PT_DocPosition getPos(void) const { } +}; +class pf_Fragments { + public: + pf_Frag * getFirst() const; +}; +class pt_PieceTable { + bool getStruxOfTypeFromPosition(PL_ListenerId listenerId, PT_DocPosition docPos, PTStruxType pts, PL_StruxFmtHandle * psfh) const; + bool _tellAndMaybeAddListener(PL_ListenerId listenerId, bool bAdd); + pf_Fragments m_fragments; +}; +class pf_Frag_Object : public pf_Frag +{ + public: + virtual bool createSpecialChangeRecord(PX_ChangeRecord ** ppcr, PT_DocPosition dpos, PT_BlockOffset blockOffset) const; +}; +bool pt_PieceTable::_tellAndMaybeAddListener(PL_ListenerId listenerId, bool bAdd) +{ + PL_StruxFmtHandle sfh = 0; + PT_DocPosition sum = 0; + UT_uint32 blockOffset = 0; + for (pf_Frag * pf = m_fragments.getFirst(); (pf); pf=pf->getNext()) + { + pf_Frag_Object * pfo = static_cast<pf_Frag_Object *> (pf); + PX_ChangeRecord * pcr = __null; + bool bStatus1 = false; + if(sfh != __null) { + bStatus1 = pfo->createSpecialChangeRecord(&pcr,sum,blockOffset); + if (!(bStatus1)) + return (false); + } + else + { + PT_DocPosition pos = pf->getPos(); + getStruxOfTypeFromPosition(listenerId,pos,PTX_Block,&sfh); + bStatus1 = pfo->createSpecialChangeRecord(&pcr,pos,blockOffset); + if (!(bStatus1)) + return (false); + } + if (!(bStatus1)) + return (false); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr33735.C b/gcc/testsuite/g++.dg/torture/pr33735.C new file mode 100644 index 000000000..0a90745b9 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33735.C @@ -0,0 +1,21 @@ +// { dg-do compile } +#include <string> +typedef struct _ts { } PyThreadState; +PyThreadState * Py_NewInterpreter(void); +void Py_EndInterpreter(PyThreadState *); +class ApplicationError { +public: + ApplicationError(std::string errormsg) : errormsg(errormsg) { } + std::string errormsg; +}; +void run() +{ + PyThreadState *py_state=__null; + try { + if (!(py_state=Py_NewInterpreter())) + throw ApplicationError("error"); + } + catch(ApplicationError e) { + Py_EndInterpreter(py_state); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr33819.C b/gcc/testsuite/g++.dg/torture/pr33819.C new file mode 100644 index 000000000..a2f868dae --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33819.C @@ -0,0 +1,22 @@ +/* { dg-do run } */ + +class s +{ +public: + s(long long aa) : a(aa), i1(0) { } + long long id() const { return (this->a << 16) >> 16; } + bool operator< (s sv) { return this->a < sv.id(); } +private: + long long a : 48; + int i1 : 16; +}; +s g(1); +extern "C" void abort (void); +int +main(int, char**) +{ + if (g < (1LL << 38) - 1) + return 0; + abort (); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr33887-1.C b/gcc/testsuite/g++.dg/torture/pr33887-1.C new file mode 100644 index 000000000..2f17d9583 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33887-1.C @@ -0,0 +1,44 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +struct S { unsigned int i : 24; } x; +void __attribute__((noinline)) test1() +{ + if (--x.i != 0x00ffffff) + abort (); + if (x.i != 0x00ffffff) + abort (); +} +void __attribute__((noinline)) test2() +{ + if (x.i-- != 0) + abort (); + if (x.i != 0x00ffffff) + abort (); +} +void __attribute__((noinline)) test3() +{ + if (++x.i != 0) + abort (); + if (x.i != 0) + abort (); +} +void __attribute__((noinline)) test4() +{ + if (x.i++ != 0x00ffffff) + abort (); + if (x.i != 0) + abort (); +} +int main() +{ + x.i = 0; + test1(); + x.i = 0; + test2(); + x.i = 0x00ffffff; + test3(); + x.i = 0x00ffffff; + test4(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr33887-2.C b/gcc/testsuite/g++.dg/torture/pr33887-2.C new file mode 100644 index 000000000..f64cfad96 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33887-2.C @@ -0,0 +1,21 @@ +/* { dg-do run } */ + +extern "C" void abort() __attribute__ ((noreturn)); + +struct s +{ + unsigned long long f1 : 40; + unsigned int f2 : 24; +} sv; + +int main() +{ + int f2; + sv.f2 = (1 << 24) - 1; + __asm__ volatile ("" : : : "memory"); + ++sv.f2; + f2 = sv.f2; + if (f2 != 0) + abort(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr33887-3.C b/gcc/testsuite/g++.dg/torture/pr33887-3.C new file mode 100644 index 000000000..b4b883fba --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr33887-3.C @@ -0,0 +1,26 @@ +/* { dg-do run } */ + +extern "C" void abort (void); + +struct s +{ + unsigned long long f1 : 40; + unsigned int f2 : 24; +}; + +s sv; + +void __attribute__((noinline)) foo(unsigned int i) +{ + unsigned int tmp; + sv.f2 = i; + tmp = sv.f2; + if (tmp != 0) + abort (); +} + +int main() +{ + foo (0xff000000u); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr34099.C b/gcc/testsuite/g++.dg/torture/pr34099.C new file mode 100644 index 000000000..49fa9cac1 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr34099.C @@ -0,0 +1,25 @@ +/* { dg-do run } */ + +#include <complex> + +typedef std::complex<double> NumType; + +void +multiply(NumType a, NumType b, unsigned ac, NumType &ab) +{ + NumType s; + for (unsigned j=0; j<ac; j++) + s = a * b; + ab = s; +} +extern "C" void abort (void); +int main() +{ + NumType a(1,2), b(3,-2), c; + multiply(a, b, 1, c); + if (c.real() != 7 + || c.imag() != 4) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/torture/pr34222.C b/gcc/testsuite/g++.dg/torture/pr34222.C new file mode 100644 index 000000000..130896dc9 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr34222.C @@ -0,0 +1,65 @@ +/* { dg-do compile } */ + +namespace std __attribute__ ((__visibility__ ("default"))) { + template<class _CharT> struct char_traits; + } +__extension__ typedef __PTRDIFF_TYPE__ ptrdiff_t; +namespace std __attribute__ ((__visibility__ ("default"))) { + typedef ptrdiff_t streamsize; + template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_ifstream; + typedef basic_ifstream<char> ifstream; + class ios_base { + }; + } +template<class T> class Vector4 { + public: + inline Vector4(); + inline Vector4(T, T, T, T); + T x, y, z, w; + }; +template<class T> class Matrix4 { + public: + Matrix4(const Vector4<T>&, const Vector4<T>&, const Vector4<T>&, const Vector4<T>&); + Matrix4(const Matrix4<T>& m); + Vector4<T> r[4]; + }; +typedef Vector4<float> Vec4f; +typedef Matrix4<float> Mat4f; +template<class T> Vector4<T>::Vector4() : x(0), y(0), z(0), w(0) { + } +template<class T> Vector4<T>::Vector4(T _x, T _y, T _z, T _w) : x(_x), y(_y), z(_z), w(_w) { + } +template<class T> Matrix4<T>::Matrix4(const Vector4<T>& v0, const Vector4<T>& v1, const Vector4<T>& v2, const Vector4<T>& v3) { + } +namespace std __attribute__ ((__visibility__ ("default"))) { + template<typename _CharT, typename _Traits> class basic_ios : public ios_base { + }; + template<typename _CharT, typename _Traits> class basic_istream : virtual public basic_ios<_CharT, _Traits> { + public: + typedef _CharT char_type; + typedef basic_istream<_CharT, _Traits> __istream_type; + __istream_type& read(char_type* __s, streamsize __n); + }; + template<typename _CharT, typename _Traits> class basic_ifstream : public basic_istream<_CharT, _Traits> { + }; + } +using namespace std; +static float readFloat(ifstream& in) { + float f; + in.read((char*) &f, sizeof(float)); + } +Mat4f readMeshMatrix(ifstream& in, int nBytes) { + float m00 = readFloat(in); + float m01 = readFloat(in); + float m02 = readFloat(in); + float m10 = readFloat(in); + float m11 = readFloat(in); + float m12 = readFloat(in); + float m20 = readFloat(in); + float m21 = readFloat(in); + float m22 = readFloat(in); + float m30 = readFloat(in); + float m31 = readFloat(in); + float m32 = readFloat(in); + return Mat4f(Vec4f(m00, m01, m02, 0), Vec4f(m10, m11, m12, 0), Vec4f(m20, m21, m22, 0), Vec4f(m30, m31, m32, 1)); + } diff --git a/gcc/testsuite/g++.dg/torture/pr34235.C b/gcc/testsuite/g++.dg/torture/pr34235.C new file mode 100644 index 000000000..5f05841c5 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr34235.C @@ -0,0 +1,11 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +int main() +{ + short x = -1; + unsigned int c = ((unsigned int)x) >> 1; + if (c != 0x7fffffff) + abort(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr34241.C b/gcc/testsuite/g++.dg/torture/pr34241.C new file mode 100644 index 000000000..70f186c5b --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr34241.C @@ -0,0 +1,18 @@ +/* { dg-do compile } */ + +inline void *operator new (__SIZE_TYPE__, void *__p) throw () +{ + return __p; +} +struct A +{ + A(int, double); + inline explicit A (int pattern, bool cs) + { + new (this) A (pattern, double(cs)); + } +}; +A test () +{ + const A a (42, true); +} diff --git a/gcc/testsuite/g++.dg/torture/pr34641.C b/gcc/testsuite/g++.dg/torture/pr34641.C new file mode 100644 index 000000000..0cf507762 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr34641.C @@ -0,0 +1,177 @@ +// { dg-do compile } +// { dg-require-effective-target fpic } +// { dg-require-visibility "" } +// { dg-options "-fPIC" } + + +typedef __SIZE_TYPE__ size_t; +extern "C" void * +malloc (size_t __size) +throw () __attribute__ ((__malloc__)); + namespace std __attribute__ ((__visibility__ ("default"))) +{ + using::size_t; +} +inline void *operator +new (std::size_t, void *__p) +throw () +{ + return __p; +} +template < class _T1, class _T2 > struct pair +{ + _T1 first; + _T2 second; + pair (const _T1 & __a, const _T2 & __b):first (__a), second (__b) + { + } + template < class _U1, class _U2 > + pair (const pair < _U1, _U2 > &__p):first (__p.first), second (__p.second) + { + } +}; + +template < class _T1, class _T2 > + inline pair < _T1, _T2 > make_pair (_T1 __x, _T2 __y) +{ + return pair < _T1, _T2 > (__x, __y); +} +template < typename _Tp > inline const _Tp & +max (const _Tp & __a, const _Tp & __b) +{ +} +typedef unsigned short int uint16_t; +typedef unsigned long int uintptr_t; +typedef uint16_t UChar; +namespace std __attribute__ ((__visibility__ ("default"))) +{ + struct __numeric_limits_base + { + }; + template < typename _Tp > struct numeric_limits:public __numeric_limits_base + { + static _Tp max () throw () + { + } + }; +} + +template < typename T > class VectorBufferBase +{ +public: + void allocateBuffer (size_t newCapacity) + { + if (newCapacity > std::numeric_limits < size_t >::max () / sizeof (T)) + *(int *) (uintptr_t) 0xbbadbeef = 0; + } +}; + +template < typename T, size_t inlineCapacity > class VectorBuffer; +template < typename T > class VectorBuffer < T, 0 >:private VectorBufferBase < + T > +{ +public: + typedef VectorBufferBase < T > Base; + using Base::allocateBuffer; +}; + +template < typename T, size_t inlineCapacity = 0 > class Vector +{ + typedef VectorBuffer < T, inlineCapacity > Impl; +public: + typedef T *iterator; + size_t size () const + { + return m_size; + } + size_t capacity () const + { + } + iterator begin () + { + } + iterator end () + { + return begin () + m_size; + } + void shrink (size_t size); + void reserveCapacity (size_t newCapacity); + void clear () + { + shrink (0); + } + template < typename U > void append (const U &); + void expandCapacity (size_t newMinCapacity); + template < typename U > U * expandCapacity (size_t newMinCapacity, U *); + size_t m_size; + Impl m_impl; +}; +template < typename T, size_t inlineCapacity > + void Vector < T, inlineCapacity >::expandCapacity (size_t newMinCapacity) +{ + reserveCapacity (max + (newMinCapacity, + max (static_cast < size_t > (16), + capacity () + capacity () / 4 + 1))); +} + +template < typename T, size_t inlineCapacity > + template < typename U > + inline U * Vector < T, + inlineCapacity >::expandCapacity (size_t newMinCapacity, U * ptr) +{ + expandCapacity (newMinCapacity); +} +template < typename T, size_t inlineCapacity > + void Vector < T, inlineCapacity >::reserveCapacity (size_t newCapacity) +{ + m_impl.allocateBuffer (newCapacity); +} +template < typename T, size_t inlineCapacity > + template < typename U > + inline void Vector < T, inlineCapacity >::append (const U & val) +{ + const U *ptr = &val; + if (size () == capacity ()) + ptr = expandCapacity (size () + 1, ptr); + new (end ())T (*ptr); +} + +class Range; +class TextIterator +{ +public: + explicit TextIterator (const Range *, + bool emitCharactersBetweenAllVisiblePositions = + false); + bool atEnd () const + { + } + void advance (); + int length () const + { + } +}; +UChar * +plainTextToMallocAllocatedBuffer (const Range * r, unsigned &bufferLength) +{ + static const unsigned cMaxSegmentSize = 1 << 16; + typedef pair < UChar *, unsigned >TextSegment; + Vector < TextSegment > *textSegments = 0; + Vector < UChar > textBuffer; + for (TextIterator it (r); !it.atEnd (); it.advance ()) + { + if (textBuffer.size () + && textBuffer.size () + it.length () > cMaxSegmentSize) + { + UChar *newSegmentBuffer = + static_cast < + UChar * >(malloc (textBuffer.size () * sizeof (UChar))); + if (!textSegments) + textSegments = new Vector < TextSegment >; + textSegments-> + append (make_pair (newSegmentBuffer, textBuffer.size ())); + textBuffer.clear (); + } + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr34651.C b/gcc/testsuite/g++.dg/torture/pr34651.C new file mode 100644 index 000000000..2fce4d7a1 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr34651.C @@ -0,0 +1,25 @@ +/* { dg-do compile } */ + +typedef bool Bool; +struct CString { + CString (const char * =__null); + CString & operator += (const CString &); +}; +struct THotKey { + short Key; + Bool Control; + Bool Shift; + Bool Alt; +}; +THotKey m_HotKey; +THotKey GetHotKey () { return m_HotKey; } +void Serialize () +{ + THotKey inHotKey (GetHotKey()); + CString outCombinaison (inHotKey.Control + ? ((inHotKey.Alt || inHotKey.Shift) + ? "ctrl+" : "ctrl") + : __null); + outCombinaison += inHotKey.Alt ? inHotKey.Shift ? "alt+" : "alt" : ""; + outCombinaison += inHotKey.Shift ? "shift" : ""; +} diff --git a/gcc/testsuite/g++.dg/torture/pr34850.C b/gcc/testsuite/g++.dg/torture/pr34850.C new file mode 100644 index 000000000..4f630f837 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr34850.C @@ -0,0 +1,75 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */ + +typedef unsigned char uint8_t; +typedef unsigned int uint32_t; +typedef uint8_t byte; +typedef uint32_t u32bit; +__extension__ typedef __SIZE_TYPE__ size_t; +extern "C" { + extern void __warn_memset_zero_len (void) __attribute__((__warning__ (""))); + extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) + void * memset (void *__dest, int __ch, size_t __len) throw () { + if (__builtin_constant_p (__len) && __len == 0) + __warn_memset_zero_len (); /* { dg-warning "declared with attribute warning" } */ + } +} +inline void clear_mem(void* ptr, u32bit n) { + memset(ptr, 0, n); +} +template<typename T> class MemoryRegion { +public: + u32bit size() const { + } + const T* begin() const { + } + void set(const T in[], u32bit n) { + create(n); + } + void set(const MemoryRegion<T>& in) { + set(in.begin(), in.size()); + } + void clear() { + clear_mem(buf, allocated); + } + void create(u32bit); + MemoryRegion() { + used = allocated = 0; + } + mutable T* buf; + mutable u32bit used; + mutable u32bit allocated; +}; +template<typename T> void MemoryRegion<T>::create(u32bit n) { + if(n <= allocated) { + clear(); + } +} +template<typename T> class SecureVector : public MemoryRegion<T> { +public: + SecureVector<T>& operator=(const MemoryRegion<T>& in) { + if(this != &in) set(in); + } +}; +class OctetString { +public: + SecureVector<byte> bits_of() const { + } + OctetString& operator^=(const OctetString&); + void change(const MemoryRegion<byte>& in) { + bits = in; + } + OctetString(const MemoryRegion<byte>& in) { + change(in); + } + SecureVector<byte> bits; +}; +OctetString& OctetString::operator^=(const OctetString& k) { + if(&k == this) { + bits.clear(); + } +} +bool __attribute__((flatten)) +operator==(const OctetString& s1, const OctetString& s2) { + return (s1.bits_of() == s2.bits_of()); +} diff --git a/gcc/testsuite/g++.dg/torture/pr34953.C b/gcc/testsuite/g++.dg/torture/pr34953.C new file mode 100644 index 000000000..5d7b38c92 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr34953.C @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-w" } */ + +void B_CLEAR(void* ret); +void B_NeverReturns(void* ret) __attribute__((noreturn)); + +int main() +{ + const struct AutoErrPop { ~AutoErrPop() { } } AutoErrPopper = { }; + B_NeverReturns(0); +} + +void B_NeverReturns(void* ret) +{ + B_CLEAR(ret); /* Never returns (does a setjmp/goto) */ +} + diff --git a/gcc/testsuite/g++.dg/torture/pr35164-1.C b/gcc/testsuite/g++.dg/torture/pr35164-1.C new file mode 100644 index 000000000..1704c2226 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr35164-1.C @@ -0,0 +1,69 @@ +typedef __SIZE_TYPE__ size_t; +template<typename _Iterator, typename _Container> class __normal_iterator { +public: + const _Iterator& base() const; +}; +template<typename _BI1, typename _BI2> inline +void copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) { + while (__first != __last) *--__result = *--__last; +} +template<typename _Tp> struct _Vector_base { + struct _Vector_impl { _Tp* _M_finish; }; + _Vector_impl _M_impl; +}; +template<typename _Tp > class vector : protected _Vector_base<_Tp> { + typedef vector<_Tp> vector_type; + typedef _Tp * pointer; + typedef _Tp & reference; + typedef __normal_iterator<pointer, vector_type> iterator; + typedef size_t size_type; +public: + iterator end(); + void resize(size_type __new_size) { insert(end(), __new_size); } + reference operator[](size_type __n); + void insert(iterator __position, size_type __n) + { + pointer __old_finish(this->_M_impl._M_finish); + copy_backward(__position.base(), __old_finish - __n, __old_finish); + } +}; +struct A { + virtual ~A (); + void incRef (); + void decRef (); +}; +struct C : public A { + static C *alloc (); +}; +template <class T> struct B { + B () : ptr (T::alloc ()) { } + B (T *a_ptr) : ptr (a_ptr) { } + ~B () { decRef (); } + B& operator= (const B<T>& a) { if (a.get () != this->get ()) { decRef (); +incRef (); } } + template<class U> operator B<U> () const { return B<U> (ptr); } + T* operator-> () const { } + T* get () const { return ptr; } + void decRef () const { if (ptr != 0) ptr->decRef (); } + void incRef () const { if (ptr != 0) ptr->incRef (); } + T *ptr; +}; +struct D : public C { + template <class T> inline void foo (const B<T> & x) { d.resize (1); d[0] = x; +} + vector<B <C> > d; +}; +struct E : public C { + static E *alloc (); +}; +struct F : public D { + static F *alloc (); +}; +void foo (vector<B<D> > & x) { + for (int i = 0; i < 2; ++i) + { + B<F> l; + B<E> m; + l->foo (m); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr35164-2.C b/gcc/testsuite/g++.dg/torture/pr35164-2.C new file mode 100644 index 000000000..463cad7f7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr35164-2.C @@ -0,0 +1,27 @@ +struct __shared_count { + __shared_count() { _M_pi = new int; } + int * _M_pi; +}; +template<typename _Tp> +class __shared_ptr { +public: + __shared_ptr(_Tp* __p); + void reset(int * __p) { + __shared_ptr(__p).swap(*this); + } + void swap(__shared_ptr<_Tp>& __other) { + __other._M_refcount._M_pi = _M_refcount._M_pi; + } + __shared_count _M_refcount; +}; +template<typename _Tp> class shared_ptr : public __shared_ptr<_Tp> {}; +int main() { + for (shared_ptr<int> *iter;;) + { + try { + (iter++)->reset(new int); + } + catch (...) { + } + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr35400.C b/gcc/testsuite/g++.dg/torture/pr35400.C new file mode 100644 index 000000000..021135df8 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr35400.C @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-Wtype-limits" } */ + +struct A +{ + A(); + ~A(); +}; + +void foo() +{ + A x[1]; +} diff --git a/gcc/testsuite/g++.dg/torture/pr35526.C b/gcc/testsuite/g++.dg/torture/pr35526.C new file mode 100644 index 000000000..d0a8e6d2c --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr35526.C @@ -0,0 +1,18 @@ +/* { dg-do compile } */ + +extern void *memcpy (void *__dest, __const void *__src, __SIZE_TYPE__ __n); + +char internal_crash_read_ip[] = { 0xb8 }; + +struct u_internal_crash_read_t +{ + char ip[sizeof (internal_crash_read_ip)]; +} +u_internal_crash_read; + +void +gSignalHandler (int psignalNr, int pinfo, int pctx) +{ + memcpy (u_internal_crash_read.ip, internal_crash_read_ip, + sizeof (internal_crash_read_ip)); +} diff --git a/gcc/testsuite/g++.dg/torture/pr36191.C b/gcc/testsuite/g++.dg/torture/pr36191.C new file mode 100644 index 000000000..175707d1b --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr36191.C @@ -0,0 +1,17 @@ +// PR c++/36191 +// { dg-do compile } +// { dg-options "-fnon-call-exceptions" } +// { dg-skip-if "Frame pointer required for unwind tables" { m68k*-*-* fido*-*-* } "-fomit-frame-pointer" "" } + +__complex__ double +foo (__complex__ double x, double y) +{ + try + { + return x / y; + } + catch (char *s) + { + return x; + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr36444.C b/gcc/testsuite/g++.dg/torture/pr36444.C new file mode 100644 index 000000000..ae639e25d --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr36444.C @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-options "-msse" { target { i?86-*-* x86_64-*-* } } } */ +#define vector __attribute__((vector_size(16) )) +struct struct1 { + union {} vmx; + struct struct2 { + struct2(const struct2& r) {} + } w; +} __attribute__((aligned(16))); +struct struct3 { + vector float vmx; + operator const struct1& () const{ + return *reinterpret_cast<const struct1*>(this); + } +}; +struct3 func3( struct3 V1); +struct3 func2( void ); +void func1( ) { + struct1 vVec = func2() ; + func3 ( (struct3&)vVec ); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr36445.C b/gcc/testsuite/g++.dg/torture/pr36445.C new file mode 100644 index 000000000..56642e9ec --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr36445.C @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-msse" { target { i?86-*-* x86_64-*-* } } } */ +// This used to fail as we would try to expand a VCE where one side had +// a mode of BLKmode and the other side was a vector mode. +#define vector __attribute__((vector_size(16) )) +struct struct1 { + union { float a[3]; } vmx; + struct struct2 { + struct2(const struct2& r) {} + } w; +} __attribute__((aligned(16))); +struct struct3 { + vector float vmx; + operator const struct1& () const{ + return *reinterpret_cast<const struct1*>(this); + } +}; +struct3 func3( struct3 V1); +struct3 func2( void ); +void func1( ) { + struct1 vVec = func2() ; + func3 ( (struct3&)vVec ); +} diff --git a/gcc/testsuite/g++.dg/torture/pr36745.C b/gcc/testsuite/g++.dg/torture/pr36745.C new file mode 100644 index 000000000..53845aaa7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr36745.C @@ -0,0 +1,122 @@ +/* PR target/36745 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fPIC" } */ +/* { dg-require-effective-target fpic } */ + +typedef __SIZE_TYPE__ size_t; +class QBasicAtomicInt +{ +public: + int _q_value; + inline bool operator== (int value) const + { + } + bool ref (); + bool deref (); +}; +inline bool +QBasicAtomicInt::ref () +{ + __asm__ ("": "=m" (_q_value): :); + return true; +} + +namespace std +{ + using::size_t; +} +extern "C++" +{ + inline void *operator new (std::size_t, void *__p) + { + return __p; + } +} +struct QMapData +{ + QBasicAtomicInt ref; + static QMapData shared_null; +}; +template < class Key, class T > class QMap +{ + QMapData *d; +public: inline QMap ():d (&QMapData::shared_null) + { + } + inline ~ QMap () + { + if (!d->ref.deref ()) + freeData (d); + } + void freeData (QMapData * d); +}; +struct QVectorData +{ + QBasicAtomicInt ref; + static QVectorData shared_null; +}; +template < typename T > struct QVectorTypedData +{ + QBasicAtomicInt ref; +}; +template < typename T > class QVector +{ + union + { + QVectorData *p; + QVectorTypedData < T > *d; + }; +public: inline QVector ():p (&QVectorData::shared_null) + { + d->ref.ref (); + } + inline void detach () + { + if (d->ref == 1) + detach_helper (); + } + inline T *data () + { + detach (); + } + T & operator[](int i); + void detach_helper (); + void realloc (); +}; +template < typename T > void QVector < T >::detach_helper () +{ + realloc (); +} + +template < typename T > inline T & QVector < T >::operator[](int i) +{ + return data ()[i]; +} +template < typename T > void QVector < T >::realloc () +{ + T *j, *i; + i->~T (); + while (j-- == i) + new (j) T; +} + +void +mergeInto (QVector < int >*a) +{ +}; +struct QRegExpAutomatonState +{ + QVector < int >outs; + QMap < int, int >reenter; + QMap < int, int >anchors; +}; +class QRegExpEngine +{ + void addCatTransitions (); + QVector < QRegExpAutomatonState > s; +}; +void +QRegExpEngine::addCatTransitions () +{ + mergeInto (&s[2].outs); +} diff --git a/gcc/testsuite/g++.dg/torture/pr36826.C b/gcc/testsuite/g++.dg/torture/pr36826.C new file mode 100644 index 000000000..436220ba8 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr36826.C @@ -0,0 +1,166 @@ +template <class T> T CoinMax(register const T x1, register const T x2); +template <class T> T CoinMin(register const T x1, register const T x2); +class CoinIndexedVector; +class ClpModel { +protected: + double objectiveScale_; + double rhsScale_; + int numberRows_; + int numberColumns_; + double * rowActivity_; + double * columnActivity_; + double * dual_; + double * reducedCost_; + double* rowLower_; + double* rowUpper_; + double * rowObjective_; + double * columnLower_; + double * columnUpper_; + double * rowScale_; + double * columnScale_; + double * inverseRowScale_; + double * inverseColumnScale_; + int problemStatus_; + int secondaryStatus_; +}; +class ClpSimplex : public ClpModel { + void deleteRim(int getRidOfFactorizationData=2); + double upperOut_; + double dualTolerance_; + double primalTolerance_; + double * rowLowerWork_; + double * columnLowerWork_; + double * rowUpperWork_; + double * columnUpperWork_; + double * rowObjectiveWork_; + CoinIndexedVector * columnArray_[6]; + double * reducedCostWork_; + double * rowActivityWork_; + double * columnActivityWork_; + ClpSimplex * auxiliaryModel_; +}; +class CoinIndexedVector { +public: + void clear(); +}; +void ClpSimplex::deleteRim(int getRidOfFactorizationData) +{ + int numberRows=numberRows_; + int numberColumns=numberColumns_; + int i; + int numberPrimalScaled=0; + int numberPrimalUnscaled=0; + int numberDualScaled=0; + int numberDualUnscaled=0; + double scaleC = 1.0/objectiveScale_; + double scaleR = 1.0/rhsScale_; + if (!inverseColumnScale_) { + for (i=0; i<numberColumns; i++) + { + double scaleFactor = columnScale_[i]; + double valueScaled = columnActivityWork_[i]; + double lowerScaled = columnLowerWork_[i]; + double upperScaled = columnUpperWork_[i]; + if (lowerScaled>-1.0e20||upperScaled<1.0e20) { + if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) + numberPrimalScaled++; + else + upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); + } + columnActivity_[i] = valueScaled*scaleFactor*scaleR; + double value = columnActivity_[i]; + if (value<columnLower_[i]-primalTolerance_) + numberPrimalUnscaled++; + else if (value>columnUpper_[i]+primalTolerance_) + numberPrimalUnscaled++; + double valueScaledDual = reducedCostWork_[i]; + if (valueScaled>columnLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) + numberDualScaled++; + if (valueScaled<columnUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) + numberDualScaled++; + reducedCost_[i] = (valueScaledDual*scaleC)/scaleFactor; + double valueDual = reducedCost_[i]; + if (value>columnLower_[i]+primalTolerance_&&valueDual>dualTolerance_) + numberDualUnscaled++; + if (value<columnUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) + numberDualUnscaled++; + } + for (i=0; i<numberRows; i++) + { + double scaleFactor = rowScale_[i]; + double valueScaled = rowActivityWork_[i]; + double lowerScaled = rowLowerWork_[i]; + double upperScaled = rowUpperWork_[i]; + if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); } + rowActivity_[i] = (valueScaled*scaleR)/scaleFactor; + double value = rowActivity_[i]; + if (value<rowLower_[i]-primalTolerance_) numberPrimalUnscaled++; + else if (value>rowUpper_[i]+primalTolerance_) numberPrimalUnscaled++; + double valueScaledDual = dual_[i]+rowObjectiveWork_[i]; + ; + if (valueScaled>rowLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++; + if (valueScaled<rowUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++; + dual_[i] *= scaleFactor*scaleC; + double valueDual = dual_[i]; + if (rowObjective_) valueDual += rowObjective_[i]; + if (value>rowLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++; + if (value<rowUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++; + } + } + const double * inverseScale = inverseColumnScale_; + for (i=0; i<numberColumns; i++) + { + double scaleFactor = columnScale_[i]; + double valueScaled = columnActivityWork_[i]; + double lowerScaled = columnLowerWork_[i]; + double upperScaled = columnUpperWork_[i]; + if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); } + columnActivity_[i] = valueScaled*scaleFactor*scaleR; + double value = columnActivity_[i]; + if (value<columnLower_[i]-primalTolerance_) numberPrimalUnscaled++; + else if (value>columnUpper_[i]+primalTolerance_) numberPrimalUnscaled++; + double valueScaledDual = reducedCostWork_[i]; + if (valueScaled>columnLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++; + if (valueScaled<columnUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++; + reducedCost_[i] = (valueScaledDual*scaleC)*inverseScale[i]; + double valueDual = reducedCost_[i]; + if (value>columnLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++; + if (value<columnUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++; + } + inverseScale = inverseRowScale_; + for (i=0; i<numberRows; i++) + { + double scaleFactor = rowScale_[i]; + double valueScaled = rowActivityWork_[i]; + double lowerScaled = rowLowerWork_[i]; + double upperScaled = rowUpperWork_[i]; + if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); } + rowActivity_[i] = (valueScaled*scaleR)*inverseScale[i]; + double value = rowActivity_[i]; + if (value<rowLower_[i]-primalTolerance_) numberPrimalUnscaled++; + else if (value>rowUpper_[i]+primalTolerance_) numberPrimalUnscaled++; + double valueScaledDual = dual_[i]+rowObjectiveWork_[i]; + ; + if (valueScaled>rowLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++; + if (valueScaled<rowUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++; + dual_[i] *= scaleFactor*scaleC; + double valueDual = dual_[i]; + if (rowObjective_) valueDual += rowObjective_[i]; + if (value>rowLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++; + if (value<rowUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++; + } + if (numberPrimalUnscaled) { + if (numberDualUnscaled) + secondaryStatus_=4; + else + secondaryStatus_=2; + } + if (numberDualUnscaled) + secondaryStatus_=3; + int iRow,iColumn; + for (iRow=0; iRow<4; iRow++) + ; + for (iColumn=0; iColumn<2; iColumn++) + if (columnArray_[iColumn]) + columnArray_[iColumn]->clear(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr36960.C b/gcc/testsuite/g++.dg/torture/pr36960.C new file mode 100644 index 000000000..280a6755d --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr36960.C @@ -0,0 +1,22 @@ +// { dg-do run } + +struct Lower { + const int& ref; + Lower(const int& ref) : ref(ref) { } +}; +struct Middle : public virtual Lower { + Middle(const int& ref) : Lower(ref) { } +}; +struct Upper : public Middle { + Upper(const int& ref) : Lower(ref), Middle(ref) { } + int get() { return ref; } +}; +extern "C" void abort (void); +int main() +{ + int i = 0; + Upper upper(i); + if (upper.get() != 0) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr37146-1.C b/gcc/testsuite/g++.dg/torture/pr37146-1.C new file mode 100644 index 000000000..ea65226f1 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37146-1.C @@ -0,0 +1,83 @@ +// PR c++/37146 +// { dg-do run } + +extern "C" void abort (); +int a, b; +struct A { int i:8; int j:8; int k:16; int l:32; } c; + +void +f1 (int x, int y) +{ + (x ? a : b) = y; +} + +void +f2 (int x, int y) +{ + (x ? c.i : c.j) = y; +} + +void +f3 (int x, int y) +{ + (x ? c.i : a) = y; +} + +void +f4 (int x, int y) +{ + (x ? c.i : c.k) = y; +} + +void +f5 (int x, int y) +{ + (x ? c.l : b) = y; +} + +#define CHECK(var, exp) \ + do \ + { \ + if (var != exp) \ + abort (); \ + var = -1; \ + if (a != -1 \ + || b != -1 \ + || c.i != -1 \ + || c.j != -1 \ + || c.k != -1 \ + || c.l != -1) \ + abort (); \ + } \ + while (0) + +int +main () +{ + a = -1; + b = -1; + c.i = -1; + c.j = -1; + c.k = -1; + c.l = -1; + f1 (1, 264); + CHECK (a, 264); + f1 (0, 264); + CHECK (b, 264); + f2 (1, 112); + CHECK (c.i, 112); + f2 (0, 112); + CHECK (c.j, 112); + f3 (1, 26); + CHECK (c.i, 26); + f3 (0, 26); + CHECK (a, 26); + f4 (1, 107); + CHECK (c.i, 107); + f4 (0, 107); + CHECK (c.k, 107); + f5 (1, 95); + CHECK (c.l, 95); + f5 (0, 95); + CHECK (b, 95); +} diff --git a/gcc/testsuite/g++.dg/torture/pr37146-2.C b/gcc/testsuite/g++.dg/torture/pr37146-2.C new file mode 100644 index 000000000..2a5417694 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37146-2.C @@ -0,0 +1,67 @@ +// PR c++/37146 +// { dg-do run } + +extern "C" void abort (); +int a, b; +struct A { int i:8; int j:8; int k:16; int l:32; } c; + +int +f1 (int x) +{ + return x ? a : b; +} + +int +f2 (int x) +{ + return x ? c.i : c.j; +} + +int +f3 (int x) +{ + return x ? c.i : a; +} + +int +f4 (int x) +{ + return x ? c.i : c.k; +} + +int +f5 (int x) +{ + return x ? c.l : b; +} + +int +main () +{ + a = 17; + b = 18; + c.i = 19; + c.j = 20; + c.k = 21; + c.l = 22; + if (f1 (1) != a) + abort (); + if (f1 (0) != b) + abort (); + if (f2 (1) != c.i) + abort (); + if (f2 (0) != c.j) + abort (); + if (f3 (1) != c.i) + abort (); + if (f3 (0) != a) + abort (); + if (f4 (1) != c.i) + abort (); + if (f4 (0) != c.k) + abort (); + if (f5 (1) != c.l) + abort (); + if (f5 (0) != b) + abort (); +} diff --git a/gcc/testsuite/g++.dg/torture/pr37343.C b/gcc/testsuite/g++.dg/torture/pr37343.C new file mode 100644 index 000000000..c4614f39f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37343.C @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +typedef enum RW { rwBitmapGrey, rwBitmapGrey16 } RW; +void FindDepth(RW); +void ParseDumpBitmap(RW kind, int maxfiles) +{ + static const RW normalTypes[] = { }; + const RW *bitmapTypes; + int i; + switch (kind) { + case rwBitmapGrey: + case rwBitmapGrey16: + bitmapTypes = &kind; + break; + default: + bitmapTypes = normalTypes; + } + for (i = 0; i < maxfiles; i++) + FindDepth(bitmapTypes[i]); +} diff --git a/gcc/testsuite/g++.dg/torture/pr37345.C b/gcc/testsuite/g++.dg/torture/pr37345.C new file mode 100644 index 000000000..5b49f5306 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37345.C @@ -0,0 +1,15 @@ +/* { dg-do compile } */ +class EbmlElement { + virtual EbmlElement * Clone() const; +}; +class KaxTracks : public EbmlElement { +public: + EbmlElement * Clone() const { + return new KaxTracks(*this); + } +}; +KaxTracks kax_tracks; +void finish_file(void) +{ + kax_tracks.Clone(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr37354.C b/gcc/testsuite/g++.dg/torture/pr37354.C new file mode 100644 index 000000000..acdf29110 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37354.C @@ -0,0 +1,14 @@ +/* { dg-do compile } */ + +class GenericClass; +struct AlsaDriver +{ + virtual int _read (unsigned nframes); +}; +typedef void (GenericClass::*GenericMemFuncType) (); +GenericMemFuncType m_pFunction; +void AlsaDriver1 () +{ + m_pFunction = reinterpret_cast < GenericMemFuncType > (&AlsaDriver::_read); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr37421.C b/gcc/testsuite/g++.dg/torture/pr37421.C new file mode 100644 index 000000000..4b8447eac --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37421.C @@ -0,0 +1,39 @@ +/* { dg-do compile } */ + +#include <stdio.h> +#include <string.h> + +inline int +bci (const float &source) +{ + int dest; + memcpy (&dest, &source, sizeof (dest)); + return dest; +} + +inline float +bcf (const int &source) +{ + float dest; + memcpy (&dest, &source, sizeof (dest)); + return dest; +} + +float +Foo () +{ + const int foo = bci (0.0f); + int bar = foo; + const int baz = foo & 1; + if (!baz && (foo & 2)) + bar = 0; + return bcf (bar); +} + +int +main () +{ + printf ("Foo() = %f\n", Foo()); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/torture/pr37456.C b/gcc/testsuite/g++.dg/torture/pr37456.C new file mode 100644 index 000000000..cf2021be2 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37456.C @@ -0,0 +1,14 @@ +/* { dg-do compile } */ + +int zot(int); +struct bar { + ~bar() { } +}; +int x; +void doit(int a, int b, int c) +{ + bar pn; + int b1 = zot(a) * c; + int b2 = zot(b) * c; + x = b1 + b2; +} diff --git a/gcc/testsuite/g++.dg/torture/pr37716.C b/gcc/testsuite/g++.dg/torture/pr37716.C new file mode 100644 index 000000000..13b98d68a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37716.C @@ -0,0 +1,56 @@ +// PR tree-optimization/37716 +// { dg-do compile } + +struct A +{ + struct B + { + int a, b, c, d; + void *e[1]; + }; + B *d; + inline void **f1 (int i) const + { + return d->e + d->c + i; + } +}; + +template <typename T> +struct C +{ + struct D + { + void *v; + inline T & f3 () + { + return *reinterpret_cast <T *> (this); + } + }; + union + { + A p; + A::B *d; + }; + T & operator[](int i) + { + if (d->a != 1) + f2 (); + return reinterpret_cast <D *> (p.f1 (i))->f3 (); + } + void f2 (); + void f3 (int i, const T & t); +}; + +class E +{ + int e, f; +}; + +C <E> c; + +void +foo (int x) +{ + E e = c[x]; + c.f3 (x, e); +} diff --git a/gcc/testsuite/g++.dg/torture/pr37922.C b/gcc/testsuite/g++.dg/torture/pr37922.C new file mode 100644 index 000000000..a7d05ab0f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr37922.C @@ -0,0 +1,502 @@ +// { dg-do run } +// { dg-options "-fpic" { target fpic } } + +typedef __SIZE_TYPE__ size_t; + +template <typename NumType> +inline +NumType +absolute(NumType const& x) +{ + if (x < NumType(0)) return -x; + return x; +} + +class trivial_accessor +{ + public: + typedef size_t index_type; + struct index_value_type {}; + + trivial_accessor() : size_(0) {} + + trivial_accessor(size_t const& n) : size_(n) {} + + size_t size_1d() const { return size_; } + + protected: + size_t size_; +}; + +namespace N0 +{ + template <typename ElementType, + typename AccessorType = trivial_accessor> + class const_ref + { + public: + typedef ElementType value_type; + typedef size_t size_type; + + typedef AccessorType accessor_type; + typedef typename accessor_type::index_type index_type; + typedef typename accessor_type::index_value_type index_value_type; + + const_ref() {} + + const_ref(const ElementType* begin, accessor_type const& accessor) + : begin_(begin), accessor_(accessor) + { + init(); + } + + const_ref(const ElementType* begin, index_value_type const& n0) + : begin_(begin), accessor_(n0) + { + init(); + } + + const_ref(const ElementType* begin, index_value_type const& n0, + index_value_type const& n1) + : begin_(begin), accessor_(n0, n1) + { + init(); + } + + const_ref(const ElementType* begin, index_value_type const& n0, + index_value_type const& n1, + index_value_type const& n2) + : begin_(begin), accessor_(n0, n1, n2) + { + init(); + } + + accessor_type const& accessor() const { return accessor_; } + size_type size() const { return size_; } + + const ElementType* begin() const { return begin_; } + const ElementType* end() const { return end_; } + + ElementType const& + operator[](size_type i) const { return begin_[i]; } + + const_ref<ElementType> + as_1d() const + { + return const_ref<ElementType>(begin_, size_); + } + + protected: + void + init() + { + size_ = accessor_.size_1d(); + end_ = begin_ + size_; + } + + const ElementType* begin_; + accessor_type accessor_; + size_type size_; + const ElementType* end_; + }; +} + +template <typename ElementType, + typename AccessorType = trivial_accessor> +class ref : public N0::const_ref<ElementType, AccessorType> +{ + public: + typedef ElementType value_type; + typedef size_t size_type; + + typedef N0::const_ref<ElementType, AccessorType> base_class; + typedef AccessorType accessor_type; + typedef typename accessor_type::index_type index_type; + + ref() {} + + ElementType* + begin() const { return const_cast<ElementType*>(this->begin_); } + + ElementType* + end() const { return const_cast<ElementType*>(this->end_); } + + ElementType& + operator[](size_type i) const { return begin()[i]; } +}; + +namespace N1 { + template <typename ElementType, size_t N> + class tiny_plain + { + public: + typedef ElementType value_type; + typedef size_t size_type; + + static const size_t fixed_size=N; + + ElementType elems[N]; + + tiny_plain() {} + + static size_type size() { return N; } + + ElementType* begin() { return elems; } + const ElementType* begin() const { return elems; } + ElementType* end() { return elems+N; } + const ElementType* end() const { return elems+N; } + ElementType& operator[](size_type i) { return elems[i]; } + ElementType const& operator[](size_type i) const { return elems[i]; } + }; + + template <typename ElementType, size_t N> + class tiny : public tiny_plain<ElementType, N> + { + public: + typedef ElementType value_type; + typedef size_t size_type; + + typedef tiny_plain<ElementType, N> base_class; + + tiny() {} + }; +} + +template <typename NumType> +class mat3 : public N1::tiny_plain<NumType, 9> +{ + public: + typedef typename N1::tiny_plain<NumType, 9> base_type; + + mat3() {} + mat3(NumType const& e00, NumType const& e01, NumType const& e02, + NumType const& e10, NumType const& e11, NumType const& e12, + NumType const& e20, NumType const& e21, NumType const& e22) + : base_type(e00, e01, e02, e10, e11, e12, e20, e21, e22) + {} + mat3(base_type const& a) + : base_type(a) + {} + + NumType const& + operator()(size_t r, size_t c) const + { + return this->elems[r * 3 + c]; + } + NumType& + operator()(size_t r, size_t c) + { + return this->elems[r * 3 + c]; + } + + NumType + trace() const + { + mat3 const& m = *this; + return m[0] + m[4] + m[8]; + } + + NumType + determinant() const + { + mat3 const& m = *this; + return m[0] * (m[4] * m[8] - m[5] * m[7]) + - m[1] * (m[3] * m[8] - m[5] * m[6]) + + m[2] * (m[3] * m[7] - m[4] * m[6]); + } +}; + +template <typename NumType> +inline +mat3<NumType> +operator-(mat3<NumType> const& v) +{ + mat3<NumType> result; + for(size_t i=0;i<9;i++) { + result[i] = -v[i]; + } + return result; +} + +class mat_grid : public N1::tiny<size_t, 2> +{ + public: + typedef N1::tiny<size_t, 2> index_type; + typedef index_type::value_type index_value_type; + + mat_grid() { this->elems[0]=0; this->elems[1]=0; } + + mat_grid(index_type const& n) : index_type(n) {} + + mat_grid(index_value_type const& n0, index_value_type const& n1) + { this->elems[0]=n0; this->elems[1]=n1; } + + size_t size_1d() const { return elems[0] * elems[1]; } + + size_t + operator()(index_value_type const& r, index_value_type const& c) const + { + return r * elems[1] + c; + } +}; + +template <typename NumType, typename AccessorType = mat_grid> +class mat_const_ref : public N0::const_ref<NumType, AccessorType> +{ + public: + typedef AccessorType accessor_type; + typedef typename N0::const_ref<NumType, AccessorType> base_type; + typedef typename accessor_type::index_value_type index_value_type; + + mat_const_ref() {} + + mat_const_ref(const NumType* begin, accessor_type const& grid) + : base_type(begin, grid) + {} + + mat_const_ref(const NumType* begin, index_value_type const& n_rows, + index_value_type const& n_columns) + : base_type(begin, accessor_type(n_rows, n_columns)) + {} + + accessor_type + grid() const { return this->accessor(); } + + index_value_type const& + n_rows() const { return this->accessor()[0]; } + + index_value_type const& + n_columns() const { return this->accessor()[1]; } + + NumType const& + operator()(index_value_type const& r, index_value_type const& c) const + { + return this->begin()[this->accessor()(r, c)]; + } +}; + +template <typename NumType, typename AccessorType = mat_grid> +class mat_ref : public mat_const_ref<NumType, AccessorType> +{ + public: + typedef AccessorType accessor_type; + typedef mat_const_ref<NumType, AccessorType> base_type; + typedef typename accessor_type::index_value_type index_value_type; + + mat_ref() {} + + mat_ref(NumType* begin, accessor_type const& grid) + : base_type(begin, grid) + {} + + mat_ref(NumType* begin, index_value_type n_rows, + index_value_type n_columns) + : base_type(begin, accessor_type(n_rows, n_columns)) + {} + + NumType* + begin() const { return const_cast<NumType*>(this->begin_); } + + NumType* + end() const { return const_cast<NumType*>(this->end_); } + + NumType& + operator[](index_value_type const& i) const { return begin()[i]; } + + NumType& + operator()(index_value_type const& r, index_value_type const& c) const + { + return this->begin()[this->accessor()(r, c)]; + } +}; + + template <typename AnyType> + inline void + swap(AnyType* a, AnyType* b, size_t n) + { + for(size_t i=0;i<n;i++) { + AnyType t = a[i]; a[i] = b[i]; b[i] = t; + } + } + +template <typename IntType> +size_t +form_t(mat_ref<IntType>& m, + mat_ref<IntType> const& t) +{ + typedef size_t size_t; + size_t mr = m.n_rows(); + size_t mc = m.n_columns(); + size_t tc = t.n_columns(); + if (tc) { + } + size_t i, j; + for (i = j = 0; i < mr && j < mc;) { + size_t k = i; while (k < mr && m(k,j) == 0) k++; + if (k == mr) + j++; + else { + if (i != k) { + swap(&m(i,0), &m(k,0), mc); + if (tc) swap(&t(i,0), &t(k,0), tc); + } + for (k++; k < mr; k++) { + IntType a = absolute(m(k, j)); + if (a != 0 && a < absolute(m(i,j))) { + swap(&m(i,0), &m(k,0), mc); + if (tc) swap(&t(i,0), &t(k,0), tc); + } + } + if (m(i,j) < 0) { + for(size_t ic=0;ic<mc;ic++) m(i,ic) *= -1; + if (tc) for(size_t ic=0;ic<tc;ic++) t(i,ic) *= -1; + } + bool cleared = true; + for (k = i+1; k < mr; k++) { + IntType a = m(k,j) / m(i,j); + if (a != 0) { + for(size_t ic=0;ic<mc;ic++) m(k,ic) -= a * m(i,ic); + if (tc) for(size_t ic=0;ic<tc;ic++) t(k,ic) -= a * t(i,ic); + } + if (m(k,j) != 0) cleared = false; + } + if (cleared) { i++; j++; } + } + } + m = mat_ref<IntType>(m.begin(), i, mc); + return i; +} + +template <typename IntType> +size_t +form(mat_ref<IntType>& m) +{ + mat_ref<IntType> t(0,0,0); + return form_t(m, t); +} + +typedef mat3<int> sg_mat3; + +class rot_mx +{ + public: + explicit + rot_mx(sg_mat3 const& m, int denominator=1) + : num_(m), den_(denominator) + {} + + sg_mat3 const& + num() const { return num_; } + sg_mat3& + num() { return num_; } + + int const& + operator[](size_t i) const { return num_[i]; } + int& + operator[](size_t i) { return num_[i]; } + + int + const& operator()(int r, int c) const { return num_(r, c); } + int& + operator()(int r, int c) { return num_(r, c); } + + int const& + den() const { return den_; } + int& + den() { return den_; } + + rot_mx + minus_unit_mx() const + { + rot_mx result(*this); + for (size_t i=0;i<9;i+=4) result[i] -= den_; + return result; + } + + rot_mx + operator-() const { return rot_mx(-num_, den_); } + + int + type() const; + + int + order(int type=0) const; + + private: + sg_mat3 num_; + int den_; +}; + +class rot_mx_info +{ + public: + rot_mx_info(rot_mx const& r); + + int type() const { return type_; } + + private: + int type_; +}; + +int rot_mx::type() const +{ + int det = num_.determinant(); + if (det == -1 || det == 1) { + switch (num_.trace()) { + case -3: return -1; + case -2: return -6; + case -1: if (det == -1) return -4; + else return 2; + case 0: if (det == -1) return -3; + else return 3; + case 1: if (det == -1) return -2; + else return 4; + case 2: return 6; + case 3: return 1; + } + } + return 0; +} + +int rot_mx::order(int type) const +{ + if (type == 0) type = rot_mx::type(); + if (type > 0) return type; + if (type % 2) return -type * 2; + return -type; +} + +rot_mx_info::rot_mx_info(rot_mx const& r) +: type_(r.type()) +{ + if (type_ == 0) { + return; + } + rot_mx proper_r = r; + int proper_order = type_; + // THE PROBLEM IS AROUND HERE + if (proper_order < 0) { + proper_order *= -1; + proper_r = -proper_r; // THIS FAILS ... + } + if (proper_order > 1) { + rot_mx rmi = proper_r.minus_unit_mx(); // ... THEREFORE WRONG HERE + mat_ref<int> re_mx(rmi.num().begin(), 3, 3); + if (form(re_mx) != 2) { + type_ = 0; + } + } +} + +int main() +{ + N1::tiny<int, 9> e; + e[0] = 1; e[1] = 0; e[2] = 0; + e[3] = 0; e[4] = -1; e[5] = 0; + e[6] = 0; e[7] = 0; e[8] = 1; + rot_mx r(e); + rot_mx_info ri(r); + if (ri.type() != -2) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr38565.C b/gcc/testsuite/g++.dg/torture/pr38565.C new file mode 100644 index 000000000..8cd1e1d4b --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr38565.C @@ -0,0 +1,11 @@ +// { dg-do compile } +// Ignore warning on some powerpc-linux configurations. +// { dg-prune-output "non-standard ABI extension" } +#define vector __attribute__((vector_size(16) )) +vector unsigned int f(int a) +{ + vector unsigned int mask = a ? (vector unsigned int){ 0x80000000, 0x80000000, +0x80000000, 0x80000000 } : (vector unsigned int){0}; + return mask; +} + diff --git a/gcc/testsuite/g++.dg/torture/pr38705.C b/gcc/testsuite/g++.dg/torture/pr38705.C new file mode 100644 index 000000000..8058d3a39 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr38705.C @@ -0,0 +1,27 @@ +// PR c++/38705 +// { dg-do compile } + +typedef int T; +typedef __SIZE_TYPE__ size_t; +extern "C" void *memcpy (void *, const void *, size_t); + +void +foo (char *p, const int q) +{ + memcpy (p, &q, sizeof (int)); +} + +struct S +{ + T t; + int u; + int bar () const; + template <class T> void foo (const T &x) const {} +}; + +int +S::bar () const +{ + foo (u); + foo (t); +} diff --git a/gcc/testsuite/g++.dg/torture/pr38745.C b/gcc/testsuite/g++.dg/torture/pr38745.C new file mode 100644 index 000000000..4ad9d85fe --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr38745.C @@ -0,0 +1,36 @@ +/* { dg-do compile } */ + +union u_u16 +{ + unsigned short v; + struct + { + unsigned char lo8, hi8; + } __attribute__ ((__may_alias__)) u; +} __attribute__ ((__may_alias__)); +union u_u32 +{ + unsigned int v; + struct + { + u_u16 lo16, hi16; + } u; +} __attribute__ ((__may_alias__)); +union u_u64 +{ + struct + { + u_u32 lo32, hi32; + } u; +}; +struct Record +{ +}; +long long +UnpackFullKey (Record & rec, const char *&p) +{ + long long c64 = 0; + (*(u_u16 *) & (*(u_u32 *) & ( *(u_u64*)&c64).u.lo32.v).u.lo16.v).u.hi8 = 1; + return c64; +} + diff --git a/gcc/testsuite/g++.dg/torture/pr38747.C b/gcc/testsuite/g++.dg/torture/pr38747.C new file mode 100644 index 000000000..0f18a2f22 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr38747.C @@ -0,0 +1,19 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +inline void *operator new (__SIZE_TYPE__, void *__p) throw () { return __p; } + +int __attribute__((noinline)) +foo(void) +{ + float f = 0; + int *i = new (&f) int (1); + return *(int *)&f; +} + +int main() +{ + if (foo() != 1) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr38811.C b/gcc/testsuite/g++.dg/torture/pr38811.C new file mode 100644 index 000000000..e9b304da6 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr38811.C @@ -0,0 +1,73 @@ +/* { dg-do compile } */ + +typedef unsigned long ULONG; +void iwos_ErrorMessage(long error, const char * const file_name, + ULONG line_num, const char * const message); +class AbcA2d { +public: + double x; + double y; + ~AbcA2d() { } +}; +enum AbcZyParamType { ABC_SP_1 }; +class AbcExtent2d { + AbcA2d m_vMin; + AbcA2d m_vMax; +public: + AbcExtent2d(const AbcA2d & rMin, const AbcA2d & rMax); + AbcA2d ClampPoint2d(const AbcA2d & rPoint) const; + AbcA2d GetMax() const { return m_vMax; } + AbcA2d GetMin() const { } + AbcA2d Evaluate(double dNormalizedX, double dNormalizedY) const; +}; +inline AbcExtent2d::AbcExtent2d(const AbcA2d & rMin, const AbcA2d & rMax) +{ + if (rMin.x > rMax.x || rMin.y > rMax.y) + { + long sErr = (1007); + if (sErr != 1000) + iwos_ErrorMessage(sErr,(const char * const)__null, + 0,(const char * const)__null); + } + else + { + m_vMin = rMin; + m_vMax = rMax; + } +} +inline AbcA2d AbcExtent2d::ClampPoint2d(const AbcA2d & rPoint) const +{ + AbcA2d sRet = rPoint; + if (rPoint.x < m_vMin.x) + sRet.x = m_vMin.x; + return sRet; +} +inline AbcA2d AbcExtent2d::Evaluate(double dNormalizedX, double dNormalizedY) +const +{ + AbcA2d sRet; + sRet.x = m_vMin.x + dNormalizedX * (m_vMax.x - m_vMin.x); + sRet.y = m_vMin.y + dNormalizedY * (m_vMax.y - m_vMin.y); + return ClampPoint2d(sRet); +} +class AbcAbcdTracer { + AbcExtent2d m_vUVDomain; + virtual long TestIsoAbcde(AbcZyParamType eZyParam, double dParam, + int & rbZyxIsSolution); + virtual int DoesPointLieOnAbcde(AbcA2d & rUV, int bRefinePoint) const; +}; +long AbcAbcdTracer::TestIsoAbcde(AbcZyParamType eZyParam, double dParam, + int & rbZyxIsSolution) +{ + AbcA2d sUV1(m_vUVDomain.GetMin()); + AbcA2d sUV2(m_vUVDomain.GetMax()); + AbcExtent2d sUVIso(sUV1,sUV2); + for (ULONG i=0; i<10; i++) + { + double dT = i / (10 -1.0); + AbcA2d sUV = sUVIso.Evaluate(dT,dT); + if (!DoesPointLieOnAbcde(sUV,0)) + ; + } +} + diff --git a/gcc/testsuite/g++.dg/torture/pr39002.C b/gcc/testsuite/g++.dg/torture/pr39002.C new file mode 100644 index 000000000..534d91dfa --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39002.C @@ -0,0 +1,88 @@ +// PR target/39002 +// { dg-do run } + +struct S +{ + double x; + double y; + double z; +}; + +double foo (S *, S *); +void bar (S *, S *, S *, double &, double &, double &); + +double +foo (S *a1, S *a2) +{ + return __builtin_sqrt ((a1->x - a2->x) * (a1->x - a2->x) + + (a1->y - a2->y) * (a1->y - a2->y) + + (a1->z - a2->z) * (a1->z - a2->z)); +} + +void +bar (S *p, S *q, S *r, double &x, double &y, double &z) +{ + if (foo (p, q) == 0.0) + { + x = r->x; + y = r->y; + z = r->z; + return; + } + if (foo (p, r) == 0.0) + { + x = r->x; + y = r->y; + z = r->z; + return; + } + if (foo (q, r) == 0.0) + { + x = r->x; + y = r->y; + z = r->z; + return; + } + + double a1, b1, c1, d1, e1; + double dx, dy, dz, dw, dv; + + a1 = q->x - p->x; + b1 = q->y - p->y; + c1 = q->z - p->z; + e1 = __builtin_sqrt (a1 * a1 + b1 * b1 + c1 * c1); + a1 = a1 / e1; + b1 = b1 / e1; + c1 = c1 / e1; + dx = p->x - r->x; + dy = p->y - r->y; + dz = p->z - r->z; + dw = dx * dx + dy * dy + dz * dz; + dv = 2.0 * dx * a1 + 2.0 * dy * b1 + 2.0 * dz * c1; + d1 = -dv / 2.0; + x = p->x + (a1 * d1); + y = p->y + (b1 * d1); + z = p->z + (c1 * d1); + return; +} + +int +main (void) +{ + S a, b, c, d, *p, *q, *r; + + p = &a; + q = &b; + r = &c; + a.x = 0.0; + a.y = 0.0; + a.z = 0.0; + b.x = 1.0; + b.y = 0.0; + b.z = 0.0; + c.x = 0.0; + c.y = 1.0; + c.z = 0.0; + bar (p, q, r, d.x, d.y, d.z); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr39259.C b/gcc/testsuite/g++.dg/torture/pr39259.C new file mode 100644 index 000000000..256181fa6 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39259.C @@ -0,0 +1,40 @@ +// PR tree-optimization/39259 +// { dg-do compile } +// { dg-options "-O2" } + + +extern "C" int __mysetjmp () __attribute__ ((__returns_twice__)); + +class TContStatus {}; + +class TContEvent +{ +public: + inline void Execute () throw(); +}; + +class TCont +{ +public: + TContStatus ReadD (void* buf, int deadline) + { + TContEvent event; + event.Execute (); + return TContStatus(); + } + TContStatus ReadI (void *buf) + { + return ReadD (buf, 1); + } +}; + +void TContEvent::Execute () throw () +{ + __mysetjmp(); +} + +void Broken (TCont *mCont) +{ + mCont->ReadI(0); + mCont->ReadI(0); +} diff --git a/gcc/testsuite/g++.dg/torture/pr39362.C b/gcc/testsuite/g++.dg/torture/pr39362.C new file mode 100644 index 000000000..fb23439f5 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39362.C @@ -0,0 +1,105 @@ +/* { dg-do compile } */ + +void *fastMalloc (int n); +void fastFree (void *p); +template <class T> struct C +{ + void deref () { delete static_cast <T *>(this); } +}; +template <typename T> +struct D +{ + D (T *ptr) : m_ptr (ptr) { } + ~D () { if (T * ptr = m_ptr) ptr->deref (); } + T *operator-> () const; + T *m_ptr; + typedef T *UnspecifiedBoolType; + operator UnspecifiedBoolType () const; +}; +template <typename T> struct E +{ + static void destruct (T * begin, T * end) + { + for (T * cur = begin; cur != end; ++cur) + cur->~T (); + } +}; +template <typename T> class F; +template <typename T> struct G +{ + static void destruct (T * begin, T * end) + { + E <T>::destruct (begin, end); + } + static void uninitializedFill (T * dst, T * dstEnd, const T & val) + { + F<T>::uninitializedFill (dst, dstEnd, val); + } +}; +template <typename T> struct H +{ + void allocateBuffer (int newCapacity) + { + m_buffer = static_cast <T *>(fastMalloc (newCapacity * sizeof (T))); + } + void deallocateBuffer (T * bufferToDeallocate) + { + if (m_buffer == bufferToDeallocate) + fastFree (bufferToDeallocate); + } + T *buffer () { } + int capacity () const { } + T *m_buffer; +}; +template <typename T, int cap> class I; +template <typename T> struct I <T, 0> : H <T> +{ + I (int capacity) { allocateBuffer (capacity); } + ~I () { deallocateBuffer (buffer ()); } + using H <T>::allocateBuffer; + H <T>::buffer; +}; +template <typename T, int cap = 0> struct J +{ + typedef T *iterator; + ~J () { if (m_size) shrink (0); } + J (const J &); + int capacity () const { m_buffer.capacity (); } + T & operator[](int i) { } + iterator begin () { } + iterator end () { return begin () + m_size; } + void shrink (int size); + template <typename U> void append (const U &); + int m_size; + I <T, cap> m_buffer; +}; +template <typename T, int cap> +J <T, cap>::J (const J & other) : m_buffer (other.capacity ()) +{ +} +template <typename T, int cap> +void J <T, cap>::shrink (int size) +{ + G <T>::destruct (begin () + size, end ()); + m_size = size; +} +struct A : public C <A> +{ + virtual ~A (); + typedef J <D <A> > B; + virtual A *firstChild () const; + virtual A *nextSibling () const; + virtual const B & children (int length); + B m_children; +}; +const A::B & +A::children (int length) +{ + for (D <A> obj = firstChild (); obj; obj = obj->nextSibling ()) + { + B children = obj->children (2); + for (unsigned i = 0; i <length; ++i) + m_children.append (children[i]); + } +} + diff --git a/gcc/testsuite/g++.dg/torture/pr39417.C b/gcc/testsuite/g++.dg/torture/pr39417.C new file mode 100644 index 000000000..b7bbb88b7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39417.C @@ -0,0 +1,56 @@ +// { dg-do run } + +#include <vector> + +std::vector <int> +sequence(int l, int n) +{ + std::vector <int> ret; + for(int i=n;i<=100;i++) + { + if(i%2==0) + { + if(l%i==i/2) + { + int init =l/i-i/2+1; + if(init>=0) + { + for(int j=0;j<i;j++) + { + ret.push_back(init); + init ++; + } + break; + } + } + } + else + { + if(l%i==0) + { + int init =l/i-i/2; + if(init>=0) + { + for(int j=0;j<i;j++) + { + ret.push_back(init); + init ++; + } + break; + } + } + } + } + return ret; +} +extern "C" void abort (void); +int main() +{ + std::vector<int> res = sequence(18, 2); + if (res.size () != 3 + || res[0] != 5 + || res[1] != 6 + || res[2] != 7) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr39678.C b/gcc/testsuite/g++.dg/torture/pr39678.C new file mode 100644 index 000000000..a7c120ad4 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39678.C @@ -0,0 +1,26 @@ +/* PR target/39678 */ +/* { dg-do run } */ +/* { dg-options "-Wno-psabi" } */ +struct Y {}; +struct X { + struct Y y; + __complex__ float val; +}; + +struct X __attribute__((noinline)) +foo (float *p) +{ + struct X x; + __real x.val = p[0]; + __imag x.val = p[1]; + return x; +} +extern "C" void abort (void); +float a[2] = { 3., -2. }; +int main() +{ + struct X x = foo(a); + if (__real x.val != 3. || __imag x.val != -2.) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr39713.C b/gcc/testsuite/g++.dg/torture/pr39713.C new file mode 100644 index 000000000..4ff72d1a7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39713.C @@ -0,0 +1,25 @@ +/* { dg-do compile } */ + +template <typename To, typename From> +static inline To +bitwise_cast (From from) +{ + union + { + From f; + To t; + } u; + u.f = from; + return u.t; +} + +extern void foo (unsigned char *); + +double +bar () +{ + unsigned char b[sizeof (unsigned long long)]; + foo (b); + return bitwise_cast<double> (*(unsigned long long *) b); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr39732.C b/gcc/testsuite/g++.dg/torture/pr39732.C new file mode 100644 index 000000000..418417587 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39732.C @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-fprofile-generate" } */ + +template<class _CharT> struct char_traits; +template<typename _OI> +_OI __copy_move_a2(_OI __result); +template<typename _OI> inline _OI +copy(_OI __result) +{ + return __copy_move_a2 (__result); +} +template<typename _CharT, typename _Traits> +class basic_ostream { }; +template<typename _Tp, typename _CharT = char, typename _Traits = char_traits<_CharT> > +class ostream_iterator { + typedef basic_ostream<_CharT, _Traits> ostream_type; + ostream_type* _M_stream; + const _CharT* _M_string; +public: + ostream_iterator(ostream_type& __s, const _CharT* __c) + : _M_stream(&__s), _M_string(__c) { } + ostream_iterator(const ostream_iterator& __obj) + : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { } +}; +int f(void) +{ + basic_ostream<char, char_traits<char> > os; + copy(ostream_iterator<const int>(os, ",")); +} diff --git a/gcc/testsuite/g++.dg/torture/pr39764.C b/gcc/testsuite/g++.dg/torture/pr39764.C new file mode 100644 index 000000000..a89013313 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39764.C @@ -0,0 +1,14 @@ +/* { dg-do compile } */ + +class A; +class B { }; +extern const double NaN; +B foo(A* exec, double d); +inline B baz(A* a) { + return foo(a, NaN); +} +B bar(A* a) { + return baz(a); +} +extern const double NaN = (__builtin_nanf("")); + diff --git a/gcc/testsuite/g++.dg/torture/pr40081.C b/gcc/testsuite/g++.dg/torture/pr40081.C new file mode 100644 index 000000000..e65c5a843 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40081.C @@ -0,0 +1,16 @@ +struct Atomic_t { + Atomic_t(int i) : val(i) { } + volatile int val; +}; +class RefCount { +public: + RefCount(Atomic_t c) : m_count(c) { } + Atomic_t m_count; +}; +class IntrusiveCountableBase { + RefCount m_useCount; +protected: + IntrusiveCountableBase(); +}; +IntrusiveCountableBase::IntrusiveCountableBase() : m_useCount(0) { } + diff --git a/gcc/testsuite/g++.dg/torture/pr40102.C b/gcc/testsuite/g++.dg/torture/pr40102.C new file mode 100644 index 000000000..49f56b5bc --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40102.C @@ -0,0 +1,41 @@ +/* { dg-do compile } */ +bool foo0(int) { return true; } + +bool foo1(); + +struct A +{ + A(); + ~A(); + + template<typename T> void bar1(T f) + { + if (f(0)) + foo1(); + } + + template<typename T> void bar2(T); +}; + +template<typename T> void A::bar2(T f) +{ + A a, b[1], *p; + + while (foo1()) + { + if (p) + ++p; + if (p && foo1()) + bar1(f); + if (p) + ++p; + } + + if (foo1()) + bar1(f); +} + +void baz() +{ + A().bar2(foo0); +} diff --git a/gcc/testsuite/g++.dg/torture/pr40321.C b/gcc/testsuite/g++.dg/torture/pr40321.C new file mode 100644 index 000000000..917743109 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40321.C @@ -0,0 +1,25 @@ +/* { dg-do compile } */ + +struct VectorD2 +{ + VectorD2() : x(0), y(0) { } + VectorD2(int _x, int _y) : x(_x), y(_y) { } + int x, y; + int GetLength2() const { return x*x + y*y; }; + VectorD2 operator+(const VectorD2 vec) const { + return VectorD2(x+vec.x,y+vec.y); + } +}; +struct Shape +{ + enum Type { ST_RECT, ST_CIRCLE } type; + VectorD2 pos; + VectorD2 radius; + bool CollisionWith(const Shape& s) const; +}; +bool Shape::CollisionWith(const Shape& s) const +{ + if(type == ST_CIRCLE && s.type == ST_RECT) + return s.CollisionWith(*this); + return (pos + s.pos).GetLength2() < (radius + s.radius).GetLength2(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr40323.C b/gcc/testsuite/g++.dg/torture/pr40323.C new file mode 100644 index 000000000..c7ffcb5d3 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40323.C @@ -0,0 +1,68 @@ +/* Testcase for PR 40323. */ +/* { dg-do compile } */ +/* { dg-options "-fno-early-inlining" } */ +/* { dg-add-options bind_pic_locally } */ + +extern void do_something (const char *, int); + +class Parent +{ +private: + const char *data; + +public: + Parent (const char *d) : data(d) + {} + + int funcOne (int delim) const; +}; + +class AnotherParent +{ +private: + double d; +public: + AnotherParent (void) : d(0) + {} +}; + + +class Child : public AnotherParent, Parent +{ +private: + int zzz; +public: + Child (const char *d) : Parent(d) + {} +}; + + +int Parent::funcOne (int delim) const +{ + int i; + for (i = 0; i < delim; i++) + do_something(data, i); + + return 1; +} + +int docalling (int (Child::* f)(int delim) const) +{ + Child S ("muhehehe"); + + return (S.*f)(4); +} + +typedef int (Parent::* my_mp_type)(int delim); + +int main (int argc, char *argv[]) +{ + int i; + int (Parent::* f)(int ) const; + int (Child::* g)(int ) const; + + f = &Parent::funcOne; + g = (int (Child::* )(int) const) f; + i = docalling (g); + return i; +} diff --git a/gcc/testsuite/g++.dg/torture/pr40335.C b/gcc/testsuite/g++.dg/torture/pr40335.C new file mode 100644 index 000000000..14ea95d40 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40335.C @@ -0,0 +1,16 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +int +main (void) +{ + int i = -1; + switch ((signed char) i) + { + case 255: /* { dg-bogus "exceeds maximum value" "" { xfail *-*-* } } */ + abort (); + default: + break; + } +} + diff --git a/gcc/testsuite/g++.dg/torture/pr40388.C b/gcc/testsuite/g++.dg/torture/pr40388.C new file mode 100644 index 000000000..63fbbfba5 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40388.C @@ -0,0 +1,21 @@ +void foo(); + +struct A +{ + ~A() + { + try + { + foo(); + foo(); + } + catch (...) + { + } + } +}; + +void bar() +{ + A a1, a2; +} diff --git a/gcc/testsuite/g++.dg/torture/pr40389.C b/gcc/testsuite/g++.dg/torture/pr40389.C new file mode 100644 index 000000000..e3ceb1238 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40389.C @@ -0,0 +1,84 @@ +/* { dg-do run } */ + +template <typename V> struct S +{ + V *f, *l; + __attribute__ ((noinline)) S (void) { f = 0, l = 0; } + void foo (V *x) + { + if (x->p != 0) + x->p->n = x->n; + else + f = x->n; + if (x->n != 0) + x->n->p = x->p; + else + l = x->p; + } + __attribute__ ((noinline)) void bar (V *x) + { + x->n = 0; + x->p = l; + if (l != 0) + l->n = x; + else + f = x; + l = x; + } +}; + +struct H; + +struct A +{ + S <H> k; +}; + +struct H +{ + A *a; + H *p, *n; + __attribute__ ((noinline)) H (void) { p = 0, n = 0, a = 0; } + __attribute__ ((noinline)) H (A *b) : a (b) + { + p = 0; + n = 0; + if (a != 0) + a->k.bar (this); + } + __attribute__ ((noinline)) H (const H &h) : a (h.a) + { + p = 0; + n = 0; + if (a != 0) + a->k.bar (this); + } + ~H (void) { if (a != 0) a->k.foo (this); } + H &operator= (const H &o) + { + if (a != 0 || &o == this) + __builtin_abort (); + a = o.a; + if (a != 0) + a->k.bar (this); + return *this; + } +}; + +__attribute__ ((noinline)) +H baz (void) +{ + return H (new A); +} + +H g; + +int +main (void) +{ + g = baz (); + if (g.a->k.f != &g) + __builtin_abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/torture/pr40460.C b/gcc/testsuite/g++.dg/torture/pr40460.C new file mode 100644 index 000000000..1d54df72b --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40460.C @@ -0,0 +1,9 @@ +/* { dg-do compile } */ + +void bar(int); +void foo(void) +{ + for (int i = 0; i<1; ++i) + bar (i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i*i); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr40492.C b/gcc/testsuite/g++.dg/torture/pr40492.C new file mode 100644 index 000000000..cab9426d0 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40492.C @@ -0,0 +1,26 @@ +typedef unsigned short ushort; +class QChar { +public: + QChar( const QChar& c ); + ushort ucs; +}; +inline QChar::QChar( const QChar& c ) : ucs( c.ucs ) { }; +class QString { }; +class KoAutoFormat { +public: + struct TypographicQuotes { QChar begin, end; }; + TypographicQuotes getConfigTypographicDoubleQuotes() const { + return m_typographicDoubleQuotes; + } + TypographicQuotes m_typographicDoubleQuotes; +}; +class KoAutoFormatDia { + QChar oDoubleBegin, oDoubleEnd; + KoAutoFormat * m_docAutoFormat; + bool noSignal; + void changeAutoformatLanguage(void); +}; +void KoAutoFormatDia::changeAutoformatLanguage(void) +{ + oDoubleEnd= m_docAutoFormat->getConfigTypographicDoubleQuotes().end; +} diff --git a/gcc/testsuite/g++.dg/torture/pr40642.C b/gcc/testsuite/g++.dg/torture/pr40642.C new file mode 100644 index 000000000..3f545a890 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40642.C @@ -0,0 +1,26 @@ +// { dg-do compile } +// { dg-options "-fprofile-generate" } + +// GCC used to ICE with some EH edge missing. + +inline void* operator new(__SIZE_TYPE__, void* p) throw() { return p; } +inline void operator delete (void*, void*) throw() { } + +template<typename T> void foo(void* p, T t) +{ + new(p) T(t); +} + +void bar(); + +template<typename T> struct A +{ + T* p; + + A() { try { foo(p, T()); } catch(...) {} } + + A(const A&) { try { bar(); } catch(...) { throw; } } +}; + +A<A<int> > a; + diff --git a/gcc/testsuite/g++.dg/torture/pr40834.C b/gcc/testsuite/g++.dg/torture/pr40834.C new file mode 100644 index 000000000..67d302853 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40834.C @@ -0,0 +1,52 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +class XalanDOMString +{ +public: + int y; +}; + +class XObject +{ +public: + const XalanDOMString& str() const { return x; } + XalanDOMString x; +}; + +class XObjectPtr +{ +public: + XObjectPtr(const XObjectPtr& theSource) + { + m_xobjectPtr = theSource.m_xobjectPtr; + } + const XObject* operator->() const + { + return m_xobjectPtr; + }; + XObjectPtr(XObject *p) { m_xobjectPtr = p; } + XObject* m_xobjectPtr; +}; + +class FunctionSubstringBefore +{ +public: + int execute( const XObjectPtr arg1) const + { + const XalanDOMString& theFirstString = arg1->str(); + return theFirstString.y; + } +}; + +int +main () +{ + XObject x; + XObjectPtr y (&x); + x.x.y = -1; + FunctionSubstringBefore z; + if (z.execute (y) != -1) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr40924.C b/gcc/testsuite/g++.dg/torture/pr40924.C new file mode 100644 index 000000000..9140da3ba --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40924.C @@ -0,0 +1,111 @@ +// PR rtl-optimization/40924 +// { dg-do run } + +extern "C" void abort (void); + +#define MAY_ALIAS __attribute__((__may_alias__)) + +typedef struct { float v[2]; } floata; +typedef struct { int v[2]; } inta; + +typedef unsigned int uint MAY_ALIAS; +typedef signed int sint MAY_ALIAS; +typedef float flt MAY_ALIAS; + +static inline unsigned short +less_than (inta a, inta b) +{ + unsigned short r = 0; + const uint *p1 = (const uint *) &a; + const uint *p2 = (const uint *) &b; + for (int i=0; i < 2; i++) + if (p1[i] < p2[i]) r |= (1 << i); + return r; +} + +static inline inta +multiply (inta b, inta c) +{ + inta r; + sint *p3 = (sint *) &c; + for (int i=0; i < 2; i++) + r.v[i] = (int) (b.v[i] * p3[i] & 0xFFFFFFFF); + return r; +} + +static inline floata +gather (inta indexes, const void *baseAddr) +{ + floata r; + + sint *idx = (sint *) &indexes; + flt *src = (flt *) baseAddr; + for (int i=0; i < 2; i++) + r.v[i] = *(src + idx[i]); + return r; +} + +static inline inta +add (const inta &b, const inta &c) +{ + inta result; + sint *r = (sint *) &result; + + for (int i=0; i < 2; i++) + r[i] = b.v[i] + c.v[i]; + return result; +} + +struct uintv +{ + inta data; + inline uintv () { data.v[0] = 0; data.v[1] = 1; } + inline uintv (unsigned int a) + { + for (int i=0; i < 2; i++) + *(uint *) &data.v[i] = a; + } + inline uintv (inta x) : data (x) {} + inline uintv operator* (const uintv &x) const + { return multiply (data, x.data); } + inline uintv operator+ (const uintv &x) const + { return uintv (add (data, x.data)); } + inline unsigned short operator< (const uintv &x) const + { return less_than (data, x.data); } +}; + +struct floatv +{ + floata data; + explicit inline floatv (const uintv &x) + { + uint *p2 = (uint *) &x.data; + for (int i=0; i < 2; i++) + data.v[i] = p2[i]; + } + inline floatv (const float *array, const uintv &indexes) + { + const uintv &offsets = indexes * uintv (1); + data = gather (offsets.data, array); + } + unsigned short operator== (const floatv &x) const + { + unsigned short r = 0; + for (int i=0; i < 2; i++) + if (data.v[i] == x.data.v[i]) r |= (1 << i); + return r; + } +}; + +int +main () +{ + const float array[2] = { 2, 3 }; + for (uintv i; (i < 2) == 3; i = i + 2) + { + const floatv ii (i + 2); + floatv a (array, i); + if ((a == ii) != 3) + abort (); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr40991.C b/gcc/testsuite/g++.dg/torture/pr40991.C new file mode 100644 index 000000000..c08124024 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr40991.C @@ -0,0 +1,113 @@ +/* { dg-options "-std=gnu++0x" } */ + +typedef __SIZE_TYPE__ size_t; +namespace std __attribute__ ((__visibility__ ("default"))) { + using ::size_t; + void __throw_bad_function_call() __attribute__((__noreturn__)); +} +inline void* operator new(std::size_t, void* __p) throw() { + return __p; +} +namespace std { + class type_info { + public: + bool operator==(const type_info& __arg) const { } + }; + namespace tr1 { + template<typename _Tp, _Tp __v> struct integral_constant { }; + typedef integral_constant<bool, true> true_type; + template<typename _Res, typename... _ArgTypes> + struct _Maybe_unary_or_binary_function { }; + class _Undefined_class; + union _Nocopy_types { + void (_Undefined_class::*_M_member_pointer)(); + }; + union _Any_data { + void* _M_access() { + return &_M_pod_data[0]; + } + char _M_pod_data[sizeof(_Nocopy_types)]; + }; + enum _Manager_operation { __get_type_info, __get_functor_ptr, __clone_functor, __destroy_functor }; + template<typename _Tp> struct _Simple_type_wrapper { + _Simple_type_wrapper(_Tp __value) : __value(__value) { } + _Tp __value; + }; + template<typename _Signature> class function; + class _Function_base { + public: + static const std::size_t _M_max_size = sizeof(_Nocopy_types); + static const std::size_t _M_max_align = __alignof__(_Nocopy_types); + template<typename _Functor> class _Base_manager { + static const bool __stored_locally = (sizeof(_Functor) <= _M_max_size && __alignof__(_Functor) <= _M_max_align && (_M_max_align % __alignof__(_Functor) == 0)); + typedef integral_constant<bool, __stored_locally> _Local_storage; + public: + static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { } + static void _M_init_functor(_Any_data& __functor, const _Functor& __f) { + _M_init_functor(__functor, __f, _Local_storage()); + } + template<typename _Class, typename _Tp> static bool _M_not_empty_function(_Tp _Class::* const& __mp) { + return __mp; + } + static void _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type) { + new (__functor._M_access()) _Functor(__f); + } + }; + ~_Function_base() { + if (_M_manager) _M_manager(_M_functor, _M_functor, __destroy_functor); + } + bool _M_empty() const { + return !_M_manager; + } + typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, _Manager_operation); + _Any_data _M_functor; + _Manager_type _M_manager; + }; + template<typename _Signature, typename _Functor> class _Function_handler; + template<typename _Class, typename _Member, typename _Res, typename... _ArgTypes> class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> : public _Function_handler<void(_ArgTypes...), _Member _Class::*> { + public: + static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { } + }; + template<typename _Class, typename _Member, typename... _ArgTypes> class _Function_handler<void(_ArgTypes...), _Member _Class::*> : public _Function_base::_Base_manager< _Simple_type_wrapper< _Member _Class::* > > { }; + template<typename _Res, typename... _ArgTypes> class function<_Res(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, private _Function_base { + typedef _Res _Signature_type(_ArgTypes...); + struct _Useless { }; + public: + template<typename _Functor> function(_Functor __f, _Useless = _Useless()); + _Res operator()(_ArgTypes... __args) const; + const type_info& target_type() const; + typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); + _Invoker_type _M_invoker; + }; + template<typename _Res, typename... _ArgTypes> template<typename _Functor> function<_Res(_ArgTypes...)>:: function(_Functor __f, _Useless) : _Function_base() { + typedef _Function_handler<_Signature_type, _Functor> _My_handler; + if (_My_handler::_M_not_empty_function(__f)) { + _M_invoker = &_My_handler::_M_invoke; + _M_manager = &_My_handler::_M_manager; + _My_handler::_M_init_functor(_M_functor, __f); + } + } + template<typename _Res, typename... _ArgTypes> _Res function<_Res(_ArgTypes...)>:: operator()(_ArgTypes... __args) const { + if (_M_empty()) { + __throw_bad_function_call(); + } + return _M_invoker(_M_functor, __args...); + } + template<typename _Res, typename... _ArgTypes> const type_info& function<_Res(_ArgTypes...)>:: target_type() const { + if (_M_manager) { + _Any_data __typeinfo_result; + _M_manager(__typeinfo_result, _M_functor, __get_type_info); + } + } + } +} +struct X { + int bar; +}; +void test05() { + using std::tr1::function; + X x; + function<int(X&)> frm(&X::bar); + frm(x) == 17; + typeid(int X::*) == frm.target_type(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr41144.C b/gcc/testsuite/g++.dg/torture/pr41144.C new file mode 100644 index 000000000..64dc117d7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr41144.C @@ -0,0 +1,23 @@ +/* { dg-do compile } */ + +struct rgba8; +template<class ColorT> class span_gouraud { +public: + struct coord_type { }; + coord_type m_coord[3]; +}; +template<class ColorT> class span_gouraud_rgba : public span_gouraud<ColorT> +{ + typedef ColorT color_type; + typedef span_gouraud<color_type> base_type; + typedef typename base_type::coord_type coord_type; +public: + void prepare() { + coord_type coord[3]; + } +}; +void the_application() { + typedef span_gouraud_rgba<rgba8> gouraud_span_gen_type; + gouraud_span_gen_type span_gouraud; + span_gouraud.prepare(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr41183.C b/gcc/testsuite/g++.dg/torture/pr41183.C new file mode 100644 index 000000000..df3e30341 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr41183.C @@ -0,0 +1,30 @@ +// PR c++/41183 +// { dg-do compile } + +void foo (const char *); + +template <int *> +struct A +{ + template <typename T> A (const int &, T); + int i; +}; + +template <int *X> +template <typename T> +A<X>::A (const int &j, T) : i(j) +{ + foo (0); + foo (0); + foo (__PRETTY_FUNCTION__); +} + +int N; + +struct B +{ + B (); + A<&N> a; +}; + +B::B() : a(N, 0) {} diff --git a/gcc/testsuite/g++.dg/torture/pr41186.C b/gcc/testsuite/g++.dg/torture/pr41186.C new file mode 100644 index 000000000..fdfee2cd3 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr41186.C @@ -0,0 +1,29 @@ +/* { dg-do run } */ + +struct Foo { + Foo() {}; + int i; + short f; +}; +struct Bar : public Foo { + Bar() {}; + short b; +}; + +extern "C" void abort(void); + +int main() +{ + Bar b1, b2; + b2.i = 0; + b1.f = 0; + b1.b = 1; + b2.f = 1; + b2.b = 2; + static_cast<Foo&>(b1) = static_cast<Foo&>(b2); + if (b1.i != 0 || b1.b != 1) + abort (); + if (b1.f != 1) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr41257-2.C b/gcc/testsuite/g++.dg/torture/pr41257-2.C new file mode 100644 index 000000000..230fa5dde --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr41257-2.C @@ -0,0 +1,16 @@ +/* { dg-do link } */ + +struct A +{ + virtual ~A(); +}; + +struct B : virtual A +{ + virtual ~B() {} +}; + +int main() +{ + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr41257.C b/gcc/testsuite/g++.dg/torture/pr41257.C new file mode 100644 index 000000000..60cfc5339 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr41257.C @@ -0,0 +1,20 @@ +/* { dg-do compile } */ + +struct A +{ + virtual void foo(); + virtual ~A(); + int i; +}; + +struct B : virtual A {}; + +struct C : B +{ + virtual void foo(); +}; + +void bar() +{ + C().foo(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr41273.C b/gcc/testsuite/g++.dg/torture/pr41273.C new file mode 100644 index 000000000..bdce05355 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr41273.C @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-options "-g" } */ + +long *H2_ipX_ener_sort; +double H2_old_populations[2]; +double H2_total; + +void H2_LevelPops() +{ + double sum_pop = 0.; + long nEner = 0; + while( nEner < 3 && sum_pop/H2_total < 0.99999 ) + { + long ip = H2_ipX_ener_sort[nEner]; + sum_pop += H2_old_populations[ip]; + ++nEner; + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr41680.C b/gcc/testsuite/g++.dg/torture/pr41680.C new file mode 100644 index 000000000..7faab0d5f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr41680.C @@ -0,0 +1,23 @@ +// PR target/41680 +// { dg-do compile } + +extern void baz (float); + +inline bool +bar (float x) +{ + union { float f; int i; } u; + u.f = x; + return (u.i & 1); +} + +void +foo (float *x) +{ + for (int i = 0; i < 10; i++) + { + float f = x[i]; + if (!bar (f)) + baz (f); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr41775.C b/gcc/testsuite/g++.dg/torture/pr41775.C new file mode 100644 index 000000000..3d8548e3f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr41775.C @@ -0,0 +1,284 @@ +/* { dg-do compile } */ +/* { dg-require-visibility "" } */ + +typedef unsigned int size_t; +namespace std __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Iterator > struct iterator_traits + { + }; + template < typename _Tp > struct iterator_traits <_Tp * > + { + typedef _Tp & reference; + }; +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + using std::iterator_traits; + template < typename _Iterator, typename _Container > class __normal_iterator + { + public:typedef _Iterator iterator_type; + typedef typename iterator_traits < _Iterator >::reference reference; + reference operator* () const + { + } + __normal_iterator operator++ (int) + { + } + }; + template < typename _IteratorL, typename _IteratorR, + typename _Container > inline bool operator!= (const __normal_iterator < + _IteratorL, + _Container > &__lhs, + const __normal_iterator < + _IteratorR, + _Container > &__rhs) + { + } +} + +extern "C" +{ + extern "C" + { + __extension__ typedef __SIZE_TYPE__ __intptr_t; + } +} +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Tp > class new_allocator + { + public:typedef size_t size_type; + typedef _Tp *pointer; + template < typename _Tp1 > struct rebind + { + typedef new_allocator < _Tp1 > other; + }; + }; +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +template < typename _Tp > class allocator:public __gnu_cxx::new_allocator < + _Tp > + { + }; +} + +extern "C" +{ + typedef __intptr_t intptr_t; +} +namespace llvm +{ + template < typename NodeTy > class ilist_half_node + { + }; +template < typename NodeTy > class ilist_node:private ilist_half_node < + NodeTy > + { + }; + class MachineBasicBlock; + class MachineOperand + { + public:enum MachineOperandType + { + } + Contents; + unsigned getReg () const + { + } + }; + class TargetRegisterInfo; +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Tp, typename _Alloc > struct _Vector_base + { + typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type; + }; +template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp, + _Alloc + > + { + typedef _Vector_base < _Tp, _Alloc > _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + public:typedef _Tp value_type; + typedef typename _Tp_alloc_type::pointer pointer; + typedef __gnu_cxx::__normal_iterator < pointer, vector > iterator; + iterator begin () + { + } + iterator end () + { + } + }; +} + +namespace llvm +{ + class MachineFunction; + class MachineInstr:public ilist_node < MachineInstr > + { + public:const MachineBasicBlock *getParent () const + { + } + const MachineOperand & getOperand (unsigned i) const + { + } + bool registerDefIsDead (unsigned Reg, const TargetRegisterInfo * TRI = + __null) const + { + } + }; + class AnalysisResolver; + class Pass + { + AnalysisResolver *Resolver; + intptr_t PassID; + public: explicit Pass (intptr_t pid):Resolver (0), PassID (pid) + { + } + explicit Pass (const void *pid):Resolver (0), PassID ((intptr_t) pid) + { + } + template < typename AnalysisType > AnalysisType & getAnalysis () const; + }; + class FunctionPass:public Pass + { + public:explicit FunctionPass (intptr_t pid):Pass (pid) + { + } + explicit FunctionPass (const void *pid):Pass (pid) + { + } + }; + class PassInfo + { + public:typedef Pass *(*NormalCtor_t) (); + private:const char *const PassName; + const char *const PassArgument; + const intptr_t PassID; + const bool IsCFGOnlyPass; + const bool IsAnalysis; + const bool IsAnalysisGroup; + NormalCtor_t NormalCtor; + public: PassInfo (const char *name, const char *arg, intptr_t pi, NormalCtor_t normal = 0, bool isCFGOnly = false, bool is_analysis = false):PassName (name), PassArgument (arg), PassID (pi), + IsCFGOnlyPass (isCFGOnly), IsAnalysis (is_analysis), + IsAnalysisGroup (false), NormalCtor (normal) + { + } + }; + template < typename PassName > Pass * callDefaultCtor () + { + return new PassName (); + } + template < typename passName > struct RegisterPass:public PassInfo + { + RegisterPass (const char *PassArg, const char *Name, bool CFGOnly = false, bool is_analysis = false):PassInfo (Name, PassArg, intptr_t (&passName::ID), + PassInfo::NormalCtor_t (callDefaultCtor < passName >), CFGOnly, + is_analysis) + { + } + }; + template < typename T > class SmallVectorImpl + { + }; + template < typename T, + unsigned N > class SmallVector:public SmallVectorImpl < T > + { + }; + class MachineFunctionPass:public FunctionPass + { + protected:explicit MachineFunctionPass (intptr_t ID):FunctionPass (ID) + { + } + explicit MachineFunctionPass (void *ID):FunctionPass (ID) + { + } + virtual bool runOnMachineFunction (MachineFunction & MF) = 0; + }; + class LiveIndex + { + private:unsigned index; + }; + class VNInfo + { + }; + struct LiveRange + { + LiveIndex start; + LiveIndex end; + VNInfo *valno; + }; + class LiveInterval + { + public:typedef SmallVector < LiveRange, 4 > Ranges; + bool containsOneValue () const + { + } + LiveRange *getLiveRangeContaining (LiveIndex Idx) + { + } + void removeRange (LiveIndex Start, LiveIndex End, bool RemoveDeadValNo = + false); + void removeRange (LiveRange LR, bool RemoveDeadValNo = false) + { + removeRange (LR.start, LR.end, RemoveDeadValNo); + } + }; + class LiveIntervals:public MachineFunctionPass + { + public:static char ID; + LiveIndex getDefIndex (LiveIndex index) + { + } + LiveInterval & getInterval (unsigned reg) + { + } + LiveIndex getInstructionIndex (const MachineInstr * instr) const + { + } + }; +} + +using namespace llvm; +namespace +{ +struct __attribute__ ((visibility ("hidden"))) StrongPHIElimination:public + MachineFunctionPass + { + static char ID; + StrongPHIElimination ():MachineFunctionPass (&ID) + { + } + bool runOnMachineFunction (MachineFunction & Fn); + }; +} + +static RegisterPass < StrongPHIElimination > X ("strong-phi-node-elimination", + "Eliminate PHI nodes for register allocation, intelligently"); +bool +StrongPHIElimination::runOnMachineFunction (MachineFunction & Fn) +{ + LiveIntervals & LI = getAnalysis < LiveIntervals > (); + std::vector < MachineInstr * >phis; + for (std::vector < MachineInstr * >::iterator I = phis.begin (), E = + phis.end (); I != E;) + { + MachineInstr *PInstr = *(I++); + unsigned DestReg = PInstr->getOperand (0).getReg (); + LiveInterval & PI = LI.getInterval (DestReg); + if (PInstr->registerDefIsDead (DestReg)) + { + if (PI.containsOneValue ()) + { + LiveIndex idx = + LI.getDefIndex (LI.getInstructionIndex (PInstr)); + PI.removeRange (*PI.getLiveRangeContaining (idx), true); + } + } + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr42110.C b/gcc/testsuite/g++.dg/torture/pr42110.C new file mode 100644 index 000000000..c778b4f2f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42110.C @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +bool foo(); + +struct A +{ + A* fooA() { if (foo()) foo(); return this; } + + virtual void barA(char); +}; + +template<int> struct B +{ + A *p, *q; + + void fooB(char c) { p->fooA()->barA(c); } +}; + +template<int N> inline void bar(B<N> b) { b.fooB(0); } + +extern template void bar(B<0>); + +void (*f)(B<0>) = bar; + +void baz() +{ + B<0>().fooB(0); +} diff --git a/gcc/testsuite/g++.dg/torture/pr42183.C b/gcc/testsuite/g++.dg/torture/pr42183.C new file mode 100644 index 000000000..375b37f0c --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42183.C @@ -0,0 +1,51 @@ +// { dg-do compile } + +class IntSize { +public: + IntSize(int width, int height) : m_width(width), m_height(height) { } + int m_width, m_height; +}; +class IntPoint { +public: + IntPoint(int x, int y) : m_x(x), m_y(y) { } + int m_x, m_y; +}; +class IntRect { +public: + IntRect(int x, int y, int width, int height) + : m_location(IntPoint(x, y)), m_size(IntSize(width, height)) { } + void intersect(const IntRect&); + IntPoint m_location; + IntSize m_size; +}; +inline IntRect intersection(const IntRect& a, const IntRect& b) { + IntRect c = a; + c.intersect(b); + return c; +} +class RenderObject { +public: + int contentWidth() const { } + int contentHeight() const { } + virtual int xPos() const { } + virtual int yPos() const { } + virtual int paddingTop() const; + virtual int paddingLeft() const; + virtual int borderTop() const { } + virtual int borderLeft() const { } +}; +class RenderMenuList : public RenderObject { + virtual IntRect controlClipRect(int tx, int ty) const; + RenderObject* m_innerBlock; +}; +IntRect RenderMenuList::controlClipRect(int tx, int ty) const { + IntRect outerBox(tx + borderLeft() + paddingLeft(), + ty + borderTop() + paddingTop(), + contentWidth(), contentHeight()); + IntRect innerBox(tx + m_innerBlock->xPos() + m_innerBlock->paddingLeft(), + ty + m_innerBlock->yPos() + m_innerBlock->paddingTop(), + m_innerBlock->contentWidth(), + m_innerBlock->contentHeight()); + return intersection(outerBox, innerBox); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr42357.C b/gcc/testsuite/g++.dg/torture/pr42357.C new file mode 100644 index 000000000..1a1d64e4f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42357.C @@ -0,0 +1,30 @@ +// { dg-do compile } +typedef unsigned char uint8; +typedef unsigned int uint32; +class PixelARGB { +public: + ~PixelARGB() throw() { } + PixelARGB (const uint32 argb_) throw() : argb (argb_) { } + inline __attribute__((always_inline)) uint8 getRed() const throw() { + return components.r; + } + union { + uint32 argb; + struct { + uint8 b, g, r, a; + } components; + }; +}; +class Colour { +public: + Colour() throw() : argb (0) {}; + uint8 getRed() const throw() { + return argb.getRed(); + } + PixelARGB argb; +}; +uint8 writeImage (void) { + Colour pixel; + pixel = Colour (); + return pixel.getRed(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr42450.C b/gcc/testsuite/g++.dg/torture/pr42450.C new file mode 100644 index 000000000..f630fa2b7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42450.C @@ -0,0 +1,112 @@ +/* { dg-do compile } */ + +template < typename > class basic_stringstream; + +struct basic_string { + basic_string(); +}; + +struct ios_base { + virtual ~ios_base(); +}; + +class ostream:ios_base {}; +class istream:virtual ios_base {}; + +template < typename > struct basic_iostream:public istream, ostream { + ~basic_iostream () {} +}; +extern template class basic_iostream < char >; + +template < typename > struct basic_stringstream:public basic_iostream < char > { + basic_string _M_stringbuf; + ~basic_stringstream () {} +}; +extern template class basic_stringstream < char >; + +template < typename > struct AnyMatrixBase; +template < typename, int _Rows, int _Cols, int = _Rows, int = _Cols > class Matrix; +template < typename > class CwiseNullaryOp; + +template < typename Derived > struct MatrixBase:public AnyMatrixBase < Derived > { + typedef CwiseNullaryOp < Derived > ConstantReturnType; + ConstantReturnType Constant (); + template < typename > Derived cast (); + static CwiseNullaryOp < Derived > Random (int); +}; + +template < typename Derived > struct AnyMatrixBase { + Derived derived () {} + Derived & derived () const {} +}; + +template < typename, int > struct ei_matrix_storage {}; + +template < typename _Scalar, int, int, int _MaxRows, int _MaxCols > struct Matrix:MatrixBase < Matrix < _Scalar, _MaxRows, _MaxCols > > { + typedef MatrixBase < Matrix > Base; + ei_matrix_storage < int, _MaxCols > m_storage; + Matrix operator= (const Matrix other) { + _resize_to_match (other); + lazyAssign (other.derived ()); + } + template < typename OtherDerived > Matrix lazyAssign (MatrixBase < OtherDerived > other) { + _resize_to_match (other); + return Base (other.derived ()); + } + Matrix (); + template < typename OtherDerived > Matrix (const MatrixBase < OtherDerived > &other) { + *this = other; + } + template < typename OtherDerived > void _resize_to_match (const MatrixBase < OtherDerived > &) { + throw 1; + } +}; + +template < typename MatrixType > class CwiseNullaryOp: +public MatrixBase < CwiseNullaryOp < MatrixType > > {}; + +int f() +{ + bool align_cols; + if (align_cols) { + basic_stringstream<char> sstr; + f(); + } +} + +template < typename > struct AutoDiffScalar; +template < typename Functor > struct AutoDiffJacobian:Functor { + AutoDiffJacobian (Functor); + typedef typename Functor::InputType InputType; + typedef typename Functor::ValueType ValueType; + typedef Matrix < int, Functor::InputsAtCompileTime, 1 > DerivativeType; + typedef AutoDiffScalar < DerivativeType > ActiveScalar; + typedef Matrix < ActiveScalar, Functor::InputsAtCompileTime, 1 > ActiveInput; + void operator () (InputType x, ValueType *) { + ActiveInput ax = x.template cast < ActiveScalar > (); + } +}; + +template < int NX, int NY > struct TestFunc1 { + enum { + InputsAtCompileTime = NX + }; + typedef Matrix < float, NX, 1 > InputType; + typedef Matrix < float, NY, 1 > ValueType; + typedef Matrix < float, NY, NX > JacobianType; + int inputs (); +}; + +template < typename Func > void forward_jacobian (Func f) { + typename Func::InputType x = Func::InputType::Random (f.inputs ()); + typename Func::ValueType y; + typename Func::JacobianType jref = jref.Constant (); + AutoDiffJacobian < Func > autoj (f); + autoj (x, &y); +} + +void test_autodiff_scalar () +{ + forward_jacobian (TestFunc1 < 2, 2 > ()); + forward_jacobian (TestFunc1 < 3, 2 > ()); +} diff --git a/gcc/testsuite/g++.dg/torture/pr42462.C b/gcc/testsuite/g++.dg/torture/pr42462.C new file mode 100644 index 000000000..947fa388f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42462.C @@ -0,0 +1,47 @@ +/* { dg-do run } */ + +#define INLINE inline __attribute__((always_inline)) +extern "C" void abort (void); + +template<class> struct Foo { + inline bool isFalse() { return false; } + template <bool> void f1() {} + template <bool> INLINE void f2() { f1<false>(); } + template <bool> void f3() { f2<false>(); } + template <bool> INLINE void f4() { f3<false>(); } + int exec2(); + void execute(); + inline void unused(); +}; + +template<class T> inline void Foo<T>::unused() { + f4<true>(); +} + +static int counter = 0; + +template<class T> int Foo<T>::exec2() { + static void* table[2] = { &&begin, &&end }; + if (counter++ > 10) + return 0; + goto *(table[0]); +begin: + if (isFalse()) f1<false>(); +end: + return 1; +} + +template<class T> void Foo<T>::execute() { + int r = 1; + while (r) { r = exec2(); } +} + +template class Foo<int>; + +int main() { + Foo<int> c; + c.execute(); + if (counter < 10) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr42704.C b/gcc/testsuite/g++.dg/torture/pr42704.C new file mode 100644 index 000000000..735b1e7bd --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42704.C @@ -0,0 +1,44 @@ +/* { dg-do compile } */ + +typedef int PRInt32; +class nsTreeRows { + class Subtree { }; + enum { kMaxDepth = 32 }; + struct Link { + Subtree* mParent; + PRInt32 mChildIndex; + Link& operator=(const Link& aLink) { + mParent = aLink.mParent; + mChildIndex = aLink.mChildIndex; + } + }; + class iterator { + PRInt32 mTop; + PRInt32 mRowIndex; + Link mLink[kMaxDepth]; + public: + iterator() : mTop(-1), mRowIndex(-1) { } + iterator& operator=(const iterator& aIterator); + }; + Subtree* EnsureSubtreeFor(Subtree* aParent, PRInt32 aChildIndex); + Subtree* GetSubtreeFor(const Subtree* aParent, +PRInt32 aChildIndex, PRInt32* aSubtreeSize = 0); + void InvalidateCachedRow() { + mLastRow = iterator(); + } + iterator mLastRow; +}; +nsTreeRows::Subtree* nsTreeRows::EnsureSubtreeFor(Subtree* aParent, + PRInt32 aChildIndex) { + Subtree* subtree = GetSubtreeFor(aParent, aChildIndex); + if (! subtree) { + InvalidateCachedRow(); + } +} +nsTreeRows::iterator& nsTreeRows::iterator::operator=(const iterator& +aIterator) { + mTop = aIterator.mTop; + for (PRInt32 i = mTop; + i >= 0; + --i) mLink[i] = aIterator.mLink[i]; +} diff --git a/gcc/testsuite/g++.dg/torture/pr42714.C b/gcc/testsuite/g++.dg/torture/pr42714.C new file mode 100644 index 000000000..b1b2d856e --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42714.C @@ -0,0 +1,37 @@ +struct QVectorData { + static QVectorData shared_null; +}; +template <typename T> class QVector { + union { + QVectorData *d; + }; +public: + inline QVector() : d(&QVectorData::shared_null) { } + inline QVector(const QVector<T> &v) : d(v.d) { } +}; +class QXmlStreamAttribute { }; +class QXmlStreamAttributes : public QVector<QXmlStreamAttribute> { }; +class __attribute__ ((visibility("default"))) Smoke { +public: + union StackItem; + typedef StackItem* Stack; + typedef short Index; +}; +class SmokeBinding { }; +namespace __smokeqt { + class x_QXmlStreamAttributes : public QXmlStreamAttributes { + SmokeBinding* _binding; + public: + static void x_11(Smoke::Stack x) { + x_QXmlStreamAttributes* xret = new x_QXmlStreamAttributes(); + } + explicit x_QXmlStreamAttributes() : QXmlStreamAttributes() { } + }; + void xcall_QXmlStreamAttributes(Smoke::Index xi, void *obj, + Smoke::Stack args) + { + switch(xi) { + case 11: x_QXmlStreamAttributes::x_11(args); + } + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr42739.C b/gcc/testsuite/g++.dg/torture/pr42739.C new file mode 100644 index 000000000..ccc05f836 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42739.C @@ -0,0 +1,16 @@ +/* { dg-do compile } */ + +struct s { ~s() { s(); } }; + +int f() +{ + M: + s o = s(); + f(); + f(); + + L: + goto *(f() ? &&L : &&M); + + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr42760.C b/gcc/testsuite/g++.dg/torture/pr42760.C new file mode 100644 index 000000000..be85f7fc4 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42760.C @@ -0,0 +1,46 @@ +// PR middle-end/42760 +// { dg-do compile } + +template <typename T> +struct A +{ + static T b (T it) { return it; } +}; + +template <typename T, typename U> +static U +baz (T x, T y, U z) +{ + for (long n = y - x; n > 0; --n) + { + *z = *x; + ++z; + } +}; + +template <typename T, typename U> +U +bar (T x, T y, U z) +{ + baz (A <T>::b (x), A <T>::b (y), A <U>::b (z)); +} + +struct C +{ + __complex__ float v; +}; + +template <class T> +struct B +{ + B (T y[]) { bar (y, y + 1, x); } + operator T *() { return x; } + T x[1]; +}; + +B <C> +foo () +{ + C y[1]; + return B <C> (y); +}; diff --git a/gcc/testsuite/g++.dg/torture/pr42773.C b/gcc/testsuite/g++.dg/torture/pr42773.C new file mode 100644 index 000000000..478ad278a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42773.C @@ -0,0 +1,54 @@ +// { dg-do compile } +// { dg-options "-fno-exceptions" } + +typedef unsigned int uint; +struct QShared { + bool deref() { + return !--count; + } + uint count; +}; +template <class T> class QValueListNode { +public: + QValueListNode<T>* next; + QValueListNode<T>* prev; +}; +template <class T> class QValueListPrivate : public QShared { +public: + typedef QValueListNode<T> Node; + typedef QValueListNode<T>* NodePtr; + QValueListPrivate(); + void derefAndDelete() { + if ( deref() ) delete this; + } + ~QValueListPrivate(); + NodePtr node; +}; +template <class T> QValueListPrivate<T>::QValueListPrivate() { + node = new Node; + node->next = node->prev = node; +} +template <class T> QValueListPrivate<T>::~QValueListPrivate() { + NodePtr p = node->next; + while( p != node ) { + NodePtr x = p->next; + delete p; + p = x; + } +} +template <class T> class QValueList { +public: + QValueList() { + sh = new QValueListPrivate<T>; + } + ~QValueList() { + sh->derefAndDelete(); + } + QValueListPrivate<T>* sh; +}; +class Cell { + QValueList<Cell*> obscuringCells() const; +}; +QValueList<Cell*> Cell::obscuringCells() const { + QValueList<Cell*> empty; +} diff --git a/gcc/testsuite/g++.dg/torture/pr42871.C b/gcc/testsuite/g++.dg/torture/pr42871.C new file mode 100644 index 000000000..452ad9319 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42871.C @@ -0,0 +1,40 @@ +struct C +{ + ~C (); + int c3; +}; + +C *b2; + +static void +b1 (const C &x, unsigned b3, unsigned b4) +{ + unsigned i = 0; + for (; i < b3; i++) + if (i < b4) + { + b2[0].c3 = x.c3; + return; + } +} + +int a (); + +void +bar (unsigned b3, unsigned b4) +{ + C c[100]; + for (int i = 0; i < 100; i++) + { + c[i].c3 = i; + for (int j = 0; j < b3; j++) + if (j < b4) + { + b2[0].c3 = 0; + break; + } + b1 (c[i], b3, b4); + a (); + } +} + diff --git a/gcc/testsuite/g++.dg/torture/pr42883.C b/gcc/testsuite/g++.dg/torture/pr42883.C new file mode 100644 index 000000000..f164c3781 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42883.C @@ -0,0 +1,63 @@ +// { dg-do compile } + +typedef __SIZE_TYPE__ size_t; +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { + template<typename _Tp> class new_allocator { + public: + typedef size_t size_type; + typedef _Tp* pointer; + typedef _Tp& reference; + void deallocate(pointer __p, size_type) { + ::operator delete(__p); + } + }; +} +namespace std __attribute__ ((__visibility__ ("default"))) { + template<typename _Tp> class allocator: public __gnu_cxx::new_allocator<_Tp> { + public: + template<typename _Tp1> struct rebind { + typedef allocator<_Tp1> other; + }; + }; + template<typename _Tp, typename _Alloc> struct _Vector_base { + typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; + struct _Vector_impl : public _Tp_alloc_type { + typename _Tp_alloc_type::pointer _M_start; + typename _Tp_alloc_type::pointer _M_end_of_storage; + }; + ~_Vector_base() { + _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); + } + _Vector_impl _M_impl; + void _M_deallocate(typename _Tp_alloc_type::pointer __p, size_t __n) { + if (__p) _M_impl.deallocate(__p, __n); + } + }; + template<typename _Tp, typename _Alloc = std::allocator<_Tp> > class vector : protected _Vector_base<_Tp, _Alloc> { + typedef _Vector_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + public: + typedef typename _Tp_alloc_type::reference reference; + typedef size_t size_type; + size_type size() const { + } + reference operator[](size_type __n) { + } + }; +}; +class vtkConvexPointSet { +public: + static vtkConvexPointSet *New(); +}; +void MakeInternalMesh() { + std::vector< int > tempFaces[2]; + std::vector< int > firstFace; + int i, j, k; + for(i = 0; i < 1000; i++) { + for(int pointCount = 0; pointCount < 1000; pointCount++) { + for(j = 0; j < (int)tempFaces[0].size(); k++) + if(tempFaces[0][j] == tempFaces[1][k]) break; + } + vtkConvexPointSet::New(); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr42890.C b/gcc/testsuite/g++.dg/torture/pr42890.C new file mode 100644 index 000000000..937367665 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr42890.C @@ -0,0 +1,25 @@ +// PR tree-optimization/42890 +// { dg-do compile } + +extern "C" int puts (const char *) throw (); + +struct S +{ + const char *a; + const char **b; + S (const char *s) { a = s; b = &a; } + ~S () { puts (a); } +}; + +void +foo (int (*fn) (const char *)) +{ + S a ("foo"); + fn ("bar"); +} + +int +main () +{ + foo (puts); +} diff --git a/gcc/testsuite/g++.dg/torture/pr43068.C b/gcc/testsuite/g++.dg/torture/pr43068.C new file mode 100644 index 000000000..524fd23ee --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43068.C @@ -0,0 +1,10 @@ +/* { dg-do compile } */ +/* { dg-options "-freorder-blocks -ftracer} */ + +struct A { + virtual A *f(); +}; +struct B : virtual A { + virtual B *f(); +}; +B *B::f() { return 0; } diff --git a/gcc/testsuite/g++.dg/torture/pr43257.C b/gcc/testsuite/g++.dg/torture/pr43257.C new file mode 100644 index 000000000..a3e75574a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43257.C @@ -0,0 +1,30 @@ +/* { dg-do assemble } */ + +class A {}; +class B {}; + +static void *func (int n) +{ + void *p; + if (p == 0) throw ::A (); +} + +static void *func (int n, B const &) +{ + try { + return func (n); + } + catch (::A const &) { + } + return func (n); +} + +void *f1 (int n) +{ + return func (n, B()); +} + +void *f2 (int n) +{ + return func (n, B()); +} diff --git a/gcc/testsuite/g++.dg/torture/pr43611.C b/gcc/testsuite/g++.dg/torture/pr43611.C new file mode 100644 index 000000000..6899a6ea4 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43611.C @@ -0,0 +1,22 @@ +// { dg-do compile } +// { dg-options "-fkeep-inline-functions" } + +template < typename > +struct A { + void init (int); + A () + { + this->init (0); + } +}; + +template < typename > +struct B : A < int > { + A < int > a; + B () {} +}; + +extern template struct A < int >; +extern template struct B < int >; + +B < int > b; diff --git a/gcc/testsuite/g++.dg/torture/pr43784.C b/gcc/testsuite/g++.dg/torture/pr43784.C new file mode 100644 index 000000000..a83a6f374 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43784.C @@ -0,0 +1,24 @@ +/* { dg-do run } */ +/* { dg-options "-fno-tree-sra" } */ + +struct S {int x, y, makemelarge[5];}; +S __attribute__((noinline)) f (S &s) { + S r; + r.x = s.y; + r.y = s.x; + return r; +} +int __attribute__((noinline)) glob (int a, int b) +{ + S local = { a, b }; + local = f (local); + return local.y; +} +extern "C" void abort (void); +int main (void) +{ + if (glob (1, 3) != 1) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/torture/pr43801.C b/gcc/testsuite/g++.dg/torture/pr43801.C new file mode 100644 index 000000000..3b52d4abc --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43801.C @@ -0,0 +1,22 @@ +// PR tree-optimization/43801 +// { dg-do compile } +// { dg-options "-fipa-cp -fipa-cp-clone" } + +struct A +{ + virtual void f (int); +}; +struct B : virtual A +{ + virtual void f (int i) { if (i) A::f(0); } +}; +struct C : virtual B +{ + virtual void f (int) { B::f(0); } +}; + +void +foo () +{ + C (); +} diff --git a/gcc/testsuite/g++.dg/torture/pr43879-1_0.C b/gcc/testsuite/g++.dg/torture/pr43879-1_0.C new file mode 100644 index 000000000..710f6adfe --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43879-1_0.C @@ -0,0 +1,11 @@ +struct A { + int *i; + A(); + ~A(); +}; + +static int x = 0; + +A::A() : i(&x) {} +A::~A() {} + diff --git a/gcc/testsuite/g++.dg/torture/pr43879-1_1.C b/gcc/testsuite/g++.dg/torture/pr43879-1_1.C new file mode 100644 index 000000000..0c943381f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43879-1_1.C @@ -0,0 +1,48 @@ +/* { dg-do run } */ +/* { dg-options "-fipa-pta" } */ +/* { dg-additional-sources "pr43879-1_0.C" } */ + +struct A { + int *i; + A(); + ~A(); +}; + +static inline int +aa(int *a, int *b) +{ + (void)b; + return *a; +} + +struct B { + B() : i(0) {} + int i; + B(const A &a) : i(0) + { + f(*a.i); + } + void __attribute__((noinline, noclone)) + f(int j) + { + aa(&i, &j); + i = 1; + } +}; + +int +test() +{ + B b1; + B b2 = B(A()); + b1 = B(A()); + if (b1.i != b2.i) __builtin_abort(); + return 0; +} + +int +main() +{ + return test(); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr43880.C b/gcc/testsuite/g++.dg/torture/pr43880.C new file mode 100644 index 000000000..bf82bc54b --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43880.C @@ -0,0 +1,16 @@ +// { dg-do compile } + +extern void xread(void *); +class test +{ +public: + test(void); +}; +test::test(void) +{ + union { + char pngpal[1]; + }; + xread(pngpal); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr43905.C b/gcc/testsuite/g++.dg/torture/pr43905.C new file mode 100644 index 000000000..0e49a32a1 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr43905.C @@ -0,0 +1,13 @@ +extern void sf ( __const char *); +struct Matrix{ + int operator[](int n){ + sf ( __PRETTY_FUNCTION__); + } + int operator[](int n)const{ + sf ( __PRETTY_FUNCTION__); + } +}; +void calcmy(Matrix const &b, Matrix &c, int k){ + b[k]; + c[k]; +} diff --git a/gcc/testsuite/g++.dg/torture/pr44069.C b/gcc/testsuite/g++.dg/torture/pr44069.C new file mode 100644 index 000000000..99fcd173e --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44069.C @@ -0,0 +1,25 @@ +/* { dg-do run } */ + +template <unsigned R, unsigned C> +class M { +public: + M(const int* arr) { + for (unsigned long r = 0; r < R; ++r) + for (unsigned long c = 0; c < C; ++c) + m[r*C+c] = arr[r*C+c]; + } + int operator()(unsigned r, unsigned c) const + { return m[r*C+c]; } +private: + int m[R*C]; +}; +extern "C" void abort (void); +int main() +{ + int vals[2][2] = { { 1, 2 }, { 5, 6 } }; + M<2,2> m( &(vals[0][0]) ); + if (m(1,0) != 5) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/torture/pr44148.C b/gcc/testsuite/g++.dg/torture/pr44148.C new file mode 100644 index 000000000..a60ba9aa3 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44148.C @@ -0,0 +1,60 @@ +// PR c++/44148 +// { dg-do compile } +// { dg-options "" } +// { dg-options "-fpic" { target fpic } } + +template <typename T> struct S2 +{ + typedef const T &t2; + t2 operator* () const {} +}; +template <typename T> struct S3 +{ + typedef S2 <T> t5; +}; +template <typename T1, typename T2> T2 foo1 (T1 x, T2 y) { y (*x); } +template <class T> struct S4 +{ + T &operator* () const; +}; +struct S7 {}; +struct S8 +{ + typedef::S3 <S4 <S7> >::t5 t6; + t6 m1 () const; +}; +template <class T> struct S9 +{ + typedef T t3; + inline t3 &operator[] (unsigned int) {} +}; +template <typename T1, typename T2, typename T3, void (&T4) (const T1 &, T3 &)> struct S10 +{ + S10 (T2 &x, unsigned int y = 0) : u (x), v (y) {} + void operator () (const S4 <T1> &x) { T4 (*x, u[v++]); } + T2 &u; + unsigned int v; +}; +struct S15; +struct S11 +{ + static void m3 (const S8 &, S15 &); +}; +struct S16; +struct S12; +struct S13 +{ + static void m4 (const S7 &,S16 &); +}; +typedef S10 <S7, S12, S16, S13::m4> t10; +struct S12: S9 <S16> +{ +}; +struct S15 +{ + S12 p; +}; +void S11::m3 (const S8 &x, S15 &y) +{ + foo1 (x.m1 (), t10 (y.p)); +} diff --git a/gcc/testsuite/g++.dg/torture/pr44206.C b/gcc/testsuite/g++.dg/torture/pr44206.C new file mode 100644 index 000000000..a1dedb450 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44206.C @@ -0,0 +1,21 @@ +// { dg-do compile } + +template<int> struct A +{ + void foo(void(*)(A)); + void bar(void(*f)(A)) { foo(f); foo(f); } +}; + +template<int N> inline void FOO(A<N> a) +{ + a.foo(0); +} + +extern template void FOO(A<0>); + +void BAR() +{ + A<0> a; + FOO(a); + a.bar(FOO); +} diff --git a/gcc/testsuite/g++.dg/torture/pr44295.C b/gcc/testsuite/g++.dg/torture/pr44295.C new file mode 100644 index 000000000..8169bb0a8 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44295.C @@ -0,0 +1,170 @@ +/* { dg-do compile } */ +extern "C" { + typedef __SIZE_TYPE__ size_t; + typedef struct { + } __sigset_t; + typedef union { + } pthread_barrierattr_t; + } + typedef unsigned short XMLCh; + typedef unsigned long XMLSize_t; + namespace xercesc_2_5 { + class DOMNodeList; + class DOMNode { + }; + class DOMDocumentRange { + }; + class DOMDocument: public DOMDocumentRange, public DOMNode { + }; + union wait { + struct { + } + __wait_stopped; + } + div_t; + class MemoryManager; + class XMemory { + public : void* operator new(size_t size, MemoryManager* memMgr); + void operator delete(void* p); + void operator delete(void* p, MemoryManager* memMgr); + }; + class XMLExcepts { + public : enum Codes { + NoError = 0 , HshTbl_ZeroModulus = 48 , HshTbl_BadHashFromKey = 49 }; + }; + class XMLUni { + }; + } + namespace xercesc_2_5 { + class XMLException : public XMemory { + public: + virtual ~XMLException(); + XMLException(const char* const srcFile, const unsigned int srcLine, MemoryManager* const memoryManager = 0); + void loadExceptText ( const XMLExcepts::Codes toLoad ); + }; + class XMLDeleter { + }; + class XMLPlatformUtils { + public : static MemoryManager* fgMemoryManager; + static inline size_t alignPointerForNewBlockAllocation(size_t ptrSize); + }; + inline size_t XMLPlatformUtils::alignPointerForNewBlockAllocation(size_t ptrSize) { + } + class HashBase : public XMemory { + public: + virtual bool equals(const void *const key1, const void *const key2) = 0; + virtual ~HashBase() { +}; + }; + class IllegalArgumentException : public XMLException { + public: +IllegalArgumentException(const char* const srcFile , const unsigned int srcLine , const XMLExcepts::Codes toThrow , MemoryManager* memoryManager = 0) : XMLException(srcFile, srcLine, memoryManager) { + loadExceptText(toThrow); + } + }; + class RuntimeException : public XMLException { + public: +RuntimeException(const char* const srcFile , const unsigned int srcLine , const XMLExcepts::Codes toThrow , MemoryManager* memoryManager = 0) : XMLException(srcFile, srcLine, memoryManager) { + loadExceptText(toThrow); + } + }; + class MemoryManager { + public: + virtual ~MemoryManager() { + } + virtual void* allocate(size_t size) = 0; + }; + template <class TElem> class BaseRefVectorOf : public XMemory { + BaseRefVectorOf ( const unsigned int maxElems , const bool adoptElems = true , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); + virtual ~BaseRefVectorOf(); + bool fAdoptedElems; + TElem** fElemList; + }; + template <class TElem> BaseRefVectorOf<TElem>::BaseRefVectorOf( const unsigned int maxElems , const bool adoptElems , MemoryManager* const manager) : fAdoptedElems(adoptElems) { + for (unsigned int index = 0; + index < maxElems; + index++) fElemList[index] = 0; + } + template <class TElem> BaseRefVectorOf<TElem>::~BaseRefVectorOf() { + } + class XMLString { + public: + static bool equals ( const XMLCh* const str1 , const XMLCh* const str2 ); + static void moveChars ( XMLCh* const targetStr , const XMLCh* const srcStr , const unsigned int count ); + }; + inline void XMLString::moveChars( XMLCh* const targetStr , const XMLCh* const srcStr , const unsigned int count) { + } + inline bool XMLString::equals( const XMLCh* const str1 , const XMLCh* const str2) { + const XMLCh* psz1 = str1; + const XMLCh* psz2 = str2; + if (psz1 == 0 || psz2 == 0) { + return true; + } + } + } + namespace xercesc_2_5 { + class HashPtr : public HashBase { + virtual bool equals(const void *const key1, const void *const key2); + }; + template <class TVal> struct DOMDeepNodeListPoolTableBucketElem : public XMemory { + void* fKey1; + XMLCh* fKey2; + XMLCh* fKey3; + }; + template <class TVal> class DOMDeepNodeListPool { + public: + DOMDeepNodeListPool ( const XMLSize_t modulus , const bool adoptElems , const XMLSize_t initSize = 128 ); + TVal* getByKey(const void* const key1, const XMLCh* const key2, const XMLCh* const key3); + DOMDeepNodeListPoolTableBucketElem<TVal>* findBucketElem(const void* const key1, const XMLCh* const key2, const XMLCh* const key3, XMLSize_t& hashVal); + bool fAdoptedElems; + DOMDeepNodeListPoolTableBucketElem<TVal>** fBucketList; + XMLSize_t fHashModulus; + HashBase* fHash; + TVal** fIdPtrs; + XMLSize_t fIdPtrsCount; + MemoryManager* fMemoryManager; + }; + template <class TVal> DOMDeepNodeListPool<TVal>::DOMDeepNodeListPool( const XMLSize_t modulus , const bool adoptElems , const XMLSize_t initSize) : fAdoptedElems(adoptElems) , fBucketList(0) , fHash(0) , fIdPtrs(0) { + fHash = new (fMemoryManager) HashPtr(); + fIdPtrs = (TVal**) fMemoryManager->allocate(fIdPtrsCount * sizeof(TVal*)); + if (modulus == 0) throw IllegalArgumentException("./xercesc/dom/impl/bad.c", 38, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager); + } + template <class TVal> TVal* DOMDeepNodeListPool<TVal>::getByKey(const void* const key1, const XMLCh* const key2, const XMLCh* const key3) { + XMLSize_t hashVal; + DOMDeepNodeListPoolTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal); + } + template <class TVal> DOMDeepNodeListPoolTableBucketElem<TVal>* DOMDeepNodeListPool<TVal>:: findBucketElem(const void* const key1, const XMLCh* const key2, const XMLCh* const key3, XMLSize_t& hashVal) { + if (hashVal > fHashModulus) throw RuntimeException("./xercesc/dom/impl/bad.c", 64, XMLExcepts::HshTbl_BadHashFromKey, fMemoryManager); + DOMDeepNodeListPoolTableBucketElem<TVal>* curElem = fBucketList[hashVal]; + if (fHash->equals(key1, curElem->fKey1) && (XMLString::equals(key2, curElem->fKey2)) && (XMLString::equals(key3, curElem->fKey3))) { + return curElem; + } + } + class DOMDeepNodeListImpl; + class DOMDocumentImpl: public DOMDocument { + DOMNodeList* getElementsByTagName(const XMLCh * tagname) const; + DOMNodeList* getDeepNodeList(const DOMNode *rootNode, const XMLCh *tagName); + DOMNodeList* getDeepNodeList(const DOMNode *rootNode, const XMLCh *namespaceURI, const XMLCh *localName); + DOMDeepNodeListPool<DOMDeepNodeListImpl>* fNodeListPool; + }; + } + void * operator new(size_t amt, xercesc_2_5:: DOMDocument *doc); + namespace xercesc_2_5 { + class DOMNodeList { + }; + class DOMDeepNodeListImpl: public DOMNodeList { + }; + DOMNodeList *DOMDocumentImpl::getElementsByTagName(const XMLCh *tagname) const { + return ((DOMDocumentImpl*)this)->getDeepNodeList(this,tagname); + } + DOMNodeList *DOMDocumentImpl::getDeepNodeList(const DOMNode *rootNode, const XMLCh *tagName) { + if(!fNodeListPool) { + fNodeListPool = new (this) DOMDeepNodeListPool<DOMDeepNodeListImpl>(109, false); + } + DOMNodeList* retList = fNodeListPool->getByKey(rootNode, tagName, 0); + } + DOMNodeList *DOMDocumentImpl::getDeepNodeList(const DOMNode *rootNode, const XMLCh *namespaceURI, const XMLCh *localName) { + DOMNodeList* retList = fNodeListPool->getByKey(rootNode, localName, namespaceURI); + } + } + diff --git a/gcc/testsuite/g++.dg/torture/pr44357.C b/gcc/testsuite/g++.dg/torture/pr44357.C new file mode 100644 index 000000000..3380350e8 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44357.C @@ -0,0 +1,228 @@ +/* { dg-do compile } */ +extern "C" +{ + typedef long unsigned int size_t; +} +namespace llvm +{ + namespace dont_use + { + template < typename T > double is_class_helper (...); + } + template < typename T > struct is_class + { + public:enum + { value = sizeof (char) == sizeof (dont_use::is_class_helper < T > (0)) }; + }; + template < typename T > struct isPodLike + { + static const bool value = !is_class < T >::value; + }; +} +namespace std __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Iterator > struct iterator_traits + { + }; + template < typename _Tp > struct iterator_traits <_Tp * > + { + typedef _Tp value_type; + }; +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Tp > class new_allocator + { + public:typedef size_t size_type; + typedef const _Tp & const_reference; + }; +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +template < typename _Tp > class allocator:public __gnu_cxx::new_allocator < + _Tp > + { + public:typedef size_t size_type; + template < typename _Tp1 > struct rebind + { + typedef allocator < _Tp1 > other; + }; + }; + template < typename _Tp, typename _Alloc > struct _Vector_base + { + typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type; + }; +template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp, + _Alloc + > + { + typedef _Vector_base < _Tp, _Alloc > _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + public:typedef _Tp value_type; + typedef typename _Tp_alloc_type::const_reference const_reference; + typedef size_t size_type; + size_type size () const + { + } const_reference operator[] (size_type __n) const + { + }}; +} + +namespace llvm +{ + struct LandingPadInfo; + class DwarfException + { + static bool PadLT (const LandingPadInfo * L, const LandingPadInfo * R); + struct CallSiteEntry + { + }; + void EmitExceptionTable (); + }; +} +namespace std __attribute__ ((__visibility__ ("default"))) +{ + template < typename _RandomAccessIterator, + typename _Compare > + void __unguarded_linear_insert (_RandomAccessIterator __last, + _Compare __comp) + { + typename iterator_traits < _RandomAccessIterator >::value_type __val = + (*__last); + _RandomAccessIterator __next = __last; + while (__comp (__val, *__next)) + { + } + } + template < typename _RandomAccessIterator, + typename _Compare > void __insertion_sort (_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Compare __comp) + { + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + if (__comp (*__i, *__first)) + { + } + else + std::__unguarded_linear_insert (__i, __comp); + } + } + enum + { _S_threshold = 16 }; + template < typename _RandomAccessIterator, + typename _Compare > + void __final_insertion_sort (_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Compare __comp) + { + if (__last - __first > int (_S_threshold)) + { + std::__insertion_sort (__first, __first + int (_S_threshold), __comp); + } + } + template < typename _RandomAccessIterator, + typename _Compare > inline void sort (_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Compare __comp) + { + if (__first != __last) + { + std::__final_insertion_sort (__first, __last, __comp); + } + } +} + +namespace llvm +{ + class SmallVectorBase + { + protected:void *BeginX, *EndX, *CapacityX; + struct U + { + } FirstEl; + protected: SmallVectorBase (size_t Size):BeginX (&FirstEl), EndX (&FirstEl), + CapacityX ((char *) &FirstEl + Size) + { + }}; +template < typename T > class SmallVectorTemplateCommon:public + SmallVectorBase + { + public: SmallVectorTemplateCommon (size_t Size):SmallVectorBase (Size) + { + } typedef size_t size_type; + typedef T *iterator; + iterator begin () + { + } iterator end () + { + } size_type size () const + { + }}; +template < typename T, bool isPodLike > class SmallVectorTemplateBase:public SmallVectorTemplateCommon < + T > + { + public: SmallVectorTemplateBase (size_t Size):SmallVectorTemplateCommon < T > + (Size) + { + }}; +template < typename T > class SmallVectorImpl:public SmallVectorTemplateBase < T, + isPodLike < T >::value > + { + typedef SmallVectorTemplateBase < T, isPodLike < T >::value > SuperClass; + public:typedef typename SuperClass::iterator iterator; + explicit SmallVectorImpl (unsigned N):SmallVectorTemplateBase < T, + isPodLike < T >::value > (N * sizeof (T)) + { + } + }; + template < typename T, + unsigned N > class SmallVector:public SmallVectorImpl < T > + { + typedef typename SmallVectorImpl < T >::U U; + enum + { MinUs = + (static_cast < unsigned int >(sizeof (T)) * N + static_cast < + unsigned int >(sizeof (U)) - 1) /static_cast < + unsigned int >(sizeof (U)), NumInlineEltsElts = + MinUs > 1 ? (MinUs - 1) : 1, NumTsAvailable = + (NumInlineEltsElts + 1) * static_cast < + unsigned int >(sizeof (U)) / static_cast < + unsigned int >(sizeof (T)) }; + public: SmallVector ():SmallVectorImpl < T > (NumTsAvailable) + { + } + }; + struct LandingPadInfo + { + std::vector < int >TypeIds; + union + { + } Contents; + }; +} + +using namespace llvm; +bool +DwarfException::PadLT (const LandingPadInfo * L, const LandingPadInfo * R) +{ + const std::vector < int >&LIds = L->TypeIds, &RIds = R->TypeIds; + unsigned LSize = LIds.size (), RSize = RIds.size (); + unsigned MinSize = LSize < RSize ? LSize : RSize; + for (unsigned i = 0; i != MinSize; ++i) + if (LIds[i] != RIds[i]) + return LIds[i] < RIds[i]; +} + +void +DwarfException::EmitExceptionTable () +{ + SmallVector < const LandingPadInfo *, 64 > LandingPads; + std::sort (LandingPads.begin (), LandingPads.end (), PadLT); + SmallVector < CallSiteEntry, 64 > CallSites; + for (unsigned i = 0, e = CallSites.size (); i < e; ++i) + { + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr44492.C b/gcc/testsuite/g++.dg/torture/pr44492.C new file mode 100644 index 000000000..41669241e --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44492.C @@ -0,0 +1,31 @@ +// PR middle-end/44492 +// { dg-do run } + +struct T { unsigned long p; }; +struct S { T a, b, c; unsigned d; }; + +__attribute__((noinline)) +void +bar (const T &x, const T &y) +{ + if (x.p != 0x2348 || y.p != 0x2346) + __builtin_abort (); +} + +__attribute__((noinline)) +void +foo (S &s, T e) +{ + unsigned long a = e.p; + unsigned long b = s.b.p; + __asm__ volatile ("" : : "rm" (a), "rm" (b)); + bar (e, s.b); +} + +int +main () +{ + S s = { { 0x2345 }, { 0x2346 }, { 0x2347 }, 6 }; + T t = { 0x2348 }; + foo (s, t); +} diff --git a/gcc/testsuite/g++.dg/torture/pr44535.C b/gcc/testsuite/g++.dg/torture/pr44535.C new file mode 100644 index 000000000..9126f3997 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44535.C @@ -0,0 +1,34 @@ +/* { dg-do run } */ + +namespace FOO { + +template <typename T> +class A +{ +public: + void Enum(); + virtual void OnProv() = 0; + virtual ~A() { } +}; +typedef A<char> B; + +template<typename T> +void A<T>::Enum () +{ + OnProv (); +} +} // namespace FOO + +class C {}; + +class D: public C, public FOO::B { +public: + void OnProv() {} +}; + +int main(int argc, char *argv[]) +{ + D x; + x.Enum(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr44809.C b/gcc/testsuite/g++.dg/torture/pr44809.C new file mode 100644 index 000000000..b6615f23f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44809.C @@ -0,0 +1,6 @@ +// { dg-do compile } +unsigned int mEvictionRank[(1 << 5)]; +void Unswap(int i) +{ + mEvictionRank[i] = ({ unsigned int __v = i; __v; }); +} diff --git a/gcc/testsuite/g++.dg/torture/pr44813.C b/gcc/testsuite/g++.dg/torture/pr44813.C new file mode 100644 index 000000000..1dc01b06a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44813.C @@ -0,0 +1,60 @@ +typedef unsigned int PRUint32; +typedef int PRInt32; +typedef unsigned long PRUint64; +typedef int PRIntn; +typedef PRIntn PRBool; +struct nsRect { + nsRect(const nsRect& aRect) { } +}; +enum nsCompatibility { eCompatibility_NavQuirks = 3 }; +class gfxContext; +typedef PRUint64 nsFrameState; +class nsPresContext { +public: + nsCompatibility CompatibilityMode() const { } +}; +class nsStyleContext { +public: + PRBool HasTextDecorations() const; +}; +class nsIFrame { +public: + nsPresContext* PresContext() const; + nsStyleContext* GetStyleContext() const; + nsFrameState GetStateBits() const; + nsRect GetOverflowRect() const; +}; +class nsFrame : public nsIFrame { }; +class nsLineList_iterator { }; +class nsLineList { +public: + typedef nsLineList_iterator iterator; +}; +class gfxSkipCharsIterator { }; +class gfxTextRun { +public: + class PropertyProvider { }; +}; +class nsTextFrame : public nsFrame +{ + virtual nsRect ComputeTightBounds(gfxContext* aContext) const; + gfxSkipCharsIterator EnsureTextRun(gfxContext* aReferenceContext = 0L, + nsIFrame* aLineContainer = 0L, + const nsLineList::iterator* aLine = 0L, + PRUint32* aFlowEndInTextRun = 0L); +}; +class PropertyProvider : public gfxTextRun::PropertyProvider +{ +public: + PropertyProvider(nsTextFrame* aFrame, const gfxSkipCharsIterator& aStart); + PRInt32 mLength[64]; +}; +nsRect nsTextFrame::ComputeTightBounds(gfxContext* aContext) const +{ + if ((GetStyleContext()->HasTextDecorations() + && eCompatibility_NavQuirks == PresContext()->CompatibilityMode()) + || (GetStateBits() & (nsFrameState(1) << (23)))) + return GetOverflowRect(); + gfxSkipCharsIterator iter = const_cast<nsTextFrame*>(this)->EnsureTextRun(); + PropertyProvider provider(const_cast<nsTextFrame*>(this), iter); +} diff --git a/gcc/testsuite/g++.dg/torture/pr44826.C b/gcc/testsuite/g++.dg/torture/pr44826.C new file mode 100644 index 000000000..aece14070 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44826.C @@ -0,0 +1,44 @@ +typedef unsigned short PRUint16; +typedef PRUint16 PRUnichar; +template <class CharT> struct nsCharTraits { +}; +class nsAString_internal { +public: + typedef PRUnichar char_type; +}; +class nsString : public nsAString_internal { +public: + typedef nsString self_type; + nsString( const self_type& str ); +}; +class nsDependentString : public nsString { +public: + explicit nsDependentString( const char_type* data ); +}; +typedef struct sqlite3_stmt sqlite3_stmt; +const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +class nsIVariant { }; +template <typename DataType> struct variant_storage_traits { + typedef DataType ConstructorType; + typedef DataType StorageType; + static inline StorageType storage_conversion(ConstructorType aData) { + return aData; + } +}; +template <typename DataType> class Variant : public nsIVariant { +public: + Variant(typename variant_storage_traits<DataType>::ConstructorType aData) + : mData(variant_storage_traits<DataType>::storage_conversion(aData)) {} + typename variant_storage_traits<DataType>::StorageType mData; +}; +typedef Variant<nsString> TextVariant; +class Row { + void initialize(sqlite3_stmt *aStatement); +}; +void Row::initialize(sqlite3_stmt *aStatement) +{ + nsDependentString str(static_cast<const PRUnichar +*>(::sqlite3_column_text16(aStatement, 0))); + new TextVariant(str); +} + diff --git a/gcc/testsuite/g++.dg/torture/pr44900.C b/gcc/testsuite/g++.dg/torture/pr44900.C new file mode 100644 index 000000000..ad150d7fb --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44900.C @@ -0,0 +1,76 @@ +/* { dg-do run { target i?86-*-* x86_64-*-* } } */ +/* { dg-options "-msse" } */ +/* { dg-require-effective-target sse_runtime } */ + +typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__)); +typedef float __v4sf __attribute__ ((__vector_size__ (16))); + +extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, +__artificial__)) +_mm_set_ps (const float __Z, const float __Y, const float __X, const float __W) +{ + return __extension__ (__m128)(__v4sf){ __W, __X, __Y, __Z }; +} + +struct vec +{ + union { + __m128 v; + float e[4]; + }; + + static const vec & zero() + { + static const vec v = _mm_set_ps(0, 0, 0, 0); + return v; + } + + vec() {} + vec(const __m128 & a) : v(a) {} + + operator const __m128&() const { return v; } +}; + +struct vec2 +{ + vec _v1; + vec _v2; + + vec2() {} + vec2(const vec & a, const vec & b) : _v1(a), _v2(b) {} + + static vec2 load(const float * a) + { + return vec2( + __builtin_ia32_loadups(&a[0]), + __builtin_ia32_loadups(&a[4])); + } + + const vec & v1() const { return _v1; } + const vec & v2() const { return _v2; } +}; + +extern "C" void abort(void); + + +inline bool operator==(const vec & a, const vec & b) +{ return 0xf == __builtin_ia32_movmskps(__builtin_ia32_cmpeqps(a, b)); } + +int main( int argc, char * argv[] ) +{ + __attribute__((aligned(16))) float data[] = + { 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5 }; + + float * p = &data[2]; + vec2 a; + + a = vec2::load(p); + + vec v1 = a.v1(); + vec v2 = a.v2(); + + if (v2.e[3] != 7.0) + abort(); + + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr44915.C b/gcc/testsuite/g++.dg/torture/pr44915.C new file mode 100644 index 000000000..ba7e96606 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44915.C @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-findirect-inlining" } */ + +struct A; + +typedef void (A::*f_ptr) (); + +void dummy (f_ptr) { } + +void call_dummy (f_ptr cb) +{ + dummy (cb); +} diff --git a/gcc/testsuite/g++.dg/torture/pr44972.C b/gcc/testsuite/g++.dg/torture/pr44972.C new file mode 100644 index 000000000..e409148da --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44972.C @@ -0,0 +1,142 @@ +/* { dg-do compile } */ + +#include<cassert> +#include<new> +#include<utility> + +namespace boost { + +template<class T> +class optional; + +class aligned_storage +{ + char data[ 1000 ]; + public: + void const* address() const { return &data[0]; } + void * address() { return &data[0]; } +} ; + + +template<class T> +class optional_base +{ + protected : + optional_base(){} + optional_base ( T const& val ) + { + construct(val); + } + + template<class U> + void assign ( optional<U> const& rhs ) + { + if (!is_initialized()) + if ( rhs.is_initialized() ) + construct(T()); + } + + public : + + bool is_initialized() const { return m_initialized ; } + + protected : + + void construct ( T const& val ) + { + new (m_storage.address()) T(val) ; + } + + T const* get_ptr_impl() const + { return static_cast<T const*>(m_storage.address()); } + + private : + + bool m_initialized ; + aligned_storage m_storage ; +} ; + + +template<class T> +class optional : public optional_base<T> +{ + typedef optional_base<T> base ; + + public : + + optional() : base() {} + optional ( T const& val ) : base(val) {} + optional& operator= ( optional const& rhs ) + { + this->assign( rhs ) ; + return *this ; + } + + T const& get() const ; + + T const* operator->() const { assert(this->is_initialized()) ; return this->get_ptr_impl() ; } + +} ; + + +} // namespace boost + + +namespace std +{ + + template<typename _Tp, std::size_t _Nm> + struct array + { + typedef _Tp value_type; + typedef const value_type* const_iterator; + + value_type _M_instance[_Nm]; + + }; +} + + +class NT +{ + double _inf, _sup; +}; + + +template < typename T > inline +std::array<T, 1> +make_array(const T& b1) +{ + std::array<T, 1> a = { { b1 } }; + return a; +} + +class V +{ + typedef std::array<NT, 1> Base; + Base base; + +public: + V() {} + V(const NT &x) + : base(make_array(x)) {} + +}; + +using boost::optional ; + +optional< std::pair< NT, NT > > + linsolve_pointC2() ; + +optional< V > construct_normal_offset_lines_isecC2 ( ) +{ + optional< std::pair<NT,NT> > ip; + + ip = linsolve_pointC2(); + + V a(ip->first) ; + return a; +} + + + diff --git a/gcc/testsuite/g++.dg/torture/pr45393.C b/gcc/testsuite/g++.dg/torture/pr45393.C new file mode 100644 index 000000000..5bf16b034 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45393.C @@ -0,0 +1,38 @@ +// { dg-do compile } + +class FloatPoint; +class Path { +public: + ~Path(); + void moveTo(const FloatPoint&); + static void createEllipse(const FloatPoint& center, float rx, float ry); +}; +extern "C" { + extern float cosf (float); + extern float sinf (float); +} +const float piFloat = static_cast<float>(3.14159265358979323846); +class FloatPoint { +public: + FloatPoint(float x, float y) : m_x(x), m_y(y) { } + float x() const; + float y() const; + float m_x, m_y; +}; +void Path::createEllipse(const FloatPoint& center, float rx, float ry) +{ + float cx = center.x(); + float cy = center.y(); + Path path; + float x = cx; + float y = cy; + unsigned step = 0, num = 100; + while (1) { + float angle = static_cast<float>(step) / num * 2.0f * piFloat; + x = cx + cosf(angle) * rx; + y = cy + sinf(angle) * ry; + step++; + if (step == 1) + path.moveTo(FloatPoint(x, y)); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr45580.C b/gcc/testsuite/g++.dg/torture/pr45580.C new file mode 100644 index 000000000..c3af4910a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45580.C @@ -0,0 +1,50 @@ +// { dg-do compile } + +namespace std { + typedef __SIZE_TYPE__ size_t; +} +inline void* operator new(std::size_t, void* __p) throw() { + return __p; +} +class Noncopyable { }; +struct CollectorCell { }; +template<typename T> class PassRefPtr { +public: + T* releaseRef() const { } +}; +template <typename T> class NonNullPassRefPtr { +public: + template <class U> NonNullPassRefPtr(const PassRefPtr<U>& o) + : m_ptr(o.releaseRef()) { } + mutable T* m_ptr; +}; +struct ClassInfo; +class JSValue { }; +JSValue jsNull(); +class Structure; +class JSGlobalData { + static void storeVPtrs(); +}; +class JSCell : public Noncopyable { + friend class JSObject; + friend class JSGlobalData; + virtual ~JSCell(); +}; +class JSObject : public JSCell { +public: + explicit JSObject(NonNullPassRefPtr<Structure>); + static PassRefPtr<Structure> createStructure(JSValue prototype) { } +}; +class JSByteArray : public JSObject { + friend class JSGlobalData; + enum VPtrStealingHackType { VPtrStealingHack }; + JSByteArray(VPtrStealingHackType) + : JSObject(createStructure(jsNull())), m_classInfo(0) { } + const ClassInfo* m_classInfo; +}; +void JSGlobalData::storeVPtrs() { + CollectorCell cell; + void* storage = &cell; + JSCell* jsByteArray = new (storage) JSByteArray(JSByteArray::VPtrStealingHack); + jsByteArray->~JSCell(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr45699.C b/gcc/testsuite/g++.dg/torture/pr45699.C new file mode 100644 index 000000000..828c1ef8e --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45699.C @@ -0,0 +1,61 @@ +// { dg-do run } + +extern "C" void abort (); + +class A +{ +public: + virtual void foo () {abort();} +}; + +class B : public A +{ +public: + int z; + virtual void foo () {abort();} +}; + +class C : public A +{ +public: + void *a[32]; + unsigned long b; + long c[32]; + + virtual void foo () {abort();} +}; + +class D : public C, public B +{ +public: + D () : C(), B() + { + int i; + for (i = 0; i < 32; i++) + { + a[i] = (void *) 0; + c[i] = 0; + } + b = 0xaaaa; + } + + virtual void foo (); +}; + +void D::foo() +{ + if (b != 0xaaaa) + abort(); +} + +static inline void bar (B &b) +{ + b.foo (); +} + +int main() +{ + D d; + bar (d); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr45709-2.C b/gcc/testsuite/g++.dg/torture/pr45709-2.C new file mode 100644 index 000000000..1f6a2344f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45709-2.C @@ -0,0 +1,20 @@ +// { dg-do compile } + +struct Region { + int storage[4]; + int count; +}; +static inline Region subtract(int lhs) +{ + Region reg; + int* storage = reg.storage; + int* storage2 = reg.storage; + if (lhs > 0) + storage++, storage2--; + reg.count = storage - reg.storage + storage2 - reg.storage; + return reg; +} +void bar(int a) +{ + const Region copyBack(subtract(a)); +} diff --git a/gcc/testsuite/g++.dg/torture/pr45709.C b/gcc/testsuite/g++.dg/torture/pr45709.C new file mode 100644 index 000000000..1584ec76a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45709.C @@ -0,0 +1,19 @@ +// { dg-do compile } + +struct Region { + int storage[4]; + int count; +}; +static inline Region subtract(int lhs) +{ + Region reg; + int* storage = reg.storage; + if (lhs > 0) + storage++; + reg.count = storage - reg.storage; + return reg; +} +void bar(int a) +{ + const Region copyBack(subtract(a)); +} diff --git a/gcc/testsuite/g++.dg/torture/pr45843.C b/gcc/testsuite/g++.dg/torture/pr45843.C new file mode 100644 index 000000000..f77b8cb01 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45843.C @@ -0,0 +1,28 @@ +// PR target/45843 +// { dg-do run } + +#include <stdarg.h> + +extern "C" void abort (); +struct S { struct T { } a[14]; char b; }; +struct S arg, s; + +void +foo (int z, ...) +{ + char c; + va_list ap; + va_start (ap, z); + c = 'a'; + arg = va_arg (ap, struct S); + if (c != 'a') + abort (); + va_end (ap); +} + +int +main () +{ + foo (1, s); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr45854.C b/gcc/testsuite/g++.dg/torture/pr45854.C new file mode 100644 index 000000000..17ee006e0 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45854.C @@ -0,0 +1,30 @@ +// { dg-do compile } + +template < typename = void > +struct X { } ; +struct Y +{ + Y () ; +} ; +template < typename = X < > > +struct T +{ + void f () + { + f () ; + } +} ; +struct S +{ + S ( X < > = X < > ()) ; + ~S () + { + T < > () . f () ; + } +} ; +struct Z +{ + S s ; + Y y ; +} a ; + diff --git a/gcc/testsuite/g++.dg/torture/pr45874.C b/gcc/testsuite/g++.dg/torture/pr45874.C new file mode 100644 index 000000000..70965ff57 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45874.C @@ -0,0 +1,58 @@ +// { dg-do compile } + +typedef struct { +} IppLibraryVersion; +typedef unsigned char Ipp8u; +typedef unsigned int Ipp32u; +typedef signed int Ipp32s; +typedef enum e_vm_Status { + VM_OK = 0, VM_OPERATION_FAILED =-999, VM_NOT_INITIALIZED =-998, VM_TIMEOUT =-987, VM_NOT_ENOUGH_DATA =-996, VM_NULL_PTR =-995, VM_SO_CANT_LOAD =-994, VM_SO_INVALID_HANDLE =-993, VM_SO_CANT_GET_ADDR =-992 } + vm_status; + typedef Ipp32s Status; + class MediaReceiver { + }; +class MediaBuffer : public MediaReceiver { +}; +struct TrackInfo { +}; +struct Mpeg2TrackInfo : public TrackInfo { +}; +class BitstreamReader { +public: BitstreamReader(void); + virtual ~BitstreamReader(void) { + } + Ipp32u GetBits(Ipp32s iNum); + void SkipBits(Ipp32s iNum); +protected: virtual void Refresh(void); + Ipp32s m_iReadyBits; +}; +class FrameConstructor : public MediaBuffer { +}; +class VideoFrameConstructor : public FrameConstructor { +}; +class Mpeg2FrameConstructor : public VideoFrameConstructor { + static Status ParsePictureHeader(Ipp8u *buf, Ipp32s iLen, Mpeg2TrackInfo *pInfo); +}; +Status Mpeg2FrameConstructor::ParsePictureHeader(Ipp8u *buf, Ipp32s iLen, Mpeg2TrackInfo *pInfo) { + BitstreamReader bs; + bs.SkipBits(32 + 4 + 4 + 4 + 4 + 4 + 2); + bs.SkipBits(1 + 1 + 1 + 1 + 1 + 1 + 1); + bs.SkipBits(5); + bs.SkipBits(3); + Ipp8u source_format; + bs.SkipBits(22); + bs.SkipBits(8); + if (7 == source_format) { + Ipp8u ufep = (Ipp8u)bs.GetBits(3); + if (0x01 == ufep) { + bs.SkipBits(10); + } + } +} +void BitstreamReader::SkipBits(Ipp32s iNum) { + if (iNum <= m_iReadyBits) { + m_iReadyBits -= iNum; + Refresh(); + } +} +void BitstreamReader::Refresh(void) { } diff --git a/gcc/testsuite/g++.dg/torture/pr45875.C b/gcc/testsuite/g++.dg/torture/pr45875.C new file mode 100644 index 000000000..f1347f543 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45875.C @@ -0,0 +1,25 @@ +// { dg-do compile } + +struct c1 {}; + +struct c10 : c1 +{ + virtual void foo (); +}; + +struct c11 : c10, c1 // // { dg-warning "" } +{ + virtual void f6 (); +}; + +struct c28 : virtual c11 +{ + void f6 (); +}; + +void check_c28 () +{ + c28 obj; + c11 *ptr = &obj; + ptr->f6 (); +} diff --git a/gcc/testsuite/g++.dg/torture/pr45877.C b/gcc/testsuite/g++.dg/torture/pr45877.C new file mode 100644 index 000000000..9af6ae999 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45877.C @@ -0,0 +1,141 @@ +// { dg-do compile } + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + typedef __SIZE_TYPE__ size_t; + template<typename _Alloc> class allocator; + template<class _CharT> struct char_traits; + template<typename _CharT, typename _Traits = char_traits<_CharT>, + typename _Alloc = allocator<_CharT> > + class basic_string; + typedef basic_string<char> string; + template<class _T1, class _T2> struct pair { }; + template<typename _Tp> class allocator { }; + template<typename _Arg1, typename _Arg2, typename _Result> + struct binary_function { + typedef _Arg1 first_argument_type; + typedef _Arg2 second_argument_type; + typedef _Result result_type; + }; + template<typename _CharT, typename _Traits, typename _Alloc> + class basic_string { + public: + basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()); + }; + class type_info { + public: + const char* name() const; + }; + extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) + void * memcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw () + { + return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0)); + } + template <typename _Key, typename _Tp > + class map { + typedef _Key key_type; + typedef _Tp mapped_type; + public: + mapped_type& operator[](const key_type& __k); + }; +} +class CodeAlloc { }; +using namespace std; +typedef void *Stack; +class basicForEachType; +typedef const basicForEachType * aType; +extern map<const string,basicForEachType *> map_type; +class AnyTypeWithOutCheck { }; +typedef AnyTypeWithOutCheck AnyType; +template<typename T> AnyTypeWithOutCheck inline SetAny(const T & x) +{ + AnyTypeWithOutCheck any; + memcpy(&any,&x,sizeof(x)); +} +template<typename T> const T& GetAny(const AnyTypeWithOutCheck & x); +class E_F0; +class C_F0; +class Polymorphic; +typedef E_F0 * Expression; +class basicAC_F0; +extern Polymorphic * TheOperators, * TheRightOperators; +class basicForEachType : public CodeAlloc { +public: + virtual C_F0 CastTo(const C_F0 & e) const ; +}; +class E_F0 :public CodeAlloc { +public: + virtual AnyType operator()(Stack) const =0; +}; +class E_F0mps : public E_F0 { +}; +class ArrayOfaType : public CodeAlloc{ +protected: + aType * t; +}; +class OneOperator : public ArrayOfaType { +public: + OneOperator(aType rr,aType a,aType b); + virtual E_F0 * code(const basicAC_F0 &) const =0; +}; +class Polymorphic: public E_F0mps { +public: + void Add(const char * op,OneOperator * p0 ,OneOperator * p1=0) const; +}; +class C_F0 { +public: + operator E_F0 * () const; +}; +class basicAC_F0 { +public: + const C_F0 & operator [] (int i) const; +}; +struct OneBinaryOperatorMI { }; +struct evalE_F2 { }; +template<typename C,class MI=OneBinaryOperatorMI,class MIx=evalE_F2 > +class OneBinaryOperator : public OneOperator +{ + typedef typename C::result_type R; + typedef typename C::first_argument_type A; + typedef typename C::second_argument_type B; + aType t0,t1; + class Op : public E_F0 { + Expression a,b; + public: + AnyType operator()(Stack s) const { + return SetAny<R>(static_cast<R>(C::f( GetAny<A>((*a)(s)), + GetAny<B>((*b)(s))))); + } + Op(Expression aa,Expression bb) : a(aa),b(bb) { } + }; +public: + E_F0 * code(const basicAC_F0 & args) const { + return new Op(t0->CastTo(args[0]),t1->CastTo(args[1])); + } + OneBinaryOperator() + : OneOperator(map_type[typeid(R).name()], + map_type[typeid(A).name()], + map_type[typeid(B).name()]), t0(t[0]), t1(t[1]) { } +}; +struct NothingType { }; +class ShapeOfArray{ }; +template<class R> class KN_: public ShapeOfArray { }; +template <class T> struct affectation: binary_function<T, T, T> { }; +template<class K,class L,class OP> struct set_A_BI +: public binary_function<KN_<K>,pair<KN_<K>, KN_<L> > *,KN_<K> > +{ + static KN_<K> f(const KN_<K> & a, pair<KN_<K>, KN_<L> > * const & b); +}; +template<class K,class L,class OP> struct set_AI_B +: public binary_function<pair<KN_<K>, KN_<L> > * ,KN_<K>, NothingType > +{ + static NothingType f( pair<KN_<K>, KN_<L> > * const & b,const KN_<K> & a); +}; +template<class K,class Z> void ArrayOperator() +{ + TheOperators->Add("=", new OneBinaryOperator<set_A_BI< K,Z,affectation<K> > >, + new OneBinaryOperator<set_AI_B< K,Z,affectation<K> > >); +} +void initArrayOperatorlong() { + ArrayOperator<long,long>(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr45934.C b/gcc/testsuite/g++.dg/torture/pr45934.C new file mode 100644 index 000000000..f43964107 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr45934.C @@ -0,0 +1,23 @@ +/* { dg-do run } */ + +extern "C" void abort (); + +struct B *b; + +struct B +{ + virtual void f () { } + ~B() { b->f(); } +}; + +struct D : public B +{ + virtual void f () { abort (); } +}; + +int main () +{ + D d; + b = &d; + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr46111.C b/gcc/testsuite/g++.dg/torture/pr46111.C new file mode 100644 index 000000000..df57d8d02 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr46111.C @@ -0,0 +1,32 @@ +// { dg-do compile } +// { dg-require-effective-target pthread } +// { dg-options "-ftree-parallelize-loops=2 -g" } + +struct A +{ + int zero () + { + return 0; + } +}; + +static inline void +bar (int) +{ +} + +struct B +{ + struct A a; + B (int n) + { + for (int i = 0; i < n; i++) + bar (a.zero ()); + } +}; + +void +foo (int n) +{ + struct B b (n); +} diff --git a/gcc/testsuite/g++.dg/torture/pr46149.C b/gcc/testsuite/g++.dg/torture/pr46149.C new file mode 100644 index 000000000..bdc3d7704 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr46149.C @@ -0,0 +1,51 @@ +// { dg-do run } +// { dg-options "-fno-tree-sra" } + +struct S +{ + S ():p ((char *) __builtin_calloc (1, 1)) + { + } + char *p; +}; + +template < class T > struct A +{ + A (const S & __m1, const T & __m2):m1 (__m1), m2 (__m2) + { + } + const S & m1; + const T & m2; +}; + +struct B:A < S > +{ + B (const S & __v):A < S > (__v, __v) + { + } +}; + +struct C:A < B > +{ + C (const S & __e1, const B & __e2):A < B > (__e1, __e2) + { + } +}; + +struct D +{ + D (const C & __c):c (__c) + { + } + const C c; +}; + +int +main () +{ + S s; + B b (s); + C c (s, b); + D d (c); + return d.c.m2.m2.p[0]; +} diff --git a/gcc/testsuite/g++.dg/torture/pr46154.C b/gcc/testsuite/g++.dg/torture/pr46154.C new file mode 100644 index 000000000..424b1fad8 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr46154.C @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-fipa-cp-clone" } */ + +struct S +{ + virtual int foo () + { + return foo () == 0; + } + virtual void baz (); +}; + +void A () +{ + S s; + s.foo (); +} diff --git a/gcc/testsuite/g++.dg/torture/pr46287.C b/gcc/testsuite/g++.dg/torture/pr46287.C new file mode 100644 index 000000000..fd201c48d --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr46287.C @@ -0,0 +1,66 @@ +// Check that indirect calls to thunks do not lead to errors. +// { dg-do run } + +extern "C" void abort (); + +class A +{ +public: + virtual void foo () {abort();} +}; + +class B : public A +{ +public: + int z; + virtual void foo () {abort();} +}; + +class C : public A +{ +public: + void *a[32]; + unsigned long b; + long c[32]; + + virtual void foo () {abort();} +}; + +class D : public C, public B +{ +public: + D () : C(), B() + { + int i; + for (i = 0; i < 32; i++) + { + a[i] = (void *) 0; + c[i] = 0; + } + b = 0xaaaa; + } + + virtual void foo (); +}; + +void D::foo() +{ + if (b != 0xaaaa) + abort(); +} + +static inline void bar (B &b) +{ + + b.foo (); +} + +int main() +{ + int i; + D d; + + for (i = 0; i < 5000; i++) + bar (d); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr46364.C b/gcc/testsuite/g++.dg/torture/pr46364.C new file mode 100644 index 000000000..8098991ac --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr46364.C @@ -0,0 +1,20 @@ +// { dg-do compile } +#include <string> + +void a() throw (int); +void b(std::string const &); + +void c(std::string *e) +{ + b(""); + + try { + a(); + } catch (...) { + *e = ""; + } +} + +void d() { + c(0); +} diff --git a/gcc/testsuite/g++.dg/torture/pr46367.C b/gcc/testsuite/g++.dg/torture/pr46367.C new file mode 100644 index 000000000..260b5c113 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr46367.C @@ -0,0 +1,11 @@ +#pragma interface +struct S +{ + S *s; + ~S () + { + delete s; + } +}; + +S s; diff --git a/gcc/testsuite/g++.dg/torture/pr46383.C b/gcc/testsuite/g++.dg/torture/pr46383.C new file mode 100644 index 000000000..2b610394b --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr46383.C @@ -0,0 +1,252 @@ +// { dg-do compile } + +namespace std { +template<class,class>struct pair{}; + template<typename _Tp> struct _Vector_base { + struct _Vector_impl + { + _Tp* _M_start; + _Tp* _M_finish; + _Tp* _M_end_of_storage; + }; + _Vector_impl _M_impl; + }; + template<typename _Tp > + struct vector : _Vector_base<_Tp> + { + vector(const vector& __x); + }; +} +namespace boost { +struct G{}; +template <class T, class U > +struct modable2 +: G +{ }; +} +namespace CGAL { +struct Rep { }; +struct Handle +{ + Handle() ; + Handle(const Handle& x) ; + Rep* PTR; +}; +template <typename ET_> class Lazy_exact_nt + : Handle + , boost::modable2< Lazy_exact_nt<ET_>, int > + , boost::modable2< Lazy_exact_nt<ET_>, double > +{ }; + struct CC_iterator { }; +struct Triangulation_data_structure_3 { + typedef CC_iterator Vertex_handle; + typedef CC_iterator Cell_handle; + typedef std::pair<Cell_handle, int> Facet; +}; +template < class GT, class Tds_ > struct Triangulation_3 { + typedef Tds_ Tds; + typedef typename GT::Point_3 Point; + typedef typename Tds::Facet Facet; + typedef typename Tds::Vertex_handle Vertex_handle; + enum Locate_type { VERTEX=0, EDGE, FACET, CELL, OUTSIDE_CONVEX_HULL, OUTSIDE_AFFINE_HULL }; + Tds _tds; + bool is_infinite(const Facet & f) const ; +}; +template < class Gt, class Tds_ > struct Delaunay_triangulation_3 : public Triangulation_3<Gt, Tds_> { }; + namespace Surface_mesher { enum Verbose_flag { VERBOSE, NOT_VERBOSE }; } +enum Mesher_level_conflict_status { NO_CONFLICT = 0, CONFLICT_BUT_ELEMENT_CAN_BE_RECONSIDERED, CONFLICT_AND_ELEMENT_SHOULD_BE_DROPPED }; +struct Null_mesher_level { + template <typename P, typename Z> Mesher_level_conflict_status test_point_conflict_from_superior(P, Z) ; +}; +template < class Tr, class Derived, class Element, class Previous, class Triangulation_traits > struct Mesher_level { + typedef Tr Triangulation; + typedef typename Triangulation::Point Point; + typedef typename Triangulation::Vertex_handle Vertex_handle; + typedef typename Triangulation_traits::Zone Zone; + typedef Previous Previous_level; + Derived& derived() { return static_cast<Derived&>(*this); } + Previous& previous_level; + Mesher_level(Previous_level& previous) + : previous_level(previous) + { } + Vertex_handle insert(Point p, Zone& z) ; + Zone conflicts_zone(const Point& p, Element e) ; + Element get_next_element() ; + template <class Mesh_visitor> void before_insertion(Element& e, const Point& p, Zone& zone, Mesh_visitor visitor) { + visitor.before_insertion(e, p, zone); + } + template <class Mesh_visitor> void after_insertion(Vertex_handle vh, Mesh_visitor visitor) { + derived().after_insertion_impl(vh); + } + template <class Mesh_visitor> void after_no_insertion(const Element& e, const Point& p, Zone& zone, Mesh_visitor visitor) { + visitor.after_no_insertion(e, p, zone); + } + template <class Mesh_visitor> void refine(Mesh_visitor visitor) + { + Element e = get_next_element(); + const Mesher_level_conflict_status result = try_to_refine_element(e, visitor); + } + template <class Mesh_visitor> Mesher_level_conflict_status try_to_refine_element(Element e, Mesh_visitor visitor) + { + Point p ; + Zone zone = conflicts_zone(p, e); + const Mesher_level_conflict_status result = test_point_conflict(p, zone); + before_insertion(e, p, zone, visitor); + Vertex_handle v = insert(p, zone); + after_insertion(v, visitor); + after_no_insertion(e, p, zone, visitor); + } + Mesher_level_conflict_status test_point_conflict(const Point& p, Zone& zone) + { + return previous_level.test_point_conflict_from_superior(p, zone); + } +}; +struct Null_mesh_visitor { + template <typename E, typename P, typename Z> void before_insertion(E, P, Z) const {} + template <typename E, typename P, typename Z> void after_no_insertion(E, P, Z) const {} +}; +template <class Tr> struct Triangulation_ref_impl { + Triangulation_ref_impl(Tr& t); +}; +template <typename Tr> struct Triangulation_mesher_level_traits_3 +: public Triangulation_ref_impl<Tr> +{ + typedef typename Tr::Facet Facet; + Triangulation_mesher_level_traits_3(Tr& t) + : Triangulation_ref_impl<Tr>(t) + { } + struct Zone { + typedef std::vector<int*> Cells; + typedef std::vector<Facet> Facets; + typedef typename Tr::Locate_type Locate_type; + Locate_type locate_type; + Cells cells; + Facets boundary_facets; + Facets internal_facets; + }; +}; + namespace Surface_mesher { + namespace details { + template <typename Base> struct Triangulation_generator { + typedef typename Base::Complex_2_in_triangulation_3 C2T3; + typedef typename C2T3::Triangulation Triangulation; + typedef Triangulation Type; + typedef Type type; + }; + template <typename Base> struct Facet_generator { + typedef typename Triangulation_generator<Base>::type Tr; + typedef typename Tr::Facet Type; + typedef Type type; + }; + template <typename Base, typename Self, typename Element, typename PreviousLevel = Null_mesher_level> struct Mesher_level_generator { + typedef typename Base::Complex_2_in_triangulation_3 C2T3; + typedef typename C2T3::Triangulation Triangulation; + typedef Triangulation_mesher_level_traits_3<Triangulation> Tr_m_l_traits_3; + typedef Mesher_level <Triangulation, Self, Element, PreviousLevel, Tr_m_l_traits_3> Type; + }; + } + template < class C2T3, class Surface_, class SurfaceMeshTraits, class Criteria_ > struct Surface_mesher_base + : public Triangulation_mesher_level_traits_3<typename C2T3::Triangulation> + { + typedef C2T3 Complex_2_in_triangulation_3; + typedef Surface_ Surface; + typedef SurfaceMeshTraits Surface_mesh_traits; + typedef Criteria_ Criteria; + typedef typename C2T3::Triangulation Tr; + typedef typename Tr::Vertex_handle Vertex_handle; + typedef typename Tr::Facet Facet; + Surface_mesher_base (C2T3& co, const Surface& s, const Surface_mesh_traits& mesh_traits, const Criteria& c) +: Triangulation_mesher_level_traits_3<Tr>(co.triangulation()), c2t3(co), tr(co.triangulation()), surf(s), meshtraits(mesh_traits), criteria(c) + { } + C2T3& c2t3; + Tr& tr; + const Surface& surf; + const Surface_mesh_traits& meshtraits; + const Criteria& criteria; + void after_insertion_impl(const Vertex_handle& v) { + after_insertion_handle_opposite_facet (Facet ()); + after_insertion_handle_incident_facet (Facet ()); + } + void after_insertion_handle_incident_facet (const Facet& f) { + tr.is_infinite(f) ; + new_facet<false>(f); + } + template <bool remove_from_complex_if_not_in_restricted_Delaunay> void new_facet (const Facet& f) ; + void after_insertion_handle_opposite_facet (const Facet& f) { + after_insertion_handle_incident_facet (f); + } + }; + template < typename Base, typename Element = typename details::Facet_generator<Base>::type, typename PreviousLevel = Null_mesher_level, Verbose_flag verbose = NOT_VERBOSE > struct Surface_mesher + : public Base , public details::Mesher_level_generator< Base, Surface_mesher<Base, Element, PreviousLevel, verbose>, Element, PreviousLevel >::Type + { + typedef typename Base::Complex_2_in_triangulation_3 C2T3; + typedef typename Base::Surface Surface; + typedef typename Base::Criteria Criteria; + typedef typename Base::Surface_mesh_traits Surface_mesh_traits; + typedef typename details::Mesher_level_generator< Base, Surface_mesher<Base, Element, PreviousLevel, verbose>, Element, PreviousLevel >::Type Mesher_lvl; + using Mesher_lvl::refine; + Null_mesher_level null_mesher_level; + Null_mesh_visitor null_visitor; + bool initialized; + Surface_mesher(C2T3& c2t3, const Surface& surface, const Surface_mesh_traits& mesh_traits, const Criteria& criteria) + : Base(c2t3, surface, mesh_traits, criteria), Mesher_lvl(null_mesher_level), initialized(false) + { } + void refine_mesh () { + refine(null_visitor); + } + }; + } +template <typename Surface> struct Surface_mesh_traits_generator_3 { + typedef typename Surface::Surface_mesher_traits_3 Type; + typedef Type type; +}; +template < class Tr, typename Edge_info_ = void > struct Complex_2_in_triangulation_3 { + typedef Tr Triangulation; + Triangulation& triangulation(); +}; +template <class Tr> struct Surface_mesh_complex_2_in_triangulation_3 +: public Complex_2_in_triangulation_3<Tr> +{ }; + struct Non_manifold_tag {}; + template < typename C2T3, typename SurfaceMeshTraits_3, typename Criteria, typename Tag > struct Make_surface_mesh_helper { + typedef Surface_mesher::Surface_mesher_base< C2T3, typename SurfaceMeshTraits_3::Surface_3, SurfaceMeshTraits_3, Criteria> Mesher_base; + }; + template <typename C2T3, typename SurfaceMeshTraits_3, typename Criteria, typename Tag, Surface_mesher::Verbose_flag verbosity = Surface_mesher::NOT_VERBOSE > struct Surface_mesher_generator { + typedef typename Make_surface_mesh_helper< C2T3, SurfaceMeshTraits_3, Criteria, Tag>::Mesher_base Mesher_base; + typedef Surface_mesher::Surface_mesher< Mesher_base, typename Surface_mesher::details::Facet_generator<Mesher_base>::type, Null_mesher_level, verbosity> Mesher; + typedef Mesher type; + }; +template <typename C2T3, typename SurfaceMeshTraits_3, typename Criteria> void make_surface_mesh(C2T3& c2t3, const typename SurfaceMeshTraits_3::Surface_3& surface, const SurfaceMeshTraits_3& surface_mesh_traits, const Criteria& criteria) { + typedef typename Surface_mesher_generator< C2T3, SurfaceMeshTraits_3, Criteria, Non_manifold_tag, Surface_mesher::NOT_VERBOSE >::type Mesher; + Mesher mesher(c2t3, surface, surface_mesh_traits, criteria); + mesher.refine_mesh(); +} +template <class Kernel> struct Surface_mesh_triangulation_generator_3 { + typedef CGAL::Triangulation_data_structure_3 Tds; + typedef CGAL::Delaunay_triangulation_3<Kernel, Tds> Type; +}; + namespace Surface_mesher { + namespace { struct Return_min { }; } + template < class GT, class Surface, class Unused = Return_min > struct Implicit_surface_oracle_3 { + typedef Surface Surface_3; + }; + } + template< typename GT> struct Implicit_surface_3 { + typedef GT Geom_traits; + typedef Implicit_surface_3<Geom_traits > Self; + typedef Surface_mesher::Implicit_surface_oracle_3< Geom_traits, Self> Surface_mesher_traits_3; + }; +} +struct K { +struct Point_3 { +CGAL::Lazy_exact_nt<double> a[3]; +}; +}; +typedef CGAL::Surface_mesh_triangulation_generator_3<K>::Type Tr; +typedef CGAL::Surface_mesh_complex_2_in_triangulation_3<Tr> C2T3; +typedef CGAL::Implicit_surface_3<K > Surface; +typedef CGAL::Surface_mesh_traits_generator_3<Surface>::type Traits; +void f() { + C2T3 c2t3 ; + CGAL::make_surface_mesh(c2t3, Surface(), Traits(), 3); +} diff --git a/gcc/testsuite/g++.dg/torture/pr46469.C b/gcc/testsuite/g++.dg/torture/pr46469.C new file mode 100644 index 000000000..8212ea4f9 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr46469.C @@ -0,0 +1,13 @@ +extern "C" __inline __attribute__ ((__gnu_inline__)) int pthread_equal () + { + } + +static + __typeof + (pthread_equal) + __gthrw_pthread_equal __attribute__ ((__weakref__ ("pthread_equal"))); + +int identifierByPthreadHandle () +{ + pthread_equal (); +} diff --git a/gcc/testsuite/g++.dg/torture/pr47290.C b/gcc/testsuite/g++.dg/torture/pr47290.C new file mode 100644 index 000000000..b739de5b7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr47290.C @@ -0,0 +1,19 @@ +// PR tree-optimization/47290 +// { dg-do compile } + +struct V +{ + V (int = 0); + ~V () + { + for (;;) + ; + } + int size (); +}; + +struct S +{ + V a, b; + S () : b (a.size ()) {} +} s; diff --git a/gcc/testsuite/g++.dg/torture/pr47313.C b/gcc/testsuite/g++.dg/torture/pr47313.C new file mode 100644 index 000000000..c10f558a3 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr47313.C @@ -0,0 +1,53 @@ +// { dg-do compile } + +namespace internal { + template < class DSC, bool Const > struct CC_iterator { + typedef CC_iterator iterator; + typedef typename DSC::value_type value_type; + typedef const value_type* pointer; + CC_iterator () ; + CC_iterator (const iterator &it) { + } + pointer p; + pointer operator->() const ; + }; +} +template < class T > struct Compact_container { + typedef Compact_container <T> Self; + typedef T value_type; + typedef internal::CC_iterator<Self, false> iterator; +}; +template < typename TDS = void > struct Periodic_3_triangulation_ds_cell_base_3 { + typedef typename TDS::Vertex_handle Vertex_handle; + const Vertex_handle& vertex(int i) const { + } +}; +struct Triangulation_data_structure_3 { + typedef Triangulation_data_structure_3 Tds; + typedef Periodic_3_triangulation_ds_cell_base_3<Tds> Cell; + typedef Compact_container<Cell> Cell_range; + typedef Compact_container<int> Vertex_range; + typedef typename Cell_range::iterator Cell_handle; + typedef typename Vertex_range::iterator Vertex_handle; +}; +typedef Triangulation_data_structure_3 TDS1; +template < class > struct Periodic_3_Delaunay_triangulation_3 { + typedef TDS1::Vertex_handle Vertex_handle; + typedef TDS1::Cell_handle Cell_handle; + int compare_distance() const { + } + Vertex_handle nearest_vertex() const; +}; +template < class Tds > typename Periodic_3_Delaunay_triangulation_3<Tds>::Vertex_handle Periodic_3_Delaunay_triangulation_3<Tds>::nearest_vertex() const { + Cell_handle c ; + Vertex_handle nearest = c->vertex(0); + nearest = (compare_distance() == -1) ? nearest : c->vertex(0); + return nearest; +} +typedef Periodic_3_Delaunay_triangulation_3<TDS1> PDT1; +struct Periodic_3_triangulation_hierarchy_3 : PDT1 { + Vertex_handle nearest_vertex() const; +}; +Periodic_3_triangulation_hierarchy_3::Vertex_handle Periodic_3_triangulation_hierarchy_3:: nearest_vertex() const { + return PDT1::nearest_vertex(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr47382.C b/gcc/testsuite/g++.dg/torture/pr47382.C new file mode 100644 index 000000000..a12dbe3fd --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr47382.C @@ -0,0 +1,30 @@ +// { dg-do run } + +extern "C" void abort (); + +struct A +{ + inline ~A (); + virtual void foo () {} +}; + +struct B : A +{ + virtual void foo () { abort(); } +}; + +static inline void middleman (A *a) +{ + a->foo (); +} + +inline A::~A () +{ + middleman (this); +} + +int main () +{ + B b; + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr47541.C b/gcc/testsuite/g++.dg/torture/pr47541.C new file mode 100644 index 000000000..350a05192 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr47541.C @@ -0,0 +1,27 @@ +/* { dg-do run } */ + +struct Dummy {}; +struct RefCount : public Dummy { + ~RefCount(); /* Has to be non-pod. */ + int *a; + int *b; +}; +RefCount::~RefCount(){} +struct Wrapper : public Dummy { RefCount ref; }; +void __attribute__((noinline,noclone)) +Push(Wrapper ptr) +{ + *ptr.ref.b = 0; +} +extern "C" void abort (void); +int main() +{ + int a = 1, b = 1; + Wrapper x; + x.ref.a = &a; + x.ref.b = &b; + Push(x); + if (b != 0) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr47559.C b/gcc/testsuite/g++.dg/torture/pr47559.C new file mode 100644 index 000000000..42dedee29 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr47559.C @@ -0,0 +1,8 @@ +// { dg-do compile } +// { dg-options "-std=c++0x -fnon-call-exceptions" } + +void foo (int *k) noexcept +{ + for (;;) + *k = 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr47714.C b/gcc/testsuite/g++.dg/torture/pr47714.C new file mode 100644 index 000000000..4ff2eeef0 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr47714.C @@ -0,0 +1,16 @@ +struct A { virtual ~A () {} }; +struct B { virtual ~B () {} }; +struct C { virtual const A *foo (int) const = 0; }; +struct E : public B, public A { }; +struct F : public C +{ + virtual const E *foo (int) const; +}; +void bar (int &); + +const E * +F::foo (int x) const +{ + bar (x); + return __null; +} diff --git a/gcc/testsuite/g++.dg/torture/pr48165.C b/gcc/testsuite/g++.dg/torture/pr48165.C new file mode 100644 index 000000000..a42893f60 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr48165.C @@ -0,0 +1,38 @@ +/* { dg-do compile } */ + +typedef __SIZE_TYPE__ size_t; + +extern "C" { + extern __inline __attribute__ ((__always_inline__)) + __attribute__ ((__gnu_inline__, __artificial__)) void * + memcpy (void *__restrict __dest, __const void *__restrict __src, + size_t __len) throw () + { + return __builtin___memcpy_chk (__dest, __src, __len, + __builtin_object_size (__dest, 0)); + } +} + +typedef char TCODE[20]; +typedef TCODE TCODE_ARRAY[5]; +typedef struct PARAM +{ + TCODE_ARRAY tcode; +} PARAM; + +static void foo (void* p) +{ + char buffer[4+sizeof(PARAM)]; + PARAM *param = (PARAM *)(buffer + 4); + int i; + + for (i=0; i < 5; i++) + { + memcpy( param->tcode[i], p, 20 ); + } +} + +void bar (void* p) +{ + foo (p); +} diff --git a/gcc/testsuite/g++.dg/torture/pr48661.C b/gcc/testsuite/g++.dg/torture/pr48661.C new file mode 100644 index 000000000..8de2142f7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr48661.C @@ -0,0 +1,77 @@ +// PR middle-end/48661 +// { dg-do run } + +extern "C" void abort (); + +__attribute__((noinline)) +double +foo (double x, double y) +{ + asm volatile ("" : : : "memory"); + return x + y; +} + +__attribute__((noinline, noclone)) +void +bar (int x) +{ + if (x != 123) + abort (); +} + +struct A +{ + double a1, a2; +}; + +struct B +{ + virtual int m () const = 0 ; +}; + +struct C +{ + virtual ~C () {} +}; + +struct D : virtual public B, public C +{ + explicit D (const A &x) : d(123) { foo (x.a2, x.a1); } + int m () const { return d; } + int d; +}; + +struct E +{ + E () : d(0) {} + virtual void n (const B &x) { d = x.m (); x.m (); x.m (); } + int d; +}; + +void +test () +{ + A a; + a.a1 = 0; + a.a2 = 1; + E p; + D q (a); + const B &b = q; + bar (b.m ()); + p.n (b); + bar (p.d); +} + +void +baz () +{ + A a; + D p2 (a); +} + +int +main () +{ + test (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr48695.C b/gcc/testsuite/g++.dg/torture/pr48695.C new file mode 100644 index 000000000..44e6c771d --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr48695.C @@ -0,0 +1,38 @@ +// { dg-do run } + +typedef __SIZE_TYPE__ size_t; + +inline void *operator new (size_t, void *__p) throw() { return __p; } + +struct _Vector_impl +{ + int *_M_start; + int *_M_finish; + _Vector_impl () :_M_start (0), _M_finish (0) {} +}; + +struct vector +{ + _Vector_impl _M_impl; + int *_M_allocate (size_t __n) + { + return __n != 0 ? new int[__n] : 0; + } + void push_back () + { + new (this->_M_impl._M_finish) int (); + this->_M_impl._M_finish = + this->_M_allocate (this->_M_impl._M_finish - this->_M_impl._M_start) + 1; + } +}; + +int +main () +{ + for (int i = 0; i <= 1; i++) + for (int j = 0; j <= 1; j++) + { + vector a[2]; + a[i].push_back (); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr49039.C b/gcc/testsuite/g++.dg/torture/pr49039.C new file mode 100644 index 000000000..f576cba42 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr49039.C @@ -0,0 +1,76 @@ +// PR tree-optimization/49039 +// { dg-do run } + +template <class T1, class T2> +struct pair +{ + T1 first; + T2 second; + pair (const T1 & a, const T2 & b):first (a), second (b) {} +}; + +template <class T1, class T2> +inline pair <T1, T2> +make_pair (T1 x, T2 y) +{ + return pair <T1, T2> (x, y); +} + +typedef __SIZE_TYPE__ size_t; +struct S +{ + const char *Data; + size_t Length; + static size_t min (size_t a, size_t b) { return a < b ? a : b; } + static size_t max (size_t a, size_t b) { return a > b ? a : b; } + S () :Data (0), Length (0) { } + S (const char *Str) : Data (Str), Length (__builtin_strlen (Str)) {} + S (const char *data, size_t length) : Data (data), Length (length) {} + bool empty () const { return Length == 0; } + size_t size () const { return Length; } + S slice (size_t Start, size_t End) const + { + Start = min (Start, Length); + End = min (max (Start, End), Length); + return S (Data + Start, End - Start); + } + pair <S, S> split (char Separator) const + { + size_t Idx = find (Separator); + if (Idx == ~size_t (0)) + return make_pair (*this, S ()); + return make_pair (slice (0, Idx), slice (Idx + 1, ~size_t (0))); + } + size_t find (char C, size_t From = 0) const + { + for (size_t i = min (From, Length), e = Length; i != e; ++i) + if (Data[i] == C) + return i; + return ~size_t (0); + } +}; + +void +Test (const char *arg) +{ + S Desc (arg); + while (!Desc.empty ()) + { + pair <S, S> Split = Desc.split ('-'); + S Token = Split.first; + Desc = Split.second; + if (Token.empty ()) + continue; + Split = Token.split (':'); + S Specifier = Split.first; + if (Specifier.empty ()) + __builtin_abort (); + } +} + +int +main () +{ + Test ("-"); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr49115.C b/gcc/testsuite/g++.dg/torture/pr49115.C new file mode 100644 index 000000000..c4cce21ba --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr49115.C @@ -0,0 +1,25 @@ +// { dg-do run } + +extern "C" void abort (void); +struct MyException {}; +struct Data { + int nr; + Data() : nr(66) {} +}; +Data __attribute__((noinline,noclone)) getData(int i) +{ + if (i) throw MyException(); + Data data; + data.nr = i; + return data; +} +int main(int, char **) +{ + Data data; + try { + data = getData(1); + } catch (MyException& e) { + if (data.nr != 66) + abort (); + } +} diff --git a/gcc/testsuite/g++.dg/torture/pr49309.C b/gcc/testsuite/g++.dg/torture/pr49309.C new file mode 100644 index 000000000..a34537792 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr49309.C @@ -0,0 +1,15 @@ +// PR tree-optimization/49309 +// { dg-do compile } +// { dg-options "-fpreprocessed -fmudflap" } + +struct A +{ + int i; + + A(); + A(const A&); +}; + +inline void foo(A a) { a = A(); } + +void bar() { foo(A()); } diff --git a/gcc/testsuite/g++.dg/torture/pr49615.C b/gcc/testsuite/g++.dg/torture/pr49615.C new file mode 100644 index 000000000..98a2f95b8 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr49615.C @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-g" } */ + +template <class T> +static inline bool Dispatch (T* obj, void (T::*func) ()) +{ + (obj->*func) (); +} +class C +{ + bool f (int); + void g (); +}; +bool C::f (int n) +{ + bool b; + switch (n) + { + case 0: + b = Dispatch (this, &C::g); + case 1: + b = Dispatch (this, &C::g); + } +} +void C::g () +{ + for (;;) { } +} + diff --git a/gcc/testsuite/g++.dg/torture/pr49628.C b/gcc/testsuite/g++.dg/torture/pr49628.C new file mode 100644 index 000000000..4bc6543a3 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr49628.C @@ -0,0 +1,37 @@ +/* { dg-do compile } */ + +#include <vector> + +template <int rank, int dim> class Tensor; +template <int dim> class Tensor<1,dim> { +public: + explicit Tensor (const bool initialize = true); + Tensor (const Tensor<1,dim> &); + Tensor<1,dim> & operator = (const Tensor<1,dim> &); + double values[(dim!=0) ? (dim) : 1]; +}; +template <int dim> +inline Tensor<1,dim> & Tensor<1,dim>::operator = (const Tensor<1,dim> &p) +{ + for (unsigned int i=0; i<dim; ++i) + values[i] = p.values[i]; +}; +template <int dim> class Quadrature { +public: + const unsigned int n_quadrature_points; +}; +class MappingQ1 +{ + class InternalData { + public: + std::vector<Tensor<1,3> > shape_derivatives; + unsigned int n_shape_functions; + }; + void compute_data (const Quadrature<3> &quadrature, InternalData &data) + const; +}; +void MappingQ1::compute_data (const Quadrature<3> &q, InternalData &data) const +{ + const unsigned int n_q_points = q.n_quadrature_points; + data.shape_derivatives.resize(data.n_shape_functions * n_q_points); +} diff --git a/gcc/testsuite/g++.dg/torture/pr49644.C b/gcc/testsuite/g++.dg/torture/pr49644.C new file mode 100644 index 000000000..5fb82e017 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr49644.C @@ -0,0 +1,17 @@ +// PR c/49644 +// { dg-do run } + +extern "C" void abort (); + +int +main () +{ + _Complex double a[12], *c = a, s = 3.0 + 1.0i; + double b[12] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }, *d = b; + int i; + for (i = 0; i < 6; i++) + *c++ = *d++ * s; + if (c != a + 6 || d != b + 6) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr49720.C b/gcc/testsuite/g++.dg/torture/pr49720.C new file mode 100644 index 000000000..c5da7ba67 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr49720.C @@ -0,0 +1,8 @@ +/* { dg-do compile } */ + +extern char t_start[], t_end[], t_size[]; +bool foo (void) +{ + long size = reinterpret_cast<long>(t_size); + return (size == t_end - t_start); +} diff --git a/gcc/testsuite/g++.dg/torture/pr50189.C b/gcc/testsuite/g++.dg/torture/pr50189.C new file mode 100644 index 000000000..06f1d3695 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr50189.C @@ -0,0 +1,121 @@ +// { dg-do run } +// { dg-options "-fstrict-enums" } + +extern "C" void abort (void); +class CCUTILS_KeyedScalarLevelPosition +{ +public: + + typedef enum + { + UNINITED = 0, + AT_BEGIN = 1, + AT_END = 2, + AT_KEY = 3 + + } position_t; + + bool is_init() const + { return(m_timestamp != UNINITED); } + + bool is_at_begin() const + { return(m_timestamp == AT_BEGIN); } + + position_t get_state() const + { + return((m_timestamp >= AT_KEY) + ? AT_KEY + : ((position_t)m_timestamp)); + } + + void set_at_begin() + { m_timestamp = AT_BEGIN; } + + unsigned int get_index() const + { return(m_index); } + + void set_pos(unsigned int a_index, unsigned int a_timestmap) + { + m_index = a_index; + m_timestamp = a_timestmap; + } + + bool check_pos(unsigned int a_num_entries, unsigned int a_timestamp) const + { + if (get_state() != AT_KEY) + return(false); + + if (m_timestamp != a_timestamp) + return(false); + + return(m_index < a_num_entries); + } + + void set_not_init() + { m_timestamp = 0; } + +private: + + unsigned int m_timestamp; + unsigned int m_index; + +}; + +class CCUTILS_KeyedScalarPosition +{ +public: + + CCUTILS_KeyedScalarLevelPosition m_L1; + CCUTILS_KeyedScalarLevelPosition m_L2; +}; + +class baz +{ +public: + int *n[20]; + unsigned int m_cur_array_len; + unsigned int m_timestamp; + + unsigned int _get_timestamp() const + { return(m_timestamp); } + + bool _check_L1_pos(const CCUTILS_KeyedScalarPosition &a_position) const + { + return(a_position.m_L1.check_pos( + m_cur_array_len, _get_timestamp())); + } + + void *next (CCUTILS_KeyedScalarPosition &); +}; + +void * baz::next (CCUTILS_KeyedScalarPosition &a_position) +{ + if (a_position.m_L1.is_at_begin() || (!a_position.m_L1.is_init())) + { + a_position.m_L1.set_pos(0, _get_timestamp()); + a_position.m_L2.set_at_begin(); + } + else if (!_check_L1_pos(a_position)) + return(0); + + return n[a_position.m_L1.get_index ()]; +} + +int main (int, char **) +{ + baz obj; + CCUTILS_KeyedScalarPosition a_pos; + void *ret; + int n[5]; + + obj.n[0] = n; + obj.m_cur_array_len = 1; + obj.m_timestamp = 42; + + a_pos.m_L1.set_pos (0, 42); + + ret = obj.next (a_pos); + if (ret == 0) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/pr51344.C b/gcc/testsuite/g++.dg/torture/pr51344.C new file mode 100644 index 000000000..07be919c3 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr51344.C @@ -0,0 +1,11 @@ +/* { dg-do compile { target { i?86-*-* && ilp32 } } } */ +class A; + +template <class T> +class B +{ + friend __attribute__((cdecl)) A& operator >>(A& a, B& b) + { + return a; + } +}; diff --git a/gcc/testsuite/g++.dg/torture/pr55355.C b/gcc/testsuite/g++.dg/torture/pr55355.C new file mode 100644 index 000000000..6d8f8b6be --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr55355.C @@ -0,0 +1,23 @@ +/* { dg-do compile } */ + +struct A +{ + void funcA(void); +}; + +struct B {}; + +struct C +{ + void funcC(void) { a_mp->funcA(); } + + char buf_ma[268435456]; + A *a_mp; + B b_m; +}; + +void +func(C *c_p) +{ + c_p->funcC(); +} diff --git a/gcc/testsuite/g++.dg/torture/pr56403.C b/gcc/testsuite/g++.dg/torture/pr56403.C new file mode 100644 index 000000000..27b6eeb88 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr56403.C @@ -0,0 +1,12 @@ +// PR c++/56403 +// { dg-do compile } + +#include <stdarg.h> + +struct S { va_list err_args; }; + +void * +foo () +{ + return new S (); +} diff --git a/gcc/testsuite/g++.dg/torture/predcom-1.C b/gcc/testsuite/g++.dg/torture/predcom-1.C new file mode 100644 index 000000000..c668cac60 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/predcom-1.C @@ -0,0 +1,29 @@ +/* Test for ICE in predictive commoning with empty loop header block + on arm-none-linux-gnueabi. */ + +struct Foo +{ + double *ptr; + + Foo (double *ptr_) + : ptr (ptr_) + { + } + + Foo PostInc () + { + return Foo (ptr++); + } +}; + +bool Baz (Foo first, double *last) +{ + Foo prev (first.ptr); + + first.ptr++; + + while (first.ptr != last) + if (*first.PostInc ().ptr < *prev.PostInc ().ptr) + return false; +} + diff --git a/gcc/testsuite/g++.dg/torture/pushpop_macro.C b/gcc/testsuite/g++.dg/torture/pushpop_macro.C new file mode 100644 index 000000000..98065e6ee --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pushpop_macro.C @@ -0,0 +1,19 @@ +/* Do the preprocessor push_macro/pop_macro test. */ + +/* { dg-do run } */ + +extern "C" void abort (); + +#define _ 2 +#pragma push_macro("_") +#undef _ +#define _ 1 +#pragma pop_macro("_") + +int main () +{ + if (_ != 2) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/torture/stackalign/check.h b/gcc/testsuite/g++.dg/torture/stackalign/check.h new file mode 100644 index 000000000..af1988512 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/check.h @@ -0,0 +1,36 @@ +#include <stddef.h> +#ifdef DEBUG +#include <stdio.h> +#endif + +#ifdef __cplusplus +extern "C" void abort (void); +#else +extern void abort (void); +#endif + +int +check_int (int *i, int align) +{ + *i = 20; + if ((((ptrdiff_t) i) & (align - 1)) != 0) + { +#ifdef DEBUG + printf ("\nUnalign address (%d): %p!\n", align, i); +#endif + abort (); + } + return *i; +} + +void +check (void *p, int align) +{ + if ((((ptrdiff_t) p) & (align - 1)) != 0) + { +#ifdef DEBUG + printf ("\nUnalign address (%d): %p!\n", align, p); +#endif + abort (); + } +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/eh-alloca-1.C b/gcc/testsuite/g++.dg/torture/stackalign/eh-alloca-1.C new file mode 100644 index 000000000..89b0a6a67 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/eh-alloca-1.C @@ -0,0 +1,57 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +void +foo (int size) throw (B,A) +{ + char *p = (char*) __builtin_alloca (size + 1); + aligned i; + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + throw A(); +} + +int +main() +{ + try { foo (5); } + catch (A& a) { } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/eh-fastcall-1.C b/gcc/testsuite/g++.dg/torture/stackalign/eh-fastcall-1.C new file mode 100644 index 000000000..4b849a2e4 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/eh-fastcall-1.C @@ -0,0 +1,43 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +__attribute__ ((fastcall)) +void +foo (int j, int k, int m, int n, int o) throw (B,A) +{ + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + if (i != 20 || j != 1 || k != 2 || m != 3 || n != 4 || o != 5) + abort (); + + throw A(); +} + +int +main() +{ + try { foo (1, 2, 3, 4, 5); } + catch (A& a) { } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/eh-global-1.C b/gcc/testsuite/g++.dg/torture/stackalign/eh-global-1.C new file mode 100644 index 000000000..cc05ed04f --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/eh-global-1.C @@ -0,0 +1,40 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +void +foo (void) throw (B,A) +{ + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + throw A(); +} + +int +main() +{ + try { foo (); } + catch (A& a) { } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/eh-inline-1.C b/gcc/testsuite/g++.dg/torture/stackalign/eh-inline-1.C new file mode 100644 index 000000000..d2555f2e2 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/eh-inline-1.C @@ -0,0 +1,40 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +static void +inline __attribute__((always_inline)) +foo (void) throw (B,A) +{ + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); + throw A(); +} + +int +main() +{ + try { foo (); } + catch (A& a) { } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/eh-inline-2.C b/gcc/testsuite/g++.dg/torture/stackalign/eh-inline-2.C new file mode 100644 index 000000000..1cbc68cc4 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/eh-inline-2.C @@ -0,0 +1,58 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +static void +inline __attribute__((always_inline)) +foo (int size) throw (B,A) +{ + char *p = (char *) __builtin_alloca (size + 1); + aligned i; + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + throw A(); +} + +int +main() +{ + try { foo (5); } + catch (A& a) { } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/eh-thiscall-1.C b/gcc/testsuite/g++.dg/torture/stackalign/eh-thiscall-1.C new file mode 100644 index 000000000..de9bed55c --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/eh-thiscall-1.C @@ -0,0 +1,43 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +__attribute__ ((thiscall)) +void +foo (int j, int k, int m, int n, int o) throw (B,A) +{ + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + if (i != 20 || j != 1 || k != 2 || m != 3 || n != 4 || o != 5) + abort (); + + throw A(); +} + +int +main() +{ + try { foo (1, 2, 3, 4, 5); } + catch (A& a) { } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/eh-vararg-1.C b/gcc/testsuite/g++.dg/torture/stackalign/eh-vararg-1.C new file mode 100644 index 000000000..b9ba81b12 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/eh-vararg-1.C @@ -0,0 +1,73 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include <stdarg.h> +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +void +foo (const char *fmt, ...) throw (B,A) +{ + va_list arg; + char *p; + aligned i; + int size; + double x; + + va_start (arg, fmt); + size = va_arg (arg, int); + if (size != 5) + abort (); + p = (char *) __builtin_alloca (size + 1); + + x = va_arg (arg, double); + if (x != 5.0) + abort (); + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + throw A(); + + va_end (arg); +} + +int +main() +{ + try { foo ("foo", 5, 5.0); } + catch (A& a) { } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/eh-vararg-2.C b/gcc/testsuite/g++.dg/torture/stackalign/eh-vararg-2.C new file mode 100644 index 000000000..5e282179c --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/eh-vararg-2.C @@ -0,0 +1,79 @@ +/* { dg-options "-Wno-abi" {target arm_eabi} } */ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include <stdarg.h> +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +class Base {}; + +struct A : virtual public Base +{ + A() {} +}; + +struct B {}; + +void +test (va_list arg) throw (B,A) +{ + char *p; + aligned i; + int size; + double x; + + size = va_arg (arg, int); + if (size != 5) + abort (); + + p = (char *) __builtin_alloca (size + 1); + + x = va_arg (arg, double); + if (x != 5.0) + abort (); + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + throw A(); +} + +void +foo (const char *fmt, ...) +{ + va_list arg; + va_start (arg, fmt); + test (arg); + va_end (arg); +} +int +main() +{ + try { foo ("foo", 5, 5.0); } + catch (A& a) { } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/stackalign.exp b/gcc/testsuite/g++.dg/torture/stackalign/stackalign.exp new file mode 100644 index 000000000..3d0609fc4 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/stackalign.exp @@ -0,0 +1,35 @@ +# Copyright (C) 2008, 2010 +# Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# <http://www.gnu.org/licenses/>. + +# This harness is for tests that should be run at all optimisation levels. + +load_lib g++-dg.exp +dg-init +set additional_flags "" + +# If automatic stack alignment is supported, force it on. +if { [check_effective_target_automatic_stack_alignment] } then { + lappend additional_flags "-mstackrealign" + lappend additional_flags "-mpreferred-stack-boundary=5" +} + +gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.C]] $additional_flags +if { [check_effective_target_fpic] } then { + lappend additional_flags "-fpic" + gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.C]] $additional_flags +} +dg-finish diff --git a/gcc/testsuite/g++.dg/torture/stackalign/stdcall-1.C b/gcc/testsuite/g++.dg/torture/stackalign/stdcall-1.C new file mode 100644 index 000000000..393b37e7b --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/stdcall-1.C @@ -0,0 +1,17 @@ +// { dg-do compile { target { { i?86-*-* x86_64-*-* } && ilp32 } } } + +// This case is to detect an assertion failure in stack branch development. + +bool f(); +struct S { + __attribute__ ((stdcall)) ~S(); +}; +void g() { + for (;;) { + S s1, s2, s3; + if (f()) + continue; + if (f()) + return; + } +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/test-unwind.h b/gcc/testsuite/g++.dg/torture/stackalign/test-unwind.h new file mode 100644 index 000000000..ff5602784 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/test-unwind.h @@ -0,0 +1,142 @@ +#include "check.h" + + +#define ASMNAME(cname) ASMNAME2 (__USER_LABEL_PREFIX__, cname) +#define ASMNAME2(prefix, cname) STRING (prefix) cname +#define STRING(x) #x + +#ifdef __cplusplus +extern "C" void abort (void); +#else +extern void abort (void); +#endif + +extern void foo(void); + +#define INIT_EDI 1 +#define INIT_ESI 2 +#define INIT_EBX 3 + +/* Set DI/SI/BX to wrong value + Use following template so that RA will save/restore callee + save registers in prologue/epilogue */ +#define ALTER_REGS() \ + { \ + int dummy; \ + __asm__ __volatile__ (\ + "movl %1, %0" : "=D" (dummy) : "i" (-INIT_EDI)\ + );\ + __asm__ __volatile__ (\ + "movl %1, %0" : "=S" (dummy) : "i" (-INIT_ESI)\ + );\ + __asm__ __volatile__ (\ + "movl %1, %0" : "=b" (dummy) : "i" (-INIT_EBX)\ + );\ + } + +#if defined __PIC__ || defined __USING_SJLJ_EXCEPTIONS__ +int +main () +{ + return 0; +} +#else +void __attribute__ ((noinline)) +copy (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +int g_edi __attribute__((externally_visible)) =INIT_EDI; +int g_esi __attribute__((externally_visible)) =INIT_ESI; +int g_ebx __attribute__((externally_visible)) = INIT_EBX; +int g_ebp __attribute__((externally_visible)); +int g_esp __attribute__((externally_visible)); +int g_ebp_save __attribute__((externally_visible)); +int g_esp_save __attribute__((externally_visible)); +int n_error; + +int +main() +{ + int dummy; + // Init registers to correct value. + // Use following template so that RA will save/restore callee + // save registers in prologue/epilogue + __asm__ __volatile__ ( + "movl %1, %0" + : "=D" (dummy) + : "i" (INIT_EDI) + ); + __asm__ __volatile__ ( + "movl %1, %0" + : "=S" (dummy) + : "i" (INIT_ESI) + ); + __asm__ __volatile__ ( + "movl %1, %0" + : "=b" (dummy) + : "i" (INIT_EBX) + ); + __asm__ __volatile__ ( + "movl %ebp," ASMNAME("g_ebp_save")"\n\t" + "movl %esp," ASMNAME("g_esp_save")"\n\t" + ); + try { + foo(); + } + catch (...) + { + } + + // Get DI/SI/BX register value after exception caught + __asm__ __volatile__ ( + "movl %edi," ASMNAME("g_edi")"\n\t" + "movl %esi," ASMNAME("g_esi")"\n\t" + "movl %ebx," ASMNAME("g_ebx")"\n\t" + "movl %ebp," ASMNAME("g_ebp")"\n\t" + "movl %esp," ASMNAME("g_esp")"\n\t" + ); + + // Check if DI/SI/BX register value are the same as before calling + // foo. + if (g_edi != INIT_EDI) + { + n_error++; +#ifdef DEBUG + printf("edi=%d, correct value:%d\n", g_edi, INIT_EDI); +#endif + } + if (g_esi != INIT_ESI) + { + n_error++; +#ifdef DEBUG + printf("esi=%d, correct value:%d\n", g_esi, INIT_ESI); +#endif + } + if (g_ebx != INIT_EBX) + { + n_error++; +#ifdef DEBUG + printf("ebx=%d, correct value:%d\n", g_ebx, INIT_EBX); +#endif + } + if (g_ebp != g_ebp_save) + { + n_error++; +#ifdef DEBUG + printf("ebp=0x%x, correct value:0x%x\n", g_ebp, g_ebp_save); +#endif + } + if (g_esp != g_esp_save) + { + n_error++; +#ifdef DEBUG + printf("esp=0x%x, correct value:0x%x\n", g_esp, g_esp_save); +#endif + } + if (n_error !=0) + abort(); + return 0; +} +#endif diff --git a/gcc/testsuite/g++.dg/torture/stackalign/throw-1.C b/gcc/testsuite/g++.dg/torture/stackalign/throw-1.C new file mode 100644 index 000000000..3eddc1d02 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/throw-1.C @@ -0,0 +1,62 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int t_align __attribute__((aligned(ALIGNMENT))); + + +int global, global2; +void bar() +{ + volatile t_align a = 1; + int i,j,k,l,m,n; + i=j=k=0; + for (i=0; i < global; i++) + for (j=0; j < i; j++) + for (k=0; k < j; k++) + for (l=0; l < k; l++) + for (m=0; m < l; m++) + for (n=0; n < m; n++) + global2 = k; + if (check_int ((int *) &a, __alignof__(a)) != a) + abort (); + throw 0; +} + +void foo() +{ + bar(); +} + +int main() +{ + int ll = 1; + int i = 0,j = 1,k = 2,l = 3,m = 4,n = 5; + try { + for (; i < global; i++) + for (; j < i; j++) + for (; k < j; k++) + for (; l < k; l++) + for (; m < l; m++) + for (; n < m; n++) + global2 = k; + foo(); + } + catch (...) + { + } + ll = i+j+k+l+m+n; + if (ll != 15) + { +#ifdef DEBUG + printf("FAIL: sum %d != 15\n", ll); +#endif + abort(); + } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/throw-2.C b/gcc/testsuite/g++.dg/torture/stackalign/throw-2.C new file mode 100644 index 000000000..63a8c6e7c --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/throw-2.C @@ -0,0 +1,53 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int t_align __attribute__((aligned(ALIGNMENT))); + + +int global, global2; +void bar() +{ + volatile t_align a = 1; + int i,j,k; + i=j=k=0; + for (i=0; i < global; i++) + for (j=0; j < i; j++) + global2 = k; + if (check_int ((int *) &a, __alignof__(a)) != a) + abort (); + throw 0; +} + +int main() +{ + int ll = 1; + int i = 0,j = 1,k = 2,l = 3,m = 4,n = 5; + try { + for (; i < global; i++) + for (; j < i; j++) + for (; k < j; k++) + for (; l < k; l++) + for (; m < l; m++) + for (; n < m; n++) + global2 = k; + bar (); + } + catch (...) + { + } + ll = i+j+k+l+m+n; + if (ll != 15) + { +#ifdef DEBUG + printf("FAIL: sum %d != 15\n", ll); +#endif + abort(); + } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/throw-3.C b/gcc/testsuite/g++.dg/torture/stackalign/throw-3.C new file mode 100644 index 000000000..d3e53b829 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/throw-3.C @@ -0,0 +1,52 @@ +/* { dg-do run } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int t_align __attribute__((aligned(ALIGNMENT))); + + +int global, global2; +void bar() +{ + volatile t_align a = 1; + int i,j,k; + i=j=k=0; + for (i=0; i < global; i++) + for (j=0; j < i; j++) + global2 = k; + throw 0; + if (check_int ((int *) &a, __alignof__(a)) != a) + abort (); +} + +int main() +{ + int ll = 1; + int i = 0,j = 1,k = 2,l = 3,m = 4,n = 5; + try { + for (; i < global; i++) + for (; j < i; j++) + for (; k < j; k++) + for (; l < k; l++) + for (; m < l; m++) + for (; n < m; n++) + global2 = k; + bar (); + } + catch (...) + { + } + ll = i+j+k+l+m+n; + if (ll != 15) + { +#ifdef DEBUG + printf("FAIL: sum %d != 15\n", ll); +#endif + abort(); + } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/throw-4.C b/gcc/testsuite/g++.dg/torture/stackalign/throw-4.C new file mode 100644 index 000000000..52e6f7ff7 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/throw-4.C @@ -0,0 +1,55 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int t_align __attribute__((aligned(ALIGNMENT))); + + +int global, global2; +void bar() +{ + volatile t_align a = 1; + int i,j,k; + i=j=k=0; + for (i=0; i < global; i++) + for (j=0; j < i; j++) + { + global2 = k; + throw 0; + } + if (check_int ((int *) &a, __alignof__(a)) != a) + abort (); +} + +int main() +{ + int ll = 1; + int i = 0,j = 1,k = 2,l = 3,m = 4,n = 5; + try { + for (; i < global; i++) + for (; j < i; j++) + for (; k < j; k++) + for (; l < k; l++) + for (; m < l; m++) + for (; n < m; n++) + global2 = k; + bar (); + } + catch (...) + { + } + ll = i+j+k+l+m+n; + if (ll != 15) + { +#ifdef DEBUG + printf("FAIL: sum %d != 15\n", ll); +#endif + abort(); + } + return 0; +} diff --git a/gcc/testsuite/g++.dg/torture/stackalign/unwind-0.C b/gcc/testsuite/g++.dg/torture/stackalign/unwind-0.C new file mode 100644 index 000000000..f8166eb95 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/unwind-0.C @@ -0,0 +1,12 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "test-unwind.h" + +#if !defined __PIC__ && !defined __USING_SJLJ_EXCEPTIONS__ +void __attribute__ ((noinline)) foo() +{ + ALTER_REGS(); + // Throw the except and expect returning to main + throw 1; +} +#endif diff --git a/gcc/testsuite/g++.dg/torture/stackalign/unwind-1.C b/gcc/testsuite/g++.dg/torture/stackalign/unwind-1.C new file mode 100644 index 000000000..70dce7485 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/unwind-1.C @@ -0,0 +1,16 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "test-unwind.h" + +#if !defined __PIC__ && !defined __USING_SJLJ_EXCEPTIONS__ +/* Test situation 1: Stack really realign without DRAP */ +void __attribute__ ((noinline)) +foo () +{ + int __attribute__ ((aligned(64))) a=1; + if (check_int (&a, __alignof__(a)) != a) + abort (); + ALTER_REGS(); + throw a; +} +#endif diff --git a/gcc/testsuite/g++.dg/torture/stackalign/unwind-2.C b/gcc/testsuite/g++.dg/torture/stackalign/unwind-2.C new file mode 100644 index 000000000..791eeb551 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/unwind-2.C @@ -0,0 +1,29 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "test-unwind.h" + +#if !defined __PIC__ && !defined __USING_SJLJ_EXCEPTIONS__ +/* Test situation 2: stack really realign with DRAP reg CX */ +void __attribute__ ((noinline)) +foo () +{ + int __attribute__ ((aligned(64))) a=4; + char * s = (char *) __builtin_alloca (a + 1); + + copy (s, a); + if (__builtin_strncmp (s, "good", a) != 0) + { +#ifdef DEBUG + s[a] = '\0'; + printf ("Failed: %s != good\n", s); +#endif + abort (); + } + + if (check_int (&a, __alignof__(a)) != a) + abort (); + + ALTER_REGS(); + throw a; +} +#endif diff --git a/gcc/testsuite/g++.dg/torture/stackalign/unwind-3.C b/gcc/testsuite/g++.dg/torture/stackalign/unwind-3.C new file mode 100644 index 000000000..29dee2d5a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/unwind-3.C @@ -0,0 +1,35 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "test-unwind.h" + +#if !defined __PIC__ && !defined __USING_SJLJ_EXCEPTIONS__ +/* Test situation 3: Stack realign really happen with DRAP reg DI */ +void __attribute__ ((noinline)) __attribute__ ((regparm(3))) +bar (int arg1, int arg2, int arg3) +{ + int __attribute__ ((aligned(64))) a=1; + char * s = (char *) __builtin_alloca (arg3 + 1); + + copy (s, arg3); + if (__builtin_strncmp (s, "good", arg3) != 0) + { +#ifdef DEBUG + s[arg3] = '\0'; + printf ("Failed: %s != good\n", s); +#endif + abort (); + } + + if (check_int (&a, __alignof__(a)) != a) + abort (); + + ALTER_REGS(); + throw arg1+arg2+arg3+a; +} + +void +foo() +{ + bar (1,2,3); +} +#endif diff --git a/gcc/testsuite/g++.dg/torture/stackalign/unwind-4.C b/gcc/testsuite/g++.dg/torture/stackalign/unwind-4.C new file mode 100644 index 000000000..a896176ae --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/unwind-4.C @@ -0,0 +1,17 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "test-unwind.h" + +#if !defined __PIC__ && !defined __USING_SJLJ_EXCEPTIONS__ +volatile int __attribute__ ((aligned(32))) g_a=1; +/* Test situation 4: no Drap and stack realign doesn't really happen */ +void __attribute__ ((noinline)) +foo() +{ + int i; + ALTER_REGS(); + for (i=0; i < 10; i++) + g_a++; + throw g_a; +} +#endif diff --git a/gcc/testsuite/g++.dg/torture/stackalign/unwind-5.C b/gcc/testsuite/g++.dg/torture/stackalign/unwind-5.C new file mode 100644 index 000000000..514e4e77a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/unwind-5.C @@ -0,0 +1,31 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "test-unwind.h" + +#if !defined __PIC__ && !defined __USING_SJLJ_EXCEPTIONS__ +double g_f=1.0; +/* Test situation 5: Stack realign dosn't really happen with DRAP reg CX */ +void __attribute__ ((noinline)) __attribute__ ((regparm(2))) +bar(int arg1, int arg2, int arg3, int arg4) +{ + char * s = (char *) __builtin_alloca (arg4 + 1); + + copy (s, arg4); + if (__builtin_strncmp (s, "good", arg4) != 0) + { +#ifdef DEBUG + s[arg4] = '\0'; + printf ("Failed: %s != good\n", s); +#endif + abort (); + } + ALTER_REGS(); + if (g_f) throw arg1+arg2+arg3+ g_f; +} + +void __attribute__((noinline)) +foo() +{ + bar(1,2,3,4); +} +#endif diff --git a/gcc/testsuite/g++.dg/torture/stackalign/unwind-6.C b/gcc/testsuite/g++.dg/torture/stackalign/unwind-6.C new file mode 100644 index 000000000..a888ca1b5 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/stackalign/unwind-6.C @@ -0,0 +1,31 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "test-unwind.h" + +#if !defined __PIC__ && !defined __USING_SJLJ_EXCEPTIONS__ +double g_f=1.0; +/* Test situation 6: Stack realign dosn't really happen with DRAP reg DI */ +void __attribute__ ((noinline)) __attribute__ ((regparm(3))) +bar(int arg1, int arg2, int arg3, int arg4) +{ + char * s = (char *) __builtin_alloca (arg4 + 1); + + copy (s, arg4); + if (__builtin_strncmp (s, "good", arg4) != 0) + { +#ifdef DEBUG + s[arg4] = '\0'; + printf ("Failed: %s != good\n", s); +#endif + abort (); + } + ALTER_REGS(); + if (g_f) throw arg1+arg2+arg3+ g_f; +} + +void __attribute__((noinline)) +foo() +{ + bar(1,2,3,4); +} +#endif diff --git a/gcc/testsuite/g++.dg/torture/str_empty.C b/gcc/testsuite/g++.dg/torture/str_empty.C new file mode 100644 index 000000000..e24f0b6ac --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/str_empty.C @@ -0,0 +1,15 @@ +// PR c++/31617 +// Segfault in integer_zerop +// Origin: Andrew Pinski <andrew_pinski@playstation.sony.com> +// { dg-do compile } + +struct polynomial { + ~polynomial (); +}; + +void spline_rep1 () +{ + new polynomial[0]; // { dg-bogus "allocating zero-element array" } +} + + diff --git a/gcc/testsuite/g++.dg/torture/type-generic-1.C b/gcc/testsuite/g++.dg/torture/type-generic-1.C new file mode 100644 index 000000000..4d82592af --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/type-generic-1.C @@ -0,0 +1,13 @@ +/* Do the type-generic tests. Unlike pr28796-2.c, we test these + without any fast-math flags. */ + +/* { dg-do run } */ +/* { dg-add-options ieee } */ +/* { dg-skip-if "No Inf/NaN support" { spu-*-* } } */ + +#include "../../gcc.dg/tg-tests.h" + +int main(void) +{ + return main_tests (); +} |