# Keep these sync'd with the list in Makefile.am. The first provides an
# expandable list at autoconf time; the second provides an expandable list
# (i.e., shell variable) at configure time.
- m4_define([glibcxx_SUBDIRS],[include libsupc++ python src src/c++98 src/c++11 doc po testsuite])
+ m4_define([glibcxx_SUBDIRS],[include libsupc++ src src/c++98 src/c++11 src/c++17 src/filesystem doc po testsuite python])
SUBDIRS='glibcxx_SUBDIRS'
# These need to be absolute paths, yet at the same time need to
ac_test_CXXFLAGS="${CXXFLAGS+set}"
ac_save_CXXFLAGS="$CXXFLAGS"
- # Check for maintainer-mode bits.
- if test x"$USE_MAINTAINER_MODE" = xno; then
- WERROR=''
- else
- WERROR='-Werror'
- fi
-
# Check for -ffunction-sections -fdata-sections
AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
AC_MSG_RESULT($ac_fdsections)
AC_LANG_RESTORE
- AC_SUBST(WERROR)
AC_SUBST(SECTION_FLAGS)
])
-dnl
-dnl Check if the assembler used supports disabling generation of hardware
-dnl capabilities. This is only supported by Sun as at the moment.
-dnl
-dnl Defines:
-dnl HWCAP_FLAGS='-Wa,-nH' if possible.
-dnl
-AC_DEFUN([GLIBCXX_CHECK_ASSEMBLER_HWCAP], [
- test -z "$HWCAP_FLAGS" && HWCAP_FLAGS=''
-
- # Restrict the test to Solaris, other assemblers (e.g. AIX as) have -nH
- # with a different meaning.
- case ${target_os} in
- solaris2*)
- ac_save_CFLAGS="$CFLAGS"
- CFLAGS="$CFLAGS -Wa,-nH"
-
- AC_MSG_CHECKING([for as that supports -Wa,-nH])
- AC_TRY_COMPILE([], [return 0;], [ac_hwcap_flags=yes],[ac_hwcap_flags=no])
- if test "$ac_hwcap_flags" = "yes"; then
- HWCAP_FLAGS="-Wa,-nH $HWCAP_FLAGS"
- fi
- AC_MSG_RESULT($ac_hwcap_flags)
-
- CFLAGS="$ac_save_CFLAGS"
- ;;
- esac
-
- AC_SUBST(HWCAP_FLAGS)
-])
-
-
dnl
dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
dnl the native linker is in use, all variables will be defined to something
res=no
if test $glibcxx_cv_S_ISREG = yes; then
AC_DEFINE(HAVE_S_ISREG, 1,
- [Define if S_IFREG is available in <sys/stat.h>.])
+ [Define if S_ISREG is available in <sys/stat.h>.])
res=S_ISREG
elif test $glibcxx_cv_S_IFREG = yes; then
AC_DEFINE(HAVE_S_IFREG, 1,
dnl baseline_subdir_switch
dnl
AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
- if $GLIBCXX_IS_NATIVE ; then
- # Do checks for resource limit functions.
- GLIBCXX_CHECK_SETRLIMIT
+ # Do checks for resource limit functions.
+ GLIBCXX_CHECK_SETRLIMIT
+ if $GLIBCXX_IS_NATIVE ; then
# Look for setenv, so that extended locale tests can be performed.
GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
fi
# OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
AC_SUBST(OPTIMIZE_CXXFLAGS)
- WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi'
+ WARN_FLAGS="-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi=2"
AC_SUBST(WARN_FLAGS)
])
GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
if test x"$enable_c99" = x"yes"; then
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
- AC_LANG_SAVE
- AC_LANG_CPLUSPLUS
+ # Use -std=c++98 (instead of -std=gnu++98) because leaving __STRICT_ANSI__
+ # undefined may cause fake C99 facilities, like pre-standard snprintf,
+ # to be spuriously enabled.
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -std=c++98"
+ ac_save_LIBS="$LIBS"
+ ac_save_gcc_no_link="$gcc_no_link"
+
+ if test x$gcc_no_link != xyes; then
+ # Use -fno-exceptions to that the C driver can link these tests without
+ # hitting undefined references to personality routines.
+ CXXFLAGS="$CXXFLAGS -fno-exceptions"
+ AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
+ # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
+ gcc_no_link=yes
+ ])
+ fi
- # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
- # undefined and fake C99 facilities - like pre-standard snprintf - may be
- # spuriously enabled.
- # Long term, -std=c++0x could be even better, could manage to explicitly
- # request C99 facilities to the underlying C headers.
- ac_save_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS="$CXXFLAGS -std=c++98"
- ac_save_LIBS="$LIBS"
- ac_save_gcc_no_link="$gcc_no_link"
+ # Check for the existence of <math.h> functions used if C99 is enabled.
+ AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++98])
+ AC_CACHE_VAL(glibcxx_cv_c99_math_cxx98, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <math.h>
+ volatile double d1, d2;
+ volatile int i;],
+ [i = fpclassify(d1);
+ i = isfinite(d1);
+ i = isinf(d1);
+ i = isnan(d1);
+ i = isnormal(d1);
+ i = signbit(d1);
+ i = isgreater(d1, d2);
+ i = isgreaterequal(d1, d2);
+ i = isless(d1, d2);
+ i = islessequal(d1, d2);
+ i = islessgreater(d1, d2);
+ i = islessgreater(d1, d2);
+ i = isunordered(d1, d2);
+ ], [glibcxx_cv_c99_math_cxx98=yes], [glibcxx_cv_c99_math_cxx98=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_math_cxx98)
+ if test x"$glibcxx_cv_c99_math_cxx98" = x"yes"; then
+ AC_DEFINE(_GLIBCXX98_USE_C99_MATH, 1,
+ [Define if C99 functions or macros in <math.h> should be imported
+ in <cmath> in namespace std for C++98.])
+ fi
- if test x$gcc_no_link != xyes; then
- # Use -fno-exceptions to that the C driver can link these tests without
- # hitting undefined references to personality routines.
- CXXFLAGS="$CXXFLAGS -fno-exceptions"
- AC_CHECK_LIB(m, sin, [
- LIBS="$LIBS -lm"
- ], [
- # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
- gcc_no_link=yes
+ # Check for the existence of <complex.h> complex math functions.
+ # This is necessary even though libstdc++ uses the builtin versions
+ # of these functions, because if the builtin cannot be used, a reference
+ # to the library function is emitted.
+ AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
+ AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
+ if test x"$ac_has_complex_h" = x"yes"; then
+ AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++98])
+ AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx98, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <complex.h>
+ typedef __complex__ float float_type;
+ typedef __complex__ double double_type;
+ typedef __complex__ long double ld_type;
+ volatile float_type tmpf;
+ volatile double_type tmpd;
+ volatile ld_type tmpld;
+ volatile float f;
+ volatile double d;
+ volatile long double ld;],
+ [f = cabsf(tmpf);
+ f = cargf(tmpf);
+ tmpf = ccosf(tmpf);
+ tmpf = ccoshf(tmpf);
+ tmpf = cexpf(tmpf);
+ tmpf = clogf(tmpf);
+ tmpf = csinf(tmpf);
+ tmpf = csinhf(tmpf);
+ tmpf = csqrtf(tmpf);
+ tmpf = ctanf(tmpf);
+ tmpf = ctanhf(tmpf);
+ tmpf = cpowf(tmpf, tmpf);
+ tmpf = cprojf(tmpf);
+ d = cabs(tmpd);
+ d = carg(tmpd);
+ tmpd = ccos(tmpd);
+ tmpd = ccosh(tmpd);
+ tmpd = cexp(tmpd);
+ tmpd = clog(tmpd);
+ tmpd = csin(tmpd);
+ tmpd = csinh(tmpd);
+ tmpd = csqrt(tmpd);
+ tmpd = ctan(tmpd);
+ tmpd = ctanh(tmpd);
+ tmpd = cpow(tmpd, tmpd);
+ tmpd = cproj(tmpd);
+ ld = cabsl(tmpld);
+ ld = cargl(tmpld);
+ tmpld = ccosl(tmpld);
+ tmpld = ccoshl(tmpld);
+ tmpld = cexpl(tmpld);
+ tmpld = clogl(tmpld);
+ tmpld = csinl(tmpld);
+ tmpld = csinhl(tmpld);
+ tmpld = csqrtl(tmpld);
+ tmpld = ctanl(tmpld);
+ tmpld = ctanhl(tmpld);
+ tmpld = cpowl(tmpld, tmpld);
+ tmpld = cprojl(tmpld);
+ ], [glibcxx_cv_c99_complex_cxx98=yes], [glibcxx_cv_c99_complex_cxx98=no])
+ ])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx98)
+ if test x"$glibcxx_cv_c99_complex_cxx98" = x"yes"; then
+ AC_DEFINE(_GLIBCXX98_USE_C99_COMPLEX, 1,
+ [Define if C99 functions in <complex.h> should be used in
+ <complex> for C++98. Using compiler builtins for these functions
+ requires corresponding C99 library functions to be present.])
+ fi
+
+ # Check for the existence in <stdio.h> of vscanf, et. al.
+ AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++98])
+ AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx98, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <stdio.h>
+ #include <stdarg.h>
+ void foo(char* fmt, ...)
+ {
+ va_list args; va_start(args, fmt);
+ vfscanf(stderr, "%i", args);
+ vscanf("%i", args);
+ vsnprintf(fmt, 0, "%i", args);
+ vsscanf(fmt, "%i", args);
+ snprintf(fmt, 0, "%i");
+ }], [],
+ [glibcxx_cv_c99_stdio_cxx98=yes], [glibcxx_cv_c99_stdio_cxx98=no])
])
- fi
+ AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx98)
+ if test x"$glibcxx_cv_c99_stdio_cxx98" = x"yes"; then
+ AC_DEFINE(_GLIBCXX98_USE_C99_STDIO, 1,
+ [Define if C99 functions or macros in <stdio.h> should be imported
+ in <cstdio> in namespace std for C++98.])
+ fi
- # Check for the existence of <math.h> functions used if C99 is enabled.
- AC_MSG_CHECKING([for ISO C99 support in <math.h>])
- AC_CACHE_VAL(glibcxx_cv_c99_math, [
- GCC_TRY_COMPILE_OR_LINK(
- [#include <math.h>
- volatile double d1, d2;
- volatile int i;],
- [i = fpclassify(d1);
- i = isfinite(d1);
- i = isinf(d1);
- i = isnan(d1);
- i = isnormal(d1);
- i = signbit(d1);
- i = isgreater(d1, d2);
- i = isgreaterequal(d1, d2);
- i = isless(d1, d2);
- i = islessequal(d1, d2);
- i = islessgreater(d1, d2);
- i = islessgreater(d1, d2);
- i = isunordered(d1, d2);
- ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
- ])
- AC_MSG_RESULT($glibcxx_cv_c99_math)
- if test x"$glibcxx_cv_c99_math" = x"yes"; then
- AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
- [Define if C99 functions or macros in <math.h> should be imported
- in <cmath> in namespace std.])
- fi
+ # Check for the existence in <stdlib.h> of lldiv_t, et. al.
+ AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++98])
+ AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx98, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <stdlib.h>
+ volatile float f;
+ volatile long double ld;
+ volatile unsigned long long ll;
+ lldiv_t mydivt;],
+ [char* tmp;
+ f = strtof("gnu", &tmp);
+ ld = strtold("gnu", &tmp);
+ ll = strtoll("gnu", &tmp, 10);
+ ll = strtoull("gnu", &tmp, 10);
+ ll = llabs(10);
+ mydivt = lldiv(10,1);
+ ll = mydivt.quot;
+ ll = mydivt.rem;
+ ll = atoll("10");
+ _Exit(0);
+ ], [glibcxx_cv_c99_stdlib_cxx98=yes], [glibcxx_cv_c99_stdlib_cxx98=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx98)
+ if test x"$glibcxx_cv_c99_stdlib_cxx98" = x"yes"; then
+ AC_DEFINE(_GLIBCXX98_USE_C99_STDLIB, 1,
+ [Define if C99 functions or macros in <stdlib.h> should be imported
+ in <cstdlib> in namespace std for C++98.])
+ fi
- # Check for the existence of <complex.h> complex math functions.
- # This is necessary even though libstdc++ uses the builtin versions
- # of these functions, because if the builtin cannot be used, a reference
- # to the library function is emitted.
- AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
- AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
- glibcxx_cv_c99_complex=no;
- if test x"$ac_has_complex_h" = x"yes"; then
- AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
- GCC_TRY_COMPILE_OR_LINK(
- [#include <complex.h>
- typedef __complex__ float float_type;
- typedef __complex__ double double_type;
- typedef __complex__ long double ld_type;
- volatile float_type tmpf;
- volatile double_type tmpd;
- volatile ld_type tmpld;
- volatile float f;
- volatile double d;
- volatile long double ld;],
- [f = cabsf(tmpf);
- f = cargf(tmpf);
- tmpf = ccosf(tmpf);
- tmpf = ccoshf(tmpf);
- tmpf = cexpf(tmpf);
- tmpf = clogf(tmpf);
- tmpf = csinf(tmpf);
- tmpf = csinhf(tmpf);
- tmpf = csqrtf(tmpf);
- tmpf = ctanf(tmpf);
- tmpf = ctanhf(tmpf);
- tmpf = cpowf(tmpf, tmpf);
- tmpf = cprojf(tmpf);
- d = cabs(tmpd);
- d = carg(tmpd);
- tmpd = ccos(tmpd);
- tmpd = ccosh(tmpd);
- tmpd = cexp(tmpd);
- tmpd = clog(tmpd);
- tmpd = csin(tmpd);
- tmpd = csinh(tmpd);
- tmpd = csqrt(tmpd);
- tmpd = ctan(tmpd);
- tmpd = ctanh(tmpd);
- tmpd = cpow(tmpd, tmpd);
- tmpd = cproj(tmpd);
- ld = cabsl(tmpld);
- ld = cargl(tmpld);
- tmpld = ccosl(tmpld);
- tmpld = ccoshl(tmpld);
- tmpld = cexpl(tmpld);
- tmpld = clogl(tmpld);
- tmpld = csinl(tmpld);
- tmpld = csinhl(tmpld);
- tmpld = csqrtl(tmpld);
- tmpld = ctanl(tmpld);
- tmpld = ctanhl(tmpld);
- tmpld = cpowl(tmpld, tmpld);
- tmpld = cprojl(tmpld);
- ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
- fi
- AC_MSG_RESULT($glibcxx_cv_c99_complex)
- if test x"$glibcxx_cv_c99_complex" = x"yes"; then
- AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
- [Define if C99 functions in <complex.h> should be used in
- <complex>. Using compiler builtins for these functions requires
- corresponding C99 library functions to be present.])
- fi
-
- # Check for the existence in <stdio.h> of vscanf, et. al.
- AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
- AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
- GCC_TRY_COMPILE_OR_LINK(
- [#include <stdio.h>
- #include <stdarg.h>
- void foo(char* fmt, ...)
- {
- va_list args; va_start(args, fmt);
- vfscanf(stderr, "%i", args);
- vscanf("%i", args);
- vsnprintf(fmt, 0, "%i", args);
- vsscanf(fmt, "%i", args);
- snprintf(fmt, 0, "%i");
- }], [],
- [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
- ])
- AC_MSG_RESULT($glibcxx_cv_c99_stdio)
-
- # Check for the existence in <stdlib.h> of lldiv_t, et. al.
- AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
- AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
- GCC_TRY_COMPILE_OR_LINK(
- [#include <stdlib.h>
- volatile float f;
- volatile long double ld;
- volatile unsigned long long ll;
- lldiv_t mydivt;],
- [char* tmp;
- f = strtof("gnu", &tmp);
- ld = strtold("gnu", &tmp);
- ll = strtoll("gnu", &tmp, 10);
- ll = strtoull("gnu", &tmp, 10);
- ll = llabs(10);
- mydivt = lldiv(10,1);
- ll = mydivt.quot;
- ll = mydivt.rem;
- ll = atoll("10");
- _Exit(0);
- ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
- ])
- AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
-
- # Check for the existence in <wchar.h> of wcstold, etc.
- glibcxx_cv_c99_wchar=no;
- if test x"$ac_has_wchar_h" = xyes &&
- test x"$ac_has_wctype_h" = xyes; then
- AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
- AC_TRY_COMPILE([#include <wchar.h>
- namespace test
- {
- using ::wcstold;
- using ::wcstoll;
- using ::wcstoull;
- }
- ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
-
- # Checks for wide character functions that may not be present.
- # Injection of these is wrapped with guard macros.
- # NB: only put functions here, instead of immediately above, if
- # absolutely necessary.
- AC_TRY_COMPILE([#include <wchar.h>
- namespace test { using ::vfwscanf; } ], [],
- [AC_DEFINE(HAVE_VFWSCANF,1,
- [Defined if vfwscanf exists.])],[])
-
- AC_TRY_COMPILE([#include <wchar.h>
- namespace test { using ::vswscanf; } ], [],
- [AC_DEFINE(HAVE_VSWSCANF,1,
- [Defined if vswscanf exists.])],[])
-
- AC_TRY_COMPILE([#include <wchar.h>
- namespace test { using ::vwscanf; } ], [],
- [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
-
- AC_TRY_COMPILE([#include <wchar.h>
- namespace test { using ::wcstof; } ], [],
- [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
-
- AC_TRY_COMPILE([#include <wctype.h>],
- [ wint_t t; int i = iswblank(t);],
- [AC_DEFINE(HAVE_ISWBLANK,1,
- [Defined if iswblank exists.])],[])
-
- AC_MSG_RESULT($glibcxx_cv_c99_wchar)
- fi
-
- # Option parsed, now set things appropriately.
- if test x"$glibcxx_cv_c99_math" = x"no" ||
- test x"$glibcxx_cv_c99_complex" = x"no" ||
- test x"$glibcxx_cv_c99_stdio" = x"no" ||
- test x"$glibcxx_cv_c99_stdlib" = x"no" ||
- test x"$glibcxx_cv_c99_wchar" = x"no"; then
- enable_c99=no;
- else
- AC_DEFINE(_GLIBCXX_USE_C99, 1,
- [Define if C99 functions or macros from <wchar.h>, <math.h>,
- <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
- fi
+ # Check for the existence in <wchar.h> of wcstold, etc.
+ if test x"$ac_has_wchar_h" = xyes &&
+ test x"$ac_has_wctype_h" = xyes; then
+ AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++98])
+ AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx98, [
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test
+ {
+ using ::wcstold;
+ using ::wcstoll;
+ using ::wcstoull;
+ }
+ ], [], [glibcxx_cv_c99_wchar_cxx98=yes], [glibcxx_cv_c99_wchar_cxx98=no])
+ ])
- gcc_no_link="$ac_save_gcc_no_link"
- LIBS="$ac_save_LIBS"
- CXXFLAGS="$ac_save_CXXFLAGS"
- AC_LANG_RESTORE
+ # Checks for wide character functions that may not be present.
+ # Injection of these is wrapped with guard macros.
+ # NB: only put functions here, instead of immediately above, if
+ # absolutely necessary.
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vfwscanf; }], [],
+ [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vswscanf; }], [],
+ [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vwscanf; }], [],
+ [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::wcstof; }], [],
+ [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
+
+ AC_TRY_COMPILE([#include <wctype.h>],
+ [wint_t t; int i = iswblank(t);],
+ [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
+
+ AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx98)
+ if test x"$glibcxx_cv_c99_wchar_cxx98" = x"yes"; then
+ AC_DEFINE(_GLIBCXX98_USE_C99_WCHAR, 1,
+ [Define if C99 functions or macros in <wchar.h> should be imported
+ in <cwchar> in namespace std for C++98.])
+ fi
+ fi
+
+ # Option parsed, now set things appropriately.
+ if test x"$glibcxx_cv_c99_math_cxx98" = x"no" ||
+ test x"$glibcxx_cv_c99_complex_cxx98" = x"no" ||
+ test x"$glibcxx_cv_c99_stdio_cxx98" = x"no" ||
+ test x"$glibcxx_cv_c99_stdlib_cxx98" = x"no" ||
+ test x"$glibcxx_cv_c99_wchar_cxx98" = x"no"; then
+ enable_c99=no;
+ else
+ AC_DEFINE(_GLIBCXX_USE_C99, 1,
+ [Define if C99 functions or macros from <wchar.h>, <math.h>,
+ <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
+ fi
+
+ gcc_no_link="$ac_save_gcc_no_link"
+ LIBS="$ac_save_LIBS"
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+
+ # Use -std=c++11 and test again for C99 library feature in C++11 mode.
+ # For the reasons given above we use -std=c++11 not -std=gnu++11.
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -std=c++11"
+ ac_save_LIBS="$LIBS"
+ ac_save_gcc_no_link="$gcc_no_link"
+
+ if test x$gcc_no_link != xyes; then
+ # Use -fno-exceptions to that the C driver can link these tests without
+ # hitting undefined references to personality routines.
+ CXXFLAGS="$CXXFLAGS -fno-exceptions"
+ AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
+ # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
+ gcc_no_link=yes
+ ])
+ fi
+
+ # Check for the existence of <math.h> functions used if C99 is enabled.
+ AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++11])
+ AC_CACHE_VAL(glibcxx_cv_c99_math_cxx11, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <math.h>
+ volatile double d1, d2;
+ volatile int i;],
+ [i = fpclassify(d1);
+ i = isfinite(d1);
+ i = isinf(d1);
+ i = isnan(d1);
+ i = isnormal(d1);
+ i = signbit(d1);
+ i = isgreater(d1, d2);
+ i = isgreaterequal(d1, d2);
+ i = isless(d1, d2);
+ i = islessequal(d1, d2);
+ i = islessgreater(d1, d2);
+ i = islessgreater(d1, d2);
+ i = isunordered(d1, d2);
+ ], [glibcxx_cv_c99_math_cxx11=yes], [glibcxx_cv_c99_math_cxx11=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_math_cxx11)
+ if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
+ AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
+ [Define if C99 functions or macros in <math.h> should be imported
+ in <cmath> in namespace std for C++11.])
+ fi
+
+ # Check for the existence of <complex.h> complex math functions.
+ # This is necessary even though libstdc++ uses the builtin versions
+ # of these functions, because if the builtin cannot be used, a reference
+ # to the library function is emitted.
+ AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
+ AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
+ if test x"$ac_has_complex_h" = x"yes"; then
+ AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++11])
+ AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx11, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <complex.h>
+ typedef __complex__ float float_type;
+ typedef __complex__ double double_type;
+ typedef __complex__ long double ld_type;
+ volatile float_type tmpf;
+ volatile double_type tmpd;
+ volatile ld_type tmpld;
+ volatile float f;
+ volatile double d;
+ volatile long double ld;],
+ [f = cabsf(tmpf);
+ f = cargf(tmpf);
+ tmpf = ccosf(tmpf);
+ tmpf = ccoshf(tmpf);
+ tmpf = cexpf(tmpf);
+ tmpf = clogf(tmpf);
+ tmpf = csinf(tmpf);
+ tmpf = csinhf(tmpf);
+ tmpf = csqrtf(tmpf);
+ tmpf = ctanf(tmpf);
+ tmpf = ctanhf(tmpf);
+ tmpf = cpowf(tmpf, tmpf);
+ tmpf = cprojf(tmpf);
+ d = cabs(tmpd);
+ d = carg(tmpd);
+ tmpd = ccos(tmpd);
+ tmpd = ccosh(tmpd);
+ tmpd = cexp(tmpd);
+ tmpd = clog(tmpd);
+ tmpd = csin(tmpd);
+ tmpd = csinh(tmpd);
+ tmpd = csqrt(tmpd);
+ tmpd = ctan(tmpd);
+ tmpd = ctanh(tmpd);
+ tmpd = cpow(tmpd, tmpd);
+ tmpd = cproj(tmpd);
+ ld = cabsl(tmpld);
+ ld = cargl(tmpld);
+ tmpld = ccosl(tmpld);
+ tmpld = ccoshl(tmpld);
+ tmpld = cexpl(tmpld);
+ tmpld = clogl(tmpld);
+ tmpld = csinl(tmpld);
+ tmpld = csinhl(tmpld);
+ tmpld = csqrtl(tmpld);
+ tmpld = ctanl(tmpld);
+ tmpld = ctanhl(tmpld);
+ tmpld = cpowl(tmpld, tmpld);
+ tmpld = cprojl(tmpld);
+ ], [glibcxx_cv_c99_complex_cxx11=yes], [glibcxx_cv_c99_complex_cxx11=no])
+ ])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx11)
+ if test x"$glibcxx_cv_c99_complex_cxx11" = x"yes"; then
+ AC_DEFINE(_GLIBCXX11_USE_C99_COMPLEX, 1,
+ [Define if C99 functions in <complex.h> should be used in
+ <complex> for C++11. Using compiler builtins for these functions
+ requires corresponding C99 library functions to be present.])
+ fi
+
+ # Check for the existence in <stdio.h> of vscanf, et. al.
+ AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++11])
+ AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx11, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <stdio.h>
+ #include <stdarg.h>
+ void foo(char* fmt, ...)
+ {
+ va_list args; va_start(args, fmt);
+ vfscanf(stderr, "%i", args);
+ vscanf("%i", args);
+ vsnprintf(fmt, 0, "%i", args);
+ vsscanf(fmt, "%i", args);
+ snprintf(fmt, 0, "%i");
+ }], [],
+ [glibcxx_cv_c99_stdio_cxx11=yes], [glibcxx_cv_c99_stdio_cxx11=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx11)
+ if test x"$glibcxx_cv_c99_stdio_cxx11" = x"yes"; then
+ AC_DEFINE(_GLIBCXX11_USE_C99_STDIO, 1,
+ [Define if C99 functions or macros in <stdio.h> should be imported
+ in <cstdio> in namespace std for C++11.])
+ fi
+
+ # Check for the existence in <stdlib.h> of lldiv_t, et. al.
+ AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++11])
+ AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx11, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <stdlib.h>
+ volatile float f;
+ volatile long double ld;
+ volatile unsigned long long ll;
+ lldiv_t mydivt;],
+ [char* tmp;
+ f = strtof("gnu", &tmp);
+ ld = strtold("gnu", &tmp);
+ ll = strtoll("gnu", &tmp, 10);
+ ll = strtoull("gnu", &tmp, 10);
+ ll = llabs(10);
+ mydivt = lldiv(10,1);
+ ll = mydivt.quot;
+ ll = mydivt.rem;
+ ll = atoll("10");
+ _Exit(0);
+ ], [glibcxx_cv_c99_stdlib_cxx11=yes], [glibcxx_cv_c99_stdlib_cxx11=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx11)
+ if test x"$glibcxx_cv_c99_stdlib_cxx11" = x"yes"; then
+ AC_DEFINE(_GLIBCXX11_USE_C99_STDLIB, 1,
+ [Define if C99 functions or macros in <stdlib.h> should be imported
+ in <cstdlib> in namespace std for C++11.])
+ fi
+
+ # Check for the existence in <wchar.h> of wcstold, etc.
+ if test x"$ac_has_wchar_h" = xyes &&
+ test x"$ac_has_wctype_h" = xyes; then
+ AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++11])
+ AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx11, [
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test
+ {
+ using ::wcstold;
+ using ::wcstoll;
+ using ::wcstoull;
+ }
+ ], [], [glibcxx_cv_c99_wchar_cxx11=yes], [glibcxx_cv_c99_wchar_cxx11=no])
+ ])
+
+ # Checks for wide character functions that may not be present.
+ # Injection of these is wrapped with guard macros.
+ # NB: only put functions here, instead of immediately above, if
+ # absolutely necessary.
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vfwscanf; }], [],
+ [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vswscanf; }], [],
+ [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vwscanf; }], [],
+ [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::wcstof; }], [],
+ [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
+
+ AC_TRY_COMPILE([#include <wctype.h>],
+ [wint_t t; int i = iswblank(t);],
+ [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
+
+ AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx11)
+ if test x"$glibcxx_cv_c99_wchar_cxx11" = x"yes"; then
+ AC_DEFINE(_GLIBCXX11_USE_C99_WCHAR, 1,
+ [Define if C99 functions or macros in <wchar.h> should be imported
+ in <cwchar> in namespace std for C++11.])
+ fi
+ fi
+
+ gcc_no_link="$ac_save_gcc_no_link"
+ LIBS="$ac_save_LIBS"
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
fi
AC_MSG_CHECKING([for fully enabled ISO C99 support])
ac_has_nanosleep=yes
ac_has_sched_yield=yes
;;
- freebsd*|netbsd*|dragonfly*)
+ freebsd*|netbsd*|dragonfly*|rtems*)
ac_has_clock_monotonic=yes
ac_has_clock_realtime=yes
ac_has_nanosleep=yes
lgamma(0.0);
lgammaf(0.0f);
lgammal(0.0l);
+ #ifndef __APPLE__ /* see below */
llrint(0.0);
llrintf(0.0f);
llrintl(0.0l);
llround(0.0);
llroundf(0.0f);
llroundl(0.0l);
+ #endif
log1p(0.0);
log1pf(0.0f);
log1pl(0.0l);
AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
[Define if C99 functions or macros in <math.h> should be imported
in <tr1/cmath> in namespace std::tr1.])
+
+ case "${target_os}" in
+ darwin*)
+ AC_MSG_CHECKING([for ISO C99 rounding functions in <math.h>])
+ AC_CACHE_VAL(glibcxx_cv_c99_math_llround, [
+ AC_TRY_COMPILE([#include <math.h>],
+ [llrint(0.0);
+ llrintf(0.0f);
+ llrintl(0.0l);
+ llround(0.0);
+ llroundf(0.0f);
+ llroundl(0.0l);
+ ],
+ [glibcxx_cv_c99_math_llround=yes],
+ [glibcxx_cv_c99_math_llround=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_math_llround)
+ ;;
+ esac
+ if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
+ AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
+ [Define if C99 llrint and llround functions are missing from <math.h>.])
+ fi
fi
# Check for the existence of <inttypes.h> functions (NB: doesn't make
])
dnl
-dnl Check whether "/dev/random" and "/dev/urandom" are available for the
+dnl Check for uchar.h and usability.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_UCHAR_H], [
+
+ # Test uchar.h.
+ AC_CHECK_HEADERS(uchar.h, ac_has_uchar_h=yes, ac_has_uchar_h=no)
+
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -std=c++11"
+
+ if test x"$ac_has_uchar_h" = x"yes"; then
+ AC_MSG_CHECKING([for ISO C11 support for <uchar.h>])
+ AC_TRY_COMPILE([#include <uchar.h>
+ #ifdef __STDC_UTF_16__
+ long i = __STDC_UTF_16__;
+ #endif
+ #ifdef __STDC_UTF_32__
+ long j = __STDC_UTF_32__;
+ #endif
+ namespace test
+ {
+ using ::c16rtomb;
+ using ::c32rtomb;
+ using ::mbrtoc16;
+ using ::mbrtoc32;
+ }
+ ],
+ [], [ac_c11_uchar_cxx11=yes], [ac_c11_uchar_cxx11=no])
+ else
+ ac_c11_uchar_cxx11=no
+ fi
+ AC_MSG_RESULT($ac_c11_uchar_cxx11)
+ if test x"$ac_c11_uchar_cxx11" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C11_UCHAR_CXX11, 1,
+ [Define if C11 functions in <uchar.h> should be imported into
+ namespace std in <cuchar>.])
+ fi
+
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+])
+
+
+dnl
+dnl Check whether "/dev/random" and "/dev/urandom" are available for
+dnl class std::random_device from C++ 2011 [rand.device], and
dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
dnl
-AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
+AC_DEFUN([GLIBCXX_CHECK_DEV_RANDOM], [
- AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
- AC_CACHE_VAL(glibcxx_cv_random_tr1, [
+ AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for std::random_device])
+ AC_CACHE_VAL(glibcxx_cv_dev_random, [
if test -r /dev/random && test -r /dev/urandom; then
- ## For MSys environment the test above is detect as false-positive
- ## on mingw-targets. So disable it explicit for them.
+ ## For MSys environment the test above is detected as false-positive
+ ## on mingw-targets. So disable it explicitly for them.
case ${target_os} in
- *mingw*) glibcxx_cv_random_tr1=no ;;
- *) glibcxx_cv_random_tr1=yes ;;
+ *mingw*) glibcxx_cv_dev_random=no ;;
+ *) glibcxx_cv_dev_random=yes ;;
esac
else
- glibcxx_cv_random_tr1=no;
+ glibcxx_cv_dev_random=no;
fi
])
- AC_MSG_RESULT($glibcxx_cv_random_tr1)
+ AC_MSG_RESULT($glibcxx_cv_dev_random)
- if test x"$glibcxx_cv_random_tr1" = x"yes"; then
+ if test x"$glibcxx_cv_dev_random" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_DEV_RANDOM, 1,
+ [Define if /dev/random and /dev/urandom are available for
+ std::random_device.])
AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
[Define if /dev/random and /dev/urandom are available for
the random_device of TR1 (Chapter 5.1).])
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
+ # Use C++11 because a conforming <stdio.h> won't define gets for C++14,
+ # and we don't need a declaration for C++14 anyway.
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -std=gnu++11"
AC_MSG_CHECKING([for gets declaration])
AC_CACHE_VAL(glibcxx_cv_gets, [
)])
if test $glibcxx_cv_gets = yes; then
- AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h>.])
+ AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h> before C++14.])
fi
AC_MSG_RESULT($glibcxx_cv_gets)
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+])
+
+dnl
+dnl Check whether required C++11 overloads for floating point and integral
+dnl types are present in <math.h>.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
+
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -std=c++11"
+
+ case "$host" in
+ *-*-solaris2.*)
+ # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
+ # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
+ AC_MSG_CHECKING([for C++11 <math.h> floating point overloads])
+ AC_CACHE_VAL(glibcxx_cv_math11_fp_overload, [
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE(
+ [#include <math.h>
+ #undef isfinite
+ namespace std {
+ inline bool isfinite(float __x)
+ { return __builtin_isfinite(__x); }
+ }
+ ])],
+ [glibcxx_cv_math11_fp_overload=no],
+ [glibcxx_cv_math11_fp_overload=yes]
+ )])
+
+ # autoheader cannot handle indented templates.
+ AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP],
+ [/* Define if all C++11 floating point overloads are available in <math.h>. */
+#if __cplusplus >= 201103L
+#undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+#endif])
+
+ if test $glibcxx_cv_math11_fp_overload = yes; then
+ AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP)
+ fi
+ AC_MSG_RESULT([$glibcxx_cv_math11_fp_overload])
+
+ # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
+ # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
+ AC_MSG_CHECKING([for C++11 <math.h> integral type overloads])
+ AC_CACHE_VAL(glibcxx_cv_math11_int_overload, [
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE(
+ [#include <math.h>
+ namespace std {
+ template<typename _Tp>
+ struct __is_integer;
+ template<>
+ struct __is_integer<int>
+ {
+ enum { __value = 1 };
+ };
+ }
+ namespace __gnu_cxx {
+ template<bool, typename>
+ struct __enable_if;
+ template<typename _Tp>
+ struct __enable_if<true, _Tp>
+ { typedef _Tp __type; };
+ }
+ namespace std {
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if
+ <__is_integer<_Tp>::__value, double>::__type
+ log2(_Tp __x)
+ { return __builtin_log2(__x); }
+ }
+ int
+ main (void)
+ {
+ int i = 1000;
+ return std::log2(i);
+ }
+ ])],
+ [glibcxx_cv_math11_int_overload=no],
+ [glibcxx_cv_math11_int_overload=yes]
+ )])
+
+ # autoheader cannot handle indented templates.
+ AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT],
+ [/* Define if all C++11 integral type overloads are available in <math.h>. */
+#if __cplusplus >= 201103L
+#undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+#endif])
+
+ if test $glibcxx_cv_math11_int_overload = yes; then
+ AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT)
+ fi
+ AC_MSG_RESULT([$glibcxx_cv_math11_int_overload])
+ ;;
+ *)
+ # If <math.h> defines the obsolete isinf(double) and isnan(double)
+ # functions (instead of or as well as the C99 generic macros) then we
+ # can't define std::isinf(double) and std::isnan(double) in <cmath>
+ # and must use the ones from <math.h> instead.
+ AC_MSG_CHECKING([for obsolete isinf function in <math.h>])
+ AC_CACHE_VAL(glibcxx_cv_obsolete_isinf, [
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE(
+ [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
+ #include <math.h>
+ #undef isinf
+ namespace std {
+ using ::isinf;
+ bool isinf(float);
+ bool isinf(long double);
+ }
+ using std::isinf;
+ bool b = isinf(0.0);
+ ])],
+ [glibcxx_cv_obsolete_isinf=yes],
+ [glibcxx_cv_obsolete_isinf=no]
+ )])
+ AC_MSG_RESULT([$glibcxx_cv_obsolete_isinf])
+ if test $glibcxx_cv_obsolete_isinf = yes; then
+ AC_DEFINE(HAVE_OBSOLETE_ISINF, 1,
+ [Define if <math.h> defines obsolete isinf function.])
+ fi
+
+ AC_MSG_CHECKING([for obsolete isnan function in <math.h>])
+ AC_CACHE_VAL(glibcxx_cv_obsolete_isnan, [
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE(
+ [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
+ #include <math.h>
+ #undef isnan
+ namespace std {
+ using ::isnan;
+ bool isnan(float);
+ bool isnan(long double);
+ }
+ using std::isnan;
+ bool b = isnan(0.0);
+ ])],
+ [glibcxx_cv_obsolete_isnan=yes],
+ [glibcxx_cv_obsolete_isnan=no]
+ )])
+ AC_MSG_RESULT([$glibcxx_cv_obsolete_isnan])
+ if test $glibcxx_cv_obsolete_isnan = yes; then
+ AC_DEFINE(HAVE_OBSOLETE_ISNAN, 1,
+ [Define if <math.h> defines obsolete isnan function.])
+ fi
+ ;;
+ esac
+
+ CXXFLAGS="$ac_save_CXXFLAGS"
AC_LANG_RESTORE
])
linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
enable_clocale_flag=gnu
;;
- darwin* | freebsd*)
+ darwin*)
enable_clocale_flag=darwin
;;
- dragonfly*)
+ dragonfly* | freebsd*)
enable_clocale_flag=dragonfly
;;
openbsd*)
CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
;;
darwin)
- AC_MSG_RESULT(darwin or freebsd)
+ AC_MSG_RESULT(darwin)
CLOCALE_H=config/locale/generic/c_locale.h
CLOCALE_CC=config/locale/generic/c_locale.cc
;;
dragonfly)
- AC_MSG_RESULT(dragonfly)
+ AC_MSG_RESULT(dragonfly or freebsd)
- CLOCALE_H=config/locale/generic/c_locale.h
+ CLOCALE_H=config/locale/dragonfly/c_locale.h
CLOCALE_CC=config/locale/dragonfly/c_locale.cc
- CCODECVT_CC=config/locale/generic/codecvt_members.cc
- CCOLLATE_CC=config/locale/generic/collate_members.cc
+ CCODECVT_CC=config/locale/dragonfly/codecvt_members.cc
+ CCOLLATE_CC=config/locale/dragonfly/collate_members.cc
CCTYPE_CC=config/locale/dragonfly/ctype_members.cc
CMESSAGES_H=config/locale/generic/messages_members.h
CMESSAGES_CC=config/locale/generic/messages_members.cc
- CMONEY_CC=config/locale/generic/monetary_members.cc
- CNUMERIC_CC=config/locale/generic/numeric_members.cc
- CTIME_H=config/locale/generic/time_members.h
- CTIME_CC=config/locale/generic/time_members.cc
+ CMONEY_CC=config/locale/dragonfly/monetary_members.cc
+ CNUMERIC_CC=config/locale/dragonfly/numeric_members.cc
+ CTIME_H=config/locale/dragonfly/time_members.h
+ CTIME_CC=config/locale/dragonfly/time_members.cc
CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
;;
;;
esac
+ GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
+ test $enable_libstdcxx_allocator_flag = new)
AC_SUBST(ALLOCATOR_H)
AC_SUBST(ALLOCATOR_NAME)
])
case ${target_os} in
cygwin*|mingw32*)
VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
+ VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
vtv_cygmin=yes
;;
+ darwin*)
+ VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u,_vtable_map_vars_start -Wl,-u,_vtable_map_vars_end"
+ VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-rpath,${toplevel_builddir}/libvtv/.libs"
+ ;;
+ solaris2*)
+ VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
+ VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-R -Wl,${toplevel_builddir}/libvtv/.libs"
+ ;;
*)
VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
+ VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
;;
esac
VTV_PCH_CXXFLAGS="-fvtable-verify=std"
- VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
else
VTV_CXXFLAGS=
VTV_PCH_CXXFLAGS=
dnl
dnl --enable-libstdcxx-debug-flags='-O1'
dnl is a general method for passing flags to be used when
-dnl building debug libraries with --enable-debug.
+dnl building debug libraries with --enable-libstdcxx-debug.
dnl
dnl --disable-libstdcxx-debug-flags does nothing.
dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
dnl
dnl Defines:
dnl _GLIBCXX_USE_INT128
-dnl _GLIBCXX_USE_FLOAT128
+dnl ENABLE_FLOAT128
dnl
AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
AC_MSG_CHECKING([for __float128])
if AC_TRY_EVAL(ac_compile); then
- AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
- [Define if __float128 is supported on this host.])
enable_float128=yes
else
enable_float128=no
fi
AC_MSG_RESULT($enable_float128)
+ GLIBCXX_CONDITIONAL(ENABLE_FLOAT128, test $enable_float128 = yes)
rm -f conftest*
AC_LANG_RESTORE
atomic_type c1;
atomic_type c2;
atomic_type c3(0);
- __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
+ // N.B. __atomic_fetch_add is not supported for bool.
__atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
__ATOMIC_RELAXED);
__atomic_test_and_set(&c1, __ATOMIC_RELAXED);
atomic_type c1;
atomic_type c2;
atomic_type c3(0);
- __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
+ // N.B. __atomic_fetch_add is not supported for bool.
__atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
__ATOMIC_RELAXED);
__atomic_test_and_set(&c1, __ATOMIC_RELAXED);
CXXFLAGS="$old_CXXFLAGS"
AC_LANG_RESTORE
- # Set atomicity_dir to builtins if all but the long long test above passes.
- if test $glibcxx_cv_atomic_bool = yes \
- && test $glibcxx_cv_atomic_short = yes \
- && test $glibcxx_cv_atomic_int = yes; then
+ # Set atomicity_dir to builtins if all but the long long test above passes,
+ # or if the builtins were already chosen (e.g. by configure.host).
+ if { test "$glibcxx_cv_atomic_bool" = yes \
+ && test "$glibcxx_cv_atomic_short" = yes \
+ && test "$glibcxx_cv_atomic_int" = yes; } \
+ || test "$atomicity_dir" = "cpu/generic/atomicity_builtins"; then
AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
[Define if the compiler supports C++11 atomics.])
atomicity_dir=cpu/generic/atomicity_builtins
])
-dnl
-dnl Check for exception handling support. If an explicit enable/disable
-dnl sjlj exceptions is given, we don't have to detect. Otherwise the
-dnl target may or may not support call frame exceptions.
-dnl
-dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
-dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
-dnl Neither one forces an attempt at detection.
-dnl
-dnl Defines:
-dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
-dnl
-AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
- AC_MSG_CHECKING([for exception model to use])
- AC_LANG_SAVE
- AC_LANG_CPLUSPLUS
- GLIBCXX_ENABLE(sjlj-exceptions,auto,,
- [force use of builtin_setjmp for exceptions],
- [permit yes|no|auto])
-
- if test $enable_sjlj_exceptions = auto; then
- # Botheration. Now we've got to detect the exception model. Link tests
- # against libgcc.a are problematic since we've not been given proper -L
- # bits for single-tree newlib and libgloss.
- #
- # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style.
- cat > conftest.$ac_ext << EOF
-[#]line __oline__ "configure"
-struct S { ~S(); };
-void bar();
-void foo()
-{
- S s;
- bar();
-}
-EOF
- old_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS=-S
- if AC_TRY_EVAL(ac_compile); then
- if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
- enable_sjlj_exceptions=yes
- elif grep _Unwind_SjLj_Register conftest.s >/dev/null 2>&1 ; then
- enable_sjlj_exceptions=yes
- elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
- enable_sjlj_exceptions=no
- elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
- enable_sjlj_exceptions=no
- fi
- fi
- CXXFLAGS="$old_CXXFLAGS"
- rm -f conftest*
- fi
-
- # This is a tad weird, for hysterical raisins. We have to map
- # enable/disable to two different models.
- case $enable_sjlj_exceptions in
- yes)
- AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
- [Define if the compiler is configured for setjmp/longjmp exceptions.])
- ac_exception_model_name=sjlj
- ;;
- no)
- ac_exception_model_name="call frame"
- ;;
- *)
- AC_MSG_ERROR([unable to detect exception model])
- ;;
- esac
- AC_LANG_RESTORE
- AC_MSG_RESULT($ac_exception_model_name)
-])
-
-
dnl
dnl Allow visibility attributes to be used on namespaces, objects, etc.
dnl
fi
# For libtool versioning info, format is CURRENT:REVISION:AGE
-libtool_VERSION=6:21:0
+libtool_VERSION=6:26:0
# Everything parsed; figure out what files and settings to use.
case $enable_symvers in
[Define to use GNU versioning in the shared library.])
;;
gnu-versioned-namespace)
- libtool_VERSION=7:0:0
+ libtool_VERSION=8:0:0
SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
[Define to use GNU namespace versioning in the shared library.])
if test x"$ac_has_gthreads" = x"yes"; then
AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
[Define if gthreads library is available.])
+
+ # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14
+ AC_CHECK_TYPE([pthread_rwlock_t],
+ [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1,
+ [Define if POSIX read/write locks are available in <gthr.h>.])],
+ [],
+ [#include "gthr.h"])
fi
CXXFLAGS="$ac_save_CXXFLAGS"
dnl
AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [
GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string])
+ if test x$enable_symvers = xgnu-versioned-namespace; then
+ # gnu-versioned-namespace is incompatible with the dual ABI.
+ enable_libstdcxx_dual_abi="no"
+ fi
if test x"$enable_libstdcxx_dual_abi" != xyes; then
AC_MSG_NOTICE([dual ABI is disabled])
- default_libstdcxx_abi="c++98"
+ default_libstdcxx_abi="gcc4-compatible"
fi
GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes)
])
dnl
dnl Check to see which ABI should be enabled by default.
dnl
-dnl --with-default-libstdcxx-abi={c++98,c++11}
+dnl --with-default-libstdcxx-abi={gcc4-compatible,new}
dnl
dnl Defines:
dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
AS_HELP_STRING([--with-default-libstdcxx-abi],
[set the std::string ABI to use by default]),
[case "$withval" in
- c++98|gnu++98|c++03|gnu++03) default_libstdcxx_abi="c++98" ;;
- c++1?|gnu++1?) default_libstdcxx_abi="c++11" ;;
- *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
- esac],
- [default_libstdcxx_abi="c++11"])
+ gcc4-compatible) default_libstdcxx_abi="gcc4-compatible" ;;
+ new|cxx11) default_libstdcxx_abi="new" ;;
+ c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;;
+ *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
+ esac
+ ],
+ [default_libstdcxx_abi="new"])
AC_MSG_RESULT(${default_libstdcxx_abi})
fi
- if test $default_libstdcxx_abi = "c++11"; then
+ if test $default_libstdcxx_abi = "new"; then
glibcxx_cxx11_abi=1
glibcxx_cxx98_abi=0
else
GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1)
])
+dnl
+dnl Check to see whether to build libstdc++fs.a
+dnl
+dnl --enable-libstdcxx-filesystem-ts
+dnl
+AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [
+ GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,,
+ [turns on ISO/IEC TS 18822 support],
+ [permit yes|no|auto])
+
+ AC_MSG_CHECKING([whether to build Filesystem TS support])
+ if test x"$ac_cv_header_dirent_h" != x"yes"; then
+ enable_libstdcxx_filesystem_ts=no
+ fi
+ if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then
+ case "${target_os}" in
+ freebsd*|netbsd*|openbsd*|dragonfly*|darwin*)
+ enable_libstdcxx_filesystem_ts=yes
+ ;;
+ gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
+ enable_libstdcxx_filesystem_ts=yes
+ ;;
+ rtems*)
+ enable_libstdcxx_filesystem_ts=yes
+ ;;
+ solaris*)
+ enable_libstdcxx_filesystem_ts=yes
+ ;;
+ *)
+ enable_libstdcxx_filesystem_ts=no
+ ;;
+ esac
+ fi
+ AC_MSG_RESULT($enable_libstdcxx_filesystem_ts)
+ GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes)
+])
+
+dnl
+dnl Check whether the library calls required by the Filesystem TS are present.
+dnl Defines:
+dnl HAVE_STRUCT_DIRENT_D_TYPE
+dnl _GLIBCXX_USE_REALPATH
+dnl _GLIBCXX_USE_UTIMENSAT
+dnl _GLIBCXX_USE_ST_MTIM
+dnl _GLIBCXX_USE_FCHMOD
+dnl _GLIBCXX_USE_FCHMODAT
+dnl _GLIBCXX_USE_SENDFILE
+dnl HAVE_LINK
+dnl HAVE_READLINK
+dnl HAVE_SYMLINK
+dnl
+AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
+dnl
+ if test $enable_libstdcxx_filesystem_ts = yes; then
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -fno-exceptions"
+dnl
+ AC_MSG_CHECKING([for struct dirent.d_type])
+ AC_CACHE_VAL(glibcxx_cv_dirent_d_type, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <dirent.h>],
+ [
+ struct dirent d;
+ if (sizeof d.d_type) return 0;
+ ],
+ [glibcxx_cv_dirent_d_type=yes],
+ [glibcxx_cv_dirent_d_type=no])
+ ])
+ if test $glibcxx_cv_dirent_d_type = yes; then
+ AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_dirent_d_type)
+dnl
+ AC_MSG_CHECKING([for realpath])
+ AC_CACHE_VAL(glibcxx_cv_realpath, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [
+ #include <limits.h>
+ #include <stdlib.h>
+ #include <unistd.h>
+ ],
+ [
+ #if _XOPEN_VERSION < 500
+ #error
+ #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX)
+ char *tmp = realpath((const char*)NULL, (char*)NULL);
+ #else
+ #error
+ #endif
+ ],
+ [glibcxx_cv_realpath=yes],
+ [glibcxx_cv_realpath=no])
+ ])
+ if test $glibcxx_cv_realpath = yes; then
+ AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_realpath)
+dnl
+ AC_MSG_CHECKING([for utimensat])
+ AC_CACHE_VAL(glibcxx_cv_utimensat, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [
+ #include <fcntl.h>
+ #include <sys/stat.h>
+ ],
+ [
+ struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } };
+ int i = utimensat(AT_FDCWD, "path", ts, 0);
+ ],
+ [glibcxx_cv_utimensat=yes],
+ [glibcxx_cv_utimensat=no])
+ ])
+ if test $glibcxx_cv_utimensat = yes; then
+ AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_utimensat)
+dnl
+ AC_MSG_CHECKING([for struct stat.st_mtim.tv_nsec])
+ AC_CACHE_VAL(glibcxx_cv_st_mtim, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [ #include <sys/stat.h> ],
+ [
+ struct stat st;
+ return st.st_mtim.tv_nsec;
+ ],
+ [glibcxx_cv_st_mtim=yes],
+ [glibcxx_cv_st_mtim=no])
+ ])
+ if test $glibcxx_cv_st_mtim = yes; then
+ AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_st_mtim)
+dnl
+ AC_MSG_CHECKING([for fchmod])
+ AC_CACHE_VAL(glibcxx_cv_fchmod, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <sys/stat.h>],
+ [fchmod(1, S_IWUSR);],
+ [glibcxx_cv_fchmod=yes],
+ [glibcxx_cv_fchmod=no])
+ ])
+ if test $glibcxx_cv_fchmod = yes; then
+ AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_fchmod)
+dnl
+ AC_MSG_CHECKING([for fchmodat])
+ AC_CACHE_VAL(glibcxx_cv_fchmodat, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [
+ #include <fcntl.h>
+ #include <sys/stat.h>
+ ],
+ [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);],
+ [glibcxx_cv_fchmodat=yes],
+ [glibcxx_cv_fchmodat=no])
+ ])
+ if test $glibcxx_cv_fchmodat = yes; then
+ AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_fchmodat)
+dnl
+ AC_MSG_CHECKING([for sendfile that can copy files])
+ AC_CACHE_VAL(glibcxx_cv_sendfile, [dnl
+ case "${target_os}" in
+ gnu* | linux* | solaris*)
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <sys/sendfile.h>],
+ [sendfile(1, 2, (off_t*)0, sizeof 1);],
+ [glibcxx_cv_sendfile=yes],
+ [glibcxx_cv_sendfile=no])
+ ;;
+ *)
+ glibcxx_cv_sendfile=no
+ ;;
+ esac
+ ])
+ if test $glibcxx_cv_sendfile = yes; then
+ AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_sendfile)
+dnl
+ AC_MSG_CHECKING([for link])
+ AC_CACHE_VAL(glibcxx_cv_link, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <unistd.h>],
+ [link("", "");],
+ [glibcxx_cv_link=yes],
+ [glibcxx_cv_link=no])
+ ])
+ if test $glibcxx_cv_link = yes; then
+ AC_DEFINE(HAVE_LINK, 1, [Define if link is available in <unistd.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_link)
+dnl
+ AC_MSG_CHECKING([for readlink])
+ AC_CACHE_VAL(glibcxx_cv_readlink, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <unistd.h>],
+ [char buf[32]; readlink("", buf, sizeof(buf));],
+ [glibcxx_cv_readlink=yes],
+ [glibcxx_cv_readlink=no])
+ ])
+ if test $glibcxx_cv_readlink = yes; then
+ AC_DEFINE(HAVE_READLINK, 1, [Define if readlink is available in <unistd.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_readlink)
+dnl
+ AC_MSG_CHECKING([for symlink])
+ AC_CACHE_VAL(glibcxx_cv_symlink, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <unistd.h>],
+ [symlink("", "");],
+ [glibcxx_cv_symlink=yes],
+ [glibcxx_cv_symlink=no])
+ ])
+ if test $glibcxx_cv_symlink = yes; then
+ AC_DEFINE(HAVE_SYMLINK, 1, [Define if symlink is available in <unistd.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_symlink)
+dnl
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+ fi
+])
+
+dnl
+dnl Check how size_t is mangled. Copied from libitm.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_SIZE_T_MANGLING], [
+ AC_CACHE_CHECK([how size_t is mangled],
+ glibcxx_cv_size_t_mangling, [
+ AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
+ [glibcxx_cv_size_t_mangling=m], [
+ AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
+ [glibcxx_cv_size_t_mangling=j], [
+ AC_TRY_COMPILE([],
+ [extern __SIZE_TYPE__ x; extern unsigned long long x;],
+ [glibcxx_cv_size_t_mangling=y], [
+ AC_TRY_COMPILE([],
+ [extern __SIZE_TYPE__ x; extern unsigned short x;],
+ [glibcxx_cv_size_t_mangling=t], [
+ AC_TRY_COMPILE([],
+ [extern __SIZE_TYPE__ x; extern __int20 unsigned x;],
+ [glibcxx_cv_size_t_mangling=u6uint20],
+ [glibcxx_cv_size_t_mangling=x])
+ ])
+ ])
+ ])
+ ])
+ ])
+ if test $glibcxx_cv_size_t_mangling = x; then
+ AC_MSG_ERROR([Unknown underlying type for size_t])
+ fi
+ AC_DEFINE_UNQUOTED(_GLIBCXX_MANGLE_SIZE_T, [$glibcxx_cv_size_t_mangling],
+ [Define to the letter to which size_t is mangled.])
+])
+
+dnl
+dnl Determine whether std::exception_ptr symbols should be exported with
+dnl the symbol versions from GCC 4.6.0 or GCC 7.1.0, depending on which
+dnl release first added support for std::exception_ptr. Originally it was
+dnl only supported for targets with always-lock-free atomics for int, but
+dnl since GCC 7.1 it is supported for all targets.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_EXCEPTION_PTR_SYMVER], [
+ if test $enable_symvers != no; then
+ AC_MSG_CHECKING([for first version to support std::exception_ptr])
+ case ${target} in
+ aarch64-*-* | alpha-*-* | hppa*-*-* | i?86-*-* | x86_64-*-* | \
+ m68k-*-* | powerpc*-*-* | s390*-*-* | *-*-solaris* )
+ ac_exception_ptr_since_gcc46=yes
+ ;;
+ *)
+ # If the value of this macro changes then we will need to hardcode
+ # yes/no here for additional targets based on the original value.
+ AC_TRY_COMPILE([], [
+ #if __GCC_ATOMIC_INT_LOCK_FREE <= 1
+ # error atomic int not always lock free
+ #endif
+ ],
+ [ac_exception_ptr_since_gcc46=yes],
+ [ac_exception_ptr_since_gcc46=no])
+ ;;
+ esac
+ if test x"$ac_exception_ptr_since_gcc46" = x"yes" ; then
+ AC_DEFINE(HAVE_EXCEPTION_PTR_SINCE_GCC46, 1,
+ [Define to 1 if GCC 4.6 supported std::exception_ptr for the target])
+ AC_MSG_RESULT([4.6.0])
+ else
+ AC_MSG_RESULT([7.1.0])
+ fi
+ fi
+])
# Macros from the top-level gcc directory.
m4_include([../config/gc++filt.m4])
m4_include([../config/tls.m4])
m4_include([../config/gthr.m4])
+m4_include([../config/cet.m4])
projects / gcc.git / blobdiff