[4.8] Merge GCC 4.8.1

Change-Id: Ic8a60b7563f5172440fd40788605163a0cca6e30

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 > { };