# 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/filesystem doc po testsuite python])
SUBDIRS='glibcxx_SUBDIRS'
# These need to be absolute paths, yet at the same time need to
AC_DEFUN([GLIBCXX_CHECK_ASSEMBLER_HWCAP], [
test -z "$HWCAP_FLAGS" && HWCAP_FLAGS=''
- ac_save_CFLAGS="$CFLAGS"
- CFLAGS="$CFLAGS -Wa,-nH"
+ # 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)
+ 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"
+ CFLAGS="$ac_save_CFLAGS"
+ ;;
+ esac
AC_SUBST(HWCAP_FLAGS)
])
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
glibcxx_local_stylesheets=yes
XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
fi
+ if test -d /usr/share/xml/docbook/stylesheet/nwalsh5/current; then
+ glibcxx_local_stylesheets=yes
+ XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/nwalsh5/current
+ fi
fi
AC_MSG_RESULT($glibcxx_local_stylesheets)
dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
dnl
-dnl See docs/html/17_intro/configury.html#enable for documentation.
+dnl See manual/appendix_porting.html#appendix.porting.build_hacking for
+dnl documentation.
dnl
m4_define([GLIBCXX_ENABLE],[dnl
m4_define([_g_switch],[--enable-$1])dnl
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 explicitely
- # 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("12", 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])
dnl links in the latter.
dnl --enable-libstdcxx-time=rt
dnl also searches (and, if needed, links) librt. Note that this is
-dnl not always desirable because, in glibc, for example, in turn it
-dnl triggers the linking of libpthread too, which activates locking,
+dnl not always desirable because, in glibc 2.16 and earlier, for
+dnl example, in turn it triggers the linking of libpthread too,
+dnl which activates locking,
dnl a large overhead for single-thread programs.
dnl --enable-libstdcxx-time=no
dnl --disable-libstdcxx-time
dnl disables the checks completely
dnl
+dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
+dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
+dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
+dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
+dnl
AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
- AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
- GLIBCXX_ENABLE(libstdcxx-time,$1,[[[=KIND]]],
+ GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]],
[use KIND for check type],
[permit yes|no|rt])
ac_has_clock_monotonic=no
ac_has_clock_realtime=no
- AC_MSG_RESULT($enable_libstdcxx_time)
+ ac_has_nanosleep=no
+ ac_has_sched_yield=no
+
+ if test x"$enable_libstdcxx_time" = x"auto"; then
+
+ case "${target_os}" in
+ cygwin*)
+ ac_has_nanosleep=yes
+ ;;
+ darwin*)
+ ac_has_nanosleep=yes
+ ac_has_sched_yield=yes
+ ;;
+ gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
+ AC_MSG_CHECKING([for at least GNU libc 2.17])
+ AC_TRY_COMPILE(
+ [#include <features.h>],
+ [
+ #if ! __GLIBC_PREREQ(2, 17)
+ #error
+ #endif
+ ],
+ [glibcxx_glibc217=yes], [glibcxx_glibc217=no])
+ AC_MSG_RESULT($glibcxx_glibc217)
+
+ if test x"$glibcxx_glibc217" = x"yes"; then
+ ac_has_clock_monotonic=yes
+ ac_has_clock_realtime=yes
+ fi
+ ac_has_nanosleep=yes
+ ac_has_sched_yield=yes
+ ;;
+ freebsd*|netbsd*|dragonfly*)
+ ac_has_clock_monotonic=yes
+ ac_has_clock_realtime=yes
+ ac_has_nanosleep=yes
+ ac_has_sched_yield=yes
+ ;;
+ openbsd*)
+ ac_has_clock_monotonic=yes
+ ac_has_clock_realtime=yes
+ ac_has_nanosleep=yes
+ ;;
+ solaris*)
+ GLIBCXX_LIBS="$GLIBCXX_LIBS -lrt"
+ ac_has_clock_monotonic=yes
+ ac_has_clock_realtime=yes
+ ac_has_nanosleep=yes
+ ac_has_sched_yield=yes
+ ;;
+ esac
- if test x"$enable_libstdcxx_time" != x"no"; then
+ elif test x"$enable_libstdcxx_time" != x"no"; then
if test x"$enable_libstdcxx_time" = x"rt"; then
AC_SEARCH_LIBS(clock_gettime, [rt posix4])
case "$ac_cv_search_sched_yield" in
-lposix4*)
GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
- AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
- [ Defined if sched_yield is available. ])
+ ac_has_sched_yield=yes
;;
-lrt*)
if test x"$enable_libstdcxx_time" = x"rt"; then
GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
- AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
- [ Defined if sched_yield is available. ])
+ ac_has_sched_yield=yes
fi
;;
*)
- AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
- [ Defined if sched_yield is available. ])
+ ac_has_sched_yield=yes
;;
esac
fi
fi
+ if test x"$ac_has_clock_monotonic" != x"yes"; then
+ case ${target_os} in
+ linux*)
+ AC_MSG_CHECKING([for clock_gettime syscall])
+ AC_TRY_COMPILE(
+ [#include <unistd.h>
+ #include <time.h>
+ #include <sys/syscall.h>
+ ],
+ [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
+ timespec tp;
+ #endif
+ syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp);
+ syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp);
+ ], [ac_has_clock_monotonic_syscall=yes], [ac_has_clock_monotonic_syscall=no])
+ AC_MSG_RESULT($ac_has_clock_monotonic_syscall)
+ if test x"$ac_has_clock_monotonic_syscall" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1,
+ [ Defined if clock_gettime syscall has monotonic and realtime clock support. ])
+ ac_has_clock_monotonic=yes
+ ac_has_clock_realtime=yes
+ fi;;
+ esac
+ fi
+
if test x"$ac_has_clock_monotonic" = x"yes"; then
AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
[ Defined if clock_gettime has monotonic clock support. ])
[ Defined if clock_gettime has realtime clock support. ])
fi
+ if test x"$ac_has_sched_yield" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
+ [ Defined if sched_yield is available. ])
+ fi
+
if test x"$ac_has_nanosleep" = x"yes"; then
AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
[ Defined if nanosleep is available. ])
+ else
+ AC_MSG_CHECKING([for sleep])
+ AC_TRY_COMPILE([#include <unistd.h>],
+ [sleep(1)],
+ [ac_has_sleep=yes],[ac_has_sleep=no])
+ if test x"$ac_has_sleep" = x"yes"; then
+ AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.])
+ fi
+ AC_MSG_RESULT($ac_has_sleep)
+ AC_MSG_CHECKING([for usleep])
+ AC_TRY_COMPILE([#include <unistd.h>],
+ [sleep(1);
+ usleep(100);],
+ [ac_has_usleep=yes],[ac_has_usleep=no])
+ if test x"$ac_has_usleep" = x"yes"; then
+ AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.])
+ fi
+ AC_MSG_RESULT($ac_has_usleep)
+ fi
+
+ if test x"$ac_has_nanosleep$ac_has_sleep" = x"nono"; then
+ AC_MSG_CHECKING([for Sleep])
+ AC_TRY_COMPILE([#include <windows.h>],
+ [Sleep(1)],
+ [ac_has_win32_sleep=yes],[ac_has_win32_sleep=no])
+ if test x"$ac_has_win32_sleep" = x"yes"; then
+ AC_DEFINE(HAVE_WIN32_SLEEP,1, [Defined if Sleep exists.])
+ fi
+ AC_MSG_RESULT($ac_has_win32_sleep)
fi
AC_SUBST(GLIBCXX_LIBS)
<tr1/cinttypes> in namespace std::tr1.])
fi
- # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
+ # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
# make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
ac_c99_inttypes_wchar_t_tr1=no;
if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
AC_LANG_RESTORE
])
+dnl
+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 the
dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
AC_CACHE_VAL(glibcxx_cv_random_tr1, [
if test -r /dev/random && test -r /dev/urandom; then
- glibcxx_cv_random_tr1=yes;
+ ## For MSys environment the test above is detect as false-positive
+ ## on mingw-targets. So disable it explicit for them.
+ case ${target_os} in
+ *mingw*) glibcxx_cv_random_tr1=no ;;
+ *) glibcxx_cv_random_tr1=yes ;;
+ esac
else
glibcxx_cv_random_tr1=no;
fi
AC_LANG_RESTORE
])
+dnl
+dnl Check whether required C++11 overloads 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 introduced the C++11 <math.h> overloads. A backport to
+ # a Solaris 11.3 SRU is likely, maybe even a Solaris 10 patch.
+ AC_MSG_CHECKING([for C++11 <math.h> overloads])
+ AC_CACHE_VAL(glibcxx_cv_math11_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_overload=no],
+ [glibcxx_cv_math11_overload=yes]
+ )])
+
+ # autoheader cannot handle indented templates.
+ AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO],
+ [/* Define if all C++11 overloads are available in <math.h>. */
+#if __cplusplus >= 201103L
+#undef __CORRECT_ISO_CPP11_MATH_H_PROTO
+#endif])
+
+ if test $glibcxx_cv_math11_overload = yes; then
+ AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO)
+ fi
+ AC_MSG_RESULT([$glibcxx_cv_math11_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(
+ [#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
+])
+
dnl
dnl Check whether macros, etc are present for <system_error>
dnl
linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
enable_clocale_flag=gnu
;;
- darwin* | freebsd*)
+ darwin*)
enable_clocale_flag=darwin
;;
+ dragonfly* | freebsd*)
+ enable_clocale_flag=dragonfly
+ ;;
+ openbsd*)
+ enable_clocale_flag=newlib
+ ;;
*)
if test x"$with_newlib" = x"yes"; then
enable_clocale_flag=newlib
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
CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
;;
+ dragonfly)
+ AC_MSG_RESULT(dragonfly or freebsd)
+
+ CLOCALE_H=config/locale/dragonfly/c_locale.h
+ CLOCALE_CC=config/locale/dragonfly/c_locale.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/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
+ ;;
+
gnu)
AC_MSG_RESULT(gnu)
;;
esac
+ GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
+ test $enable_libstdcxx_allocator_flag = new)
AC_SUBST(ALLOCATOR_H)
AC_SUBST(ALLOCATOR_NAME)
])
GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
])
+dnl
+dnl Use vtable verification.
+dnl
+dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1
+dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0
+
+dnl + Usage: GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)]
+dnl Where DEFAULT is `yes' or `no'.
+dnl
+AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [
+
+ GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify])
+
+ AC_MSG_CHECKING([for vtable verify support])
+ AC_MSG_RESULT([$enable_vtable_verify])
+
+ vtv_cygmin=no
+ if test $enable_vtable_verify = yes; then
+ 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"
+ else
+ VTV_CXXFLAGS=
+ VTV_PCH_CXXFLAGS=
+ VTV_CXXLINKFLAGS=
+ fi
+
+ AC_SUBST(VTV_CXXFLAGS)
+ AC_SUBST(VTV_PCH_CXXFLAGS)
+ AC_SUBST(VTV_CXXLINKFLAGS)
+ AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes)
+ GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes)
+])
+
dnl
dnl Check for parallel mode pre-requisites, including OpenMP support.
dnl
AC_MSG_CHECKING([for parallel mode support])
AC_MSG_RESULT([$enable_parallel])
- GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
])
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)
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);
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
+ if test "$glibcxx_cv_atomic_bool" = yes \
+ && test "$glibcxx_cv_atomic_short" = yes \
+ && test "$glibcxx_cv_atomic_int" = yes; 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_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:17:0
+libtool_VERSION=6:23:0
# Everything parsed; figure out what files and settings to use.
case $enable_symvers in
dnl namespace are complex and fragile enough as it is). We must also
dnl add a relative path so that -I- is supported properly.
dnl
+dnl Substs:
+dnl thread_header
+dnl
AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
AC_MSG_CHECKING([for thread model used by GCC])
target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
AC_MSG_RESULT([$target_thread_file])
+ GCC_AC_THREAD_HEADER([$target_thread_file])
])
#ifndef __GTHREADS_CXX0X
#error
#endif
- ], [case $target_os in
- # gthreads support breaks symbol versioning on Solaris 9 (PR
- # libstdc++/52189).
- solaris2.9*)
- if test x$enable_symvers = xno; then
- ac_has_gthreads=yes
- elif test x$enable_libstdcxx_threads = xyes; then
- AC_MSG_WARN([You have requested C++11 threads support, but])
- AC_MSG_WARN([this breaks symbol versioning.])
- ac_has_gthreads=yes
- else
- ac_has_gthreads=no
- fi
- ;;
- *)
- ac_has_gthreads=yes
- ;;
- esac],
- [ac_has_gthreads=no])
+ ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
else
ac_has_gthreads=no
fi
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"
GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
])
+dnl
+dnl Check whether obsolescent tmpnam is available in <stdio.h>,
+dnl and define _GLIBCXX_USE_TMPNAM.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl
+dnl
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -fno-exceptions"
+dnl
+ AC_MSG_CHECKING([for tmpnam])
+ AC_CACHE_VAL(glibcxx_cv_TMPNAM, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <stdio.h>],
+ [char *tmp = tmpnam(NULL);],
+ [glibcxx_cv_TMPNAM=yes],
+ [glibcxx_cv_TMPNAM=no])
+ ])
+ if test $glibcxx_cv_TMPNAM = yes; then
+ AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_TMPNAM)
+dnl
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+])
+
+dnl
+dnl Check to see if sys/sdt.h exists and that it is suitable for use.
+dnl Some versions of sdt.h were not compatible with C++11.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_SDT_H], [
+ AC_MSG_CHECKING([for suitable sys/sdt.h])
+ # Note that this test has to be run with the C language.
+ # Otherwise, sdt.h will try to include some headers from
+ # libstdc++ itself.
+ AC_LANG_SAVE
+ AC_LANG_C
+ AC_CACHE_VAL(glibcxx_cv_sys_sdt_h, [
+ # Because we have to run the test in C, we use grep rather
+ # than the compiler to check for the bug. The bug is that
+ # were strings without trailing whitespace, causing g++
+ # to look for operator"". The pattern searches for the fixed
+ # output.
+ AC_EGREP_CPP([ \",\" ], [
+ #include <sys/sdt.h>
+ int f() { STAP_PROBE(hi, bob); }
+ ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no])
+ ])
+ AC_LANG_RESTORE
+ if test $glibcxx_cv_sys_sdt_h = yes; then
+ AC_DEFINE(HAVE_SYS_SDT_H, 1,
+ [Define to 1 if you have a suitable <sys/sdt.h> header file])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_sys_sdt_h)
+])
+
+dnl
+dnl Control whether the library should define symbols for old and new ABIs.
+dnl This affects definitions of strings, stringstreams and locale facets.
+dnl
+dnl --disable-libstdcxx-dual-abi will use old ABI for all types.
+dnl
+dnl Defines:
+dnl _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0)
+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="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={gcc4-compatible,new}
+dnl
+dnl Defines:
+dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
+dnl
+AC_DEFUN([GLIBCXX_DEFAULT_ABI], [
+ if test x$enable_libstdcxx_dual_abi = xyes; then
+ AC_MSG_CHECKING([for default std::string ABI to use])
+ AC_ARG_WITH([default-libstdcxx-abi],
+ AS_HELP_STRING([--with-default-libstdcxx-abi],
+ [set the std::string ABI to use by default]),
+ [case "$withval" in
+ 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 = "new"; then
+ glibcxx_cxx11_abi=1
+ glibcxx_cxx98_abi=0
+ else
+ glibcxx_cxx11_abi=0
+ glibcxx_cxx98_abi=1
+ fi
+ AC_SUBST(glibcxx_cxx98_abi)
+ 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
+ ;;
+ 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 and define _GLIBCXX_USE_REALPATH and _GLIBCXX_USE_UTIMENSAT.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
+dnl
+ 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 <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
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+])
+
+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],
+ [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.])
+])
# Macros from the top-level gcc directory.
m4_include([../config/gc++filt.m4])
m4_include([../config/tls.m4])
+m4_include([../config/gthr.m4])
projects / gcc.git / blobdiff