diff options
author | kan <kan@FreeBSD.org> | 2007-05-19 01:25:07 +0000 |
---|---|---|
committer | kan <kan@FreeBSD.org> | 2007-05-19 01:25:07 +0000 |
commit | 7865836f4b0f698454c31b4593effcb032c22c1e (patch) | |
tree | ea6c2718dc1e45ed535d194df808ef31f0ebac92 /contrib/libstdc++/acinclude.m4 | |
parent | 1f9ea4d0a40cca64d60cf4dab152349da7b9dddf (diff) | |
download | FreeBSD-src-7865836f4b0f698454c31b4593effcb032c22c1e.zip FreeBSD-src-7865836f4b0f698454c31b4593effcb032c22c1e.tar.gz |
GCC 4.2.0 release C++ standard library and runtime support code.
Diffstat (limited to 'contrib/libstdc++/acinclude.m4')
-rw-r--r-- | contrib/libstdc++/acinclude.m4 | 1358 |
1 files changed, 981 insertions, 377 deletions
diff --git a/contrib/libstdc++/acinclude.m4 b/contrib/libstdc++/acinclude.m4 index cf541ed..214ce30 100644 --- a/contrib/libstdc++/acinclude.m4 +++ b/contrib/libstdc++/acinclude.m4 @@ -27,44 +27,11 @@ AC_DEFUN([GLIBCXX_CHECK_HOST], [ AC_MSG_NOTICE([OS config directory is $os_include_dir]) ]) - -dnl -dnl Initialize basic configure bits. -dnl -dnl Substs: -dnl multi_basedir -dnl -AC_DEFUN([GLIBCXX_TOPREL_CONFIGURE], [ - # Sets up multi_basedir, which is srcdir/.. plus the usual - # "multi_source_toprel_bottom_adjust" lunacy as needed. - AM_ENABLE_MULTILIB(, ..) - - # The generated code is exactly the same, except that automake's looks in - # ".. $srcdir/.." and autoconf's looks in multi_basedir. Apparently other - # things are triggered on the presence of the two ...AUX_DIR[S], but I don't - # know what they are or what the other differences might be (and they keep - # changing anyhow). - # - # Looking in multi_basedir seems smarter, so actually execute that branch. - if false; then - # this is for automake - AC_CONFIG_AUX_DIR(..) - else - # this is for autoconf - AC_CONFIG_AUX_DIRS(${multi_basedir}) - fi - - dnl XXX Turn this on. - dnl AC_LANG_CPLUSPLUS -]) - - dnl dnl Initialize the rest of the library configury. At this point we have dnl variables like $host. dnl dnl Sets: -dnl gcc_version (x.y.z format) dnl SUBDIRS dnl Substs: dnl glibcxx_builddir (absolute path) @@ -141,11 +108,6 @@ AC_DEFUN([GLIBCXX_CONFIGURE], [ AC_SUBST(CFLAGS) AC_SUBST(CXXFLAGS) - # For directory versioning (e.g., headers) and other variables. - AC_MSG_CHECKING([for GCC version number]) - gcc_version=`$CXX -dumpversion` - AC_MSG_RESULT($gcc_version) - # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't # available). Uncomment the next line to force a particular method. AC_PROG_LN_S @@ -162,14 +124,15 @@ AC_DEFUN([GLIBCXX_CONFIGURE], [ ## (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 - enable_wchar_t=no - #enable_libstdcxx_debug=no - #enable_libstdcxx_pch=no - #enable_cheaders=c - #c_compatibility=no - #enable_abi_check=no - #enable_symvers=no - #enable_hosted_libstdcxx=yes + + # Check for uClibc since Linux platforms use different configuration + # directories depending on the C library in use. + AC_EGREP_CPP([_using_uclibc], [ + #include <stdio.h> + #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. @@ -177,10 +140,6 @@ AC_DEFUN([GLIBCXX_CONFIGURE], [ ]) -m4_include([linkage.m4]) -m4_include([../config/no-executables.m4]) - - dnl dnl Tests for newer compiler features, or features that are present in newer dnl compiler versions but not older compiler versions still in use, should @@ -237,7 +196,7 @@ dnl safe (like an empty string). dnl dnl Defines: dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible -dnl OPT_LDFLAGS='-Wl,-O1' if possible +dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible dnl LD (as a side effect of testing) dnl Sets: dnl with_gnu_ld @@ -272,49 +231,72 @@ 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. - 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 }'` + if test x"$with_gnu_ld" = x"yes"; then + AC_MSG_CHECKING([for ld version]) + changequote(,) + ldver=`$LD --version 2>/dev/null | head -1 | \ + sed -e 's/GNU ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\3/'` + 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. - if test "$with_gnu_ld" = "notbroken"; then - # GNU ld it is! Joy and bunny rabbits! + glibcxx_gcsections_min_ld=21602 + if test x"$with_gnu_ld" = x"yes" && + test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then - # All these tests are for C++; save the language and the compiler flags. - # Need to do this so that g++ won't try to link in libstdc++ + # 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='-x c++ -Wl,--gc-sections' # Check for -Wl,--gc-sections - # XXX This test is broken at the moment, as symbols required for linking - # are now in libsupc++ (not built yet). In addition, this test has - # cored on solaris in the past. In addition, --gc-sections doesn't - # really work at the moment (keeps on discarding used sections, first - # .eh_frame and now some of the glibc sections for iconv). - # Bzzzzt. Thanks for playing, maybe next time. AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections]) - AC_TRY_RUN([ - int main(void) - { - try { throw 1; } - catch (...) { }; - return 0; - } - ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes]) + AC_TRY_LINK([ int one(void) { return 1; } + int two(void) { return 2; } + ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no]) + if test "$ac_gcsections" = "yes"; then + rm -f conftest.c + touch conftest.c + if $CC -c conftest.c; then + if $LD --gc-sections -o conftest conftest.o 2>&1 | \ + grep "Warning: gc-sections option ignored" > /dev/null; then + ac_gcsections=no + fi + fi + rm -f conftest.c conftest.o conftest + fi + if test "$ac_gcsections" = "yes"; then + SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS" + fi + AC_MSG_RESULT($ac_gcsections) + if test "$ac_test_CFLAGS" = set; then CFLAGS="$ac_save_CFLAGS" else # this is the suspicious part CFLAGS='' fi - if test "$ac_sectionLDflags" = "yes"; then - SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS" + fi + + # Set -z,relro. + # Note this is only for shared objects. + ac_ld_relro=no + if test x"$with_gnu_ld" = x"yes"; then + AC_MSG_CHECKING([for ld that supports -Wl,-z,relro]) + cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"` + if test -n "$cxx_z_relo"; then + OPT_LDFLAGS="-Wl,-z,relro" + ac_ld_relro=yes fi - AC_MSG_RESULT($ac_sectionLDflags) + AC_MSG_RESULT($ac_ld_relro) fi # Set linker optimization flags. @@ -328,83 +310,21 @@ AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [ dnl -dnl Check to see if this target can enable the wchar_t parts. -dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled. (This -dnl must have been previously checked.) By default, wide characters are -dnl disabled. +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 HAVE_MBSTATE_T if mbstate_t is not in wchar.h -dnl _GLIBCXX_USE_WCHAR_T if all the bits are found. +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_WCHAR_T_SUPPORT], [ - # Test wchar.h for mbstate_t, which is needed for char_traits and - # others even if wchar_t support is not on. - AC_MSG_CHECKING([for mbstate_t]) - AC_TRY_COMPILE([#include <wchar.h>], - [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) - fi - - # Sanity check for existence of ISO C99 headers for extended encoding. - AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no) - AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no) +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"$ac_has_wchar_h" = xyes && - test x"$ac_has_wctype_h" = xyes && - test x"$enable_c_mbchar" != xno; then - - # Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before - # numeric_limits can instantiate type_traits<wchar_t> - AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX]) - AC_TRY_COMPILE([#include <wchar.h>], - [int i = WCHAR_MIN; int j = WCHAR_MAX;], - has_wchar_minmax=yes, has_wchar_minmax=no) - AC_MSG_RESULT($has_wchar_minmax) - - # Test wchar.h for WEOF, which is what we use to determine whether - # to specialize for char_traits<wchar_t> or not. - AC_MSG_CHECKING([for WEOF]) - AC_TRY_COMPILE([ - #include <wchar.h> - #include <stddef.h>], - [wint_t i = WEOF;], - has_weof=yes, has_weof=no) - AC_MSG_RESULT($has_weof) - - # Tests for wide character functions used in char_traits<wchar_t>. - ac_wfuncs=yes - AC_CHECK_FUNCS([wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset], - [],[ac_wfuncs=no]) - - # Checks for names injected into std:: by the c_std headers. - AC_CHECK_FUNCS([btowc wctob fgetwc fgetws fputwc fputws fwide \ - fwprintf fwscanf swprintf swscanf vfwprintf vswprintf \ - vwprintf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \ - mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstol \ - wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \ - wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr], - [],[ac_wfuncs=no]) - - # Checks for wide character functions that are not required - # for basic wchar_t support. Don't disable support if they are missing. - # Injection of these is wrapped with guard macros. - AC_CHECK_FUNCS([vfwscanf vswscanf vwscanf wcstof iswblank],[],[]) - - AC_MSG_CHECKING([for ISO C99 wchar_t support]) - if test x"$has_weof" = xyes && - test x"$has_wchar_minmax" = xyes && - test x"$ac_wfuncs" = xyes; - then - ac_isoC99_wchar_t=yes - else - ac_isoC99_wchar_t=no - fi - AC_MSG_RESULT($ac_isoC99_wchar_t) + 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). @@ -412,37 +332,27 @@ AC_DEFUN([GLIBCXX_CHECK_WCHAR_T_SUPPORT], [ 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_CHECK_LIB(iconv, iconv, LIBICONV="-liconv") ac_save_LIBS="$LIBS" - LIBS="$LIBS $libiconv" + 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" - AC_MSG_CHECKING([for XPG2 wchar_t support]) if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes && test x"$ac_XPG2funcs" = xyes; then - ac_XPG2_wchar_t=yes - else - ac_XPG2_wchar_t=no - fi - AC_MSG_RESULT($ac_XPG2_wchar_t) - - # At the moment, only enable wchar_t specializations if all the - # above support is present. - if test x"$ac_isoC99_wchar_t" = xyes && - test x"$ac_XPG2_wchar_t" = xyes; - then - AC_DEFINE(_GLIBCXX_USE_WCHAR_T) - enable_wchar_t=yes + 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 wchar_t specializations]) - AC_MSG_RESULT($enable_wchar_t) + AC_MSG_CHECKING([for enabled iconv specializations]) + AC_MSG_RESULT($enable_iconv) ]) @@ -455,6 +365,7 @@ dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits dnl various HAVE_LIMIT_* for individual limit names dnl AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [ + AC_MSG_CHECKING([for RLIMIT_$1]) AC_TRY_COMPILE( [#include <unistd.h> #include <sys/time.h> @@ -464,6 +375,8 @@ AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [ [glibcxx_mresult=1], [glibcxx_mresult=0]) AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult, [Only used in build directory testsuite_hooks.h.]) + if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi + AC_MSG_RESULT($res) ]) AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [ @@ -497,7 +410,9 @@ AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [ AC_MSG_CHECKING([for testsuite resource limits support]) if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then ac_res_limits=yes - AC_DEFINE(_GLIBCXX_RES_LIMITS) + AC_DEFINE(_GLIBCXX_RES_LIMITS, 1, + [Define if using setrlimit to set resource limits during + "make check"]) else ac_res_limits=no fi @@ -510,6 +425,7 @@ dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>. dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately. dnl AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [ + AC_MSG_CHECKING([for S_ISREG or S_IFREG]) AC_CACHE_VAL(glibcxx_cv_S_ISREG, [ AC_TRY_LINK( [#include <sys/stat.h>], @@ -528,11 +444,17 @@ AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [ [glibcxx_cv_S_IFREG=yes], [glibcxx_cv_S_IFREG=no]) ]) + res=no if test $glibcxx_cv_S_ISREG = yes; then - AC_DEFINE(HAVE_S_ISREG) + AC_DEFINE(HAVE_S_ISREG, 1, + [Define if S_IFREG is available in <sys/stat.h>.]) + res=S_ISREG elif test $glibcxx_cv_S_IFREG = yes; then - AC_DEFINE(HAVE_S_IFREG) + AC_DEFINE(HAVE_S_IFREG, 1, + [Define if S_IFREG is available in <sys/stat.h>.]) + res=S_IFREG fi + AC_MSG_RESULT($res) ]) @@ -540,6 +462,7 @@ dnl dnl Check whether poll is available in <poll.h>, and define HAVE_POLL. dnl AC_DEFUN([GLIBCXX_CHECK_POLL], [ + AC_MSG_CHECKING([for poll]) AC_CACHE_VAL(glibcxx_cv_POLL, [ AC_TRY_LINK( [#include <poll.h>], @@ -550,8 +473,9 @@ AC_DEFUN([GLIBCXX_CHECK_POLL], [ [glibcxx_cv_POLL=no]) ]) if test $glibcxx_cv_POLL = yes; then - AC_DEFINE(HAVE_POLL) + AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.]) fi + AC_MSG_RESULT($glibcxx_cv_POLL) ]) @@ -559,6 +483,7 @@ dnl dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV. dnl AC_DEFUN([GLIBCXX_CHECK_WRITEV], [ + AC_MSG_CHECKING([for writev]) AC_CACHE_VAL(glibcxx_cv_WRITEV, [ AC_TRY_LINK( [#include <sys/uio.h>], @@ -568,8 +493,9 @@ AC_DEFUN([GLIBCXX_CHECK_WRITEV], [ [glibcxx_cv_WRITEV=no]) ]) if test $glibcxx_cv_WRITEV = yes; then - AC_DEFINE(HAVE_WRITEV) + AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.]) fi + AC_MSG_RESULT($glibcxx_cv_WRITEV) ]) @@ -577,6 +503,7 @@ dnl dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T. dnl AC_DEFUN([GLIBCXX_CHECK_INT64_T], [ + AC_MSG_CHECKING([for int64_t]) AC_CACHE_VAL(glibcxx_cv_INT64_T, [ AC_TRY_COMPILE( [#include <stdint.h>], @@ -585,8 +512,9 @@ AC_DEFUN([GLIBCXX_CHECK_INT64_T], [ [glibcxx_cv_INT64_T=no]) ]) if test $glibcxx_cv_INT64_T = yes; then - AC_DEFINE(HAVE_INT64_T) + AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.]) fi + AC_MSG_RESULT($glibcxx_cv_INT64_T) ]) @@ -598,22 +526,27 @@ AC_DEFUN([GLIBCXX_CHECK_LFS], [ AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" CXXFLAGS="$CXXFLAGS -fno-exceptions" + AC_MSG_CHECKING([for LFS support]) AC_CACHE_VAL(glibcxx_cv_LFS, [ AC_TRY_LINK( [#include <unistd.h> #include <stdio.h> + #include <sys/stat.h> ], [FILE* fp; fopen64("t", "w"); fseeko64(fp, 0, SEEK_CUR); ftello64(fp); - lseek64(1, 0, SEEK_CUR);], + lseek64(1, 0, SEEK_CUR); + struct stat64 buf; + fstat64(1, &buf);], [glibcxx_cv_LFS=yes], [glibcxx_cv_LFS=no]) ]) if test $glibcxx_cv_LFS = yes; then - AC_DEFINE(_GLIBCXX_USE_LFS) + AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.]) fi + AC_MSG_RESULT($glibcxx_cv_LFS) CXXFLAGS="$ac_save_CXXFLAGS" AC_LANG_RESTORE ]) @@ -633,7 +566,8 @@ dnl AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [ GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory]) if test $enable_fully_dynamic_string = yes; then - AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING) + AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1, + [Define if a fully dynamic basic_string is wanted.]) fi ]) @@ -645,40 +579,38 @@ dnl dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this. dnl dnl Sets: -dnl enable_abi_check / GLIBCXX_TEST_ABI +dnl enable_abi_check +dnl GLIBCXX_TEST_WCHAR_T +dnl GLIBCXX_TEST_THREAD dnl Substs: dnl baseline_dir dnl AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [ - if $GLIBCXX_IS_NATIVE && test $is_hosted = yes; then + if $GLIBCXX_IS_NATIVE ; then # Do checks for resource limit functions. GLIBCXX_CHECK_SETRLIMIT # Look for setenv, so that extended locale tests can be performed. GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv) + fi - if test $enable_symvers = no; then - enable_abi_check=no - else - case "$host" in - *-*-cygwin*) - enable_abi_check=no ;; - *) - enable_abi_check=yes ;; - esac - fi + if $GLIBCXX_IS_NATIVE && test $is_hosted = yes && + test $enable_symvers != no; then + case "$host" in + *-*-cygwin*) + enable_abi_check=no ;; + *) + enable_abi_check=yes ;; + esac else # Only build this as native, since automake does not understand # CXX_FOR_BUILD. enable_abi_check=no fi - + # Export file names for ABI checking. - baseline_dir="$glibcxx_srcdir/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)" + baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}\$(MULTISUBDIR)" AC_SUBST(baseline_dir) - - GLIBCXX_CONDITIONAL(GLIBCXX_TEST_WCHAR_T, test $enable_wchar_t = yes) - GLIBCXX_CONDITIONAL(GLIBCXX_TEST_ABI, test $enable_abi_check = yes) ]) @@ -727,7 +659,7 @@ AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [ OPTIMIZE_CXXFLAGS= AC_SUBST(OPTIMIZE_CXXFLAGS) - WARN_FLAGS='-Wall -W -Wwrite-strings -Wcast-qual' + WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual' AC_SUBST(WARN_FLAGS) ]) @@ -744,6 +676,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 @@ -775,7 +709,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. @@ -785,10 +725,10 @@ AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [ # is selected. FIXME: these variables are misnamed, there are # no executables installed in _toolexecdir or _toolexeclibdir. if test x"$gxx_include_dir" = x"no"; then - gxx_include_dir='${libdir}/gcc/${host_alias}/'$gcc_version/include/c++ + gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++' fi glibcxx_toolexecdir='${libdir}/gcc/${host_alias}' - glibcxx_toolexeclibdir='${toolexecdir}/'$gcc_version'$(MULTISUBDIR)' + glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)' fi # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir @@ -867,121 +807,503 @@ dnl AC_DEFUN([GLIBCXX_ENABLE_C99], [ 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 # Check for the existence of <math.h> functions used if C99 is enabled. - ac_c99_math=yes; AC_MSG_CHECKING([for ISO C99 support in <math.h>]) - AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>], - [isgreaterequal(0.0,0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no]) + AC_CACHE_VAL(ac_c99_math, [ AC_TRY_COMPILE([#include <math.h>], - [islessgreater(0.0,0.0);],, [ac_c99_math=no]) - AC_TRY_COMPILE([#include <math.h>], - [isunordered(0.0,0.0);],, [ac_c99_math=no]) + [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_MSG_RESULT($ac_c99_math) - if test x"$ac_c99_math" = x"yes"; then - AC_DEFINE(_GLIBCXX_USE_C99_MATH) + 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 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(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no) + ac_c99_complex=no; + if test x"$ac_has_complex_h" = x"yes"; then + AC_MSG_CHECKING([for ISO C99 support in <complex.h>]) + AC_TRY_COMPILE([#include <complex.h>], + [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 + 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_c99_stdio=yes; AC_MSG_CHECKING([for ISO C99 support in <stdio.h>]) - AC_TRY_COMPILE([#include <stdio.h>], - [snprintf("12", 0, "%i");],, [ac_c99_stdio=no]) + AC_CACHE_VAL(ac_c99_stdio, [ AC_TRY_COMPILE([#include <stdio.h> - #include <stdarg.h> + #include <stdarg.h> void foo(char* fmt, ...) - {va_list args; va_start(args, fmt); - vfscanf(stderr, "%i", args);}], - [],, [ac_c99_stdio=no]) - AC_TRY_COMPILE([#include <stdio.h> - #include <stdarg.h> - void foo(char* fmt, ...) - {va_list args; va_start(args, fmt); - vscanf("%i", args);}], - [],, [ac_c99_stdio=no]) - AC_TRY_COMPILE([#include <stdio.h> - #include <stdarg.h> - void foo(char* fmt, ...) - {va_list args; va_start(args, fmt); - vsnprintf(fmt, 0, "%i", args);}], - [],, [ac_c99_stdio=no]) - AC_TRY_COMPILE([#include <stdio.h> - #include <stdarg.h> - void foo(char* fmt, ...) - {va_list args; va_start(args, fmt); - vsscanf(fmt, "%i", args);}], - [],, [ac_c99_stdio=no]) + { + 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_MSG_RESULT($ac_c99_stdio) # Check for the existence in <stdlib.h> of lldiv_t, et. al. - ac_c99_stdlib=yes; - AC_MSG_CHECKING([for lldiv_t declaration]) - AC_CACHE_VAL(ac_c99_lldiv_t, [ - AC_TRY_COMPILE([#include <stdlib.h>], - [ lldiv_t mydivt;], - [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no]) - ]) - AC_MSG_RESULT($ac_c99_lldiv_t) - AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>]) + AC_CACHE_VAL(ac_c99_stdlib, [ AC_TRY_COMPILE([#include <stdlib.h>], - [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no]) - AC_TRY_COMPILE([#include <stdlib.h>], - [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no]) - AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no]) - AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no]) - AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no]) - AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no]) - if test x"$ac_c99_lldiv_t" = x"no"; then - ac_c99_stdlib=no; - fi; + [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_MSG_RESULT($ac_c99_stdlib) - # Check for the existence of <wchar.h> functions used if C99 is enabled. - # XXX the wchar.h checks should be rolled into the general C99 bits. - ac_c99_wchar=yes; - AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>]) - AC_TRY_COMPILE([#include <wchar.h>], - [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no]) - AC_TRY_COMPILE([#include <wchar.h>], - [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no]) - AC_TRY_COMPILE([#include <wchar.h>], - [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no]) - AC_MSG_RESULT($ac_c99_wchar) + # Check for the existence in <wchar.h> of wcstold, etc. + ac_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; + } + ],[],[ac_c99_wchar=yes], [ac_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($ac_c99_wchar) + fi - AC_MSG_CHECKING([for enabled ISO C99 support]) + # 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 enable_c99=no; - fi; + 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 + + AC_LANG_RESTORE + fi + + AC_MSG_CHECKING([for fully enabled ISO C99 support]) AC_MSG_RESULT($enable_c99) +]) + - if test x"$ac_99_math" = x"yes"; then - AC_DEFINE(_GLIBCXX_USE_C99_MATH) +dnl +dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1" +dnl facilities in Chapter 8, "C compatibility". +dnl +AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [ + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + + # Check for the existence of <complex.h> complex math functions used + # by tr1/complex. + AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no) + ac_c99_complex_tr1=no; + if test x"$ac_has_complex_h" = x"yes"; then + AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>]) + AC_TRY_COMPILE([#include <complex.h>], + [typedef __complex__ float float_type; float_type tmpf; + cacosf(tmpf); + casinf(tmpf); + catanf(tmpf); + cacoshf(tmpf); + casinhf(tmpf); + catanhf(tmpf); + typedef __complex__ double double_type; double_type tmpd; + cacos(tmpd); + casin(tmpd); + catan(tmpd); + cacosh(tmpd); + casinh(tmpd); + catanh(tmpd); + typedef __complex__ long double ld_type; ld_type tmpld; + cacosl(tmpld); + casinl(tmpld); + catanl(tmpld); + cacoshl(tmpld); + casinhl(tmpld); + catanhl(tmpld); + ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no]) + fi + AC_MSG_RESULT($ac_c99_complex_tr1) + if test x"$ac_c99_complex_tr1" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1, + [Define if C99 functions in <complex.h> should be used in + <tr1/complex>. Using compiler builtins for these functions + requires corresponding C99 library functions to be present.]) fi - # Option parsed, now set things appropriately - if test x"$enable_c99" = x"yes"; then - AC_DEFINE(_GLIBCXX_USE_C99) + # Check for the existence of <ctype.h> functions. + AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>]) + AC_CACHE_VAL(ac_c99_ctype_tr1, [ + AC_TRY_COMPILE([#include <ctype.h>], + [int ch; + int ret; + ret = isblank(ch); + ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no]) + ]) + AC_MSG_RESULT($ac_c99_ctype_tr1) + if test x"$ac_c99_ctype_tr1" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1, + [Define if C99 functions in <ctype.h> should be imported in + <tr1/cctype> in namespace std::tr1.]) + fi + + # Check for the existence of <fenv.h> functions. + AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no) + ac_c99_fenv_tr1=no; + if test x"$ac_has_fenv_h" = x"yes"; then + AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>]) + AC_TRY_COMPILE([#include <fenv.h>], + [int except, mode; + fexcept_t* pflag; + fenv_t* penv; + int ret; + ret = feclearexcept(except); + ret = fegetexceptflag(pflag, except); + ret = feraiseexcept(except); + ret = fesetexceptflag(pflag, except); + ret = fetestexcept(except); + ret = fegetround(); + ret = fesetround(mode); + ret = fegetenv(penv); + ret = feholdexcept(penv); + ret = fesetenv(penv); + ret = feupdateenv(penv); + ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no]) + fi + AC_MSG_RESULT($ac_c99_fenv_tr1) + if test x"$ac_c99_fenv_tr1" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1, + [Define if C99 functions in <fenv.h> should be imported in + <tr1/cfenv> in namespace std::tr1.]) + fi + + # Check for the existence of <stdint.h> types. + AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>]) + AC_CACHE_VAL(ac_c99_stdint_tr1, [ + AC_TRY_COMPILE([#include <stdint.h>], + [typedef int8_t my_int8_t; + typedef int16_t my_int16_t; + typedef int32_t my_int32_t; + typedef int64_t my_int64_t; + typedef int_fast8_t my_int_fast8_t; + typedef int_fast16_t my_int_fast16_t; + typedef int_fast32_t my_int_fast32_t; + typedef int_fast64_t my_int_fast64_t; + typedef int_least8_t my_int_least8_t; + typedef int_least16_t my_int_least16_t; + typedef int_least32_t my_int_least32_t; + typedef int_least64_t my_int_least64_t; + typedef intmax_t my_intmax_t; + typedef intptr_t my_intptr_t; + typedef uint8_t my_uint8_t; + typedef uint16_t my_uint16_t; + typedef uint32_t my_uint32_t; + typedef uint64_t my_uint64_t; + typedef uint_fast8_t my_uint_fast8_t; + typedef uint_fast16_t my_uint_fast16_t; + typedef uint_fast32_t my_uint_fast32_t; + typedef uint_fast64_t my_uint_fast64_t; + typedef uint_least8_t my_uint_least8_t; + typedef uint_least16_t my_uint_least16_t; + typedef uint_least32_t my_uint_least32_t; + typedef uint_least64_t my_uint_least64_t; + typedef uintmax_t my_uintmax_t; + typedef uintptr_t my_uintptr_t; + ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no]) + ]) + AC_MSG_RESULT($ac_c99_stdint_tr1) + if test x"$ac_c99_stdint_tr1" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1, + [Define if C99 types in <stdint.h> should be imported in + <tr1/cstdint> in namespace std::tr1.]) + fi + + # Check for the existence of <math.h> functions. + AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>]) + AC_CACHE_VAL(ac_c99_math_tr1, [ + AC_TRY_COMPILE([#include <math.h>], + [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); + remquo(0.0f, 0.0f, 0); + remquo(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); + ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no]) + ]) + AC_MSG_RESULT($ac_c99_math_tr1) + if test x"$ac_c99_math_tr1" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1, + [Define if C99 functions or macros in <math.h> should be imported + in <tr1/cmath> in namespace std::tr1.]) fi + # Check for the existence of <inttypes.h> functions (NB: doesn't make + # sense if the previous check fails, per C99, 7.8/1). + ac_c99_inttypes_tr1=no; + if test x"$ac_c99_stdint_tr1" = x"yes"; then + AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>]) + AC_TRY_COMPILE([#include <inttypes.h>], + [intmax_t i, numer, denom, base; + const char* s; + char** endptr; + intmax_t ret = imaxabs(i); + imaxdiv_t dret = imaxdiv(numer, denom); + ret = strtoimax(s, endptr, base); + uintmax_t uret = strtoumax(s, endptr, base); + ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no]) + fi + AC_MSG_RESULT($ac_c99_inttypes_tr1) + if test x"$ac_c99_inttypes_tr1" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1, + [Define if C99 functions in <inttypes.h> should be imported in + <tr1/cinttypes> in namespace std::tr1.]) + fi + + # Check for the existence of the <stdbool.h> header. + AC_CHECK_HEADERS(stdbool.h) + 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(ac_random_tr1, [ + AC_TRY_RUN([#include <stdio.h> + int main() + { + return !(fopen("/dev/random", "r") + && fopen("/dev/urandom", "r")); + } + ], + [ac_random_tr1=yes], [ac_random_tr1=no], + [ac_random_tr1=no]) + ]) + AC_MSG_RESULT($ac_random_tr1) + if test x"$ac_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 for what type of C headers to use. @@ -1030,8 +1352,8 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ # Probe for locale support if no specific model is specified. # Default to "generic". if test $enable_clocale_flag = auto; then - case x${target_os} in - xlinux* | xgnu* | xkfreebsd*-gnu | xknetbsd*-gnu) + case ${target_os} in + linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) AC_EGREP_CPP([_GLIBCXX_ok], [ #include <features.h> #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) @@ -1040,7 +1362,7 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ ], enable_clocale_flag=gnu, enable_clocale_flag=generic) # Test for bugs early in glibc-2.2.x series - if test x$enable_clocale_flag = xgnu; then + if test $enable_clocale_flag = gnu; then AC_TRY_RUN([ #define _GNU_SOURCE 1 #include <locale.h> @@ -1071,6 +1393,9 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ # ... at some point put __strxfrm_l tests in as well. ;; + darwin* | freebsd*) + enable_clocale_flag=darwin + ;; *) enable_clocale_flag=generic ;; @@ -1093,7 +1418,6 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ CLOCALE_H=config/locale/generic/c_locale.h CLOCALE_CC=config/locale/generic/c_locale.cc - CCODECVT_H=config/locale/generic/codecvt_specializations.h CCODECVT_CC=config/locale/generic/codecvt_members.cc CCOLLATE_CC=config/locale/generic/collate_members.cc CCTYPE_CC=config/locale/generic/ctype_members.cc @@ -1105,6 +1429,23 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ CTIME_CC=config/locale/generic/time_members.cc CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h ;; + darwin) + AC_MSG_RESULT(darwin or freebsd) + + CLOCALE_H=config/locale/generic/c_locale.h + CLOCALE_CC=config/locale/generic/c_locale.cc + CCODECVT_CC=config/locale/generic/codecvt_members.cc + CCOLLATE_CC=config/locale/generic/collate_members.cc + CCTYPE_CC=config/locale/darwin/ctype_members.cc + CMESSAGES_H=config/locale/generic/messages_members.h + CMESSAGES_CC=config/locale/generic/messages_members.cc + CMONEY_CC=config/locale/generic/monetary_members.cc + CNUMERIC_CC=config/locale/generic/numeric_members.cc + CTIME_H=config/locale/generic/time_members.h + CTIME_CC=config/locale/generic/time_members.cc + CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h + ;; + gnu) AC_MSG_RESULT(gnu) @@ -1128,7 +1469,6 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ CLOCALE_H=config/locale/gnu/c_locale.h CLOCALE_CC=config/locale/gnu/c_locale.cc - CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h CCODECVT_CC=config/locale/gnu/codecvt_members.cc CCOLLATE_CC=config/locale/gnu/collate_members.cc CCTYPE_CC=config/locale/gnu/ctype_members.cc @@ -1145,7 +1485,6 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc - CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h CCODECVT_CC=config/locale/generic/codecvt_members.cc CCOLLATE_CC=config/locale/generic/collate_members.cc CCTYPE_CC=config/locale/generic/ctype_members.cc @@ -1170,12 +1509,12 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no) fi if test $USE_NLS = yes; then - AC_DEFINE(_GLIBCXX_USE_NLS) + AC_DEFINE(_GLIBCXX_USE_NLS, 1, + [Define if NLS translations are to be used.]) fi AC_SUBST(USE_NLS) AC_SUBST(CLOCALE_H) - AC_SUBST(CCODECVT_H) AC_SUBST(CMESSAGES_H) AC_SUBST(CCODECVT_CC) AC_SUBST(CCOLLATE_CC) @@ -1197,24 +1536,31 @@ dnl dnl Default is new. dnl AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [ - AC_MSG_CHECKING([for std::allocator base class to use]) + AC_MSG_CHECKING([for std::allocator base class]) GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND], [use KIND for target std::allocator base], [permit new|malloc|mt|bitmap|pool|yes|no|auto]) + # 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. - if test $enable_libstdcxx_allocator = no || test $enable_libstdcxx_allocator = yes; then + if test $enable_libstdcxx_allocator = no || + test $enable_libstdcxx_allocator = yes; + then enable_libstdcxx_allocator=auto fi - # Either a known package, or "auto" + # Either a known package, or "auto". Auto implies the default choice + # for a particular platform. enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator # Probe for host-specific support if no specific model is specified. # Default to "new". if test $enable_libstdcxx_allocator_flag = auto; then case ${target_os} in + linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) + enable_libstdcxx_allocator_flag=new + ;; *) enable_libstdcxx_allocator_flag=new ;; @@ -1263,7 +1609,8 @@ dnl AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [ GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks]) if test $enable_concept_checks = yes; then - AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS) + AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1, + [Define to use concept checking code from the boost libraries.]) fi ]) @@ -1339,21 +1686,6 @@ AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl dnl -dnl Check for wide character support. Has the same effect as the option -dnl in gcc's configure, but in a form that autoconf can mess with. -dnl -dnl --enable-c-mbchar requests all the wchar_t stuff. -dnl --disable-c-mbchar doesn't. -dnl + Usage: GLIBCXX_ENABLE_C_MBCHAR[(DEFAULT)] -dnl Where DEFAULT is either `yes' or `no'. -dnl -AC_DEFUN([GLIBCXX_ENABLE_C_MBCHAR], [ - GLIBCXX_ENABLE(c-mbchar,$1,,[enable multibyte (wide) characters]) - # Option parsed, now other scripts can test enable_c_mbchar for yes/no. -]) - - -dnl dnl Check to see if debugging libraries are to be built. dnl dnl --enable-libstdcxx-debug @@ -1424,7 +1756,14 @@ AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [ AC_ARG_ENABLE([hosted-libstdcxx], AC_HELP_STRING([--disable-hosted-libstdcxx], [only build freestanding C++ runtime support]),, - [enable_hosted_libstdcxx=yes]) + [case "$host" in + arm*-*-symbianelf*) + enable_hosted_libstdcxx=no + ;; + *) + enable_hosted_libstdcxx=yes + ;; + esac]) if test "$enable_hosted_libstdcxx" = no; then AC_MSG_NOTICE([Only freestanding libraries will be built]) is_hosted=no @@ -1442,7 +1781,7 @@ AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [ dnl -dnl Check for template specializations for the 'long long' type extension. +dnl Check for template specializations for the 'long long' type. dnl The result determines only whether 'long long' I/O is enabled; things dnl like numeric_limits<> specializations are always available. dnl @@ -1452,10 +1791,127 @@ dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)] dnl Where DEFAULT is either `yes' or `no'. dnl AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [ - GLIBCXX_ENABLE(long-long,$1,,[enables I/O support for 'long long']) + GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long']) if test $enable_long_long = yes; then - AC_DEFINE(_GLIBCXX_USE_LONG_LONG) + AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1, + [Define if code specialized for long long should be used.]) fi + AC_MSG_CHECKING([for enabled long long specializations]) + AC_MSG_RESULT([$enable_long_long]) +]) + + +dnl +dnl Check for template specializations for the 'wchar_t' type. +dnl +dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T +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 must also be present. +dnl +AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [ + GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t']) + + # 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 <wchar.h>], + [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 <wchar.h> + #include <stddef.h> + 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]) ]) @@ -1474,10 +1930,7 @@ dnl Substs: dnl glibcxx_PCHFLAGS dnl AC_DEFUN([GLIBCXX_ENABLE_PCH], [ - AC_MSG_CHECKING([for enabled PCH]) GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers]) - AC_MSG_RESULT([$enable_libstdcxx_pch]) - if test $enable_libstdcxx_pch = yes; then AC_CACHE_CHECK([for compiler with PCH support], [glibcxx_cv_prog_CXX_pch], @@ -1503,9 +1956,12 @@ AC_DEFUN([GLIBCXX_ENABLE_PCH], [ enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch fi + AC_MSG_CHECKING([for enabled PCH]) + AC_MSG_RESULT([$enable_libstdcxx_pch]) + GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes) if test $enable_libstdcxx_pch = yes; then - glibcxx_PCHFLAGS="-include bits/stdc++.h" + glibcxx_PCHFLAGS="-include bits/stdtr1c++.h" else glibcxx_PCHFLAGS="" fi @@ -1514,6 +1970,69 @@ 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. Note, this is intended to be an +dnl all-or-nothing switch, so all the atomic operations that are used +dnl 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 if the compiler on this target supports atomics. +dnl +AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [ + AC_MSG_CHECKING([for atomic builtins]) + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + + # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style. + 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); + if (__sync_fetch_and_add(&c1, c2) == c3) + { + // Do something. + } + return 0; +} +EOF + old_CXXFLAGS="$CXXFLAGS" + CXXFLAGS=-S + if AC_TRY_EVAL(ac_compile); then + if grep __sync_fetch_and_add conftest.s >/dev/null 2>&1 ; then + enable_atomic_builtins=no + else + AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1, + [Define if builtin atomic operations are supported on this host.]) + enable_atomic_builtins=yes + atomicity_dir=cpu/generic/atomicity_builtins + fi + fi + CXXFLAGS="$old_CXXFLAGS" + rm -f conftest* + + # Now, if still generic, set to mutex. + if test $atomicity_dir = "cpu/generic" ; then + atomicity_dir=cpu/generic/atomicity_mutex + fi + AC_LANG_RESTORE + AC_MSG_RESULT($enable_atomic_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. @@ -1556,14 +2075,16 @@ EOF 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. + # 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, @@ -1583,6 +2104,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], + have_attribute_visibility, [ + save_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -Werror" + AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }], + [], have_attribute_visibility=yes, + have_attribute_visibility=no) + CFLAGS="$save_CFLAGS"]) + if test $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 @@ -1599,20 +2152,38 @@ AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [ GLIBCXX_ENABLE(symvers,$1,[=STYLE], [enables symbol versioning of the shared library], - [permit yes|no|gnu]) + [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export]) # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we # don't know enough about $LD to do tricks... AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES]) -# FIXME The following test is too strict, in theory. -if test $enable_shared = no || - test "x$LD" = x || - test x$glibcxx_gnu_ld_version = x; then - enable_symvers=no + +# Turn a 'yes' into a suitable default. +if test x$enable_symvers = xyes ; 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 + else + case ${target_os} in + darwin*) + enable_symvers=darwin ;; + *) + enable_symvers=no ;; + esac + fi + fi +fi + +# Check to see if 'darwin' or 'darwin-export' can win. +if test x$enable_symvers = xdarwin-export ; then + enable_symvers=darwin fi -# Check to see if libgcc_s exists, indicating that shared libgcc is possible. -if test $enable_symvers != no; then +# Check to see if 'gnu' can win. +if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then + # Check to see if libgcc_s exists, indicating that shared libgcc is possible. AC_MSG_CHECKING([for shared libgcc]) ac_save_CFLAGS="$CFLAGS" CFLAGS=' -lgcc_s' @@ -1636,44 +2207,29 @@ changequote([,])dnl fi fi AC_MSG_RESULT($glibcxx_shared_libgcc) -fi - -# For GNU ld, we need at least this version. The format is described in -# GLIBCXX_CHECK_LINKER_FEATURES above. -glibcxx_min_gnu_ld_version=21400 -# XXXXXXXXXXX glibcxx_gnu_ld_version=21390 -# Check to see if unspecified "yes" value can win, given results above. -# Change "yes" into either "no" or a style name. -if test $enable_symvers = yes; then - if test $with_gnu_ld = yes && - test $glibcxx_shared_libgcc = yes; - then - if test $glibcxx_gnu_ld_version -ge $glibcxx_min_gnu_ld_version ; then - enable_symvers=gnu - else - # The right tools, the right setup, but too old. Fallbacks? - AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for) - AC_MSG_WARN(=== full symbol versioning support in this release of GCC.) - AC_MSG_WARN(=== You would need to upgrade your binutils to version) - AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.) - if test $glibcxx_gnu_ld_version -ge 21200 ; then - # Globbing fix is present, proper block support is not. - dnl AC_MSG_WARN([=== Dude, you are soooo close. Maybe we can fake it.]) - dnl enable_symvers=??? - AC_MSG_WARN([=== Symbol versioning will be disabled.]) - enable_symvers=no - else - # 2.11 or older. - AC_MSG_WARN([=== Symbol versioning will be disabled.]) - enable_symvers=no - fi - fi - else + # For GNU ld, we need at least this version. The format is described in + # GLIBCXX_CHECK_LINKER_FEATURES above. + glibcxx_min_gnu_ld_version=21400 + + # If no shared libgcc, can't win. + if test $glibcxx_shared_libgcc != yes; then + AC_MSG_WARN([=== You have requested GNU symbol versioning, but]) + AC_MSG_WARN([=== you are not building a shared libgcc_s.]) + AC_MSG_WARN([=== Symbol versioning will be disabled.]) + enable_symvers=no + elif test $with_gnu_ld != yes ; then # just fail for now - AC_MSG_WARN([=== You have requested some kind of symbol versioning, but]) - AC_MSG_WARN([=== either you are not using a supported linker, or you are]) - AC_MSG_WARN([=== not building a shared libgcc_s (which is required).]) + AC_MSG_WARN([=== You have requested GNU symbol versioning, but]) + AC_MSG_WARN([=== you are not using the GNU linker.]) + AC_MSG_WARN([=== Symbol versioning will be disabled.]) + enable_symvers=no + 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) + AC_MSG_WARN(=== full symbol versioning support in this release of GCC.) + AC_MSG_WARN(=== You would need to upgrade your binutils to version) + AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.) AC_MSG_WARN([=== Symbol versioning will be disabled.]) enable_symvers=no fi @@ -1682,18 +2238,63 @@ fi # Everything parsed; figure out what file to use. case $enable_symvers in no) - SYMVER_MAP=config/linker-map.dummy + SYMVER_FILE=config/abi/pre/none.ver ;; gnu) - SYMVER_MAP=config/linker-map.gnu - AC_DEFINE(_GLIBCXX_SYMVER) + SYMVER_FILE=config/abi/pre/gnu.ver + AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1, + [Define to use GNU versioning in the shared library.]) + ;; + gnu-versioned-namespace) + SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver + AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1, + [Define to use GNU namespace versioning in the shared library.]) + ;; + darwin) + SYMVER_FILE=config/abi/pre/gnu.ver + AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1, + [Define to use darwin versioning in the shared library.]) ;; esac -AC_SUBST(SYMVER_MAP) +if test x$enable_symvers != xno ; then + AC_DEFINE(_GLIBCXX_SYMVER, 1, + [Define to use symbol versioning in the shared library.]) +fi + +AC_SUBST(SYMVER_FILE) AC_SUBST(port_specific_symbol_files) -GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_VERSIONED_SHLIB, test $enable_symvers != no) +GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no) +GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu) +GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace) +GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin) AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers) + +# Now, set up compatibility support, if any. +# In addition, need this to deal with std::size_t mangling in +# src/compatibility.cc. In a perfect world, could use +# typeid(std::size_t).name()[0] to do direct substitution. +AC_MSG_CHECKING([for size_t as unsigned int]) +ac_save_CFLAGS="$CFLAGS" +CFLAGS="-Werror" +AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;], + [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no]) +CFLAGS=$ac_save_CFLAGS +if test "$glibcxx_size_t_is_i" = yes; then + AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.]) +fi +AC_MSG_RESULT([$glibcxx_size_t_is_i]) + +AC_MSG_CHECKING([for ptrdiff_t as int]) +ac_save_CFLAGS="$CFLAGS" +CFLAGS="-Werror" +AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;], + [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no]) +CFLAGS=$ac_save_CFLAGS +if test "$glibcxx_ptrdiff_t_is_i" = yes; then + AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.]) +fi +AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i]) ]) @@ -1721,10 +2322,21 @@ AC_DEFUN([GLIBCXX_ENABLE_THREADS], [ AC_MSG_RESULT([$target_thread_file]) if test $target_thread_file != single; then - AC_DEFINE(HAVE_GTHR_DEFAULT) + AC_DEFINE(HAVE_GTHR_DEFAULT, 1, + [Define if gthr-default.h exists + (meaning that threading support is enabled).]) fi glibcxx_thread_h=gthr-$target_thread_file.h + + dnl Check for __GTHREADS define. + gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h} + if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then + enable_thread=yes + else + enable_thread=no + fi + AC_SUBST(glibcxx_thread_h) ]) @@ -1744,20 +2356,12 @@ AC_DEFUN([AC_LC_MESSAGES], [ [AC_TRY_LINK([#include <locale.h>], [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) + AC_DEFINE(HAVE_LC_MESSAGES, 1, + [Define if LC_MESSAGES is available in <locale.h>.]) fi ]) ]) +# Macros from the top-level gcc directory. +m4_include([../config/tls.m4]) -sinclude([../libtool.m4]) -dnl The lines below arrange for aclocal not to bring an installed -dnl libtool.m4 into aclocal.m4, while still arranging for automake to -dnl add a definition of LIBTOOL to Makefile.in. -ifelse(,,,[AC_SUBST(LIBTOOL) -AC_DEFUN([AM_PROG_LIBTOOL]) -AC_DEFUN([AC_LIBTOOL_DLOPEN]) -AC_DEFUN([AC_PROG_LD]) -]) - -dnl vim:et:ts=2:sw=2 |