diff options
Diffstat (limited to 'gcc-4.8/gcc/testsuite/g++.dg')
86 files changed, 2097 insertions, 18 deletions
diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/alias-decl-34.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/alias-decl-34.C new file mode 100644 index 000000000..4306ab703 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/alias-decl-34.C @@ -0,0 +1,23 @@ +// PR c++/57222 +// { dg-require-effective-target c++11 } + +template <template <typename T> class Templ> +using Bool = Templ<bool>; + +template <typename T> +class Foo { +private: +public: + template<template<typename U> class Templ> + void method(Bool<Templ> boolTempl); +}; + +template <typename T> +template <template <typename U> class Templ> +void Foo<T>::method(Bool<Templ> boolTempl) { +} + +int main() { + Foo<char> foo; + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/alias-decl-35.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/alias-decl-35.C new file mode 100644 index 000000000..f412b302d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/alias-decl-35.C @@ -0,0 +1,9 @@ +// PR c++/57279 +// { dg-require-effective-target c++11 } + +typedef void fc1() const; // OK +typedef void frr1() &&; // OK +typedef void fcr1() const &; +using fc2 = void() const; // #4 +using frr2 = void() &&; // OK +using fcr2 = void() const &; // #6 diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/auto38.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/auto38.C new file mode 100644 index 000000000..070a39b9e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/auto38.C @@ -0,0 +1,8 @@ +// PR c++/57183 +// { dg-do compile { target c++11 } } +// { dg-options "-Wunused-variable" } + +constexpr float PI_0 = 3.1415926F; +constexpr auto PI_1 = 3.1415926F; +const float PI_2 = 3.1415926F; +const auto PI_3 = 3.1415926F; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-array-ptr8.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-array-ptr8.C new file mode 100644 index 000000000..ee425ea1a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-array-ptr8.C @@ -0,0 +1,54 @@ +// PR c++/57047 +// { dg-require-effective-target c++11 } + +template <typename> +struct A; +template <typename T> +struct A <T &> +{ + typedef T type; +}; +template <typename T> +constexpr T && foo (typename A <T>::type & __t) noexcept +{ + return static_cast <T &&>(__t); +} +template <class T1, class T2> +struct B +{ + T1 t1; + T2 t2; + template <class U> + constexpr B (U && __x, const T2 & __y) : t1 (foo <U> (__x)), t2 (__y) {} +}; +static inline constexpr bool +fn1 (const char c) +{ + return ('0' <= c) && (c <= '9'); +} +static inline constexpr bool +fn2 (const char c) +{ + return (('A' <= c) && (c <= 'Z')) || (('a' <= c) && (c <= 'z')); +} +static constexpr bool +fn3 (const char *const x) +{ + return (x[1] == '\0' && x[0] == ']') ? true : (!fn1 (x[0])) ? false : fn3 (&x[1]); +} +static constexpr bool +fn4 (const char *const x) +{ + return (x[0] == '\0') ? fn3 (&x[1]) : fn4 (&x[1]); +} +static inline constexpr bool +fn5 (const char *const x) +{ + return fn2 (x[0]) ? fn4 (x) : false; +} +struct C final +{ + constexpr C (const char *const t1) : c (fn5 (t1) ? 199 : 69) {} + unsigned c; +}; +B <C, C> p ("a", "b"); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-array5.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-array5.C new file mode 100644 index 000000000..4605b4be9 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-array5.C @@ -0,0 +1,9 @@ +// PR c++/56582 +// { dg-do compile { target c++11 } } + +// Reliable ICE +constexpr int n[3] = {}; +constexpr int k = n[-1]; // { dg-error "negative" } + +// Some random byte +constexpr char c = "foo"[-1000]; // { dg-error "negative" } diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-reinterpret1.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-reinterpret1.C new file mode 100644 index 000000000..30bbc18a1 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/constexpr-reinterpret1.C @@ -0,0 +1,39 @@ +// PR c++/56728 +// { dg-require-effective-target c++11 } + +// { dg-prune-output "error" } + +class B { +public: + static B instance; + class Inner + { + public: + class Wuzi + { + unsigned int m; + } m_Class[3]; + unsigned m_Int[4]; + }; + + constexpr static Inner & getInner() + { + /* I am surprised this is considered a constexpr */ + return *((Inner *)4); + } +}; + +B B::instance; + +class A +{ +public: + constexpr A(B &bridge, B::Inner &bridge2, unsigned char index) + : m_Bridge(bridge), m_Wuz(bridge2.m_Class[index]) + {} + + B &m_Bridge; + B::Inner::Wuzi &m_Wuz; +}; +A works{B::instance, B::getInner(), 3}; +A crashnkill[1]{{B::instance, B::getInner(), 3}}; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype-call1.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype-call1.C new file mode 100644 index 000000000..2616bb090 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype-call1.C @@ -0,0 +1,32 @@ +// PR c++/52748 +// N3276 +// { dg-do compile { target c++11 } } + +struct A; // { dg-error "forward declaration" } +A f(); + +decltype(f()) g1(); // OK +decltype(((f()))) g2b(); // OK +decltype(42,f()) g3(); // OK +decltype(42,45,f()) g3b(); // OK +decltype(42,45,(f())) g3c(); // OK +decltype(42,((45,(f())))) g3c(); // OK + +decltype(f(),42) g4(); // { dg-error "" } +decltype(45,f(),42) g4b(); // { dg-error "" } + +class B +{ + ~B(); // { dg-error "private" } +public: + int i; + void operator[](int); +}; +B h(); + +void i(const B&); + +decltype(h()) g5a(); // OK +decltype(h().i) g5(); // { dg-error "" } +decltype(h()[0]) g6(); // { dg-error "" } +decltype(i(h())) g7(); // { dg-error "" } diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype-call3.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype-call3.C new file mode 100644 index 000000000..27797a2fa --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype-call3.C @@ -0,0 +1,132 @@ +// Testcase for N3276 and operator overloading +// { dg-require-effective-target c++11 } + +struct A; +struct B { + A operator()(int); + A operator[](int); + A operator=(int); + A operator+=(int); + A operator-=(int); + A operator*=(int); + A operator/=(int); + A operator^=(int); + A operator&=(int); + A operator|=(int); + A operator<<=(int); + A operator>>=(int); +}; + +A operator-(B); +A operator+(B); +A operator*(B); +A operator&(B); +A operator!(B); +A operator~(B); +A operator++(B); +A operator--(B); + +A operator+(B,B); +A operator-(B,B); +A operator*(B,B); +A operator/(B,B); +A operator%(B,B); +A operator^(B,B); +A operator&(B,B); +A operator|(B,B); +A operator<(B,B); +A operator>(B,B); +A operator,(B,B); +A operator<<(B,B); +A operator>>(B,B); +A operator==(B,B); +A operator->*(B,B); + +#define TRY(E) static_cast<decltype(E)*>(0) + +template <class B> +void f() +{ + B b; + TRY(b(0)); + TRY(b[0]); + TRY(b=0); + TRY(b+=0); + TRY(b-=0); + TRY(b*=0); + TRY(b/=0); + TRY(b^=0); + TRY(b&=0); + TRY(b|=0); + TRY(b<<=0); + TRY(b>>=0); + + TRY(-b); + TRY(+b); + TRY(*b); + TRY(&b); + TRY(!b); + TRY(~b); + TRY(++b); + TRY(--b); + + TRY(b+b); + TRY(b-b); + TRY(b*b); + TRY(b/b); + TRY(b%b); + TRY(b^b); + TRY(b&b); + TRY(b|b); + TRY(b>b); + TRY(b<b); + TRY((b,b)); + TRY(b<<b); + TRY(b>>b); + TRY(b==b); + TRY(b->*b); +} + +int main() +{ + B b; + TRY(b(0)); + TRY(b[0]); + TRY(b=0); + TRY(b+=0); + TRY(b-=0); + TRY(b*=0); + TRY(b/=0); + TRY(b^=0); + TRY(b&=0); + TRY(b|=0); + TRY(b<<=0); + TRY(b>>=0); + + TRY(-b); + TRY(+b); + TRY(*b); + TRY(&b); + TRY(!b); + TRY(~b); + TRY(++b); + TRY(--b); + + TRY(b+b); + TRY(b-b); + TRY(b*b); + TRY(b/b); + TRY(b%b); + TRY(b^b); + TRY(b&b); + TRY(b|b); + TRY(b>b); + TRY(b<b); + TRY((b,b)); + TRY(b<<b); + TRY(b>>b); + TRY(b==b); + TRY(b->*b); + + f<B>(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype49.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype49.C new file mode 100644 index 000000000..c3174982f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype49.C @@ -0,0 +1,10 @@ +// PR c++/45282 +// { dg-require-effective-target c++11 } + +struct A { int i; }; +int A::*ipm = &A::i; + +template <class T, class U> class assert_same_type; +template <class T> class assert_same_type<T,T> { }; + +assert_same_type<decltype(A().*ipm),int> x2; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype52.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype52.C new file mode 100644 index 000000000..e6b5a4caf --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype52.C @@ -0,0 +1,18 @@ +// PR c++/56450 +// { dg-do compile { target c++11 } } + +template<typename T> +T&& declval(); + +template<typename, typename> +struct is_same +{ static constexpr bool value = false; }; + +template<typename T> +struct is_same<T, T> +{ static constexpr bool value = true; }; + +struct A { static const int dummy = 0; }; + +static_assert(is_same<decltype(declval<A>().dummy), const int>::value, ""); +static_assert(!is_same<decltype(declval<A>().dummy), const int&>::value, ""); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype53.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype53.C new file mode 100644 index 000000000..4580e97b7 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/decltype53.C @@ -0,0 +1,11 @@ +// PR c++/57092 +// { dg-do compile { target c++11 } } + +template <void (*F)(int)> +class B { + decltype(F) v; +}; + +void foo(int) {} + +B<foo> o; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/defaulted42.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/defaulted42.C new file mode 100644 index 000000000..1ac25a90b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/defaulted42.C @@ -0,0 +1,10 @@ +// DR 941 +// { dg-require-effective-target c++11 } + +template <class T> T f(T) = delete; +template<> int f(int) { return 42; } + +int main() +{ + f(42); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/enum24.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/enum24.C new file mode 100644 index 000000000..dd6678e1e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/enum24.C @@ -0,0 +1,57 @@ +// PR c++/56749 +// { dg-require-effective-target c++11 } + +enum normal_enum +{ + not_scoped1, + not_scoped2 +}; + +enum class scoped_enum +{ + scoped1, + scoped2 +}; + +template <normal_enum N=not_scoped1> +class A +{ +public: + template <typename T> + void fun () + { + } +}; + +template <scoped_enum N=scoped_enum::scoped1> +class B +{ +public: + template <typename T> + void fun () + { + } +}; + + +template <typename T> +void tfun () +{ + A<> a; + a.fun<char>(); //<------------ THIS IS FINE + + B<> b_defaulted; + B<scoped_enum::scoped1> b_explicited; + + b_defaulted.fun<char>(); //<------------ UNEXPECTED: THIS FAILS + b_defaulted.template fun<char>(); //<------------ THIS IS FINE + + b_explicited.fun<char>(); //<------------ UNEXPECTED: THIS FAILS + b_explicited.template fun<char>();//<------------ THIS IS FINE +} + +int main(int argc, char const *argv[]) +{ + tfun<int>(); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/enum25.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/enum25.C new file mode 100644 index 000000000..cb2cf8f53 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/enum25.C @@ -0,0 +1,18 @@ +// PR c++/56793 +// { dg-require-effective-target c++11 } + +struct A +{ + enum struct B {X, Y} b; +} a; + +enum struct D {X,Y}; +struct C { } c; + +int main () +{ + if (a.b == a.B::Y) + a.b = A::B::X; + + c.D::Y; // { dg-error "not a member" } +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/gen-attrs-4.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/gen-attrs-4.C index bad33d6e8..dff46b4af 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/gen-attrs-4.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/gen-attrs-4.C @@ -3,17 +3,17 @@ // Test for syntax support of various attribute permutations. int -[[gnu::noreturn]] // { dg-warning "ignored" } +[[noreturn]] // { dg-warning "ignored" } one [[gnu::unused]] (void); -int one_third [[gnu::noreturn]] [[gnu::unused]] (void); +int one_third [[noreturn]] [[gnu::unused]] (void); int [[gnu::unused]] one_half(); // { dg-warning "ignored" } static -[[gnu::noreturn]] // { dg-warning "ignored" } +[[noreturn]] // { dg-warning "ignored" } void two [[gnu::unused]] (void) {} @@ -21,10 +21,10 @@ void two [[gnu::unused]] (void) {} [[gnu::unused]] int five(void) -[[gnu::noreturn]] // { dg-warning "ignored" } +[[noreturn]] // { dg-warning "ignored" } {} -[[gnu::noreturn]] +[[noreturn]] void six (void) ; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/gen-attrs-54.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/gen-attrs-54.C new file mode 100644 index 000000000..45aa8e475 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/gen-attrs-54.C @@ -0,0 +1,14 @@ +// PR c++/56859 +// { dg-require-effective-target c++11 } + +template<unsigned size, unsigned alignment> +struct aligned_storage +{ + using type = struct { alignas(alignment) unsigned char data[size]; }; +}; + +#define SA(X) static_assert((X),#X) +SA(alignof(aligned_storage<8,1>::type) == 1); +SA(alignof(aligned_storage<8,2>::type) == 2); +SA(alignof(aligned_storage<8,4>::type) == 4); +SA(alignof(aligned_storage<8,8>::type) == 8); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist68.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist68.C new file mode 100644 index 000000000..7cfe1a34b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist68.C @@ -0,0 +1,20 @@ +// PR c++/56772 +// { dg-require-effective-target c++11 } + +typedef __SIZE_TYPE__ size_t; +void* operator new[](size_t, void *p) { return p; } +template <typename T = size_t> +void f () +{ + size_t coord [2][2]; + new (&coord) size_t [2][2] + { + {0,0}, + {0,0}, + }; +} + +int main () +{ + f<>(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist69.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist69.C new file mode 100644 index 000000000..5d59dfeaa --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist69.C @@ -0,0 +1,29 @@ +// PR c++/50261 +// { dg-require-effective-target c++11 } + +template <typename T> +struct ca { + T elem[1]; + + ca(const T (&s)[1]): elem{{s}} { } // { dg-error "braces" } + ca(const T (&s)[1],int): elem({{s}}) { } // { dg-error "paren|invalid" } + ca(const T (&s)[1],char): elem(s) { } // { dg-error "array" } + ca(const T (&s)[1],double): elem{s} { } // { dg-error "invalid" } + + ca(const T &v): elem{{v}} { } // { dg-error "braces" } + ca(const T &v,int): elem{{{v}}} { } // { dg-error "braces" } + ca(const T &v,char): elem{v} { } // OK + ca(const T &v,double): elem({v}) { } // { dg-error "paren" } +}; + +int main() { + int a[1] = {0}; + ca<int> d(a); + ca<int> d1(a,1); + ca<int> d2(a,'2'); + ca<int> d3(a,3.0); + ca<int> e(a[0]); + ca<int> e1(a[0],1); + ca<int> e2(a[0],'2'); + ca<int> e3(a[0],3.0); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist70.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist70.C new file mode 100644 index 000000000..f215b9d79 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/initlist70.C @@ -0,0 +1,27 @@ +// PR c++/57196 +// { dg-require-effective-target c++11 } + +#include <initializer_list> + +template<class T> +struct set { + set() = default; + set(std::initializer_list<T>){} +}; + +struct string { + string(const char*){} + ~string(){} +}; + +typedef decltype(sizeof(0)) size_t; + +template <size_t> struct EqHelper { }; + +int IsNullLiteralHelper(...); + +void Fn() { + EqHelper<sizeof IsNullLiteralHelper(set<int>{1})> eq1; // ok + EqHelper<sizeof IsNullLiteralHelper(set<string>())> eq2; // ok + EqHelper<sizeof IsNullLiteralHelper(set<string>{"foo"})> eq3; // error +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv8.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv8.C new file mode 100644 index 000000000..abe272a8b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv8.C @@ -0,0 +1,15 @@ +// PR c++/56447 +// { dg-do compile { target c++11 } } + +template <class T> +void f() +{ + int i; + // This lambda should not have a conversion op, since it captures i + int (*p)() = [=]{ return i; }; // { dg-error "cannot convert" } +} + +int main() +{ + f<int>(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-defarg4.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-defarg4.C new file mode 100644 index 000000000..221795459 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-defarg4.C @@ -0,0 +1,8 @@ +// PR c++/54764 +// { dg-require-effective-target c++11 } + +template<class T = void> +struct c +{ + int (*f)(int) = [](int i){return i + i;}; +}; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-eh3.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-eh3.C new file mode 100644 index 000000000..10dc6e36d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-eh3.C @@ -0,0 +1,14 @@ +// PR c++/56388 +// { dg-require-effective-target c++11 } + +int main() +{ + bool /*const*/ condition = false; + + [&]{ + try{} + catch(...){ + if(condition){} + } + }(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-mutable2.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-mutable2.C new file mode 100644 index 000000000..c54ff5c84 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-mutable2.C @@ -0,0 +1,23 @@ +// PR c++/55532 +// { dg-do compile { target c++11 } } + +struct Foo { + void doit() { + } +}; + +template<typename T> +void oops(Foo &foo, const T &) { + auto fun = [&] () mutable { + foo.doit(); + }; + auto fun2 = [=]() { + fun(); // { dg-error "" } + }; + fun2(); +} + +int main() { + Foo foo; + oops(foo, 1); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi3.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi3.C new file mode 100644 index 000000000..da7e0bfed --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi3.C @@ -0,0 +1,9 @@ +// PR c++/55972 +// { dg-do compile { target c++11 } } + +class C +{ + void f(); + int j = 10; + int i = [this]() { return this->j; }(); +}; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-sfinae1.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-sfinae1.C new file mode 100644 index 000000000..973f8a780 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-sfinae1.C @@ -0,0 +1,55 @@ +// PR c++/56039 +// { dg-do compile { target c++11 } } + +template <bool> struct BoolSink { typedef void type; }; + +template <typename T, typename U> +struct AddRvalueReferenceImpl { typedef T type; }; + +template <typename T> +struct AddRvalueReferenceImpl<T, typename BoolSink<false && + [] { + extern T &&tref; + }>::type> { // { dg-error "lambda" } + typedef T &&type; +}; + +template <typename T> +struct AddRvalueReference : AddRvalueReferenceImpl<T, void> { }; + +namespace ImplHelpers { + template <typename T> + typename AddRvalueReference<T>::type create(void) { } +} + +template <typename T, typename U, typename ...Args> +struct IsConstructibleImpl { enum { value = 0 }; }; + +template <typename T, typename ...Args> +struct IsConstructibleImpl<T, typename BoolSink<false && + [] { + T t( ::ImplHelpers::create<Args>() ...); + }>::type, Args ...> { // { dg-error "lambda" } + enum { value = 1 }; +}; + +template <typename T, typename ...Args> +struct IsConstructible : IsConstructibleImpl<T, void, Args ...> { }; + +struct DestroyMe { + ~DestroyMe() = delete; +}; + +static_assert(+IsConstructible<int>::value, "error"); +static_assert(!IsConstructible<void>::value, "error"); +static_assert(+IsConstructible<int [1]>::value, "error"); +static_assert(!IsConstructible<DestroyMe>::value, "error"); +static_assert(!IsConstructible<int *, char *>::value, "error"); + +static_assert(+IsConstructible<int &&, int>::value, "error"); +static_assert(!IsConstructible<int &&, int &>::value, "error"); +static_assert(+IsConstructible<int &&, int &&>::value, "error"); + +// { dg-prune-output "expected" } +// { dg-prune-output "does not name a class" } +// { dg-prune-output "static assertion" } diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this13.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this13.C new file mode 100644 index 000000000..090d0a13e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this13.C @@ -0,0 +1,20 @@ +// PR c++/52374 +// { dg-do compile { target c++11 } } + +struct B +{ + int get() const { return 42; } +}; + +template<typename X> +struct D + : public X +{ + int get() const { return [this]() -> int { return X::get(); }(); } +}; + +int main() +{ + D<B> d; + d.get(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this14.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this14.C new file mode 100644 index 000000000..9834bfdb3 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this14.C @@ -0,0 +1,49 @@ +// PR c++/52014 +// { dg-require-effective-target c++11 } + +template <class Iterator, class Func> +void for_each(const Iterator first, const Iterator last, Func func) +{ + for (Iterator it = first; it != last; ++it) { + func(*it); + } +} + +template <class T> +struct helper +{ + typedef typename T::size_type type; +}; + +template <class T> +struct helper<T&> +{ + typedef typename T::size_type type; +}; + +template <class T> +struct helper<T*> +{ + typedef typename T::size_type type; +}; + +struct bar +{ + struct foo + { + typedef int size_type; + } foo_; + + void test() + { + int arr[] = { 1, 2, 3 }; + for_each(arr, arr + 3, [&](helper<foo>::type i) { + for_each(arr, arr + 3, [&](helper<decltype(foo_)>::type j) { }); + }); + } +}; + +int main() +{ + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this15.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this15.C new file mode 100644 index 000000000..d44bec949 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this15.C @@ -0,0 +1,12 @@ +// PR c++/56692 +// { dg-require-effective-target c++11 } + +struct Class { + void f () { } + static void f (int) { } +}; + +int main () +{ + []{ Class::f(0); }; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this16.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this16.C new file mode 100644 index 000000000..736d5f50e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this16.C @@ -0,0 +1,28 @@ +// PR c++/56699 +// { dg-require-effective-target c++11 } + +struct A +{ + int a; +}; + +struct T +{ + int x; + + T() : x([]{ + sizeof(::A::a); + return 0; + }()) + {} +}; + +struct B +{ + int a; +}; + +void f() +{ + []{sizeof(B::a);}; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this9.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this9.C new file mode 100644 index 000000000..07ddd0863 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this9.C @@ -0,0 +1,19 @@ +// PR c++/54277 +// { dg-do compile { target c++11 } } + +struct Used +{ + void foo() { } +}; + +template <typename> +struct S +{ + Used x; + + void bar() + { + auto f = [this] { x.foo(); }; + f(); + } +}; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/noexcept03.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/noexcept03.C index 54e04f3d0..41c442e90 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/noexcept03.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/noexcept03.C @@ -1,6 +1,6 @@ // Runtime test for noexcept-specification. // { dg-options "-std=c++0x -Wnoexcept" } -// { dg-do run } +// { dg-do run { target nonpic } } #include <exception> #include <cstdlib> diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for23.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for23.C new file mode 100644 index 000000000..849682c02 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for23.C @@ -0,0 +1,8 @@ +// PR c++/56722 +// { dg-do compile { target c++11 } } + +int main() +{ + for (const auto& i, 21) // { dg-error "has no initializer|expected" } + i; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for24.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for24.C new file mode 100644 index 000000000..b4a5b185b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for24.C @@ -0,0 +1,15 @@ +// PR c++/56794 +// { dg-require-effective-target c++11 } + +template<int... values> +static void Colors() +{ + static const int colors[] = { values... }; + + for(auto c: colors) { } +} + +int main() +{ + Colors<0,1,2> (); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for25.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for25.C new file mode 100644 index 000000000..8ba9f652d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/range-for25.C @@ -0,0 +1,30 @@ +// PR c++/57243 +// { dg-require-effective-target c++11 } + +struct snarf +{ + template <class T> + void get() {} +}; + +template <class T> +struct container +{ + snarf * begin() { return nullptr; } + snarf * end() { return nullptr; } +}; + +template <class T> +void foo() +{ + container<int> arr; + + for( auto i : arr ) + i.get<int>(); +} + +int main() +{ + return 0; +} + diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual-mangle1.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual-mangle1.C new file mode 100644 index 000000000..c6ef0792b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual-mangle1.C @@ -0,0 +1,37 @@ +// PR c++/56821 +// { dg-require-effective-target c++11 } + +struct A { + // { dg-final { scan-assembler "_ZNR1A1fEv" } } + void f() & {} + // { dg-final { scan-assembler "_ZNO1A1gEv" } } + void g() && {} + // { dg-final { scan-assembler "_ZNKR1A1hEv" } } + void h() const & {} +}; + +// { dg-final { scan-assembler "_Z1jM1AFvvRE" } } +void j(void (A::*)() &) { } +// { dg-final { scan-assembler "_Z1kM1AFvvOE" } } +void k(void (A::*)() &&) { } +// { dg-final { scan-assembler "_Z1lM1AKFvvRE" } } +void l(void (A::*)() const &) { } + +// { dg-final { scan-assembler "_Z1mIFvvOEEvM1AT_" } } +// { dg-final { scan-assembler "_Z1mIFvvREEvM1AT_" } } +// { dg-final { scan-assembler "_Z1mIKFvvREEvM1AT_" } } +template <typename T> +void m(T A::*) {} + +// { dg-final { scan-assembler "_Z1nIM1AFvvOEEvT_" } } +// { dg-final { scan-assembler "_Z1nIM1AFvvREEvT_" } } +// { dg-final { scan-assembler "_Z1nIM1AKFvvREEvT_" } } +template <typename T> +void n(T) {} + +int main() +{ + j(&A::f); k(&A::g); l(&A::h); + m(&A::f); m(&A::g); m(&A::h); + n(&A::f); n(&A::g); n(&A::h); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual1.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual1.C new file mode 100644 index 000000000..7fa826c3d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual1.C @@ -0,0 +1,30 @@ +// { dg-require-effective-target c++11 } + +template <class,class> struct ST; +template <class T> struct ST<T,T> {}; + +struct A +{ + int f() &; + char f() &&; +}; + +template <class T> struct B +{ + int f() &; + char f() &&; +}; + +int main() +{ + A a; + a.f(); + A().f(); + ST<decltype(a.f()), int>(); + ST<decltype(A().f()), char>(); + B<int> b; + b.f(); + B<int>().f(); + ST<decltype(b.f()), int>(); + ST<decltype(B<int>().f()), char>(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual10.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual10.C new file mode 100644 index 000000000..1b6c54fd4 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual10.C @@ -0,0 +1,13 @@ +// PR c++/57252 +// { dg-require-effective-target c++11 } + +struct foo { + void bar() & {} + void bar() && {} +}; + +int main() +{ + auto p = &foo::bar; // { dg-error "" } + (foo{}.*p)(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual11.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual11.C new file mode 100644 index 000000000..15dd049f2 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual11.C @@ -0,0 +1,10 @@ +// PR c++/57253 +// { dg-require-effective-target c++11 } + +template<typename T> struct foo; + +template<> struct foo<void()&> {}; +template<> struct foo<void()> {}; + +int main() +{} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual12.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual12.C new file mode 100644 index 000000000..b0a16fe94 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual12.C @@ -0,0 +1,22 @@ +// PR c++/57254 +// { dg-require-effective-target c++11 } + +struct foo { + template<typename T> + void bar(T) &; + + template<typename T> + void bar(T) &&; +}; + +template<typename T> +void foo::bar(T) & {} + +template<typename T> +void foo::bar(T) && {} + +int main() +{ + foo f; + f.bar(0); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual13.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual13.C new file mode 100644 index 000000000..84d3b0f2d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual13.C @@ -0,0 +1,29 @@ +// PR c++/57388 +// { dg-require-effective-target c++11 } + +template<class> struct A +{ + static constexpr bool value = false; +}; + +template<class Res, class... Args> +struct A<Res(Args...)> +{ + static constexpr bool value = true; +}; + +template<class Res, class... Args> +struct A<Res(Args...) const &> +{ + static constexpr bool value = true; +}; + +template<class Res, class... Args> +struct A<Res(Args...) const &&> +{ + static constexpr bool value = true; +}; + +static_assert(A<void()>::value, "Ouch"); +static_assert(A<void() const &>::value, ""); // #1 +static_assert(A<void() const &&>::value, ""); // #2 diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual2.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual2.C new file mode 100644 index 000000000..fa09ab48a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual2.C @@ -0,0 +1,75 @@ +// In a .* expression whose object expression is an rvalue, the program is +// ill-formed if the second operand is a pointer to member function with +// ref-qualifier &. In a .* expression whose object expression is an +// lvalue, the program is ill-formed if the second operand is a pointer to +// member function with ref-qualifier &&. + +// { dg-require-effective-target c++11 } + +struct A { + void f() &; + void g() &&; + void h(); +}; + +void one() +{ + A a; + + void (A::*p)() & = &A::f; + (a.*p)(); + (A().*p)(); // { dg-error "" } + + p = &A::g; // { dg-error "" } + p = &A::h; // { dg-error "" } + + void (A::*p2)() && = &A::g; + (A().*p2)(); + (a.*p2)(); // { dg-error "" } + p2 = &A::f; // { dg-error "" } + p2 = &A::h; // { dg-error "" } + + void (A::*p3)() = &A::h; + (a.*p3)(); + (A().*p3)(); + p3 = &A::f; // { dg-error "" } + p3 = &A::g; // { dg-error "" } +} + +template <class T> +struct B { + void f() &; + void g() &&; + void h(); +}; + +template <class T> +void two() +{ + B<T> a; + + void (B<T>::*p)() & = &B<T>::f; + (a.*p)(); + (B<T>().*p)(); // { dg-error "" } + + p = &B<T>::g; // { dg-error "" } + p = &B<T>::h; // { dg-error "" } + + void (B<T>::*p2)() && = &B<T>::g; + (B<T>().*p2)(); + (a.*p2)(); // { dg-error "" } + p2 = &B<T>::f; // { dg-error "" } + p2 = &B<T>::h; // { dg-error "" } + + void (B<T>::*p3)() = &B<T>::h; + (a.*p3)(); + (B<T>().*p3)(); + p3 = &B<T>::f; // { dg-error "" } + p3 = &B<T>::g; // { dg-error "" } +} + +int main() +{ + one(); + two<int>(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual3.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual3.C new file mode 100644 index 000000000..1b2119632 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual3.C @@ -0,0 +1,29 @@ +// An explicitly defaulted function can have a ref-qualifier. + +// { dg-require-effective-target c++11 } + +struct A { + A& operator=(const A&) & = default; +}; + +template<class T> +struct B { + B& operator=(const B&) & = default; +}; + +template<class T> +void f() +{ + B<T> b; + b = B<T>(); + B<T>() = b; // { dg-error "" } +} + +int main() +{ + A a; + a = A(); + A() = a; // { dg-error "" } + + f<int>(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual4.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual4.C new file mode 100644 index 000000000..5a0ee162f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual4.C @@ -0,0 +1,14 @@ +// 12.1: A constructor shall not be declared with a ref-qualifier. +// 12.4: A destructor shall not be declared with a ref-qualifier. + +// { dg-require-effective-target c++11 } + +struct A { + A() & = default; // { dg-error "constructor" } + ~A() & = default; // { dg-error "destructor" } +}; + +int main() +{ + A a; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual5.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual5.C new file mode 100644 index 000000000..e3d26e5a7 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual5.C @@ -0,0 +1,13 @@ +// 13.1: ...cannot be overloaded if any of them, but not all, have a +// ref-qualifier. + +// { dg-require-effective-target c++11 } + +class Y { + void h() &; + void h() const &; // OK + void h() &&; // OK, all declarations have a ref-qualifier + void i() &; // { dg-message "" } + void i() const; // { dg-error "" } prior declaration of i + // has a ref-qualifier +}; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual6.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual6.C new file mode 100644 index 000000000..02e3f6e68 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual6.C @@ -0,0 +1,15 @@ +// Binding an rvalue to && beats binding it to const& (13.3.3.2). + +// { dg-require-effective-target c++11 } + +struct A +{ + int operator+(int) &&; +}; + +void operator+ (const A&, int); + +int main() +{ + return A() + 42; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual7.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual7.C new file mode 100644 index 000000000..2430665db --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual7.C @@ -0,0 +1,19 @@ +// typedef test +// { dg-require-effective-target c++11 } + +typedef void F() &; + +F f; // { dg-error "" } +F* p; // { dg-error "" } +extern F& r; // { dg-error "" } + +struct A { + F f; +}; + +int main() +{ + A a; + a.f(); + A().f(); // { dg-error "" } +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual8.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual8.C new file mode 100644 index 000000000..b4c972b3c --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual8.C @@ -0,0 +1,13 @@ +// { dg-require-effective-target c++11 } + +struct A +{ + virtual void f() & = 0; +}; + +struct B: A +{ + void f(); // doesn't override +}; + +B b; // { dg-error "abstract" } diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual9.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual9.C new file mode 100644 index 000000000..cdb8d6856 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/ref-qual9.C @@ -0,0 +1,14 @@ +// PR c++/57064 +// { dg-require-effective-target c++11 } + +template <class T> T&& move(T& t); + +struct A { + void p() &; + int p() &&; +}; + +void g(A &&a) +{ + int i = move(a).p(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/sfinae44.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/sfinae44.C new file mode 100644 index 000000000..bbcae6226 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/sfinae44.C @@ -0,0 +1,26 @@ +// PR c++/56913 +// { dg-do compile { target c++11 } } + +template<typename T> +T &&declval(); + +template<typename T, typename U, + typename = decltype((declval<T>().*declval<U>())())> +constexpr bool test(int) +{ + return true; +} + +template<typename T, typename U> +constexpr bool test(...) +{ + return false; +} + +struct S +{}; + +static_assert(!test<S, void (S::*)() &>(0), ""); +static_assert(test<S, void (S::*)() &&>(0), ""); +static_assert(test<S &, void (S::*)() &>(0), ""); +static_assert(!test<S &, void (S::*)() &&>(0), ""); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/sfinae45.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/sfinae45.C new file mode 100644 index 000000000..bd375145f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/sfinae45.C @@ -0,0 +1,35 @@ +// PR c++/56970 +// { dg-do compile { target c++11 } } + +template <typename T> +struct has +{ + template <typename> + constexpr static int test(...) { + return 0; + } + + template <typename C> + constexpr static int test(decltype(sizeof(C::x))) { // Doesn't compile. + return 1; // Is a member variable. + } + + template <typename C, int c = sizeof(decltype(((C*)nullptr)->x()))> + constexpr static int test(int) { + return 2; // Is a member function. + } + + static const int value = test<T>(0); +}; + +struct foo { + int x; +}; + +struct bar { + int x(); +}; + +static_assert(has<int>::value == 0, ""); +static_assert(has<foo>::value == 1, ""); +static_assert(has<bar>::value == 2, ""); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/trailing8.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/trailing8.C new file mode 100644 index 000000000..304845e66 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/trailing8.C @@ -0,0 +1,25 @@ +// PR c++/54359 +// { dg-require-effective-target c++11 } + +int& ref(int& x) { return x; } +const int& ref(const int& x) { return x; } + +class A { + int x; + int f() const; + auto test1() const -> decltype(this); + auto test2() const -> decltype(ref(x)); + auto test3() const -> decltype(f()); +}; + +auto A::test1() const -> decltype(this) { + return this; +} + +auto A::test2() const -> decltype(ref(x)) { + return ref(x); +} + +auto A::test3() const -> decltype(f()) { + return f(); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/trailing9.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/trailing9.C new file mode 100644 index 000000000..d7895b38e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/trailing9.C @@ -0,0 +1,12 @@ +// PR c++/56646 +// { dg-require-effective-target c++11 } + +struct A { + void f(); +}; + +void A::f() { + struct B { + auto g() -> void { } + }; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/traits1.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/traits1.C new file mode 100644 index 000000000..9085b71a3 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/traits1.C @@ -0,0 +1,133 @@ +// PR c++/57016 +// { dg-require-effective-target c++11 } + +template < typename _Tp, _Tp __v > struct integral_constant +{ + static constexpr _Tp value = __v; +}; +template < bool, typename, typename > struct conditional; +template < typename ... >struct __and_; +template + < + typename + _B1, + typename + _B2 > struct __and_ <_B1, _B2 >:conditional < _B1::value, _B2, _B1 >::type +{}; +template < typename _Pp > struct __not_:integral_constant < bool, _Pp::value > +{}; +template < typename > struct add_rvalue_reference; +template + < typename _Tp > typename add_rvalue_reference < _Tp >::type declval (); +template < bool, typename _Iftrue, typename > struct conditional +{ + typedef _Iftrue type; +}; +template < class, class > struct pair; +template < typename > class allocator; +template < typename, typename, typename > struct binary_function; +template < typename _Tp > struct equal_to:binary_function < _Tp, _Tp, bool > +{}; +template < typename > struct hash; +template < >struct hash <int > +{}; +template + < + typename, + typename, + typename, + typename, typename, typename, typename, typename > struct _Hashtable_base; +template + < + typename, + typename + > struct __is_noexcept_hash:integral_constant < bool, noexcept ((declval)) > +{} +; +struct _Identity; +template < bool, bool _Constant_iterators, bool > struct _Hashtable_traits + ; +struct _Mod_range_hashing; +struct _Default_ranged_hash; +struct _Prime_rehash_policy; +template + < + typename + _Tp, + typename + _Hash + > + using + __cache_default + = + __not_ + < + __and_ + < + integral_constant + < bool, __is_final (_Hash) >, __is_noexcept_hash < _Tp, _Hash > >>; +template < typename _Key, typename _Value, typename, typename _ExtractKey, typename _Equal, typename _H1, typename _H2, typename, typename _RehashPolicy, typename _Traits > class _Hashtable: +_Hashtable_base + < _Key, _Value, _ExtractKey, _Equal, _H1, _H2, _RehashPolicy, _Traits > +{} +; +template + < + bool + _Cache > using __uset_traits = _Hashtable_traits < _Cache, true, true >; +template + < + typename + _Value, + typename + _Hash + = + hash + < + _Value + >, + typename + _Pred + = + equal_to + < + _Value + >, + typename + _Alloc + = + allocator + < + _Value + >, + typename + _Tr + = + __uset_traits + < + __cache_default + < + _Value, + _Hash + >::value + > + > + using + __uset_hashtable + = + _Hashtable + < + _Value, + _Value, + _Alloc, + _Identity, + _Pred, + _Hash, + _Mod_range_hashing, _Default_ranged_hash, _Prime_rehash_policy, _Tr >; +template < class _Value, class = hash < _Value > >class unordered_set +{ + typedef __uset_hashtable < _Value > iterator; + template < typename > pair < iterator, bool > emplace (); +} +; +template class unordered_set < int >; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/variadic-explicit2.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/variadic-explicit2.C new file mode 100644 index 000000000..4a8074529 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/variadic-explicit2.C @@ -0,0 +1,14 @@ +// PR c++/56774 +// { dg-require-effective-target c++11 } + +template <class ... Args> +struct mytype {}; + +template <class T, class ... Args> +void something( mytype<T, Args...> ) +{ } + +int main() +{ + something<int, char, bool>( mytype<int, char, bool>() ); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/variadic142.C b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/variadic142.C new file mode 100644 index 000000000..7737b4cac --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/cpp0x/variadic142.C @@ -0,0 +1,63 @@ +// PR c++/56782 +// { dg-options -std=c++0x } + +template<class T> +T&& declval(); + +struct is_convertible_impl { + template<class T> + static void sink(T); + + template<class T, class U, class = decltype(sink<U>(declval<T>()))> + static auto test(int) -> char; + + template<class, class> + static auto test(...) -> char(&)[2]; +}; + +template<class T, class U> +struct is_convertible : is_convertible_impl +{ + static const bool value = sizeof(test<T, U>(0)) == 1; +}; + +template<bool, class> +struct enable_if {}; + +template<class T> +struct enable_if<true, T> { typedef T type; }; + +template<bool, class If, class Else> +struct conditional { typedef If type; }; + +template<class If, class Else> +struct conditional<false, If, Else> { typedef Else type; }; + +template<class...> +struct and_; + +template<> +struct and_<> +{ + static const bool value = true; +}; + +template<class P> +struct and_<P> : P +{ +}; + +template<class P1, class P2> +struct and_<P1, P2> : conditional<P1::value, P2, P1>::type +{ +}; + +template<class... T> +struct Tuple { + template<class... U, + class = typename enable_if<and_<is_convertible<U, T>... >::value, int>::type + > + Tuple(U&&...){} +}; + +static_assert(is_convertible<Tuple<>, Tuple<>>::value, "Ouch"); //#1 diff --git a/gcc-4.8/gcc/testsuite/g++.dg/debug/pr56819.C b/gcc-4.8/gcc/testsuite/g++.dg/debug/pr56819.C new file mode 100644 index 000000000..62926be2f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/debug/pr56819.C @@ -0,0 +1,27 @@ +// PR debug/56819 +// { dg-do compile } +// { dg-options "-fcompare-debug" } + +template <typename> +struct A +{ + template <typename> + struct B; +}; + +template <typename> +struct C +{ + typedef int I; +}; + +template <typename T> +class D +{ + typedef A <void> E; + typedef typename T::template B <E> F; + typedef typename C <F>::I I; + A <I> foo () { return A<I> (); } +}; + +template class D <A <void> >; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ext/desig5.C b/gcc-4.8/gcc/testsuite/g++.dg/ext/desig5.C new file mode 100644 index 000000000..48cce3183 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/ext/desig5.C @@ -0,0 +1,7 @@ +// PR c++/55951 + +enum { A }; + +static const char *a[] = { + [A] = "a" +}; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ext/desig6.C b/gcc-4.8/gcc/testsuite/g++.dg/ext/desig6.C new file mode 100644 index 000000000..ccdafa50d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/ext/desig6.C @@ -0,0 +1,17 @@ +// PR c++/57041 +// { dg-options "-std=gnu++11" } + +template<typename T> +union u { + T a; + char b; +}; + +template<typename T> +u<T> make_u(T t) { + return { .a = t }; +} + +int main() { + return make_u<int>(1).a; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/devirt-c-7.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/devirt-c-7.C index 89d04328c..2e76cbe40 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/devirt-c-7.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/devirt-c-7.C @@ -1,6 +1,7 @@ /* Verify that ipa-cp will not get confused by placement new constructing an object within another one when looking for dynamic type change . */ /* { dg-do run } */ +/* { dg-require-effective-target nonpic } */ /* { dg-options "-O3 -Wno-attributes" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-1.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-1.C index fc63e6085..bc4dfea5c 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-1.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-1.C @@ -1,6 +1,6 @@ /* Verify that simple virtual calls are inlined even without early inlining. */ -/* { dg-do run } */ +/* { dg-do run { target nonpic } } */ /* { dg-options "-O3 -fdump-ipa-inline -fno-early-inlining -fno-ipa-cp" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-2.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-2.C index f99330361..001cff204 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-2.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-2.C @@ -1,6 +1,6 @@ /* Verify that simple virtual calls using this pointer are inlined even without early inlining.. */ -/* { dg-do run } */ +/* { dg-do run { target nonpic } } */ /* { dg-options "-O3 -fdump-ipa-inline -fno-early-inlining -fno-ipa-cp" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-3.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-3.C index d9a47f860..637a6aecc 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-3.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-3.C @@ -1,6 +1,6 @@ /* Verify that simple virtual calls on an object refrence are inlined even without early inlining. */ -/* { dg-do run } */ +/* { dg-do run { target nonpic } } */ /* { dg-options "-O3 -fdump-ipa-inline -fno-early-inlining -fno-ipa-cp" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-4.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-4.C index 93cbe0c7d..f5b8f8e5d 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-4.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-4.C @@ -1,7 +1,7 @@ /* Verify that simple virtual calls are inlined even without early inlining, even when a typecast to an ancestor is involved along the way. */ -/* { dg-do run } */ +/* { dg-do run { target nonpic } } */ /* { dg-options "-O3 -fdump-ipa-inline -fno-early-inlining -fno-ipa-cp" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-5.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-5.C index 91e8f4e3e..d78173d69 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-5.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-5.C @@ -1,6 +1,6 @@ /* Verify that virtual call inlining does not pick a wrong method when there is a user defined ancestor in an object. */ -/* { dg-do run } */ +/* { dg-do run { target nonpic } } */ /* { dg-options "-O3 -fdump-ipa-inline -fno-early-inlining -fno-ipa-cp" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-7.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-7.C index 2630dffa9..9d725a508 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-7.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-7.C @@ -1,7 +1,7 @@ /* Verify that simple virtual calls are inlined even without early inlining, even when a typecast to an ancestor is involved along the way and that ancestor is not the first one with virtual functions. */ -/* { dg-do run } */ +/* { dg-do run { target nonpic } } */ /* { dg-options "-O3 -fdump-ipa-inline -fno-early-inlining -fno-ipa-cp" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-8.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-8.C index 3bdf4c15b..eebfc6af1 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-8.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-8.C @@ -1,6 +1,6 @@ /* Verify that virtual calls are inlined (ithout early inlining) even when their caller is itself indirectly inlined. */ -/* { dg-do run } */ +/* { dg-do run { target nonpic } } */ /* { dg-options "-O3 -fdump-ipa-inline -fno-early-inlining -fno-ipa-cp" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-9.C b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-9.C index 4ff07a9bb..586c3af30 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-9.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/ipa/ivinline-9.C @@ -2,7 +2,7 @@ inlining, even when a typecast to an ancestor is involved along the way and that ancestor itself has an ancestor wich is not the primary base class. */ -/* { dg-do run } */ +/* { dg-do run { target nonpic } } */ /* { dg-options "-O3 -fdump-ipa-inline -fno-early-inlining -fno-ipa-cp" } */ extern "C" void abort (void); diff --git a/gcc-4.8/gcc/testsuite/g++.dg/opt/pr56999.C b/gcc-4.8/gcc/testsuite/g++.dg/opt/pr56999.C new file mode 100644 index 000000000..6db2f270e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/opt/pr56999.C @@ -0,0 +1,188 @@ +// PR rtl-optimization/56999 +// { dg-do run } +// { dg-options "-O2" } +// { dg-additional-options "-fpic" { target fpic } } +// { dg-additional-options "-march=i686 -mtune=atom" { target ia32 } } +// { dg-require-visibility "" } + +extern "C" void abort (void); +extern "C" void exit (int); +volatile bool do_exit = true; +struct JSScript; +struct JITScript { int i; }; +#pragma GCC visibility push(hidden) +typedef struct JSCompartment JSCompartment; +typedef struct JSContext JSContext; +namespace js +{ + struct ContextFriendFields + { + JSCompartment *compartment; + }; + struct TempAllocPolicy + { + }; + template <class T> + struct Vector + { + T *mBegin; + T *begin () { return mBegin; } + T & operator[] (unsigned i) { return begin ()[i]; } + template <class U> + __attribute__((noinline, noclone)) + bool append (U) { asm volatile ("" : : : "memory"); if (do_exit) abort (); return false; } + }; + namespace types + { + struct TypeCompartment; + } + namespace mjit + { + } + namespace ion + { + struct IonScript; + } + namespace types + { + struct CompilerOutput + { + enum Kind { MethodJIT, ParallelIon }; + JSScript *script; + unsigned kindInt : 2; + bool constructing : 1; + bool barriers : 1; + bool pendingRecompilation : 1; + Kind kind () const { return static_cast <Kind> (kindInt); } + bool isValid () const; + }; + struct RecompileInfo + { + unsigned outputIndex; + CompilerOutput *compilerOutput (TypeCompartment & types) const; + CompilerOutput *compilerOutput (JSContext *cx) const; + }; + struct TypeCompartment + { + Vector <CompilerOutput> *constrainedOutputs; + Vector <RecompileInfo> *pendingRecompiles; + void addPendingRecompile (JSContext *cx, const RecompileInfo & info); + }; + } +} +struct JSScript +{ + struct JITScriptHandle + { + static volatile JITScript *UNJITTABLE __attribute__((visibility ("default"))); + JITScript *value; + bool isValid () { return value != UNJITTABLE; } + JITScript *getValid () { return value; } + }; + struct JITScriptSet + { + JITScriptHandle jitHandleNormal, jitHandleNormalBarriered; + JITScriptHandle jitHandleCtor, jitHandleCtorBarriered; + JITScriptHandle jitNull1, jitNull2; + }; + JITScriptSet *mJITInfo; + void *ion; + JITScriptHandle *jitHandle (bool constructing, bool barriers) + { + return constructing ? (barriers ? &mJITInfo->jitHandleCtorBarriered + : &mJITInfo->jitHandleCtor) + : (barriers ? &mJITInfo->jitHandleNormalBarriered + : &mJITInfo->jitHandleNormal); + } + JITScript *getJIT (bool constructing, bool barriers) + { + JITScriptHandle *jith = jitHandle (constructing, barriers); + return jith->isValid () ? jith->getValid () : __null; + } +}; +struct JSContext : js::ContextFriendFields +{ +}; +namespace js +{ + __attribute__((noinline, noclone)) + void CancelOffThreadIonCompile (JSCompartment *, JSScript *) + { + if (do_exit) + exit (0); + } +} +struct JSCompartment +{ + js::types::TypeCompartment types; +}; +namespace js +{ + namespace types + { + inline bool CompilerOutput::isValid () const + { + if (!script) + return false; + switch (kind ()) + { + case MethodJIT: + { + JITScript *jit = script->getJIT (constructing, barriers); + if (!jit) + return false; + } + case ParallelIon: + return true; + } + return false; + } + inline CompilerOutput *RecompileInfo::compilerOutput (TypeCompartment & types) const + { + return &(*types.constrainedOutputs)[outputIndex]; + } + inline CompilerOutput *RecompileInfo::compilerOutput (JSContext *cx) const + { + return compilerOutput (cx->compartment->types); + } + } +} +using namespace js::types; +__attribute__((noinline, noclone)) void +TypeCompartment::addPendingRecompile (JSContext *cx, const RecompileInfo & info) +{ + CompilerOutput *co = info.compilerOutput (cx); + if (co->pendingRecompilation) + if (co->isValid ()) + CancelOffThreadIonCompile (cx->compartment, co->script); + if (co->isValid ()) + pendingRecompiles->append (info); +} +volatile JITScript *JSScript::JITScriptHandle::UNJITTABLE; +int +main () +{ + JSContext cx; + JSCompartment com; + RecompileInfo info; + cx.compartment = &com; + info.outputIndex = 0; + js::Vector<CompilerOutput> v; + JITScript js; + JSScript::JITScriptSet set; + __builtin_memset (&set, 0, sizeof set); + set.jitHandleCtor.value = &js; + JSScript s; + s.mJITInfo = &set; + CompilerOutput co; + co.kindInt = 0; + co.constructing = true; + co.barriers = false; + co.pendingRecompilation = true; + co.script = &s; + v.mBegin = &co; + com.types.constrainedOutputs = &v; + com.types.pendingRecompiles = __null; + com.types.addPendingRecompile (&cx, info); + abort (); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/parse/ref-qual1.C b/gcc-4.8/gcc/testsuite/g++.dg/parse/ref-qual1.C new file mode 100644 index 000000000..e3f60c09c --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/parse/ref-qual1.C @@ -0,0 +1,29 @@ +// PR c++/57068 + +enum Enums { + Enum1 = 0x00000000, + Enum2 = 0x00000001 +}; + +class Flags { +public: + Flags() : i(0) {} + Flags(int i): i(i) {} + Flags operator&(Enums f) { return Flags(Enums(i & f)); } + + operator bool() { return i; } +private: + int i; +}; + +Flags windowState() +{ + return Flags(); +} + +int main() +{ + if (bool(windowState() & Enum1) == true) + return 1; + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/array26.C b/gcc-4.8/gcc/testsuite/g++.dg/template/array26.C new file mode 100644 index 000000000..669207169 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/array26.C @@ -0,0 +1,40 @@ +// PR c++/57325 + +class valarray { int _M_data; }; +template < typename > struct SimpleJet { valarray partials; }; + +template < class C > struct scoped_ptr_impl +{ + scoped_ptr_impl (C *):data_ () { } + struct Data + { + C ptr; + }; + Data data_; +}; + +template < class, class = int >struct scoped_ptr; +template < class C, class D > struct scoped_ptr <C[], D > +{ + scoped_ptr ():impl_ (0) { } + scoped_ptr_impl < C > impl_; +}; + +template < typename JetsT > void +TestJets (JetsT *) +{ + typedef typename JetsT::JetType JetT; + scoped_ptr < JetT[] > a; +} + +template < typename T > struct SimpleJets +{ + typedef SimpleJet < T > JetType; + scoped_ptr < SimpleJet < T >[] > vars_; +}; + +void fn () +{ + SimpleJets < double >b; + TestJets (&b); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/arrow2.C b/gcc-4.8/gcc/testsuite/g++.dg/template/arrow2.C new file mode 100644 index 000000000..8ec9e01d0 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/arrow2.C @@ -0,0 +1,12 @@ +// PR c++/56639 + +struct A { + int i; + static A* f(); +}; + +struct B { + void g() { + int (A::f()->i); + } +}; diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/arrow3.C b/gcc-4.8/gcc/testsuite/g++.dg/template/arrow3.C new file mode 100644 index 000000000..b2029ba48 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/arrow3.C @@ -0,0 +1,38 @@ +// PR c++/56895 +// { dg-do compile } + +extern struct A { bool foo (); A bar (); } *a; + +template <int> +int +baz1 () +{ + return 2 << (a->bar().foo() ? 1 : 0); +} + +template <int> +int +baz2 () +{ + return 2 >> (a->bar().foo() ? 1 : 0); +} + +template <int> +int +baz3 () +{ + return 10 / (a->bar().foo() ? 1 : 2); +} + +template <int> +int +baz4 () +{ + return 10 % (a->bar().foo() ? 1 : 0); +} + +int +test () +{ + return baz1<0> () + baz2<0> () + baz3<0> () + baz4<0> (); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/arrow4.C b/gcc-4.8/gcc/testsuite/g++.dg/template/arrow4.C new file mode 100644 index 000000000..89e782219 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/arrow4.C @@ -0,0 +1,19 @@ +// PR c++/56895 +// { dg-do compile } + +void fn (int *); +void fn (int); +extern struct A { bool foo (); A bar (); } *a; + +template <int> +void +baz () +{ + fn (a->bar().foo() ? 1 : 0); +} + +void +test () +{ + baz<0> (); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/crash106.C b/gcc-4.8/gcc/testsuite/g++.dg/template/crash106.C index c2d117e03..ebd47bcff 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/template/crash106.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/crash106.C @@ -10,3 +10,5 @@ struct A template<T N = 0, void (A::*)() = &A::foo<N> > struct B {}; // { dg-error "type|declared" } B<> b; // { dg-error "type|declaration" } + +// { dg-prune-output "could not convert" } diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/crash112.C b/gcc-4.8/gcc/testsuite/g++.dg/template/crash112.C index 919c887fd..ff35764c7 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/template/crash112.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/crash112.C @@ -5,7 +5,7 @@ struct A template<typename> void foo() {} }; -template<void (A::*)()> struct B {}; // { dg-error "declaration" } +template<void (A::*)()> struct B {}; template<int> struct C { @@ -13,3 +13,5 @@ template<int> struct C }; C<0> c; + +// { dg-prune-output "could not convert" } diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/crash84.C b/gcc-4.8/gcc/testsuite/g++.dg/template/crash84.C index c42f85ce5..103e90a70 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/template/crash84.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/crash84.C @@ -5,7 +5,7 @@ template<typename T> struct a { template <template <typename> class C, typename X, C<X>* =0> - struct b // { dg-error "class C' is not a template|is not a valid type" } + struct b { }; }; @@ -13,7 +13,8 @@ template<typename T> struct a void foo () { - a<int> v; // { dg-message "required from here" } + a<int> a1; // OK + a<int>::b<a,int> b1; // { dg-error "template argument" } } - +// { dg-prune-output "invalid type in declaration" } diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/dependent-args1.C b/gcc-4.8/gcc/testsuite/g++.dg/template/dependent-args1.C index 0b197cf55..a540e55f4 100644 --- a/gcc-4.8/gcc/testsuite/g++.dg/template/dependent-args1.C +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/dependent-args1.C @@ -9,3 +9,5 @@ struct A template<int N, void (A::*)() = &A::foo<N> > struct B {}; B<int> b; // { dg-error "type/value mismatch|expected a constant|invalid type" } + +// { dg-prune-output "could not convert" } diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/overload13.C b/gcc-4.8/gcc/testsuite/g++.dg/template/overload13.C new file mode 100644 index 000000000..d41ccd01a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/overload13.C @@ -0,0 +1,16 @@ +// PR c++/56998 + +class Secret; +char IsNullLiteralHelper(Secret* p); +char (&IsNullLiteralHelper(...))[2]; + +struct C +{ + int val() { return 42; } +}; + +template <typename T> +unsigned f() +{ + return sizeof(IsNullLiteralHelper(C().val())); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/template/sfinae-dr657.C b/gcc-4.8/gcc/testsuite/g++.dg/template/sfinae-dr657.C new file mode 100644 index 000000000..b78b5a919 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/template/sfinae-dr657.C @@ -0,0 +1,22 @@ +// DR 657 +// Test that a return or parameter type with abstract class type causes a +// deduction failure. + +struct A +{ + A(); + A(int); + virtual void f() = 0; +}; + +template<class T> T declval(); +template<class T> int declval(...); + +template<class T> void arg(T); +template<class T> int arg(...); + +int main() +{ + int i = declval<A>(); + i = arg<A>(1); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56694.C b/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56694.C new file mode 100644 index 000000000..d3de05101 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56694.C @@ -0,0 +1,31 @@ +// { dg-do compile } +// { dg-options "-fopenmp" } +// { dg-require-effective-target fopenmp } + +class GException { +public: + class vector_mismatch { + public: + vector_mismatch(int size1, int size2); + }; +}; +class GVector{ +public: + GVector& operator+=(const GVector& v); + int m_num; + double* m_data; +}; +inline GVector& GVector::operator+= (const GVector& v) +{ + if (m_num != v.m_num) + throw GException::vector_mismatch(m_num, v.m_num); + for (int i = 0; i < m_num; ++i) m_data[i] += v.m_data[i]; +}; +void eval(GVector* m_gradient, GVector* vect_cpy_grad, int n) +{ +#pragma omp sections + { + for (int i = 0; i < n; ++i) + *m_gradient += vect_cpy_grad[i]; + } +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56768.C b/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56768.C new file mode 100644 index 000000000..db504c500 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56768.C @@ -0,0 +1,41 @@ +// { dg-do compile } +// { dg-options "-std=c++0x" } + +struct Iter +{ + int& operator* (); + void operator++ (); +}; + +bool operator!= (Iter &, Iter &) { } + +struct Container +{ + Iter begin () const; + Iter end () const; +}; + +struct J +{ + virtual J *mutable_child (); +}; + +struct M +{ + M (const Container &); + J ns_; +}; +namespace +{ + J MakeNamespace (const Container &src) + { + J a; + J *b = 0; + for (const int &c: src) + b = b ? b->mutable_child () : &a; + return a; + } +} +M::M (const Container &ns):ns_ (MakeNamespace (ns)) +{ +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56817.C b/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56817.C new file mode 100644 index 000000000..35fc6f74f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56817.C @@ -0,0 +1,38 @@ +// { dg-do compile } +// { dg-options "--param max-unroll-times=32" } + +struct A {}; +A **q; +struct B +{ + A **j; + B () { j = q; } + A *& operator[] (unsigned long x) { return j[x]; } +}; +struct C +{ + C (int r) : v (), s (r) {} + A *& operator () (int i, int j) { return v[i * s + j]; } + B v; + int s; +}; +struct D +{ + D () + { + unsigned h = 2; + for (int i = 0; i < 1; ++i, h *= 2) + { + C w (h); + for (unsigned j = 0; j < h; ++j) + for (unsigned k = 0; k < h; ++k) + w (j, k) = new A; + } + } +}; +void +foo () +{ + for (int i = 0; i < 3; i++) + A (), A (), D (); +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56837.C b/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56837.C new file mode 100644 index 000000000..d00712280 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/torture/pr56837.C @@ -0,0 +1,20 @@ +// { dg-do run } +// { dg-options "-ftree-loop-distribute-patterns" } + +extern "C" void abort (void); +extern "C" int memcmp (const void *, const void *, __SIZE_TYPE__); + +bool b1[8]; +bool b2[8] = { true, true, true, true, true, true, true, true }; + +int main() +{ + unsigned int i; + for(i=0 ; i < 8; i++) + b1[i] = true; + + if (memcmp (b1, b2, 8) != 0) + abort (); + + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/warn/Wdiv-by-zero-2.C b/gcc-4.8/gcc/testsuite/g++.dg/warn/Wdiv-by-zero-2.C new file mode 100644 index 000000000..d7e226ce0 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/warn/Wdiv-by-zero-2.C @@ -0,0 +1,34 @@ +// PR c++/56607 +// { dg-do compile { target { { lp64 || ilp32 } || llp64 } } } +// { dg-options "-O2 -Wdiv-by-zero -std=c++11" } + +constexpr int sc () { return sizeof (char); } +constexpr int si () { return sizeof (int); } +constexpr int zc () { return sc () - 1; } +constexpr int zi (int d) { return si () / d - 1; } + +int +f1 (void) +{ + return 1 / zc (); // { dg-warning "division by zero" } +} + +int +f2 (void) +{ + constexpr int x = zc (); + return 1 / x; // { dg-warning "division by zero" } +} + +int +f3 (void) +{ + return 1 / zi (3); // { dg-warning "division by zero" } +} + +int +f4 (void) +{ + constexpr int x = zi (3); + return 1 / x; // { dg-warning "division by zero" } +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/warn/anonymous-namespace-4.C b/gcc-4.8/gcc/testsuite/g++.dg/warn/anonymous-namespace-4.C new file mode 100644 index 000000000..7d1e89edf --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/warn/anonymous-namespace-4.C @@ -0,0 +1,12 @@ +// PR c++/57137 + +#include "anonymous-namespace-4.h" + +namespace +{ + class NonCloneable; + void fn1 () + { + is_function_impl < NonCloneable > i; + } +} diff --git a/gcc-4.8/gcc/testsuite/g++.dg/warn/anonymous-namespace-4.h b/gcc-4.8/gcc/testsuite/g++.dg/warn/anonymous-namespace-4.h new file mode 100644 index 000000000..e0b7d68c1 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/g++.dg/warn/anonymous-namespace-4.h @@ -0,0 +1,14 @@ +template < typename T > struct integral_c { + static const T value = 0; +}; +struct is_reference:integral_c < bool > { }; +template < class > struct is_function_ptr_helper { }; +template < bool > struct is_function_chooser; + +template <> struct is_function_chooser <0 > +{ + template < typename T > struct result_:is_function_ptr_helper < T * > { }; +}; + +template < typename T > struct is_function_impl:is_function_chooser < + is_reference::value >::result_ < T > { }; |