[PATCH] configure: Require C++11 for building code generation tools

[PATCH] configure: Require C++11 for building code generation tools

[Vasee Vinayagamoorthy]

[-- Attachment #1: Type: text/plain, Size: 898 bytes --]

Hello,

After commit [1] ("Redefine NULL to nullptr"), building gcc
fails when $CXX_FOR_BUILD is not using C++11 mode by default.
This happens with gcc-4.8 which is still supported.

This patch fixes this by adding -std=c++11 or its equivalent
to $CXX_FOR_BUILD using AX_CXX_COMPILE_STDCXX(11).

Tested by successful cross native build for aarch64-none-linux-gnu target.

OK for trunk?


ChangeLog:

2020-08-20  Ilya Leoshkevich  <iii@linux.ibm.com>
            Vasee Vinayagamoorthy  <vaseeharan.vinayagamoorthy@arm.com>

	PR target/95700
	* configure: Regenerate.
	* configure.ac: Require C++11 for building code generation tools.

Regards
Vasee Vinayagamoorthy


PS: I do not have commit rights, therefore could I request
someone to commit it on my behalf if this patch is approved.
Thanks in advance.

[1] https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=d59a576b8b5e12c3a56f0262912090e2921f5daa

[-- Attachment #2: cpp11.patch --]
[-- Type: text/x-diff, Size: 24571 bytes --]

diff --git a/configure b/configure
index a0c5aca9e8d..1023dc72fd4 100755
--- a/configure
+++ b/configure
@@ -6523,6 +6523,1011 @@ $as_echo "#define HAVE_CXX11 1" >>confdefs.h
 
 fi
 
+# Also require C++11 for building code generation tools.
+# Do nothing if "${build}" = "${host}", because in this case
+# CXX_FOR_BUILD="\$(CXX)", and $CXX is already set to the correct value above.
+if test "${build}" != "${host}"; then
+  saved_CXX=$CXX
+  saved_CXXCPP=$CXXCPP
+  CXX=$CXX_FOR_BUILD
+  CXXCPP=
+    ax_cxx_compile_alternatives="11 0x"    ax_cxx_compile_cxx11_required=true
+  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+  ac_success=no
+
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features by default" >&5
+$as_echo_n "checking whether $CXX supports C++11 features by default... " >&6; }
+if ${ax_cv_cxx_compile_cxx11+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual ~Base() {}
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual ~Derived() override {}
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = [](){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = [](int i, int j){ return i + j; }(1, 2);
+      auto b = []() -> int { return '0'; }();
+      auto c = [=](){ return a + b; }();
+      auto d = [&](){ return c; }();
+      auto e = [a, &b](int x) mutable {
+        const auto identity = [](int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = [](){ return 0; };
+      const auto unary = [](int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = [](nullary_t f){ return f(); };
+      const auto higher2nd = [unary](nullary_t f1){
+        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ax_cv_cxx_compile_cxx11=yes
+else
+  ax_cv_cxx_compile_cxx11=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx11" >&5
+$as_echo "$ax_cv_cxx_compile_cxx11" >&6; }
+    if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+      ac_success=yes
+    fi
+
+    if test x$ac_success = xno; then
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      switch="-std=gnu++${alternative}"
+      cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh`
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; }
+if eval \${$cachevar+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual ~Base() {}
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual ~Derived() override {}
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = [](){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = [](int i, int j){ return i + j; }(1, 2);
+      auto b = []() -> int { return '0'; }();
+      auto c = [=](){ return a + b; }();
+      auto d = [&](){ return c; }();
+      auto e = [a, &b](int x) mutable {
+        const auto identity = [](int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = [](){ return 0; };
+      const auto unary = [](int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = [](nullary_t f){ return f(); };
+      const auto higher2nd = [unary](nullary_t f1){
+        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  eval $cachevar=yes
+else
+  eval $cachevar=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+         CXX="$ac_save_CXX"
+fi
+eval ac_res=\$$cachevar
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi
+
+    if test x$ac_success = xno; then
+                for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh`
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; }
+if eval \${$cachevar+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual ~Base() {}
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual ~Derived() override {}
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = [](){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = [](int i, int j){ return i + j; }(1, 2);
+      auto b = []() -> int { return '0'; }();
+      auto c = [=](){ return a + b; }();
+      auto d = [&](){ return c; }();
+      auto e = [a, &b](int x) mutable {
+        const auto identity = [](int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = [](){ return 0; };
+      const auto unary = [](int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = [](nullary_t f){ return f(); };
+      const auto higher2nd = [unary](nullary_t f1){
+        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  eval $cachevar=yes
+else
+  eval $cachevar=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+           CXX="$ac_save_CXX"
+fi
+eval ac_res=\$$cachevar
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
+        fi
+      done
+      if test x$ac_success = xyes; then
+        break
+      fi
+    done
+  fi
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+  if test x$ax_cxx_compile_cxx11_required = xtrue; then
+    if test x$ac_success = xno; then
+      as_fn_error $? "*** A compiler with support for C++11 language features is required." "$LINENO" 5
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX11=0
+    { $as_echo "$as_me:${as_lineno-$LINENO}: No compiler with C++11 support was found" >&5
+$as_echo "$as_me: No compiler with C++11 support was found" >&6;}
+  else
+    HAVE_CXX11=1
+
+$as_echo "#define HAVE_CXX11 1" >>confdefs.h
+
+  fi
+
+
+  CXX="$CXX -std=c++11"
+  CXX_FOR_BUILD=$CXX
+  CXX=$saved_CXX
+  CXXCPP=$saved_CXXCPP
+fi
+
 # Used for setting $lt_cv_objdir
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
 $as_echo_n "checking for objdir... " >&6; }
diff --git a/configure.ac b/configure.ac
index 1a53ed418e4..30439da6d33 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1472,6 +1472,21 @@ elif test "$have_compiler" = yes; then
   AX_CXX_COMPILE_STDCXX(11)
 fi
 
+# Also require C++11 for building code generation tools.
+# Do nothing if "${build}" = "${host}", because in this case
+# CXX_FOR_BUILD="\$(CXX)", and $CXX is already set to the correct value above.
+if test "${build}" != "${host}"; then
+  saved_CXX=$CXX
+  saved_CXXCPP=$CXXCPP
+  CXX=$CXX_FOR_BUILD
+  CXXCPP=
+  AX_CXX_COMPILE_STDCXX(11)
+  CXX="$CXX -std=c++11"
+  CXX_FOR_BUILD=$CXX
+  CXX=$saved_CXX
+  CXXCPP=$saved_CXXCPP
+fi
+
 # Used for setting $lt_cv_objdir
 _LT_CHECK_OBJDIR
 

Re: [PATCH] configure: Require C++11 for building code generation tools

[Ilya Leoshkevich]

On Thu, 2020-08-20 at 13:59 +0100, Vasee Vinayagamoorthy wrote:
> Hello,
> 
> After commit [1] ("Redefine NULL to nullptr"), building gcc
> fails when $CXX_FOR_BUILD is not using C++11 mode by default.
> This happens with gcc-4.8 which is still supported.
> 
> This patch fixes this by adding -std=c++11 or its equivalent
> to $CXX_FOR_BUILD using AX_CXX_COMPILE_STDCXX(11).
> 
> Tested by successful cross native build for aarch64-none-linux-gnu
> target.
> 
> OK for trunk?
> 
> 
> ChangeLog:
> 
> 2020-08-20  Ilya Leoshkevich  <iii@linux.ibm.com>
>             Vasee Vinayagamoorthy  <
> vaseeharan.vinayagamoorthy@arm.com>
> 
> 	PR target/95700
> 	* configure: Regenerate.
> 	* configure.ac: Require C++11 for building code generation
> tools.
> 
> Regards
> Vasee Vinayagamoorthy
> 
> 
> PS: I do not have commit rights, therefore could I request
> someone to commit it on my behalf if this patch is approved.
> Thanks in advance.
> 
> [1] 
> https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=d59a576b8b5e12c3a56f0262912090e2921f5daa

Hi!

First of all, sorry about losing track of this issue.

Regarding your addition to the patch, I fear that

CXX="$CXX -std=c++11"

might break some rarely used compilers. But doing this portably is
exactly what AX_CXX_COMPILE_STDCXX(11) is for. Do you know why isn't it
working for you?

Best regards,
Ilya

Re: [PATCH] configure: Require C++11 for building code generation tools

[Szabolcs Nagy]

The 08/20/2020 13:59, Vasee Vinayagamoorthy wrote:
> +# Also require C++11 for building code generation tools.
> +# Do nothing if "${build}" = "${host}", because in this case
> +# CXX_FOR_BUILD="\$(CXX)", and $CXX is already set to the correct value above.
> +if test "${build}" != "${host}"; then
> +  saved_CXX=$CXX
> +  saved_CXXCPP=$CXXCPP
> +  CXX=$CXX_FOR_BUILD
> +  CXXCPP=
> +  AX_CXX_COMPILE_STDCXX(11)
> +  CXX="$CXX -std=c++11"
> +  CXX_FOR_BUILD=$CXX
> +  CXX=$saved_CXX
> +  CXXCPP=$saved_CXXCPP
> +fi

i think AX_CXX_COMPILE_STDCXX(11) should
set CXX correctly (it seems it would set
it to "g++ -std=gnu++11" instead of
"g++ -std=c++11" but either should work)

please look at the top level config.log
i think you should look for

"checking whether g++ supports C++11 features with -std=gnu++11"

and that check should be successful.

Re: [PATCH] configure: Require C++11 for building code generation tools

[Tobias Burnus]

Hi,

how about my (unreviewed) patch for PR 96612 at
https://gcc.gnu.org/pipermail/gcc-patches/2020-August/551900.html ?

That one also tries to solve the CXX_FOR_BUILD issue with an older GCC.
Would that solve your issue as well?

Tobias

On 8/20/20 4:19 PM, Ilya Leoshkevich via Gcc-patches wrote:

> On Thu, 2020-08-20 at 13:59 +0100, Vasee Vinayagamoorthy wrote:
>> Hello,
>>
>> After commit [1] ("Redefine NULL to nullptr"), building gcc
>> fails when $CXX_FOR_BUILD is not using C++11 mode by default.
>> This happens with gcc-4.8 which is still supported.
>>
>> This patch fixes this by adding -std=c++11 or its equivalent
>> to $CXX_FOR_BUILD using AX_CXX_COMPILE_STDCXX(11).
>>
>> Tested by successful cross native build for aarch64-none-linux-gnu
>> target.
>>
>> OK for trunk?
>>
>>
>> ChangeLog:
>>
>> 2020-08-20  Ilya Leoshkevich  <iii@linux.ibm.com>
>>              Vasee Vinayagamoorthy  <
>> vaseeharan.vinayagamoorthy@arm.com>
>>
>>      PR target/95700
>>      * configure: Regenerate.
>>      * configure.ac: Require C++11 for building code generation
>> tools.
>>
>> Regards
>> Vasee Vinayagamoorthy
>>
>>
>> PS: I do not have commit rights, therefore could I request
>> someone to commit it on my behalf if this patch is approved.
>> Thanks in advance.
>>
>> [1]
>> https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=d59a576b8b5e12c3a56f0262912090e2921f5daa
> Hi!
>
> First of all, sorry about losing track of this issue.
>
> Regarding your addition to the patch, I fear that
>
> CXX="$CXX -std=c++11"
>
> might break some rarely used compilers. But doing this portably is
> exactly what AX_CXX_COMPILE_STDCXX(11) is for. Do you know why isn't it
> working for you?
>
> Best regards,
> Ilya
>
-----------------
Mentor Graphics (Deutschland) GmbH, Arnulfstraße 201, 80634 München / Germany
Registergericht München HRB 106955, Geschäftsführer: Thomas Heurung, Alexander Walter

Re: [PATCH] configure: Require C++11 for building code generation tools

[Vaseeharan Vinayagamoorthy]

Hi Szabolcs,

In the top level gcc config.log, I see:

configure:5541: checking whether aarch64-none-linux-gnu-g++ supports C++11 features by default
configure:5837: aarch64-none-linux-gnu-g++ -c -g -O2  conftest.cpp >&5
configure:5837: $? = 0
configure:5844: result: yes
configure:6542: checking whether g++ supports C++11 features by default
configure:6845: result: yes

Not sure whether that helps?

Regards
Vasee


On 20/08/2020, 16:26, "Szabolcs Nagy" <Szabolcs.Nagy@arm.com> wrote:

    The 08/20/2020 13:59, Vasee Vinayagamoorthy wrote:
    > +# Also require C++11 for building code generation tools.
    > +# Do nothing if "${build}" = "${host}", because in this case
    > +# CXX_FOR_BUILD="\$(CXX)", and $CXX is already set to the correct value above.
    > +if test "${build}" != "${host}"; then
    > +  saved_CXX=$CXX
    > +  saved_CXXCPP=$CXXCPP
    > +  CXX=$CXX_FOR_BUILD
    > +  CXXCPP=
    > +  AX_CXX_COMPILE_STDCXX(11)
    > +  CXX="$CXX -std=c++11"
    > +  CXX_FOR_BUILD=$CXX
    > +  CXX=$saved_CXX
    > +  CXXCPP=$saved_CXXCPP
    > +fi

    i think AX_CXX_COMPILE_STDCXX(11) should
    set CXX correctly (it seems it would set
    it to "g++ -std=gnu++11" instead of
    "g++ -std=c++11" but either should work)

    please look at the top level config.log
    i think you should look for

    "checking whether g++ supports C++11 features with -std=gnu++11"

    and that check should be successful.

Re: [PATCH] configure: Require C++11 for building code generation tools

[Richard Earnshaw (lists)]

On 20/08/2020 18:07, Vaseeharan Vinayagamoorthy wrote:
> Hi Szabolcs,
> 
> In the top level gcc config.log, I see:
> 
> configure:5541: checking whether aarch64-none-linux-gnu-g++ supports C++11 features by default
> configure:5837: aarch64-none-linux-gnu-g++ -c -g -O2  conftest.cpp >&5
> configure:5837: $? = 0
> configure:5844: result: yes
> configure:6542: checking whether g++ supports C++11 features by default
> configure:6845: result: yes
> 
> Not sure whether that helps?
> 

I suspect this is a host/build confusion issue.  Are you sure that's the
compiler used for BUILD?

R.

> Regards
> Vasee
> 
> 
> On 20/08/2020, 16:26, "Szabolcs Nagy" <Szabolcs.Nagy@arm.com> wrote:
> 
>     The 08/20/2020 13:59, Vasee Vinayagamoorthy wrote:
>     > +# Also require C++11 for building code generation tools.
>     > +# Do nothing if "${build}" = "${host}", because in this case
>     > +# CXX_FOR_BUILD="\$(CXX)", and $CXX is already set to the correct value above.
>     > +if test "${build}" != "${host}"; then
>     > +  saved_CXX=$CXX
>     > +  saved_CXXCPP=$CXXCPP
>     > +  CXX=$CXX_FOR_BUILD
>     > +  CXXCPP=
>     > +  AX_CXX_COMPILE_STDCXX(11)
>     > +  CXX="$CXX -std=c++11"
>     > +  CXX_FOR_BUILD=$CXX
>     > +  CXX=$saved_CXX
>     > +  CXXCPP=$saved_CXXCPP
>     > +fi
> 
>     i think AX_CXX_COMPILE_STDCXX(11) should
>     set CXX correctly (it seems it would set
>     it to "g++ -std=gnu++11" instead of
>     "g++ -std=c++11" but either should work)
> 
>     please look at the top level config.log
>     i think you should look for
> 
>     "checking whether g++ supports C++11 features with -std=gnu++11"
> 
>     and that check should be successful.
> 

Re: [PATCH] configure: Require C++11 for building code generation tools

[Vaseeharan Vinayagamoorthy]

Hi Tobias,

This patch fixes the issue that I was seeing, thanks.
I will also now try your updated patch from https://gcc.gnu.org/pipermail/gcc-patches/2020-August/552330.html

Kind Regards
Vasee

On 20/08/2020, 17:29, "Tobias Burnus" <tobias@codesourcery.com> wrote:

    Hi,

    how about my (unreviewed) patch for PR 96612 at
    https://gcc.gnu.org/pipermail/gcc-patches/2020-August/551900.html ?

    That one also tries to solve the CXX_FOR_BUILD issue with an older GCC.
    Would that solve your issue as well?

    Tobias

    On 8/20/20 4:19 PM, Ilya Leoshkevich via Gcc-patches wrote:

    > On Thu, 2020-08-20 at 13:59 +0100, Vasee Vinayagamoorthy wrote:
    >> Hello,
    >>
    >> After commit [1] ("Redefine NULL to nullptr"), building gcc
    >> fails when $CXX_FOR_BUILD is not using C++11 mode by default.
    >> This happens with gcc-4.8 which is still supported.
    >>
    >> This patch fixes this by adding -std=c++11 or its equivalent
    >> to $CXX_FOR_BUILD using AX_CXX_COMPILE_STDCXX(11).
    >>
    >> Tested by successful cross native build for aarch64-none-linux-gnu
    >> target.
    >>
    >> OK for trunk?
    >>
    >>
    >> ChangeLog:
    >>
    >> 2020-08-20  Ilya Leoshkevich  <iii@linux.ibm.com>
    >>              Vasee Vinayagamoorthy  <
    >> vaseeharan.vinayagamoorthy@arm.com>
    >>
    >>      PR target/95700
    >>      * configure: Regenerate.
    >>      * configure.ac: Require C++11 for building code generation
    >> tools.
    >>
    >> Regards
    >> Vasee Vinayagamoorthy
    >>
    >>
    >> PS: I do not have commit rights, therefore could I request
    >> someone to commit it on my behalf if this patch is approved.
    >> Thanks in advance.
    >>
    >> [1]
    >> https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=d59a576b8b5e12c3a56f0262912090e2921f5daa
    > Hi!
    >
    > First of all, sorry about losing track of this issue.
    >
    > Regarding your addition to the patch, I fear that
    >
    > CXX="$CXX -std=c++11"
    >
    > might break some rarely used compilers. But doing this portably is
    > exactly what AX_CXX_COMPILE_STDCXX(11) is for. Do you know why isn't it
    > working for you?
    >
    > Best regards,
    > Ilya
    >
    -----------------
    Mentor Graphics (Deutschland) GmbH, Arnulfstraße 201, 80634 München / Germany
    Registergericht München HRB 106955, Geschäftsführer: Thomas Heurung, Alexander Walter