On 9/20/24 11:51 AM, Jason Merrill wrote:
On 9/19/24 4:37 PM, Jakub Jelinek wrote:
On Thu, Sep 19, 2024 at 10:21:15AM -0400, Jason Merrill wrote:
On 9/19/24 7:57 AM, Richard Biener wrote:
On Wed, Sep 18, 2024 at 6:22 PM Jason Merrill <ja...@redhat.com> wrote:
Tested x86_64-pc-linux-gnu with 5.5.0 bootstrap compiler. Thoughts?
I'm fine with this in general - do we have needs of bumping the
requirement for
GCC 15 though? IMO we should bump once we are requiring actual C++14
in some place.
Jakub's dwarf2asm patch yesterday uses C++14 if available, and I
remember
And libcpp too.
seeing a couple of other patches that would have been simpler with C++14
available.
It was just a few lines and if I removed the now never true
HAVE_DESIGNATED_INITIALIZERS cases, it wouldn't even add any new
lines, just
change some to others. Both of those patches were just minor
optimizations,
it is fine if they don't happen during stage1.
We also have some spots with
#if __cpp_inline_variables < 201606L
#else
#endif
conditionals but that doesn't mean we need to bump to C++17.
Sure, bumping the required C++ version means we can remove the
corresponding
conditionals, and more importantly stop worrying about working around GCC
4.8.x/4.9 bugs (I think that is actually more important).
The price is stopping to use some of the cfarm machines for testing or
using IBM Advanced Toolchain or hand-built GCC 14 there as the system
compiler there.
Looks like the affected cfarm machines would be the PPC CentOS 7 boxes:
cfarm110, 112, and 135, which are still on gcc 4.8.5. Currently /opt/
cfarm/gcc-latest is a dead symlink on all three. I've now installed 9.5
on cfarm110 and am building 11.5 on cfarm135.
At some point we certainly want to do that, the question is if the
benefits
right now overweight the pain.
Absolutely, the question is what pain there is at this point.
As of the version requirement as you say only some minor versions of
the GCC 5
series are OK I would suggest to say we recommend using GCC 6 or later
but GCC 5.5 should also work?
Aren't we already specifying a minor revision with 4.8.3 for C++11?
Another possibility would be to just say GCC 5, and adjust that
upward if we
run into problems.
I think for the oldest supported version we need some CFarm machines
around
with that compiler so that all people can actually test issues with it.
Dunno which distros shipped GCC 5 in long term support versions if any
and
at which minor those are.
Dongsheng Song just pointed out that Ubuntu 16.04 LTS is on GCC 5.4,
though the cfarm doesn't have such a system.
But I don't think it's necessary to have the oldest supported version be
a system compiler, IMO it should be fine to use a custom-built compiler
in /opt/cfarm for testing. I started installing 5.* on cfarm187, but
now I see it has no system gnat. I started over on cfarm186, which has
system gnat, but Ada 5.5 bootstrap fails.
On 9/20/24 8:27 AM, Richard Biener wrote:
So I'm fine with raising the requirement now and documenting the
oldest working
release; we'd just have to double-check that really does it - for
example when
we document 5.4 works that might suggest people should go and download
& build
5.4 while of course they should instead go and download the newest
release that
had the same build requirement as 5.4 had - that's why I suggested to
document
a _recommended_ version plus the oldest version that's known to work
if readily
available.
As Iain was suggesting, 9.5 seems like a good universal transition
between very old compilers and trunk, as it's the minimum requirement to
build current D, and also the last version that just requires some
version of GNAT to build Ada rather than a minimum version (currently
5.1). 9 was also the version in which we declared C++17 support stable
(though it was feature-complete in 7).
Alternatively, systems (that care about Ada and D) running 4.7 could
build 10.5, systems running 4.8 could build 11.5.
Here's an updated patch. I tested C++14 bootstrap again with 5.x
compilers, and Jakub's dwarf2asm change breaks on 5.3 due to PR69995,
while 5.4 successfully bootstraps.
I also added the 9.5 recommendation.
From 87e90d3677a6211b5bb9fc6865b987203a819108 Mon Sep 17 00:00:00 2001
From: Jason Merrill <ja...@redhat.com>
Date: Tue, 17 Sep 2024 17:38:35 -0400
Subject: [PATCH] build: update bootstrap req to C++14
To: gcc-patches@gcc.gnu.org
This implements my proposal to update our bootstrap requirement to C++14.
The big benefit of the change is the greater constexpr power, but C++14 also
added variable templates, generic lambdas, lambda init-capture, binary
literals, and numeric literal digit separators.
C++14 was feature-complete in GCC 5, and became the default in GCC 6. 5.4.0
bootstraps trunk correctly; trunk stage1 built with 5.3.0 breaks in
eh_data_format_name due to PR69995.
gcc/ChangeLog:
* doc/install.texi (Prerequisites): Update to C++14.
ChangeLog:
* configure.ac: Update requirement to C++14.
* configure: Regenerate.
---
gcc/doc/install.texi | 20 +-
configure.ac | 12 +-
configure | 832 ++++++++++++++++++++++++++++++++++++++++---
3 files changed, 795 insertions(+), 69 deletions(-)
diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi
index b7c14e8b6f0..b562b0f38d6 100644
--- a/gcc/doc/install.texi
+++ b/gcc/doc/install.texi
@@ -222,17 +222,23 @@ described below.
@heading Tools/packages necessary for building GCC
@table @asis
-@item ISO C++11 compiler
-Necessary to bootstrap GCC. GCC 4.8.3 or newer has sufficient
-support for used C++11 features.
+@item ISO C++14 compiler
+Necessary to bootstrap GCC. GCC 5.4 or newer has sufficient support
+for used C++14 features.
-Versions of GCC prior to 11 also allow bootstrapping with an ISO C++98
-compiler, and versions of GCC prior to 4.8 also allow bootstrapping with
-an ISO C89 compiler.
+Versions of GCC prior to 15 allow bootstrapping with an ISO C++11
+compiler, versions prior to 11 allow bootstrapping with an ISO C++98
+compiler, and versions prior to 4.8 allow bootstrapping with an ISO
+C89 compiler.
+
+If you need to build an intermediate version of GCC in order to
+bootstrap current GCC, consider GCC 9.5: it can build the current Ada
+and D compilers, and was also the version that declared C++17 support
+stable.
To build all languages in a cross-compiler or other configuration where
3-stage bootstrap is not performed, you need to start with an existing
-GCC binary (version 4.8.3 or later) because source code for language
+GCC binary (of a new enough version) because source code for language
frontends other than C might use GCC extensions.
@item C standard library and headers
diff --git a/configure.ac b/configure.ac
index 2567757e74d..bd2abce437e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1457,16 +1457,16 @@ case "$have_compiler:$host:$target:$enable_bootstrap" in
;;
esac
-# When bootstrapping with GCC, build stage 1 in C++11 mode to ensure that a
-# C++11 compiler can still start the bootstrap. Otherwise, if building GCC,
-# require C++11 (or higher).
+# When bootstrapping with GCC, build stage 1 in C++14 mode to ensure that a
+# C++14 compiler can still start the bootstrap. Otherwise, if building GCC,
+# require C++14 (or higher).
if test "$enable_bootstrap:$GXX" = "yes:yes"; then
- CXX="$CXX -std=c++11"
+ CXX="$CXX -std=c++14"
elif test "$have_compiler" = yes; then
- AX_CXX_COMPILE_STDCXX(11)
+ AX_CXX_COMPILE_STDCXX(14)
if test "${build}" != "${host}"; then
- AX_CXX_COMPILE_STDCXX(11, [], [], [_FOR_BUILD])
+ AX_CXX_COMPILE_STDCXX(14, [], [], [_FOR_BUILD])
fi
fi
diff --git a/configure b/configure
index 6a77d454fd5..46382dd4efd 100755
--- a/configure
+++ b/configure
@@ -712,8 +712,8 @@ gmplibs
PGO_BUILD_LTO_CFLAGS
PGO_BUILD_USE_CFLAGS
PGO_BUILD_GEN_CFLAGS
-HAVE_CXX11_FOR_BUILD
-HAVE_CXX11
+HAVE_CXX14_FOR_BUILD
+HAVE_CXX14
do_compare
CARGO
GDC
@@ -5914,13 +5914,13 @@ $as_echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
;;
esac
-# When bootstrapping with GCC, build stage 1 in C++11 mode to ensure that a
-# C++11 compiler can still start the bootstrap. Otherwise, if building GCC,
-# require C++11 (or higher).
+# When bootstrapping with GCC, build stage 1 in C++14 mode to ensure that a
+# C++14 compiler can still start the bootstrap. Otherwise, if building GCC,
+# require C++14 (or higher).
if test "$enable_bootstrap:$GXX" = "yes:yes"; then
- CXX="$CXX -std=c++11"
+ CXX="$CXX -std=c++14"
elif test "$have_compiler" = yes; then
- ax_cxx_compile_alternatives="11 0x" ax_cxx_compile_cxx11_required=true
+ ax_cxx_compile_alternatives="14 1y" ax_cxx_compile_cxx14_required=true
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -5928,9 +5928,9 @@ ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ex
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 "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++14 features by default" >&5
+$as_echo_n "checking whether $CXX supports C++14 features by default... " >&6; }
+if ${ax_cv_cxx_compile_cxx14+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -6223,26 +6223,146 @@ namespace cxx11
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+ namespace test_polymorphic_lambdas
+ {
+
+ int
+ test()
+ {
+ const auto lambda = [](auto&&... args){
+ const auto istiny = [](auto x){
+ return (sizeof(x) == 1UL) ? 1 : 0;
+ };
+ const int aretiny[] = { istiny(args)... };
+ return aretiny[0];
+ };
+ return lambda(1, 1L, 1.0f, '1');
+ }
+
+ }
+
+ namespace test_binary_literals
+ {
+
+ constexpr auto ivii = 0b0000000000101010;
+ static_assert(ivii == 42, "wrong value");
+
+ }
+
+ namespace test_generalized_constexpr
+ {
+
+ template < typename CharT >
+ constexpr unsigned long
+ strlen_c(const CharT *const s) noexcept
+ {
+ auto length = 0UL;
+ for (auto p = s; *p; ++p)
+ ++length;
+ return length;
+ }
+
+ static_assert(strlen_c("") == 0UL, "");
+ static_assert(strlen_c("x") == 1UL, "");
+ static_assert(strlen_c("test") == 4UL, "");
+ static_assert(strlen_c("another\0test") == 7UL, "");
+
+ }
+
+ namespace test_lambda_init_capture
+ {
+
+ int
+ test()
+ {
+ auto x = 0;
+ const auto lambda1 = [a = x](int b){ return a + b; };
+ const auto lambda2 = [a = lambda1(x)](){ return a; };
+ return lambda2();
+ }
+
+ }
+
+ namespace test_digit_separators
+ {
+
+ constexpr auto ten_million = 100'000'000;
+ static_assert(ten_million == 100000000, "");
+
+ }
+
+ namespace test_return_type_deduction
+ {
+
+ auto f(int& x) { return x; }
+ decltype(auto) g(int& x) { return x; }
+
+ template < typename T1, typename T2 >
+ struct is_same
+ {
+ static constexpr auto value = false;
+ };
+
+ template < typename T >
+ struct is_same<T, T>
+ {
+ static constexpr auto value = true;
+ };
+
+ int
+ test()
+ {
+ auto x = 0;
+ static_assert(is_same<int, decltype(f(x))>::value, "");
+ static_assert(is_same<int&, decltype(g(x))>::value, "");
+ return x;
+ }
+
+ }
+
+} // namespace cxx14
+
+#endif // __cplusplus >= 201402L
+
+
+
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
- ax_cv_cxx_compile_cxx11=yes
+ ax_cv_cxx_compile_cxx14=yes
else
- ax_cv_cxx_compile_cxx11=no
+ ax_cv_cxx_compile_cxx14=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
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx14" >&5
+$as_echo "$ax_cv_cxx_compile_cxx14" >&6; }
+ if test x$ax_cv_cxx_compile_cxx14 = 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; }
+ cachevar=`$as_echo "ax_cv_cxx_compile_cxx14_$switch" | $as_tr_sh`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++14 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++14 features with $switch... " >&6; }
if eval \${$cachevar+:} false; then :
$as_echo_n "(cached) " >&6
else
@@ -6538,6 +6658,126 @@ namespace cxx11
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+ namespace test_polymorphic_lambdas
+ {
+
+ int
+ test()
+ {
+ const auto lambda = [](auto&&... args){
+ const auto istiny = [](auto x){
+ return (sizeof(x) == 1UL) ? 1 : 0;
+ };
+ const int aretiny[] = { istiny(args)... };
+ return aretiny[0];
+ };
+ return lambda(1, 1L, 1.0f, '1');
+ }
+
+ }
+
+ namespace test_binary_literals
+ {
+
+ constexpr auto ivii = 0b0000000000101010;
+ static_assert(ivii == 42, "wrong value");
+
+ }
+
+ namespace test_generalized_constexpr
+ {
+
+ template < typename CharT >
+ constexpr unsigned long
+ strlen_c(const CharT *const s) noexcept
+ {
+ auto length = 0UL;
+ for (auto p = s; *p; ++p)
+ ++length;
+ return length;
+ }
+
+ static_assert(strlen_c("") == 0UL, "");
+ static_assert(strlen_c("x") == 1UL, "");
+ static_assert(strlen_c("test") == 4UL, "");
+ static_assert(strlen_c("another\0test") == 7UL, "");
+
+ }
+
+ namespace test_lambda_init_capture
+ {
+
+ int
+ test()
+ {
+ auto x = 0;
+ const auto lambda1 = [a = x](int b){ return a + b; };
+ const auto lambda2 = [a = lambda1(x)](){ return a; };
+ return lambda2();
+ }
+
+ }
+
+ namespace test_digit_separators
+ {
+
+ constexpr auto ten_million = 100'000'000;
+ static_assert(ten_million == 100000000, "");
+
+ }
+
+ namespace test_return_type_deduction
+ {
+
+ auto f(int& x) { return x; }
+ decltype(auto) g(int& x) { return x; }
+
+ template < typename T1, typename T2 >
+ struct is_same
+ {
+ static constexpr auto value = false;
+ };
+
+ template < typename T >
+ struct is_same<T, T>
+ {
+ static constexpr auto value = true;
+ };
+
+ int
+ test()
+ {
+ auto x = 0;
+ static_assert(is_same<int, decltype(f(x))>::value, "");
+ static_assert(is_same<int&, decltype(g(x))>::value, "");
+ return x;
+ }
+
+ }
+
+} // namespace cxx14
+
+#endif // __cplusplus >= 201402L
+
+
+
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
eval $cachevar=yes
@@ -6564,9 +6804,9 @@ $as_echo "$ac_res" >&6; }
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; }
+ cachevar=`$as_echo "ax_cv_cxx_compile_cxx14_$switch" | $as_tr_sh`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++14 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++14 features with $switch... " >&6; }
if eval \${$cachevar+:} false; then :
$as_echo_n "(cached) " >&6
else
@@ -6862,6 +7102,126 @@ namespace cxx11
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+ namespace test_polymorphic_lambdas
+ {
+
+ int
+ test()
+ {
+ const auto lambda = [](auto&&... args){
+ const auto istiny = [](auto x){
+ return (sizeof(x) == 1UL) ? 1 : 0;
+ };
+ const int aretiny[] = { istiny(args)... };
+ return aretiny[0];
+ };
+ return lambda(1, 1L, 1.0f, '1');
+ }
+
+ }
+
+ namespace test_binary_literals
+ {
+
+ constexpr auto ivii = 0b0000000000101010;
+ static_assert(ivii == 42, "wrong value");
+
+ }
+
+ namespace test_generalized_constexpr
+ {
+
+ template < typename CharT >
+ constexpr unsigned long
+ strlen_c(const CharT *const s) noexcept
+ {
+ auto length = 0UL;
+ for (auto p = s; *p; ++p)
+ ++length;
+ return length;
+ }
+
+ static_assert(strlen_c("") == 0UL, "");
+ static_assert(strlen_c("x") == 1UL, "");
+ static_assert(strlen_c("test") == 4UL, "");
+ static_assert(strlen_c("another\0test") == 7UL, "");
+
+ }
+
+ namespace test_lambda_init_capture
+ {
+
+ int
+ test()
+ {
+ auto x = 0;
+ const auto lambda1 = [a = x](int b){ return a + b; };
+ const auto lambda2 = [a = lambda1(x)](){ return a; };
+ return lambda2();
+ }
+
+ }
+
+ namespace test_digit_separators
+ {
+
+ constexpr auto ten_million = 100'000'000;
+ static_assert(ten_million == 100000000, "");
+
+ }
+
+ namespace test_return_type_deduction
+ {
+
+ auto f(int& x) { return x; }
+ decltype(auto) g(int& x) { return x; }
+
+ template < typename T1, typename T2 >
+ struct is_same
+ {
+ static constexpr auto value = false;
+ };
+
+ template < typename T >
+ struct is_same<T, T>
+ {
+ static constexpr auto value = true;
+ };
+
+ int
+ test()
+ {
+ auto x = 0;
+ static_assert(is_same<int, decltype(f(x))>::value, "");
+ static_assert(is_same<int&, decltype(g(x))>::value, "");
+ return x;
+ }
+
+ }
+
+} // namespace cxx14
+
+#endif // __cplusplus >= 201402L
+
+
+
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
eval $cachevar=yes
@@ -6895,41 +7255,41 @@ 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$ax_cxx_compile_cxx14_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
+ as_fn_error $? "*** A compiler with support for C++14 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;}
+ HAVE_CXX14=0
+ { $as_echo "$as_me:${as_lineno-$LINENO}: No compiler with C++14 support was found" >&5
+$as_echo "$as_me: No compiler with C++14 support was found" >&6;}
else
- HAVE_CXX11=1
+ HAVE_CXX14=1
-$as_echo "#define HAVE_CXX11 1" >>confdefs.h
+$as_echo "#define HAVE_CXX14 1" >>confdefs.h
fi
if test "${build}" != "${host}"; then
- ax_cxx_compile_alternatives="11 0x" ax_cxx_compile_cxx11_required=true
+ ax_cxx_compile_alternatives="14 1y" ax_cxx_compile_cxx14_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
- ax_cv_cxx_compile_cxx11_orig_cxx="$CXX"
- ax_cv_cxx_compile_cxx11_orig_cxxflags="$CXXFLAGS"
- ax_cv_cxx_compile_cxx11_orig_cppflags="$CPPFLAGS"
+ ax_cv_cxx_compile_cxx14_orig_cxx="$CXX"
+ ax_cv_cxx_compile_cxx14_orig_cxxflags="$CXXFLAGS"
+ ax_cv_cxx_compile_cxx14_orig_cppflags="$CPPFLAGS"
CXX="$CXX_FOR_BUILD"
CXXFLAGS="$CXXFLAGS_FOR_BUILD"
CPPFLAGS="$CPPFLAGS_FOR_BUILD"
- { $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_FOR_BUILD+:} false; then :
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++14 features by default" >&5
+$as_echo_n "checking whether $CXX supports C++14 features by default... " >&6; }
+if ${ax_cv_cxx_compile_cxx14_FOR_BUILD+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -7222,26 +7582,146 @@ namespace cxx11
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+ namespace test_polymorphic_lambdas
+ {
+
+ int
+ test()
+ {
+ const auto lambda = [](auto&&... args){
+ const auto istiny = [](auto x){
+ return (sizeof(x) == 1UL) ? 1 : 0;
+ };
+ const int aretiny[] = { istiny(args)... };
+ return aretiny[0];
+ };
+ return lambda(1, 1L, 1.0f, '1');
+ }
+
+ }
+
+ namespace test_binary_literals
+ {
+
+ constexpr auto ivii = 0b0000000000101010;
+ static_assert(ivii == 42, "wrong value");
+
+ }
+
+ namespace test_generalized_constexpr
+ {
+
+ template < typename CharT >
+ constexpr unsigned long
+ strlen_c(const CharT *const s) noexcept
+ {
+ auto length = 0UL;
+ for (auto p = s; *p; ++p)
+ ++length;
+ return length;
+ }
+
+ static_assert(strlen_c("") == 0UL, "");
+ static_assert(strlen_c("x") == 1UL, "");
+ static_assert(strlen_c("test") == 4UL, "");
+ static_assert(strlen_c("another\0test") == 7UL, "");
+
+ }
+
+ namespace test_lambda_init_capture
+ {
+
+ int
+ test()
+ {
+ auto x = 0;
+ const auto lambda1 = [a = x](int b){ return a + b; };
+ const auto lambda2 = [a = lambda1(x)](){ return a; };
+ return lambda2();
+ }
+
+ }
+
+ namespace test_digit_separators
+ {
+
+ constexpr auto ten_million = 100'000'000;
+ static_assert(ten_million == 100000000, "");
+
+ }
+
+ namespace test_return_type_deduction
+ {
+
+ auto f(int& x) { return x; }
+ decltype(auto) g(int& x) { return x; }
+
+ template < typename T1, typename T2 >
+ struct is_same
+ {
+ static constexpr auto value = false;
+ };
+
+ template < typename T >
+ struct is_same<T, T>
+ {
+ static constexpr auto value = true;
+ };
+
+ int
+ test()
+ {
+ auto x = 0;
+ static_assert(is_same<int, decltype(f(x))>::value, "");
+ static_assert(is_same<int&, decltype(g(x))>::value, "");
+ return x;
+ }
+
+ }
+
+} // namespace cxx14
+
+#endif // __cplusplus >= 201402L
+
+
+
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
- ax_cv_cxx_compile_cxx11_FOR_BUILD=yes
+ ax_cv_cxx_compile_cxx14_FOR_BUILD=yes
else
- ax_cv_cxx_compile_cxx11_FOR_BUILD=no
+ ax_cv_cxx_compile_cxx14_FOR_BUILD=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_FOR_BUILD" >&5
-$as_echo "$ax_cv_cxx_compile_cxx11_FOR_BUILD" >&6; }
- if test x$ax_cv_cxx_compile_cxx11_FOR_BUILD = xyes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx14_FOR_BUILD" >&5
+$as_echo "$ax_cv_cxx_compile_cxx14_FOR_BUILD" >&6; }
+ if test x$ax_cv_cxx_compile_cxx14_FOR_BUILD = 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_FOR_BUILD_$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; }
+ cachevar=`$as_echo "ax_cv_cxx_compile_cxx14_FOR_BUILD_$switch" | $as_tr_sh`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++14 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++14 features with $switch... " >&6; }
if eval \${$cachevar+:} false; then :
$as_echo_n "(cached) " >&6
else
@@ -7537,6 +8017,126 @@ namespace cxx11
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+ namespace test_polymorphic_lambdas
+ {
+
+ int
+ test()
+ {
+ const auto lambda = [](auto&&... args){
+ const auto istiny = [](auto x){
+ return (sizeof(x) == 1UL) ? 1 : 0;
+ };
+ const int aretiny[] = { istiny(args)... };
+ return aretiny[0];
+ };
+ return lambda(1, 1L, 1.0f, '1');
+ }
+
+ }
+
+ namespace test_binary_literals
+ {
+
+ constexpr auto ivii = 0b0000000000101010;
+ static_assert(ivii == 42, "wrong value");
+
+ }
+
+ namespace test_generalized_constexpr
+ {
+
+ template < typename CharT >
+ constexpr unsigned long
+ strlen_c(const CharT *const s) noexcept
+ {
+ auto length = 0UL;
+ for (auto p = s; *p; ++p)
+ ++length;
+ return length;
+ }
+
+ static_assert(strlen_c("") == 0UL, "");
+ static_assert(strlen_c("x") == 1UL, "");
+ static_assert(strlen_c("test") == 4UL, "");
+ static_assert(strlen_c("another\0test") == 7UL, "");
+
+ }
+
+ namespace test_lambda_init_capture
+ {
+
+ int
+ test()
+ {
+ auto x = 0;
+ const auto lambda1 = [a = x](int b){ return a + b; };
+ const auto lambda2 = [a = lambda1(x)](){ return a; };
+ return lambda2();
+ }
+
+ }
+
+ namespace test_digit_separators
+ {
+
+ constexpr auto ten_million = 100'000'000;
+ static_assert(ten_million == 100000000, "");
+
+ }
+
+ namespace test_return_type_deduction
+ {
+
+ auto f(int& x) { return x; }
+ decltype(auto) g(int& x) { return x; }
+
+ template < typename T1, typename T2 >
+ struct is_same
+ {
+ static constexpr auto value = false;
+ };
+
+ template < typename T >
+ struct is_same<T, T>
+ {
+ static constexpr auto value = true;
+ };
+
+ int
+ test()
+ {
+ auto x = 0;
+ static_assert(is_same<int, decltype(f(x))>::value, "");
+ static_assert(is_same<int&, decltype(g(x))>::value, "");
+ return x;
+ }
+
+ }
+
+} // namespace cxx14
+
+#endif // __cplusplus >= 201402L
+
+
+
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
eval $cachevar=yes
@@ -7563,9 +8163,9 @@ $as_echo "$ac_res" >&6; }
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_FOR_BUILD_$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; }
+ cachevar=`$as_echo "ax_cv_cxx_compile_cxx14_FOR_BUILD_$switch" | $as_tr_sh`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++14 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++14 features with $switch... " >&6; }
if eval \${$cachevar+:} false; then :
$as_echo_n "(cached) " >&6
else
@@ -7861,6 +8461,126 @@ namespace cxx11
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+ namespace test_polymorphic_lambdas
+ {
+
+ int
+ test()
+ {
+ const auto lambda = [](auto&&... args){
+ const auto istiny = [](auto x){
+ return (sizeof(x) == 1UL) ? 1 : 0;
+ };
+ const int aretiny[] = { istiny(args)... };
+ return aretiny[0];
+ };
+ return lambda(1, 1L, 1.0f, '1');
+ }
+
+ }
+
+ namespace test_binary_literals
+ {
+
+ constexpr auto ivii = 0b0000000000101010;
+ static_assert(ivii == 42, "wrong value");
+
+ }
+
+ namespace test_generalized_constexpr
+ {
+
+ template < typename CharT >
+ constexpr unsigned long
+ strlen_c(const CharT *const s) noexcept
+ {
+ auto length = 0UL;
+ for (auto p = s; *p; ++p)
+ ++length;
+ return length;
+ }
+
+ static_assert(strlen_c("") == 0UL, "");
+ static_assert(strlen_c("x") == 1UL, "");
+ static_assert(strlen_c("test") == 4UL, "");
+ static_assert(strlen_c("another\0test") == 7UL, "");
+
+ }
+
+ namespace test_lambda_init_capture
+ {
+
+ int
+ test()
+ {
+ auto x = 0;
+ const auto lambda1 = [a = x](int b){ return a + b; };
+ const auto lambda2 = [a = lambda1(x)](){ return a; };
+ return lambda2();
+ }
+
+ }
+
+ namespace test_digit_separators
+ {
+
+ constexpr auto ten_million = 100'000'000;
+ static_assert(ten_million == 100000000, "");
+
+ }
+
+ namespace test_return_type_deduction
+ {
+
+ auto f(int& x) { return x; }
+ decltype(auto) g(int& x) { return x; }
+
+ template < typename T1, typename T2 >
+ struct is_same
+ {
+ static constexpr auto value = false;
+ };
+
+ template < typename T >
+ struct is_same<T, T>
+ {
+ static constexpr auto value = true;
+ };
+
+ int
+ test()
+ {
+ auto x = 0;
+ static_assert(is_same<int, decltype(f(x))>::value, "");
+ static_assert(is_same<int&, decltype(g(x))>::value, "");
+ return x;
+ }
+
+ }
+
+} // namespace cxx14
+
+#endif // __cplusplus >= 201402L
+
+
+
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
eval $cachevar=yes
@@ -7890,28 +8610,28 @@ $as_echo "$ac_res" >&6; }
CXX_FOR_BUILD="$CXX"
CXXFLAGS_FOR_BUILD="$CXXFLAGS"
CPPFLAGS_FOR_BUILD="$CPPFLAGS"
- CXX="$ax_cv_cxx_compile_cxx11_orig_cxx"
- CXXFLAGS="$ax_cv_cxx_compile_cxx11_orig_cxxflags"
- CPPFLAGS="$ax_cv_cxx_compile_cxx11_orig_cppflags"
+ CXX="$ax_cv_cxx_compile_cxx14_orig_cxx"
+ CXXFLAGS="$ax_cv_cxx_compile_cxx14_orig_cxxflags"
+ CPPFLAGS="$ax_cv_cxx_compile_cxx14_orig_cppflags"
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$ax_cxx_compile_cxx14_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
+ as_fn_error $? "*** A compiler with support for C++14 language features is required." "$LINENO" 5
fi
fi
if test x$ac_success = xno; then
- HAVE_CXX11_FOR_BUILD=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;}
+ HAVE_CXX14_FOR_BUILD=0
+ { $as_echo "$as_me:${as_lineno-$LINENO}: No compiler with C++14 support was found" >&5
+$as_echo "$as_me: No compiler with C++14 support was found" >&6;}
else
- HAVE_CXX11_FOR_BUILD=1
+ HAVE_CXX14_FOR_BUILD=1
-$as_echo "#define HAVE_CXX11_FOR_BUILD 1" >>confdefs.h
+$as_echo "#define HAVE_CXX14_FOR_BUILD 1" >>confdefs.h
fi
--
2.47.0
