X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=libstdc%2B%2B-v3%2Facinclude.m4;h=186916c2e47e75b5c9ee07a35c2981414934e147;hp=bd1b380a4bc85bd9e78318931a6f06534a34e753;hb=38e9ad31b158ba7f719f7eb191ab40d856f1470f;hpb=2080d5efc4fa305a790e89276c848b2da0e0aae3 diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4 index bd1b380a4bc..186916c2e47 100644 --- a/libstdc++-v3/acinclude.m4 +++ b/libstdc++-v3/acinclude.m4 @@ -49,7 +49,7 @@ AC_DEFUN([GLIBCXX_CONFIGURE], [ # 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 libmath libsupc++ src po testsuite]) + m4_define([glibcxx_SUBDIRS],[include libsupc++ src doc po testsuite]) SUBDIRS='glibcxx_SUBDIRS' # These need to be absolute paths, yet at the same time need to @@ -123,7 +123,15 @@ AC_DEFUN([GLIBCXX_CONFIGURE], [ # which are themselves conditionally expanded. ## (Right now, this only matters for enable_wchar_t, but nothing prevents ## other macros from doing the same. This should be automated.) -pme - need_libmath=no + + # Check for uClibc since Linux platforms use different configuration + # directories depending on the C library in use. + AC_EGREP_CPP([_using_uclibc], [ + #include + #if __UCLIBC__ + _using_uclibc + #endif + ], uclibc=yes, uclibc=no) # Find platform-specific directories containing configuration info. # Also possibly modify flags used elsewhere, as needed by the platform. @@ -161,8 +169,8 @@ AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [ # Check for -ffunction-sections -fdata-sections AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections]) - CXXFLAGS='-Werror -ffunction-sections -fdata-sections' - AC_TRY_COMPILE(, [int foo;], [ac_fdsections=yes], [ac_fdsections=no]) + CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections' + AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no]) if test "$ac_test_CXXFLAGS" = set; then CXXFLAGS="$ac_save_CXXFLAGS" else @@ -191,6 +199,7 @@ dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible dnl LD (as a side effect of testing) dnl Sets: dnl with_gnu_ld +dnl glibcxx_ld_is_gold (set to "no" or "yes") dnl glibcxx_gnu_ld_version (possibly) dnl dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will @@ -222,29 +231,42 @@ AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [ # Start by getting the version number. I think the libtool test already # does some of this, but throws away the result. - AC_MSG_CHECKING([for ld version]) - changequote(,) - ldver=`$LD --version 2>/dev/null | head -1 | \ - sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'` - changequote([,]) - glibcxx_gnu_ld_version=`echo $ldver | \ - $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'` - AC_MSG_RESULT($glibcxx_gnu_ld_version) + glibcxx_ld_is_gold=no + if test x"$with_gnu_ld" = x"yes"; then + AC_MSG_CHECKING([for ld version]) + changequote(,) + if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then + glibcxx_ld_is_gold=yes + fi + ldver=`$LD --version 2>/dev/null | head -1 | \ + sed -e 's/GNU \(go\)\{0,1\}ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\4/'` + changequote([,]) + glibcxx_gnu_ld_version=`echo $ldver | \ + $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'` + AC_MSG_RESULT($glibcxx_gnu_ld_version) + fi # Set --gc-sections. - glibcxx_gcsections_min_ld=21602 - if test x"$with_gnu_ld" = x"yes" && + glibcxx_have_gc_sections=no + if test "$glibcxx_ld_is_gold" = "yes"; then + if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then + glibcxx_have_gc_sections=yes + fi + else + glibcxx_gcsections_min_ld=21602 + if test x"$with_gnu_ld" = x"yes" && test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then - + glibcxx_have_gc_sections=yes + fi + fi + if test "$glibcxx_have_gc_sections" = "yes"; then # Sufficiently young GNU ld it is! Joy and bunny rabbits! # NB: This flag only works reliably after 2.16.1. Configure tests # for this are difficult, so hard wire a value that should work. - # All these tests are for C++, but run with the "C" compiler driver. - # Need to do this so that g++ won't try to link in libstdc++/libsupc++. ac_test_CFLAGS="${CFLAGS+set}" ac_save_CFLAGS="$CFLAGS" - CFLAGS='-x c++ -Wl,--gc-sections' + CFLAGS='-Wl,--gc-sections' # Check for -Wl,--gc-sections AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections]) @@ -299,53 +321,6 @@ AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [ dnl -dnl Check to see if this target can enable the iconv specializations. -dnl If --disable-c-mbchar was given, no wchar_t specialization is enabled. -dnl (This must have been previously checked, along with the rest of C99 -dnl support.) By default, iconv support is disabled. -dnl -dnl Defines: -dnl _GLIBCXX_USE_ICONV if all the bits are found. -dnl Substs: -dnl LIBICONV to a -l string containing the iconv library, if needed. -dnl -AC_DEFUN([GLIBCXX_CHECK_ICONV_SUPPORT], [ - - enable_iconv=no - # Only continue checking if the ISO C99 headers exist and support is on. - if test x"$enable_wchar_t" = xyes; then - - # Use iconv for wchar_t to char conversions. As such, check for - # X/Open Portability Guide, version 2 features (XPG2). - AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no) - AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no) - - # Check for existence of libiconv.a providing XPG2 wchar_t support. - AC_CHECK_LIB(iconv, iconv, LIBICONV="-liconv") - ac_save_LIBS="$LIBS" - LIBS="$LIBS $LIBICONV" - AC_SUBST(LIBICONV) - - AC_CHECK_FUNCS([iconv_open iconv_close iconv nl_langinfo], - [ac_XPG2funcs=yes], [ac_XPG2funcs=no]) - - LIBS="$ac_save_LIBS" - - if test x"$ac_has_iconv_h" = xyes && - test x"$ac_has_langinfo_h" = xyes && - test x"$ac_XPG2funcs" = xyes; - then - AC_DEFINE([_GLIBCXX_USE_ICONV],1, - [Define if iconv and related functions exist and are usable.]) - enable_iconv=yes - fi - fi - AC_MSG_CHECKING([for enabled iconv specializations]) - AC_MSG_RESULT($enable_iconv) -]) - - -dnl dnl Check for headers for, and arguments to, the setrlimit() function. dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE. dnl @@ -384,7 +359,7 @@ AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [ GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE) # Check for rlimit, setrlimit. - AC_CACHE_VAL(ac_setrlimit, [ + AC_CACHE_VAL(glibcxx_cv_setrlimit, [ AC_TRY_COMPILE( [#include #include @@ -392,12 +367,12 @@ AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [ ], [struct rlimit r; setrlimit(0, &r);], - [ac_setrlimit=yes], [ac_setrlimit=no]) + [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no]) ]) fi AC_MSG_CHECKING([for testsuite resource limits support]) - if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then + if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then ac_res_limits=yes AC_DEFINE(_GLIBCXX_RES_LIMITS, 1, [Define if using setrlimit to set resource limits during @@ -414,9 +389,15 @@ dnl Check whether S_ISREG (Posix) or S_IFREG is available in . dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately. dnl AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [ + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -fno-exceptions" + AC_MSG_CHECKING([for S_ISREG or S_IFREG]) AC_CACHE_VAL(glibcxx_cv_S_ISREG, [ - AC_TRY_LINK( + GCC_TRY_COMPILE_OR_LINK( [#include ], [struct stat buffer; fstat(0, &buffer); @@ -425,7 +406,7 @@ AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [ [glibcxx_cv_S_ISREG=no]) ]) AC_CACHE_VAL(glibcxx_cv_S_IFREG, [ - AC_TRY_LINK( + GCC_TRY_COMPILE_OR_LINK( [#include ], [struct stat buffer; fstat(0, &buffer); @@ -444,6 +425,9 @@ AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [ res=S_IFREG fi AC_MSG_RESULT($res) + + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE ]) @@ -451,9 +435,15 @@ dnl dnl Check whether poll is available in , and define HAVE_POLL. dnl AC_DEFUN([GLIBCXX_CHECK_POLL], [ + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -fno-exceptions" + AC_MSG_CHECKING([for poll]) AC_CACHE_VAL(glibcxx_cv_POLL, [ - AC_TRY_LINK( + GCC_TRY_COMPILE_OR_LINK( [#include ], [struct pollfd pfd[1]; pfd[0].events = POLLIN; @@ -465,6 +455,9 @@ AC_DEFUN([GLIBCXX_CHECK_POLL], [ AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in .]) fi AC_MSG_RESULT($glibcxx_cv_POLL) + + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE ]) @@ -472,9 +465,15 @@ dnl dnl Check whether writev is available in , and define HAVE_WRITEV. dnl AC_DEFUN([GLIBCXX_CHECK_WRITEV], [ + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -fno-exceptions" + AC_MSG_CHECKING([for writev]) AC_CACHE_VAL(glibcxx_cv_WRITEV, [ - AC_TRY_LINK( + GCC_TRY_COMPILE_OR_LINK( [#include ], [struct iovec iov[2]; writev(0, iov, 0);], @@ -485,13 +484,21 @@ AC_DEFUN([GLIBCXX_CHECK_WRITEV], [ AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in .]) fi AC_MSG_RESULT($glibcxx_cv_WRITEV) + + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE ]) dnl dnl Check whether int64_t is available in , and define HAVE_INT64_T. +dnl Also check whether int64_t is actually a typedef to long or long long. dnl AC_DEFUN([GLIBCXX_CHECK_INT64_T], [ + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_MSG_CHECKING([for int64_t]) AC_CACHE_VAL(glibcxx_cv_INT64_T, [ AC_TRY_COMPILE( @@ -500,10 +507,43 @@ AC_DEFUN([GLIBCXX_CHECK_INT64_T], [ [glibcxx_cv_INT64_T=yes], [glibcxx_cv_INT64_T=no]) ]) + if test $glibcxx_cv_INT64_T = yes; then AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in .]) + AC_MSG_RESULT($glibcxx_cv_INT64_T) + + AC_MSG_CHECKING([for int64_t as long]) + AC_CACHE_VAL(glibcxx_cv_int64_t_long, [ + AC_TRY_COMPILE( + [#include + template struct same { enum { value = -1 }; }; + template struct same { enum { value = 1 }; }; + int array[same::value];], [], + [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no]) + ]) + + if test $glibcxx_cv_int64_t_long = yes; then + AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.]) + AC_MSG_RESULT($glibcxx_cv_int64_t_long) + fi + + AC_MSG_CHECKING([for int64_t as long long]) + AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [ + AC_TRY_COMPILE( + [#include + template struct same { enum { value = -1 }; }; + template struct same { enum { value = 1 }; }; + int array[same::value];], [], + [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no]) + ]) + + if test $glibcxx_cv_int64_t_long_long = yes; then + AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.]) + AC_MSG_RESULT($glibcxx_cv_int64_t_long_long) + fi fi - AC_MSG_RESULT($glibcxx_cv_INT64_T) + + AC_LANG_RESTORE ]) @@ -517,7 +557,7 @@ AC_DEFUN([GLIBCXX_CHECK_LFS], [ CXXFLAGS="$CXXFLAGS -fno-exceptions" AC_MSG_CHECKING([for LFS support]) AC_CACHE_VAL(glibcxx_cv_LFS, [ - AC_TRY_LINK( + GCC_TRY_COMPILE_OR_LINK( [#include #include #include @@ -598,7 +638,7 @@ AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [ fi # Export file names for ABI checking. - baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}\$(MULTISUBDIR)" + baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}" AC_SUBST(baseline_dir) ]) @@ -644,8 +684,8 @@ dnl AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [ # Optimization flags that are probably a good idea for thrill-seekers. Just # uncomment the lines below and make, everything else is ready to go... + # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host. # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc - OPTIMIZE_CXXFLAGS= AC_SUBST(OPTIMIZE_CXXFLAGS) WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual' @@ -665,6 +705,8 @@ dnl dnl Assumes cross_compiling bits already done, and with_cross_host in dnl particular. dnl +dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir. +dnl config/gxx-include-dir.m4 must be kept consistant with this as well. AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [ glibcxx_toolexecdir=no glibcxx_toolexeclibdir=no @@ -696,7 +738,13 @@ AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [ # Default case for install directory for include files. if test $version_specific_libs = no && test $gxx_include_dir = no; then - gxx_include_dir='${prefix}/include/c++/${gcc_version}' + gxx_include_dir='include/c++/${gcc_version}' + if test -n "$with_cross_host" && + test x"$with_cross_host" != x"no"; then + gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir" + else + gxx_include_dir='${prefix}/'"$gxx_include_dir" + fi fi # Version-specific runtime libs processing. @@ -788,44 +836,57 @@ dnl AC_DEFUN([GLIBCXX_ENABLE_C99], [ GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support]) - # Test wchar.h for mbstate_t, which is needed for char_traits and fpos - # even if C99 support is turned off. - AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no) - AC_MSG_CHECKING([for mbstate_t]) - AC_TRY_COMPILE([#include ], - [mbstate_t teststate;], - have_mbstate_t=yes, have_mbstate_t=no) - AC_MSG_RESULT($have_mbstate_t) - if test x"$have_mbstate_t" = xyes; then - AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.]) - fi - if test x"$enable_c99" = x"yes"; then AC_LANG_SAVE AC_LANG_CPLUSPLUS + # 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" + + 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 functions used if C99 is enabled. AC_MSG_CHECKING([for ISO C99 support in ]) - AC_CACHE_VAL(ac_c99_math, [ - AC_TRY_COMPILE([#include ], - [fpclassify(0.0); - isfinite(0.0); - isinf(0.0); - isnan(0.0); - isnormal(0.0); - signbit(0.0); - isgreater(0.0,0.0); - isgreaterequal(0.0,0.0); - isless(0.0,0.0); - islessequal(0.0,0.0); - islessgreater(0.0,0.0); - islessgreater(0.0,0.0); - isunordered(0.0,0.0); - ],[ac_c99_math=yes], [ac_c99_math=no]) + AC_CACHE_VAL(glibcxx_cv_c99_math, [ + GCC_TRY_COMPILE_OR_LINK( + [#include + 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($ac_c99_math) - if test x"$ac_c99_math" = x"yes"; then + 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 should be imported in in namespace std.]) @@ -835,54 +896,65 @@ AC_DEFUN([GLIBCXX_ENABLE_C99], [ # 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) - ac_c99_complex=no; + glibcxx_cv_c99_complex=no; if test x"$ac_has_complex_h" = x"yes"; then AC_MSG_CHECKING([for ISO C99 support in ]) - AC_TRY_COMPILE([#include ], - [typedef __complex__ float float_type; float_type tmpf; - cabsf(tmpf); - cargf(tmpf); - ccosf(tmpf); - ccoshf(tmpf); - cexpf(tmpf); - clogf(tmpf); - csinf(tmpf); - csinhf(tmpf); - csqrtf(tmpf); - ctanf(tmpf); - ctanhf(tmpf); - cpowf(tmpf, tmpf); - typedef __complex__ double double_type; double_type tmpd; - cabs(tmpd); - carg(tmpd); - ccos(tmpd); - ccosh(tmpd); - cexp(tmpd); - clog(tmpd); - csin(tmpd); - csinh(tmpd); - csqrt(tmpd); - ctan(tmpd); - ctanh(tmpd); - cpow(tmpd, tmpd); - typedef __complex__ long double ld_type; ld_type tmpld; - cabsl(tmpld); - cargl(tmpld); - ccosl(tmpld); - ccoshl(tmpld); - cexpl(tmpld); - clogl(tmpld); - csinl(tmpld); - csinhl(tmpld); - csqrtl(tmpld); - ctanl(tmpld); - ctanhl(tmpld); - cpowl(tmpld, tmpld); - ],[ac_c99_complex=yes], [ac_c99_complex=no]) - fi - AC_MSG_RESULT($ac_c99_complex) - if test x"$ac_c99_complex" = x"yes"; then + GCC_TRY_COMPILE_OR_LINK( + [#include + 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 should be used in . Using compiler builtins for these functions requires @@ -891,109 +963,60 @@ AC_DEFUN([GLIBCXX_ENABLE_C99], [ # Check for the existence in of vscanf, et. al. AC_MSG_CHECKING([for ISO C99 support in ]) - AC_CACHE_VAL(ac_c99_stdio, [ - AC_TRY_COMPILE([#include - #include - 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");], - [ac_c99_stdio=yes], [ac_c99_stdio=no]) + AC_CACHE_VAL(glibcxx_cv_c99_stdio, [ + GCC_TRY_COMPILE_OR_LINK( + [#include + #include + 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($ac_c99_stdio) + AC_MSG_RESULT($glibcxx_cv_c99_stdio) # Check for the existence in of lldiv_t, et. al. AC_MSG_CHECKING([for ISO C99 support in ]) - AC_CACHE_VAL(ac_c99_stdlib, [ - AC_TRY_COMPILE([#include ], - [char* tmp; - strtof("gnu", &tmp); - strtold("gnu", &tmp); - strtoll("gnu", &tmp, 10); - strtoull("gnu", &tmp, 10); - llabs(10); - lldiv(10,1); - atoll("10"); - _Exit(0); - lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no]) + AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [ + GCC_TRY_COMPILE_OR_LINK( + [#include + 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($ac_c99_stdlib) + AC_MSG_RESULT($glibcxx_cv_c99_stdlib) - # Check for the existence in of wcstoull, WEOF, etc. - AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no) - ac_c99_wchar=no; + # Check for the existence in 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 ]) AC_TRY_COMPILE([#include - #include - wint_t i; - long l = WEOF; - long j = WCHAR_MIN; - long k = WCHAR_MAX; namespace test { - using ::btowc; - using ::fgetwc; - using ::fgetws; - using ::fputwc; - using ::fputws; - using ::fwide; - using ::fwprintf; - using ::fwscanf; - using ::getwc; - using ::getwchar; - using ::mbrlen; - using ::mbrtowc; - using ::mbsinit; - using ::mbsrtowcs; - using ::putwc; - using ::putwchar; - using ::swprintf; - using ::swscanf; - using ::ungetwc; - using ::vfwprintf; - using ::vswprintf; - using ::vwprintf; - using ::wcrtomb; - using ::wcscat; - using ::wcschr; - using ::wcscmp; - using ::wcscoll; - using ::wcscpy; - using ::wcscspn; - using ::wcsftime; - using ::wcslen; - using ::wcsncat; - using ::wcsncmp; - using ::wcsncpy; - using ::wcspbrk; - using ::wcsrchr; - using ::wcsrtombs; - using ::wcsspn; - using ::wcsstr; - using ::wcstod; - using ::wcstok; - using ::wcstol; using ::wcstold; using ::wcstoll; - using ::wcstoul; using ::wcstoull; - using ::wcsxfrm; - using ::wctob; - using ::wmemchr; - using ::wmemcmp; - using ::wmemcpy; - using ::wmemmove; - using ::wmemset; - using ::wprintf; - using ::wscanf; } - ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no]) + ],[],[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. @@ -1022,16 +1045,15 @@ AC_DEFUN([GLIBCXX_ENABLE_C99], [ [AC_DEFINE(HAVE_ISWBLANK,1, [Defined if iswblank exists.])],[]) - AC_MSG_CHECKING([for ISO C99 support in ]) - AC_MSG_RESULT($ac_c99_wchar) + AC_MSG_RESULT($glibcxx_cv_c99_wchar) fi # Option parsed, now set things appropriately. - if test x"$ac_c99_math" = x"no" || - test x"$ac_c99_complex" = x"no" || - test x"$ac_c99_stdio" = x"no" || - test x"$ac_c99_stdlib" = x"no" || - test x"$ac_c99_wchar" = x"no"; then + 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, @@ -1039,6 +1061,9 @@ AC_DEFUN([GLIBCXX_ENABLE_C99], [ , , and 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 fi @@ -1048,6 +1073,180 @@ AC_DEFUN([GLIBCXX_ENABLE_C99], [ dnl +dnl Check for clock_gettime, nanosleep and sched_yield, used in the +dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this] +dnl in the current C++0x working draft. +dnl +dnl --enable-libstdcxx-time +dnl --enable-libstdcxx-time=yes +dnl checks for the availability of monotonic and realtime clocks, +dnl nanosleep and sched_yield in libc and libposix4 and, in case, links +dnl the latter +dnl --enable-libstdcxx-time=rt +dnl also searches (and, in case, 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 a large overhead for single-thread programs. +dnl --enable-libstdcxx-time=no +dnl --disable-libstdcxx-time +dnl disables the checks completely +dnl +AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [ + + AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield]) + GLIBCXX_ENABLE(libstdcxx-time,$1,[=KIND], + [use KIND for check type], + [permit yes|no|rt]) + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -fno-exceptions" + ac_save_LIBS="$LIBS" + + ac_has_clock_monotonic=no; + ac_has_clock_realtime=no; + + if test x"$enable_libstdcxx_time" != x"no"; then + + if test x"$enable_libstdcxx_time" = x"rt"; then + AC_SEARCH_LIBS(clock_gettime, [rt posix4]) + AC_SEARCH_LIBS(nanosleep, [rt posix4]) + else + AC_SEARCH_LIBS(clock_gettime, [posix4]) + AC_SEARCH_LIBS(nanosleep, [posix4]) + fi + + case "$ac_cv_search_clock_gettime" in + -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime + ;; + esac + case "$ac_cv_search_nanosleep" in + -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep" + ;; + esac + + AC_SEARCH_LIBS(sched_yield, [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. ]) + ;; + -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. ]) + fi + ;; + *) + AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1, + [ Defined if sched_yield is available. ]) + ;; + esac + + AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no) + + if test x"$ac_has_unistd_h" = x"yes"; then + AC_MSG_CHECKING([for monotonic clock]) + AC_TRY_LINK( + [#include + #include + ], + [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK) + timespec tp; + #endif + clock_gettime(CLOCK_MONOTONIC, &tp); + ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no]) + + AC_MSG_RESULT($ac_has_clock_monotonic) + + AC_MSG_CHECKING([for realtime clock]) + AC_TRY_LINK( + [#include + #include + ], + [#if _POSIX_TIMERS > 0 + timespec tp; + #endif + clock_gettime(CLOCK_REALTIME, &tp); + ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no]) + + AC_MSG_RESULT($ac_has_clock_realtime) + + AC_MSG_CHECKING([for nanosleep]) + AC_TRY_LINK( + [#include + #include + ], + [#if _POSIX_TIMERS > 0 + timespec tp; + #endif + nanosleep(&tp, 0); + ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no]) + + AC_MSG_RESULT($ac_has_nanosleep) + fi + 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. ]) + fi + + if test x"$ac_has_clock_realtime" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1, + [ Defined if clock_gettime has realtime clock support. ]) + fi + + if test x"$ac_has_nanosleep" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1, + [ Defined if nanosleep is available. ]) + fi + + AC_SUBST(GLIBCXX_LIBS) + + CXXFLAGS="$ac_save_CXXFLAGS" + LIBS="$ac_save_LIBS" + AC_LANG_RESTORE +]) + +dnl +dnl Check for gettimeofday, used in the implementation of 20.8.5 +dnl [time.clock] in the current C++0x working draft. +dnl +AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [ + + AC_MSG_CHECKING([for gettimeofday]) + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -fno-exceptions" + + ac_has_gettimeofday=no; + AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no) + if test x"$ac_has_sys_time_h" = x"yes"; then + AC_MSG_CHECKING([for gettimeofday]) + GCC_TRY_COMPILE_OR_LINK([#include ], + [timeval tv; gettimeofday(&tv, 0);], + [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no]) + + AC_MSG_RESULT($ac_has_gettimeofday) + fi + + if test x"$ac_has_gettimeofday" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1, + [ Defined if gettimeofday is available. ]) + fi + + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE +]) + +dnl dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1" dnl facilities in Chapter 8, "C compatibility". dnl @@ -1056,6 +1255,11 @@ AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [ AC_LANG_SAVE AC_LANG_CPLUSPLUS + # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__ + # undefined and fake C99 facilities may be spuriously enabled. + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -std=c++98" + # Check for the existence of complex math functions used # by tr1/complex. AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no) @@ -1096,15 +1300,16 @@ AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [ # Check for the existence of functions. AC_MSG_CHECKING([for ISO C99 support to TR1 in ]) - AC_CACHE_VAL(ac_c99_ctype_tr1, [ + AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [ AC_TRY_COMPILE([#include ], [int ch; int ret; ret = isblank(ch); - ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no]) + ],[glibcxx_cv_c99_ctype_tr1=yes], + [glibcxx_cv_c99_ctype_tr1=no]) ]) - AC_MSG_RESULT($ac_c99_ctype_tr1) - if test x"$ac_c99_ctype_tr1" = x"yes"; then + AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1) + if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1, [Define if C99 functions in should be imported in in namespace std::tr1.]) @@ -1142,49 +1347,228 @@ AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [ # Check for the existence of types. AC_MSG_CHECKING([for ISO C99 support to TR1 in ]) - AC_CACHE_VAL(ac_c99_stdint_tr1, [ - AC_TRY_COMPILE([#include ], + AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [ + AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS + #define __STDC_CONSTANT_MACROS + #include ], [typedef int8_t my_int8_t; + my_int8_t i8 = INT8_MIN; + i8 = INT8_MAX; typedef int16_t my_int16_t; + my_int16_t i16 = INT16_MIN; + i16 = INT16_MAX; typedef int32_t my_int32_t; + my_int32_t i32 = INT32_MIN; + i32 = INT32_MAX; typedef int64_t my_int64_t; + my_int64_t i64 = INT64_MIN; + i64 = INT64_MAX; typedef int_fast8_t my_int_fast8_t; + my_int_fast8_t if8 = INT_FAST8_MIN; + if8 = INT_FAST8_MAX; typedef int_fast16_t my_int_fast16_t; + my_int_fast16_t if16 = INT_FAST16_MIN; + if16 = INT_FAST16_MAX; typedef int_fast32_t my_int_fast32_t; - typedef int_fast64_t my_int_fast64_t; + my_int_fast32_t if32 = INT_FAST32_MIN; + if32 = INT_FAST32_MAX; + typedef int_fast64_t my_int_fast64_t; + my_int_fast64_t if64 = INT_FAST64_MIN; + if64 = INT_FAST64_MAX; typedef int_least8_t my_int_least8_t; + my_int_least8_t il8 = INT_LEAST8_MIN; + il8 = INT_LEAST8_MAX; typedef int_least16_t my_int_least16_t; + my_int_least16_t il16 = INT_LEAST16_MIN; + il16 = INT_LEAST16_MAX; typedef int_least32_t my_int_least32_t; + my_int_least32_t il32 = INT_LEAST32_MIN; + il32 = INT_LEAST32_MAX; typedef int_least64_t my_int_least64_t; + my_int_least64_t il64 = INT_LEAST64_MIN; + il64 = INT_LEAST64_MAX; typedef intmax_t my_intmax_t; + my_intmax_t im = INTMAX_MAX; + im = INTMAX_MIN; typedef intptr_t my_intptr_t; + my_intptr_t ip = INTPTR_MAX; + ip = INTPTR_MIN; typedef uint8_t my_uint8_t; + my_uint8_t ui8 = UINT8_MAX; + ui8 = UINT8_MAX; typedef uint16_t my_uint16_t; + my_uint16_t ui16 = UINT16_MAX; + ui16 = UINT16_MAX; typedef uint32_t my_uint32_t; + my_uint32_t ui32 = UINT32_MAX; + ui32 = UINT32_MAX; typedef uint64_t my_uint64_t; + my_uint64_t ui64 = UINT64_MAX; + ui64 = UINT64_MAX; typedef uint_fast8_t my_uint_fast8_t; + my_uint_fast8_t uif8 = UINT_FAST8_MAX; + uif8 = UINT_FAST8_MAX; typedef uint_fast16_t my_uint_fast16_t; + my_uint_fast16_t uif16 = UINT_FAST16_MAX; + uif16 = UINT_FAST16_MAX; typedef uint_fast32_t my_uint_fast32_t; - typedef uint_fast64_t my_uint_fast64_t; + my_uint_fast32_t uif32 = UINT_FAST32_MAX; + uif32 = UINT_FAST32_MAX; + typedef uint_fast64_t my_uint_fast64_t; + my_uint_fast64_t uif64 = UINT_FAST64_MAX; + uif64 = UINT_FAST64_MAX; typedef uint_least8_t my_uint_least8_t; + my_uint_least8_t uil8 = UINT_LEAST8_MAX; + uil8 = UINT_LEAST8_MAX; typedef uint_least16_t my_uint_least16_t; + my_uint_least16_t uil16 = UINT_LEAST16_MAX; + uil16 = UINT_LEAST16_MAX; typedef uint_least32_t my_uint_least32_t; + my_uint_least32_t uil32 = UINT_LEAST32_MAX; + uil32 = UINT_LEAST32_MAX; typedef uint_least64_t my_uint_least64_t; + my_uint_least64_t uil64 = UINT_LEAST64_MAX; + uil64 = UINT_LEAST64_MAX; typedef uintmax_t my_uintmax_t; + my_uintmax_t uim = UINTMAX_MAX; + uim = UINTMAX_MAX; typedef uintptr_t my_uintptr_t; - ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no]) + my_uintptr_t uip = UINTPTR_MAX; + uip = UINTPTR_MAX; + ],[glibcxx_cv_c99_stdint_tr1=yes], + [glibcxx_cv_c99_stdint_tr1=no]) ]) - AC_MSG_RESULT($ac_c99_stdint_tr1) - if test x"$ac_c99_stdint_tr1" = x"yes"; then + AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1) + if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1, [Define if C99 types in should be imported in in namespace std::tr1.]) fi + # Check for the existence of functions. + AC_MSG_CHECKING([for ISO C99 support to TR1 in ]) + AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [ + AC_TRY_COMPILE([#include ], + [typedef double_t my_double_t; + typedef float_t my_float_t; + acosh(0.0); + acoshf(0.0f); + acoshl(0.0l); + asinh(0.0); + asinhf(0.0f); + asinhl(0.0l); + atanh(0.0); + atanhf(0.0f); + atanhl(0.0l); + cbrt(0.0); + cbrtf(0.0f); + cbrtl(0.0l); + copysign(0.0, 0.0); + copysignf(0.0f, 0.0f); + copysignl(0.0l, 0.0l); + erf(0.0); + erff(0.0f); + erfl(0.0l); + erfc(0.0); + erfcf(0.0f); + erfcl(0.0l); + exp2(0.0); + exp2f(0.0f); + exp2l(0.0l); + expm1(0.0); + expm1f(0.0f); + expm1l(0.0l); + fdim(0.0, 0.0); + fdimf(0.0f, 0.0f); + fdiml(0.0l, 0.0l); + fma(0.0, 0.0, 0.0); + fmaf(0.0f, 0.0f, 0.0f); + fmal(0.0l, 0.0l, 0.0l); + fmax(0.0, 0.0); + fmaxf(0.0f, 0.0f); + fmaxl(0.0l, 0.0l); + fmin(0.0, 0.0); + fminf(0.0f, 0.0f); + fminl(0.0l, 0.0l); + hypot(0.0, 0.0); + hypotf(0.0f, 0.0f); + hypotl(0.0l, 0.0l); + ilogb(0.0); + ilogbf(0.0f); + ilogbl(0.0l); + lgamma(0.0); + lgammaf(0.0f); + lgammal(0.0l); + llrint(0.0); + llrintf(0.0f); + llrintl(0.0l); + llround(0.0); + llroundf(0.0f); + llroundl(0.0l); + log1p(0.0); + log1pf(0.0f); + log1pl(0.0l); + log2(0.0); + log2f(0.0f); + log2l(0.0l); + logb(0.0); + logbf(0.0f); + logbl(0.0l); + lrint(0.0); + lrintf(0.0f); + lrintl(0.0l); + lround(0.0); + lroundf(0.0f); + lroundl(0.0l); + nan(0); + nanf(0); + nanl(0); + nearbyint(0.0); + nearbyintf(0.0f); + nearbyintl(0.0l); + nextafter(0.0, 0.0); + nextafterf(0.0f, 0.0f); + nextafterl(0.0l, 0.0l); + nexttoward(0.0, 0.0); + nexttowardf(0.0f, 0.0f); + nexttowardl(0.0l, 0.0l); + remainder(0.0, 0.0); + remainderf(0.0f, 0.0f); + remainderl(0.0l, 0.0l); + remquo(0.0, 0.0, 0); + remquof(0.0f, 0.0f, 0); + remquol(0.0l, 0.0l, 0); + rint(0.0); + rintf(0.0f); + rintl(0.0l); + round(0.0); + roundf(0.0f); + roundl(0.0l); + scalbln(0.0, 0l); + scalblnf(0.0f, 0l); + scalblnl(0.0l, 0l); + scalbn(0.0, 0); + scalbnf(0.0f, 0); + scalbnl(0.0l, 0); + tgamma(0.0); + tgammaf(0.0f); + tgammal(0.0l); + trunc(0.0); + truncf(0.0f); + truncl(0.0l); + ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no]) + ]) + AC_MSG_RESULT($glibcxx_cv_c99_math_tr1) + if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1, + [Define if C99 functions or macros in should be imported + in in namespace std::tr1.]) + fi + # Check for the existence of functions (NB: doesn't make - # sense if the previous check fails, per C99, 7.8/1). + # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1). ac_c99_inttypes_tr1=no; - if test x"$ac_c99_stdint_tr1" = x"yes"; then + if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then AC_MSG_CHECKING([for ISO C99 support to TR1 in ]) AC_TRY_COMPILE([#include ], [intmax_t i, numer, denom, base; @@ -1203,9 +1587,107 @@ AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [ in namespace std::tr1.]) fi + # Check for the existence of whcar_t 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_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in ]) + AC_TRY_COMPILE([#include ], + [intmax_t base; + const wchar_t* s; + wchar_t** endptr; + intmax_t ret = wcstoimax(s, endptr, base); + uintmax_t uret = wcstoumax(s, endptr, base); + ],[ac_c99_inttypes_wchar_t_tr1=yes], + [ac_c99_inttypes_wchar_t_tr1=no]) + fi + AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1) + if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1, + [Define if wchar_t C99 functions in should be + imported in in namespace std::tr1.]) + fi + + # Check for the existence of the header. + AC_CHECK_HEADERS(stdbool.h) + + 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"). +dnl +AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [ + + 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; + else + glibcxx_cv_random_tr1=no; + fi + ]) + AC_MSG_RESULT($glibcxx_cv_random_tr1) + + if test x"$glibcxx_cv_random_tr1" = x"yes"; then + 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).]) + fi + +]) + +dnl +dnl Check whether EOF, SEEK_CUR, and SEEK_END have the most common values: +dnl in that case including in some C++ headers can be avoided. +dnl +AC_DEFUN([GLIBCXX_CHECK_STDIO_MACROS], [ + + AC_MSG_CHECKING([for EOF == -1, SEEK_CUR == 1, SEEK_END == 2]) + AC_CACHE_VAL(glibcxx_cv_stdio_macros, [ + AC_TRY_COMPILE([#include ], + [#if ((EOF != -1) || (SEEK_CUR != 1) || (SEEK_END != 2)) + unusual values... + #endif + ], [glibcxx_cv_stdio_macros=yes], + [glibcxx_cv_stdio_macros=no]) + ]) + AC_MSG_RESULT($glibcxx_cv_stdio_macros) + if test x"$glibcxx_cv_stdio_macros" = x"yes"; then + AC_DEFINE(_GLIBCXX_STDIO_MACROS, 1, + [Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2.]) + fi + +]) + +dnl +dnl Check whether macros, etc are present for +dnl +AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [ + +m4_pushdef([n_syserr], [1])dnl +m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA, + ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED, + EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY], +[m4_pushdef([SYSERR], m4_toupper(syserr))dnl +AC_MSG_CHECKING([for syserr]) +AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [ +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], + [int i = syserr;])], + [glibcxx_cv_system_error[]n_syserr=yes], + [glibcxx_cv_system_error[]n_syserr=no]) +]) +AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr]) +if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then + AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.]) +fi +m4_define([n_syserr], m4_incr(n_syserr))dnl +m4_popdef([SYSERR])dnl +]) +m4_popdef([n_syserr])dnl +]) dnl dnl Check for what type of C headers to use. @@ -1213,19 +1695,30 @@ dnl dnl --enable-cheaders= [does stuff]. dnl --disable-cheaders [does not do anything, really]. dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)] -dnl Where DEFAULT is either `c' or `c_std'. +dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'. dnl AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [ GLIBCXX_ENABLE(cheaders,$1,[=KIND], - [construct "C" headers for g++], [permit c|c_std]) + [construct "C" headers for g++], [permit c|c_std|c_global]) AC_MSG_NOTICE("C" header strategy set to $enable_cheaders) C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders + # Allow overrides to configure.host here. + if test $enable_cheaders = c_global; then + c_compatibility=yes + fi + + if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then + c_extra=yes + fi + AC_SUBST(C_INCLUDE_DIR) GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c) GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std) + GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global) GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes) + GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes) ]) @@ -1236,64 +1729,31 @@ dnl dnl Default is generic. dnl AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ - AC_MSG_CHECKING([for C locale to use]) GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@], [use MODEL for target locale package], [permit generic|gnu|ieee_1003.1-2001|yes|no|auto]) + + # Deal with gettext issues. Default to not using it (=no) until we detect + # support for it later. Let the user turn it off via --e/d, but let that + # default to on for easier handling. + USE_NLS=no + AC_ARG_ENABLE(nls, + AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]), + [], + [enable_nls=yes]) - # If they didn't use this option switch, or if they specified --enable - # with no specific model, we'll have to look for one. If they - # specified --disable (???), do likewise. + # Either a known packaage, or "auto" if test $enable_clocale = no || test $enable_clocale = yes; then enable_clocale=auto fi - - # Either a known package, or "auto" enable_clocale_flag=$enable_clocale - # Probe for locale support if no specific model is specified. + # Probe for locale model to use if none specified. # Default to "generic". if test $enable_clocale_flag = auto; then case ${target_os} in linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) - AC_EGREP_CPP([_GLIBCXX_ok], [ - #include - #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) - _GLIBCXX_ok - #endif - ], enable_clocale_flag=gnu, enable_clocale_flag=generic) - - # Test for bugs early in glibc-2.2.x series - if test $enable_clocale_flag = gnu; then - AC_TRY_RUN([ - #define _GNU_SOURCE 1 - #include - #include - #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) - extern __typeof(newlocale) __newlocale; - extern __typeof(duplocale) __duplocale; - extern __typeof(strcoll_l) __strcoll_l; - #endif - int main() - { - const char __one[] = "Äuglein Augmen"; - const char __two[] = "Äuglein"; - int i; - int j; - __locale_t loc; - __locale_t loc_dup; - loc = __newlocale(1 << LC_ALL, "de_DE", 0); - loc_dup = __duplocale(loc); - i = __strcoll_l(__one, __two, loc); - j = __strcoll_l(__one, __two, loc_dup); - return 0; - } - ], - [enable_clocale_flag=gnu],[enable_clocale_flag=generic], - [enable_clocale_flag=generic]) - fi - - # ... at some point put __strxfrm_l tests in as well. + enable_clocale_flag=gnu ;; darwin* | freebsd*) enable_clocale_flag=darwin @@ -1304,16 +1764,81 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ esac fi - # Deal with gettext issues. Default to not using it (=no) until we detect - # support for it later. Let the user turn it off via --e/d, but let that - # default to on for easier handling. - USE_NLS=no - AC_ARG_ENABLE(nls, - AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]), - [], - [enable_nls=yes]) + # Sanity check model, and test for special functionality. + if test $enable_clocale_flag = gnu; then + AC_EGREP_CPP([_GLIBCXX_ok], [ + #include + #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) + _GLIBCXX_ok + #endif + ], enable_clocale_flag=gnu, enable_clocale_flag=generic) + + if test $enable_clocale = auto; then + # Test for bugs early in glibc-2.2.x series + AC_TRY_RUN([ + #define _GNU_SOURCE 1 + #include + #include + #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) + extern __typeof(newlocale) __newlocale; + extern __typeof(duplocale) __duplocale; + extern __typeof(strcoll_l) __strcoll_l; + #endif + int main() + { + const char __one[] = "Äuglein Augmen"; + const char __two[] = "Äuglein"; + int i; + int j; + __locale_t loc; + __locale_t loc_dup; + loc = __newlocale(1 << LC_ALL, "de_DE", 0); + loc_dup = __duplocale(loc); + i = __strcoll_l(__one, __two, loc); + j = __strcoll_l(__one, __two, loc_dup); + return 0; + } + ], + [enable_clocale_flag=gnu],[enable_clocale_flag=generic], + [enable_clocale_flag=generic]) + fi + + # Set it to scream when it hurts. + ac_save_CFLAGS="$CFLAGS" + CFLAGS="-Wimplicit-function-declaration -Werror" + + # Use strxfrm_l if available. + AC_TRY_COMPILE([#define _GNU_SOURCE 1 + #include + #include ], + [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);], + AC_DEFINE(HAVE_STRXFRM_L, 1, + [Define if strxfrm_l is available in .]),) + + # Use strerror_l if available. + AC_TRY_COMPILE([#define _GNU_SOURCE 1 + #include + #include ], + [__locale_t loc; strerror_l(5, loc);], + AC_DEFINE(HAVE_STRERROR_L, 1, + [Define if strerror_l is available in .]),) + + CFLAGS="$ac_save_CFLAGS" + fi + + # Perhaps use strerror_r if available, and strerror_l isn't. + ac_save_CFLAGS="$CFLAGS" + CFLAGS="-Wimplicit-function-declaration -Werror" + AC_TRY_COMPILE([#define _GNU_SOURCE 1 + #include + #include ], + [char s[128]; strerror_r(5, s, 128);], + AC_DEFINE(HAVE_STRERROR_R, 1, + [Define if strerror_r is available in .]),) + CFLAGS="$ac_save_CFLAGS" # Set configure bits for specified locale package + AC_MSG_CHECKING([for C locale to use]) case ${enable_clocale_flag} in generic) AC_MSG_RESULT(generic) @@ -1516,6 +2041,28 @@ AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [ fi ]) +dnl +dnl Check for parallel mode pre-requisites, including OpenMP support. +dnl +dnl + Usage: GLIBCXX_ENABLE_PARALLEL +dnl +AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [ + + enable_parallel=no; + + # See if configured libgomp/omp.h exists. (libgomp may be in + # noconfigdirs but not explicitly disabled.) + if test -f $glibcxx_builddir/../libgomp/omp.h; then + enable_parallel=yes; + else + AC_MSG_NOTICE([$glibcxx_builddir/../libgomp/omp.h not found]) + fi + + AC_MSG_CHECKING([for parallel mode support]) + AC_MSG_RESULT([$enable_parallel]) + GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes) +]) + dnl dnl Check for which I/O library to use: stdio, or something specific. @@ -1711,14 +2258,107 @@ dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)] dnl Where DEFAULT is either `yes' or `no'. dnl -dnl Necessary support (probed along with C99 support) must also be present. +dnl Necessary support must also be present. dnl AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [ GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t']) - if test x"$ac_c99_wchar" = x"yes" && test x"$enable_wchar_t" = x"yes"; then + + # Test wchar.h for mbstate_t, which is needed for char_traits and fpos. + AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no) + AC_MSG_CHECKING([for mbstate_t]) + AC_TRY_COMPILE([#include ], + [mbstate_t teststate;], + have_mbstate_t=yes, have_mbstate_t=no) + AC_MSG_RESULT($have_mbstate_t) + if test x"$have_mbstate_t" = xyes; then + AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.]) + fi + + # Test it always, for use in GLIBCXX_ENABLE_C99, together with + # ac_has_wchar_h. + AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no) + + if test x"$enable_wchar_t" = x"yes"; then + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + + if test x"$ac_has_wchar_h" = xyes && + test x"$ac_has_wctype_h" = xyes; then + AC_TRY_COMPILE([#include + #include + wint_t i; + long l = WEOF; + long j = WCHAR_MIN; + long k = WCHAR_MAX; + namespace test + { + using ::btowc; + using ::fgetwc; + using ::fgetws; + using ::fputwc; + using ::fputws; + using ::fwide; + using ::fwprintf; + using ::fwscanf; + using ::getwc; + using ::getwchar; + using ::mbrlen; + using ::mbrtowc; + using ::mbsinit; + using ::mbsrtowcs; + using ::putwc; + using ::putwchar; + using ::swprintf; + using ::swscanf; + using ::ungetwc; + using ::vfwprintf; + using ::vswprintf; + using ::vwprintf; + using ::wcrtomb; + using ::wcscat; + using ::wcschr; + using ::wcscmp; + using ::wcscoll; + using ::wcscpy; + using ::wcscspn; + using ::wcsftime; + using ::wcslen; + using ::wcsncat; + using ::wcsncmp; + using ::wcsncpy; + using ::wcspbrk; + using ::wcsrchr; + using ::wcsrtombs; + using ::wcsspn; + using ::wcsstr; + using ::wcstod; + using ::wcstok; + using ::wcstol; + using ::wcstoul; + using ::wcsxfrm; + using ::wctob; + using ::wmemchr; + using ::wmemcmp; + using ::wmemcpy; + using ::wmemmove; + using ::wmemset; + using ::wprintf; + using ::wscanf; + } + ],[],[], [enable_wchar_t=no]) + else + enable_wchar_t=no + fi + + AC_LANG_RESTORE + fi + + if test x"$enable_wchar_t" = x"yes"; then AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1, [Define if code specialized for wchar_t should be used.]) fi + AC_MSG_CHECKING([for enabled wchar_t specializations]) AC_MSG_RESULT([$enable_wchar_t]) ]) @@ -1779,6 +2419,183 @@ AC_DEFUN([GLIBCXX_ENABLE_PCH], [ dnl +dnl Check for atomic builtins. +dnl See: +dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins +dnl +dnl This checks to see if the host supports the compiler-generated +dnl builtins for atomic operations for various integral sizes. Note, this +dnl is intended to be an all-or-nothing switch, so all the atomic operations +dnl that are used should be checked. +dnl +dnl Note: +dnl libgomp and libgfortran do this with a link test, instead of an asm test. +dnl see: CHECK_SYNC_FETCH_AND_ADD +dnl +dnl Defines: +dnl _GLIBCXX_ATOMIC_BUILTINS_1 +dnl _GLIBCXX_ATOMIC_BUILTINS_2 +dnl _GLIBCXX_ATOMIC_BUILTINS_4 +dnl _GLIBCXX_ATOMIC_BUILTINS_8 +dnl +AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + old_CXXFLAGS="$CXXFLAGS" + + # Compile unoptimized. + CXXFLAGS='-O0 -S' + + # Fake what AC_TRY_COMPILE does, without linking as this is + # unnecessary for a builtins test. + + cat > conftest.$ac_ext << EOF +[#]line __oline__ "configure" +int main() +{ + typedef bool atomic_type; + atomic_type c1; + atomic_type c2; + const atomic_type c3(0); + __sync_fetch_and_add(&c1, c2); + __sync_val_compare_and_swap(&c1, c3, c2); + __sync_lock_test_and_set(&c1, c3); + __sync_lock_release(&c1); + __sync_synchronize(); + return 0; +} +EOF + + AC_MSG_CHECKING([for atomic builtins for bool]) + if AC_TRY_EVAL(ac_compile); then + if grep __sync_ conftest.s >/dev/null 2>&1 ; then + enable_atomic_builtinsb=no + else + AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1, + [Define if builtin atomic operations for bool are supported on this host.]) + enable_atomic_builtinsb=yes + fi + fi + AC_MSG_RESULT($enable_atomic_builtinsb) + rm -f conftest* + + cat > conftest.$ac_ext << EOF +[#]line __oline__ "configure" +int main() +{ + typedef short atomic_type; + atomic_type c1; + atomic_type c2; + const atomic_type c3(0); + __sync_fetch_and_add(&c1, c2); + __sync_val_compare_and_swap(&c1, c3, c2); + __sync_lock_test_and_set(&c1, c3); + __sync_lock_release(&c1); + __sync_synchronize(); + return 0; +} +EOF + + AC_MSG_CHECKING([for atomic builtins for short]) + if AC_TRY_EVAL(ac_compile); then + if grep __sync_ conftest.s >/dev/null 2>&1 ; then + enable_atomic_builtinss=no + else + AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1, + [Define if builtin atomic operations for short are supported on this host.]) + enable_atomic_builtinss=yes + fi + fi + AC_MSG_RESULT($enable_atomic_builtinss) + rm -f conftest* + + cat > conftest.$ac_ext << EOF +[#]line __oline__ "configure" +int main() +{ + // NB: _Atomic_word not necessarily int. + typedef int atomic_type; + atomic_type c1; + atomic_type c2; + const atomic_type c3(0); + __sync_fetch_and_add(&c1, c2); + __sync_val_compare_and_swap(&c1, c3, c2); + __sync_lock_test_and_set(&c1, c3); + __sync_lock_release(&c1); + __sync_synchronize(); + return 0; +} +EOF + + AC_MSG_CHECKING([for atomic builtins for int]) + if AC_TRY_EVAL(ac_compile); then + if grep __sync_ conftest.s >/dev/null 2>&1 ; then + enable_atomic_builtinsi=no + else + AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1, + [Define if builtin atomic operations for int are supported on this host.]) + enable_atomic_builtinsi=yes + fi + fi + AC_MSG_RESULT($enable_atomic_builtinsi) + rm -f conftest* + + cat > conftest.$ac_ext << EOF +[#]line __oline__ "configure" +int main() +{ + typedef long long atomic_type; + atomic_type c1; + atomic_type c2; + const atomic_type c3(0); + __sync_fetch_and_add(&c1, c2); + __sync_val_compare_and_swap(&c1, c3, c2); + __sync_lock_test_and_set(&c1, c3); + __sync_lock_release(&c1); + __sync_synchronize(); + return 0; +} +EOF + + AC_MSG_CHECKING([for atomic builtins for long long]) + if AC_TRY_EVAL(ac_compile); then + if grep __sync_ conftest.s >/dev/null 2>&1 ; then + enable_atomic_builtinsll=no + else + AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1, + [Define if builtin atomic operations for long long are supported on this host.]) + enable_atomic_builtinsll=yes + fi + fi + AC_MSG_RESULT($enable_atomic_builtinsll) + rm -f conftest* + + + CXXFLAGS="$old_CXXFLAGS" + AC_LANG_RESTORE + + # Set atomicity_dir to builtins if either of above tests pass. + if test $enable_atomic_builtinsi = yes || test $enable_atomic_builtinsb = yes ; then + atomicity_dir=cpu/generic/atomicity_builtins + fi + + # If still generic, set to mutex. + if test $atomicity_dir = "cpu/generic" ; then + atomicity_dir=cpu/generic/atomicity_mutex + AC_MSG_WARN([No native atomic operations are provided for this platform.]) + if test "x$target_thread_file" = xsingle; then + AC_MSG_WARN([They cannot be faked when thread support is disabled.]) + AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.]) + else + AC_MSG_WARN([They will be faked using a mutex.]) + AC_MSG_WARN([Performance of certain classes will degrade as a result.]) + fi + fi + +]) + + +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. @@ -1850,6 +2667,38 @@ EOF dnl +dnl Allow visibility attributes to be used on namespaces, objects, etc. +dnl +dnl --enable-visibility enables attempt to use visibility attributes. +dnl --disable-visibility turns off all use of visibility attributes. +dnl + Usage: GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)] +dnl Where DEFAULT is 'yes'. +dnl +AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [ +GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage]) + +if test x$enable_visibility = xyes ; then + dnl all hail libgfortran + dnl Check whether the target supports hidden visibility. + AC_CACHE_CHECK([whether the target supports hidden visibility], + glibcxx_cv_have_attribute_visibility, [ + save_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -Werror" + AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }], + [], glibcxx_cv_have_attribute_visibility=yes, + glibcxx_cv_have_attribute_visibility=no) + CFLAGS="$save_CFLAGS"]) + if test $glibcxx_cv_have_attribute_visibility = no; then + enable_visibility=no + fi +fi + +GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes) +AC_MSG_NOTICE([visibility supported: $enable_visibility]) +]) + + +dnl dnl Add version tags to symbols in shared library (or not), additionally dnl marking other symbols as private/local (or not). dnl @@ -1874,11 +2723,16 @@ AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES]) # Turn a 'yes' into a suitable default. if test x$enable_symvers = xyes ; then - if test $enable_shared = no || test "x$LD" = x ; then + if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then enable_symvers=no else if test $with_gnu_ld = yes ; then - enable_symvers=gnu + case ${target_os} in + cygwin* | pe | mingw32* | hpux*) + enable_symvers=no ;; + *) + enable_symvers=gnu ;; + esac else case ${target_os} in darwin*) @@ -1938,6 +2792,8 @@ changequote([,])dnl AC_MSG_WARN([=== you are not using the GNU linker.]) AC_MSG_WARN([=== Symbol versioning will be disabled.]) enable_symvers=no + elif test $glibcxx_ld_is_gold = yes ; then + : All versions of gold support symbol versioning. elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then # The right tools, the right setup, but too old. Fallbacks? AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for) @@ -1976,6 +2832,16 @@ if test x$enable_symvers != xno ; then [Define to use symbol versioning in the shared library.]) fi +AC_CACHE_CHECK([whether the target supports .symver directive], + glibcxx_cv_have_as_symver_directive, [ + AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");], + [], glibcxx_cv_have_as_symver_directive=yes, + glibcxx_cv_have_as_symver_directive=no)]) +if test $glibcxx_cv_have_as_symver_directive = yes; then + AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1, + [Define to 1 if the target assembler supports .symver directive.]) +fi + AC_SUBST(SYMVER_FILE) AC_SUBST(port_specific_symbol_files) GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no) @@ -2055,6 +2921,51 @@ AC_DEFUN([GLIBCXX_ENABLE_THREADS], [ ]) +dnl +dnl Check if gthread implementation defines the types and functions +dnl required by the c++0x thread library. Conforming gthread +dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x. +dnl +AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -fno-exceptions -I${toplevel_srcdir}/gcc" + + target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'` + case $target_thread_file in + posix) + CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS" + esac + + AC_MSG_CHECKING([for gthreads library]) + + AC_TRY_COMPILE([#include "gthr.h"], + [ + #ifndef __GTHREADS_CXX0X + #error + #endif + + // In case of POSIX threads check _POSIX_TIMEOUTS too. + #if (defined(_PTHREADS) \ + && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0)) + #error + #endif + ], [ac_has_gthreads=yes], [ac_has_gthreads=no]) + + AC_MSG_RESULT([$ac_has_gthreads]) + + if test x"$ac_has_gthreads" = x"yes"; then + AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1, + [Define if gthreads library is available.]) + fi + + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE +]) + + # Check whether LC_MESSAGES is available in . # Ulrich Drepper , 1995. # @@ -2062,12 +2973,10 @@ AC_DEFUN([GLIBCXX_ENABLE_THREADS], [ # be used in projects which are not available under the GNU Public License # but which still want to provide support for the GNU gettext functionality. # Please note that the actual code is *not* freely available. - -# serial 1 AC_DEFUN([AC_LC_MESSAGES], [ AC_CHECK_HEADER(locale.h, [ AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES, - [AC_TRY_LINK([#include ], [return LC_MESSAGES], + [AC_TRY_COMPILE([#include ], [return LC_MESSAGES], ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)]) if test $ac_cv_val_LC_MESSAGES = yes; then AC_DEFINE(HAVE_LC_MESSAGES, 1,