# 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++ python src doc po testsuite])
SUBDIRS='glibcxx_SUBDIRS'
# These need to be absolute paths, yet at the same time need to
AC_HELP_STRING([--with-newlib],
[assume newlib as a system C library]))
- # We're almost certainly being configured before anything else which uses
- # C++, so all of our AC_PROG_* discoveries will be cached. It's vital that
- # we not cache the value of CXX that we "discover" here, because it's set
- # to something unique for us and libjava. Other target libraries need to
- # find CXX for themselves. We yank the rug out from under the normal AC_*
- # process by sneakily renaming the cache variable. This also lets us debug
- # the value of "our" CXX in postmortems.
- #
- # We must also force CXX to /not/ be a precious variable, otherwise the
- # wrong (non-multilib-adjusted) value will be used in multilibs. This
- # little trick also affects CPPFLAGS, CXXFLAGS, and LDFLAGS. And as a side
- # effect, CXXFLAGS is no longer automagically subst'd, so we have to do
- # that ourselves. Un-preciousing AC_PROG_CC also affects CC and CFLAGS.
- #
- # -fno-builtin must be present here so that a non-conflicting form of
- # std::exit can be guessed by AC_PROG_CXX, and used in later tests.
-
- m4_define([ac_cv_prog_CXX],[glibcxx_cv_prog_CXX])
- m4_rename([_AC_ARG_VAR_PRECIOUS],[glibcxx_PRECIOUS])
- m4_define([_AC_ARG_VAR_PRECIOUS],[])
- save_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS="$CXXFLAGS -fno-builtin"
- AC_PROG_CC
- AC_PROG_CXX
- CXXFLAGS="$save_CXXFLAGS"
- m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
- AC_SUBST(CFLAGS)
- AC_SUBST(CXXFLAGS)
-
# 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
# 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.
# 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
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
# 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 |
+ sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'`
+ 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])
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
GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
# Check for rlimit, setrlimit.
- AC_CACHE_VAL(ac_setrlimit, [
+ AC_CACHE_VAL(glibcxx_cv_setrlimit, [
AC_TRY_COMPILE(
[#include <unistd.h>
#include <sys/time.h>
],
[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
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 <sys/stat.h>],
[struct stat buffer;
fstat(0, &buffer);
[glibcxx_cv_S_ISREG=no])
])
AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
- AC_TRY_LINK(
+ GCC_TRY_COMPILE_OR_LINK(
[#include <sys/stat.h>],
[struct stat buffer;
fstat(0, &buffer);
res=S_IFREG
fi
AC_MSG_RESULT($res)
+
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
])
dnl Check whether poll is available in <poll.h>, 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 <poll.h>],
[struct pollfd pfd[1];
pfd[0].events = POLLIN;
AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
fi
AC_MSG_RESULT($glibcxx_cv_POLL)
+
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
])
dnl Check whether writev is available in <sys/uio.h>, 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 <sys/uio.h>],
[struct iovec iov[2];
writev(0, iov, 0);],
AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
fi
AC_MSG_RESULT($glibcxx_cv_WRITEV)
+
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
])
dnl
dnl Check whether int64_t is available in <stdint.h>, 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(
[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 <stdint.h>.])
+ 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 <stdint.h>
+ template<typename, typename> struct same { enum { value = -1 }; };
+ template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
+ int array[same<int64_t, long>::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 <stdint.h>
+ template<typename, typename> struct same { enum { value = -1 }; };
+ template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
+ int array[same<int64_t, long long>::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
])
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 <unistd.h>
#include <stdio.h>
#include <sys/stat.h>
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)
])
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'
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 <math.h> functions used if C99 is enabled.
AC_MSG_CHECKING([for ISO C99 support in <math.h>])
- AC_CACHE_VAL(ac_c99_math, [
- AC_TRY_COMPILE([#include <math.h>],
- [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 <math.h>
+ volatile double d1, d2;
+ volatile int i;],
+ [i = fpclassify(d1);
+ i = isfinite(d1);
+ i = isinf(d1);
+ i = isnan(d1);
+ i = isnormal(d1);
+ i = signbit(d1);
+ i = isgreater(d1, d2);
+ i = isgreaterequal(d1, d2);
+ i = isless(d1, d2);
+ i = islessequal(d1, d2);
+ i = islessgreater(d1, d2);
+ i = islessgreater(d1, d2);
+ i = isunordered(d1, d2);
+ ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
])
- AC_MSG_RESULT($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 <math.h> should be imported
in <cmath> in namespace std.])
# 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 <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
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <complex.h>
+ typedef __complex__ float float_type;
+ typedef __complex__ double double_type;
+ typedef __complex__ long double ld_type;
+ volatile float_type tmpf;
+ volatile double_type tmpd;
+ volatile ld_type tmpld;
+ volatile float f;
+ volatile double d;
+ volatile long double ld;],
+ [f = cabsf(tmpf);
+ f = cargf(tmpf);
+ tmpf = ccosf(tmpf);
+ tmpf = ccoshf(tmpf);
+ tmpf = cexpf(tmpf);
+ tmpf = clogf(tmpf);
+ tmpf = csinf(tmpf);
+ tmpf = csinhf(tmpf);
+ tmpf = csqrtf(tmpf);
+ tmpf = ctanf(tmpf);
+ tmpf = ctanhf(tmpf);
+ tmpf = cpowf(tmpf, tmpf);
+ tmpf = cprojf(tmpf);
+ d = cabs(tmpd);
+ d = carg(tmpd);
+ tmpd = ccos(tmpd);
+ tmpd = ccosh(tmpd);
+ tmpd = cexp(tmpd);
+ tmpd = clog(tmpd);
+ tmpd = csin(tmpd);
+ tmpd = csinh(tmpd);
+ tmpd = csqrt(tmpd);
+ tmpd = ctan(tmpd);
+ tmpd = ctanh(tmpd);
+ tmpd = cpow(tmpd, tmpd);
+ tmpd = cproj(tmpd);
+ ld = cabsl(tmpld);
+ ld = cargl(tmpld);
+ tmpld = ccosl(tmpld);
+ tmpld = ccoshl(tmpld);
+ tmpld = cexpl(tmpld);
+ tmpld = clogl(tmpld);
+ tmpld = csinl(tmpld);
+ tmpld = csinhl(tmpld);
+ tmpld = csqrtl(tmpld);
+ tmpld = ctanl(tmpld);
+ tmpld = ctanhl(tmpld);
+ tmpld = cpowl(tmpld, tmpld);
+ tmpld = cprojl(tmpld);
+ ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_c99_complex)
+ if test x"$glibcxx_cv_c99_complex" = x"yes"; then
AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
[Define if C99 functions in <complex.h> should be used in
<complex>. Using compiler builtins for these functions requires
# Check for the existence in <stdio.h> of vscanf, et. al.
AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
- AC_CACHE_VAL(ac_c99_stdio, [
- AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
- void foo(char* fmt, ...)
- {
- va_list args; va_start(args, fmt);
- vfscanf(stderr, "%i", args);
- vscanf("%i", args);
- vsnprintf(fmt, 0, "%i", args);
- vsscanf(fmt, "%i", args);
- }],
- [snprintf("12", 0, "%i");],
- [ac_c99_stdio=yes], [ac_c99_stdio=no])
+ AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <stdio.h>
+ #include <stdarg.h>
+ void foo(char* fmt, ...)
+ {
+ va_list args; va_start(args, fmt);
+ vfscanf(stderr, "%i", args);
+ vscanf("%i", args);
+ vsnprintf(fmt, 0, "%i", args);
+ vsscanf(fmt, "%i", args);
+ }],
+ [snprintf("12", 0, "%i");],
+ [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
])
- AC_MSG_RESULT($ac_c99_stdio)
+ AC_MSG_RESULT($glibcxx_cv_c99_stdio)
# Check for the existence in <stdlib.h> of lldiv_t, et. al.
AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
- AC_CACHE_VAL(ac_c99_stdlib, [
- AC_TRY_COMPILE([#include <stdlib.h>],
- [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 <stdlib.h>
+ volatile float f;
+ volatile long double ld;
+ volatile unsigned long long ll;
+ lldiv_t mydivt;],
+ [char* tmp;
+ f = strtof("gnu", &tmp);
+ ld = strtold("gnu", &tmp);
+ ll = strtoll("gnu", &tmp, 10);
+ ll = strtoull("gnu", &tmp, 10);
+ ll = llabs(10);
+ mydivt = lldiv(10,1);
+ ll = mydivt.quot;
+ ll = mydivt.rem;
+ ll = atoll("10");
+ _Exit(0);
+ ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
])
- AC_MSG_RESULT($ac_c99_stdlib)
+ AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
# Check for the existence in <wchar.h> of wcstold, etc.
- ac_c99_wchar=no;
+ glibcxx_cv_c99_wchar=no;
if test x"$ac_has_wchar_h" = xyes &&
test x"$ac_has_wctype_h" = xyes; then
AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
using ::wcstoll;
using ::wcstoull;
}
- ],[],[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.
[AC_DEFINE(HAVE_ISWBLANK,1,
[Defined if iswblank exists.])],[])
- 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,
<complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
fi
+ gcc_no_link="$ac_save_gcc_no_link"
+ LIBS="$ac_save_LIBS"
+ CXXFLAGS="$ac_save_CXXFLAGS"
AC_LANG_RESTORE
fi
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 <unistd.h>
+ #include <time.h>
+ ],
+ [#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 <unistd.h>
+ #include <time.h>
+ ],
+ [#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 <unistd.h>
+ #include <time.h>
+ ],
+ [#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 <sys/time.h>],
+ [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
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.h> complex math functions used
# by tr1/complex.
AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
# 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_CACHE_VAL(glibcxx_cv_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])
+ ],[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 <ctype.h> should be imported in
<tr1/cctype> in namespace std::tr1.])
# 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>],
+ AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
+ AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
+ #define __STDC_CONSTANT_MACROS
+ #include <stdint.h>],
[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 <stdint.h> should be imported in
<tr1/cstdint> in namespace std::tr1.])
# 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_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
AC_TRY_COMPILE([#include <math.h>],
[typedef double_t my_double_t;
typedef float_t my_float_t;
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);
+ remquof(0.0f, 0.0f, 0);
+ remquol(0.0l, 0.0l, 0);
rint(0.0);
rintf(0.0f);
rintl(0.0l);
trunc(0.0);
truncf(0.0f);
truncl(0.0l);
- ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
+ ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
])
- AC_MSG_RESULT($ac_c99_math_tr1)
- if test x"$ac_c99_math_tr1" = x"yes"; then
+ 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 <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).
+ # 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 <inttypes.h>])
AC_TRY_COMPILE([#include <inttypes.h>],
[intmax_t i, numer, denom, base;
<tr1/cinttypes> in namespace std::tr1.])
fi
+ # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
+ # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
+ ac_c99_inttypes_wchar_t_tr1=no;
+ if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
+ AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
+ AC_TRY_COMPILE([#include <inttypes.h>],
+ [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 <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)
+ CXXFLAGS="$ac_save_CXXFLAGS"
AC_LANG_RESTORE
])
dnl
-dnl Check whether "dev/random" and "dev/urandom" are available for the
+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_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($ac_random_tr1)
- if test x"$ac_random_tr1" = x"yes"; then
+ 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
+ [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 <cstdio> 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 <stdio.h>],
+ [#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 <system_error>
+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 <errno.h>]],
+ [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.
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)
])
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 <features.h>
- #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 <locale.h>
- #include <string.h>
- #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
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 <features.h>
+ #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 <locale.h>
+ #include <string.h>
+ #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 <string.h>
+ #include <locale.h>],
+ [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 <string.h>.]),)
+
+ # Use strerror_l if available.
+ AC_TRY_COMPILE([#define _GNU_SOURCE 1
+ #include <string.h>
+ #include <locale.h>],
+ [__locale_t loc; strerror_l(5, loc);],
+ AC_DEFINE(HAVE_STRERROR_L, 1,
+ [Define if strerror_l is available in <string.h>.]),)
+
+ 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 <string.h>
+ #include <locale.h>],
+ [char s[128]; strerror_r(5, s, 128);],
+ AC_DEFINE(HAVE_STRERROR_R, 1,
+ [Define if strerror_r is available in <string.h>.]),)
+ 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)
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.
dnl
+dnl Check for decimal floating point.
+dnl See:
+dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
+dnl
+dnl This checks to see if the host supports decimal floating point types.
+dnl
+dnl Defines:
+dnl _GLIBCXX_USE_DECIMAL_FLOAT
+dnl
+AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
+
+ # Fake what AC_TRY_COMPILE does, without linking as this is
+ # unnecessary for this test.
+
+ cat > conftest.$ac_ext << EOF
+[#]line __oline__ "configure"
+int main()
+{
+ _Decimal32 d1;
+ _Decimal64 d2;
+ _Decimal128 d3;
+ return 0;
+}
+EOF
+
+ AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
+ if AC_TRY_EVAL(ac_compile); then
+ AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
+ [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
+ enable_dfp=yes
+ else
+ enable_dfp=no
+ fi
+ AC_MSG_RESULT($enable_dfp)
+ rm -f conftest*
+])
+
+dnl
dnl Check for template specializations for the 'wchar_t' type.
dnl
dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
if test $enable_libstdcxx_pch = yes; then
- glibcxx_PCHFLAGS="-include bits/stdtr1c++.h"
+ glibcxx_PCHFLAGS="-include bits/stdc++.h"
else
glibcxx_PCHFLAGS=""
fi
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 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 libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
dnl
dnl Defines:
-dnl _GLIBCXX_ATOMIC_BUILTINS if the compiler on this target supports atomics.
+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_MSG_CHECKING([for atomic builtins])
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
+ old_CXXFLAGS="$CXXFLAGS"
+
+ # Do link tests if possible, instead asm tests, limited to some platforms
+ # see discussion in PR target/40134, PR libstdc++/40133 and the thread
+ # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
+ atomic_builtins_link_tests=no
+ if test x$gcc_no_link != xyes; then
+ # Can do link tests. Limit to some tested platforms
+ case "$host" in
+ *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
+ atomic_builtins_link_tests=yes
+ ;;
+ esac
+ fi
+
+ if test x$atomic_builtins_link_tests = xyes; then
+
+ # Do link tests.
+
+ CXXFLAGS="$CXXFLAGS -fno-exceptions"
+
+ AC_MSG_CHECKING([for atomic builtins for bool])
+ AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
+ AC_TRY_LINK(
+ [ ],
+ [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();],
+ [glibcxx_cv_atomic_bool=yes],
+ [glibcxx_cv_atomic_bool=no])
+ ])
+ if test $glibcxx_cv_atomic_bool = yes; then
+ AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
+ [Define if builtin atomic operations for bool are supported on this host.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_atomic_bool)
+
+ AC_MSG_CHECKING([for atomic builtins for short])
+ AC_CACHE_VAL(glibcxx_cv_atomic_short, [
+ AC_TRY_LINK(
+ [ ],
+ [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();],
+ [glibcxx_cv_atomic_short=yes],
+ [glibcxx_cv_atomic_short=no])
+ ])
+ if test $glibcxx_cv_atomic_short = yes; then
+ AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
+ [Define if builtin atomic operations for short are supported on this host.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_atomic_short)
+
+ AC_MSG_CHECKING([for atomic builtins for int])
+ AC_CACHE_VAL(glibcxx_cv_atomic_int, [
+ AC_TRY_LINK(
+ [ ],
+ [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();],
+ [glibcxx_cv_atomic_int=yes],
+ [glibcxx_cv_atomic_int=no])
+ ])
+ if test $glibcxx_cv_atomic_int = yes; then
+ AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
+ [Define if builtin atomic operations for int are supported on this host.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_atomic_int)
+
+ AC_MSG_CHECKING([for atomic builtins for long long])
+ AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
+ AC_TRY_LINK(
+ [ ],
+ [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();],
+ [glibcxx_cv_atomic_long_long=yes],
+ [glibcxx_cv_atomic_long_long=no])
+ ])
+ if test $glibcxx_cv_atomic_long_long = yes; then
+ AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
+ [Define if builtin atomic operations for long long are supported on this host.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
+
+ else
+
+ # Do asm tests.
+
+ # Compile unoptimized.
+ CXXFLAGS='-O0 -S'
+
+ # Fake what AC_TRY_COMPILE does.
+
+ 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
+ glibcxx_cv_atomic_bool=no
+ else
+ AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
+ [Define if builtin atomic operations for bool are supported on this host.])
+ glibcxx_cv_atomic_bool=yes
+ fi
+ fi
+ AC_MSG_RESULT($glibcxx_cv_atomic_bool)
+ 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
+ glibcxx_cv_atomic_short=no
+ else
+ AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
+ [Define if builtin atomic operations for short are supported on this host.])
+ glibcxx_cv_atomic_short=yes
+ fi
+ fi
+ AC_MSG_RESULT($glibcxx_cv_atomic_short)
+ rm -f conftest*
- # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style.
cat > conftest.$ac_ext << EOF
[#]line __oline__ "configure"
int main()
atomic_type c1;
atomic_type c2;
const atomic_type c3(0);
- if (__sync_fetch_and_add(&c1, c2) == c3)
- {
- // Do something.
- }
- return 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
- old_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS=-S
+
+ AC_MSG_CHECKING([for atomic builtins for int])
if AC_TRY_EVAL(ac_compile); then
- if grep __sync_fetch_and_add conftest.s >/dev/null 2>&1 ; then
- enable_atomic_builtins=no
+ if grep __sync_ conftest.s >/dev/null 2>&1 ; then
+ glibcxx_cv_atomic_int=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
+ AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
+ [Define if builtin atomic operations for int are supported on this host.])
+ glibcxx_cv_atomic_int=yes
fi
fi
- CXXFLAGS="$old_CXXFLAGS"
+ AC_MSG_RESULT($glibcxx_cv_atomic_int)
rm -f conftest*
- # Now, if still generic, set to mutex.
+ 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
+ glibcxx_cv_atomic_long_long=no
+ else
+ AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
+ [Define if builtin atomic operations for long long are supported on this host.])
+ glibcxx_cv_atomic_long_long=yes
+ fi
+ fi
+ AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
+ rm -f conftest*
+
+ fi
+
+ CXXFLAGS="$old_CXXFLAGS"
+ AC_LANG_RESTORE
+
+ # Set atomicity_dir to builtins if either of above tests pass.
+ if test $glibcxx_cv_atomic_int = yes || test $glibcxx_cv_atomic_bool = 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
+ 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
- AC_LANG_RESTORE
- AC_MSG_RESULT($enable_atomic_builtins)
+
])
dnl all hail libgfortran
dnl Check whether the target supports hidden visibility.
AC_CACHE_CHECK([whether the target supports hidden visibility],
- have_attribute_visibility, [
+ glibcxx_cv_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)
+ [], glibcxx_cv_have_attribute_visibility=yes,
+ glibcxx_cv_have_attribute_visibility=no)
CFLAGS="$save_CFLAGS"])
- if test $have_attribute_visibility = no; then
+ if test $glibcxx_cv_have_attribute_visibility = no; then
enable_visibility=no
fi
fi
# 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
+ hpux*)
+ enable_symvers=no ;;
+ *)
+ enable_symvers=gnu ;;
+ esac
else
case ${target_os} in
darwin*)
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)
[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)
])
+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 <locale.h>.
# Ulrich Drepper <drepper@cygnus.com>, 1995.
#
# 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 <locale.h>], [return LC_MESSAGES],
+ [AC_TRY_COMPILE([#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, 1,
OSDN Git Service
