libstdc++-v3/acinclude.m4

   1 dnl
   2 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
   3 dnl
   4 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
   5 dnl end of configure.  This lets tested variables be reassigned, and the
   6 dnl conditional will depend on the final state of the variable.  For a simple
   7 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
   8 dnl
   9 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
  10 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
  11   m4_divert_text([glibcxx_diversion],dnl
  12    AM_CONDITIONAL([$1],[$2])
  13   )dnl
  14 ])dnl
  15 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
  16
  17
  18 dnl
  19 dnl Check to see what architecture and operating system we are compiling
  20 dnl for.  Also, if architecture- or OS-specific flags are required for
  21 dnl compilation, pick them up here.
  22 dnl
  23 AC_DEFUN([GLIBCXX_CHECK_HOST], [
  24   . $glibcxx_srcdir/configure.host
  25   AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
  26   AC_MSG_NOTICE([OS config directory is $os_include_dir])
  27 ])
  28
  29 dnl
  30 dnl Initialize the rest of the library configury.  At this point we have
  31 dnl variables like $host.
  32 dnl
  33 dnl Sets:
  34 dnl  SUBDIRS
  35 dnl Substs:
  36 dnl  glibcxx_builddir     (absolute path)
  37 dnl  glibcxx_srcdir       (absolute path)
  38 dnl  toplevel_builddir    (absolute path)
  39 dnl  toplevel_srcdir      (absolute path)
  40 dnl  with_cross_host
  41 dnl  with_newlib
  42 dnl  with_target_subdir
  43 dnl plus
  44 dnl  - the variables in GLIBCXX_CHECK_HOST / configure.host
  45 dnl  - default settings for all AM_CONFITIONAL test variables
  46 dnl  - lots of tools, like CC and CXX
  47 dnl
  48 AC_DEFUN([GLIBCXX_CONFIGURE], [
  49   # Keep these sync'd with the list in Makefile.am.  The first provides an
  50   # expandable list at autoconf time; the second provides an expandable list
  51   # (i.e., shell variable) at configure time.
  52   m4_define([glibcxx_SUBDIRS],[include libsupc++ src src/c++98 src/c++11 src/filesystem doc po testsuite python])
  53   SUBDIRS='glibcxx_SUBDIRS'
  54
  55   # These need to be absolute paths, yet at the same time need to
  56   # canonicalize only relative paths, because then amd will not unmount
  57   # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
  58   glibcxx_builddir=`${PWDCMD-pwd}`
  59   case $srcdir in
  60     [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
  61     *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
  62   esac
  63   toplevel_builddir=${glibcxx_builddir}/..
  64   toplevel_srcdir=${glibcxx_srcdir}/..
  65   AC_SUBST(glibcxx_builddir)
  66   AC_SUBST(glibcxx_srcdir)
  67   AC_SUBST(toplevel_builddir)
  68   AC_SUBST(toplevel_srcdir)
  69
  70   # We use these options to decide which functions to include.  They are
  71   # set from the top level.
  72   AC_ARG_WITH([target-subdir],
  73     AC_HELP_STRING([--with-target-subdir=SUBDIR],
  74                    [configuring in a subdirectory]))
  75
  76   AC_ARG_WITH([cross-host],
  77     AC_HELP_STRING([--with-cross-host=HOST],
  78                    [configuring with a cross compiler]))
  79
  80   AC_ARG_WITH([newlib],
  81     AC_HELP_STRING([--with-newlib],
  82                    [assume newlib as a system C library]))
  83
  84   # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
  85   # available).  Uncomment the next line to force a particular method.
  86   AC_PROG_LN_S
  87   #LN_S='cp -p'
  88
  89   AC_CHECK_TOOL(AS, as)
  90   AC_CHECK_TOOL(AR, ar)
  91   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
  92
  93   AM_MAINTAINER_MODE
  94
  95   # Set up safe default values for all subsequent AM_CONDITIONAL tests
  96   # which are themselves conditionally expanded.
  97   ## (Right now, this only matters for enable_wchar_t, but nothing prevents
  98   ## other macros from doing the same.  This should be automated.)  -pme
  99
 100   # Check for C library flavor since GNU/Linux platforms use different
 101   # configuration directories depending on the C library in use.
 102   AC_EGREP_CPP([_using_uclibc], [
 103   #include <stdio.h>
 104   #if __UCLIBC__
 105     _using_uclibc
 106   #endif
 107   ], uclibc=yes, uclibc=no)
 108
 109   AC_EGREP_CPP([_using_bionic], [
 110   #include <stdio.h>
 111   #if __BIONIC__
 112     _using_bionic
 113   #endif
 114   ], bionic=yes, bionic=no)
 115
 116   # Find platform-specific directories containing configuration info.
 117   # Also possibly modify flags used elsewhere, as needed by the platform.
 118   GLIBCXX_CHECK_HOST
 119 ])
 120
 121
 122 dnl
 123 dnl Tests for newer compiler features, or features that are present in newer
 124 dnl compiler versions but not older compiler versions still in use, should
 125 dnl be placed here.
 126 dnl
 127 dnl Defines:
 128 dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
 129 dnl   new inlining code or the new system_header pragma will die on -Werror.
 130 dnl   Leave it out by default and use maint-mode to use it.
 131 dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 132 dnl   compiler supports it and the user has not requested debug mode.
 133 dnl
 134 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
 135   # All these tests are for C++; save the language and the compiler flags.
 136   # The CXXFLAGS thing is suspicious, but based on similar bits previously
 137   # found in GLIBCXX_CONFIGURE.
 138   AC_LANG_SAVE
 139   AC_LANG_CPLUSPLUS
 140   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 141   ac_save_CXXFLAGS="$CXXFLAGS"
 142
 143   # Check for maintainer-mode bits.
 144   if test x"$USE_MAINTAINER_MODE" = xno; then
 145     WERROR=''
 146   else
 147     WERROR='-Werror'
 148   fi
 149
 150   # Check for -ffunction-sections -fdata-sections
 151   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
 152   CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
 153   AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
 154   if test "$ac_test_CXXFLAGS" = set; then
 155     CXXFLAGS="$ac_save_CXXFLAGS"
 156   else
 157     # this is the suspicious part
 158     CXXFLAGS=''
 159   fi
 160   if test x"$ac_fdsections" = x"yes"; then
 161     SECTION_FLAGS='-ffunction-sections -fdata-sections'
 162   fi
 163   AC_MSG_RESULT($ac_fdsections)
 164
 165   AC_LANG_RESTORE
 166   AC_SUBST(WERROR)
 167   AC_SUBST(SECTION_FLAGS)
 168 ])
 169
 170
 171 dnl
 172 dnl Check if the assembler used supports disabling generation of hardware
 173 dnl capabilities.  This is only supported by Sun as at the moment.
 174 dnl
 175 dnl Defines:
 176 dnl  HWCAP_FLAGS='-Wa,-nH' if possible.
 177 dnl
 178 AC_DEFUN([GLIBCXX_CHECK_ASSEMBLER_HWCAP], [
 179   test -z "$HWCAP_FLAGS" && HWCAP_FLAGS=''
 180
 181   # Restrict the test to Solaris, other assemblers (e.g. AIX as) have -nH
 182   # with a different meaning.
 183   case ${target_os} in
 184     solaris2*)
 185       ac_save_CFLAGS="$CFLAGS"
 186       CFLAGS="$CFLAGS -Wa,-nH"
 187
 188       AC_MSG_CHECKING([for as that supports -Wa,-nH])
 189       AC_TRY_COMPILE([], [return 0;], [ac_hwcap_flags=yes],[ac_hwcap_flags=no])
 190       if test "$ac_hwcap_flags" = "yes"; then
 191         HWCAP_FLAGS="-Wa,-nH $HWCAP_FLAGS"
 192       fi
 193       AC_MSG_RESULT($ac_hwcap_flags)
 194
 195       CFLAGS="$ac_save_CFLAGS"
 196       ;;
 197   esac
 198
 199   AC_SUBST(HWCAP_FLAGS)
 200 ])
 201
 202
 203 dnl
 204 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
 205 dnl the native linker is in use, all variables will be defined to something
 206 dnl safe (like an empty string).
 207 dnl
 208 dnl Defines:
 209 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
 210 dnl  OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
 211 dnl  LD (as a side effect of testing)
 212 dnl Sets:
 213 dnl  with_gnu_ld
 214 dnl  glibcxx_ld_is_gold (set to "no" or "yes")
 215 dnl  glibcxx_gnu_ld_version (possibly)
 216 dnl
 217 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
 218 dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
 219 dnl
 220 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
 221   # If we're not using GNU ld, then there's no point in even trying these
 222   # tests.  Check for that first.  We should have already tested for gld
 223   # by now (in libtool), but require it now just to be safe...
 224   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
 225   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
 226   AC_REQUIRE([AC_PROG_LD])
 227   AC_REQUIRE([AC_PROG_AWK])
 228
 229   # The name set by libtool depends on the version of libtool.  Shame on us
 230   # for depending on an impl detail, but c'est la vie.  Older versions used
 231   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
 232   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
 233   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
 234   # set (hence we're using an older libtool), then set it.
 235   if test x${with_gnu_ld+set} != xset; then
 236     if test x${ac_cv_prog_gnu_ld+set} != xset; then
 237       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
 238       with_gnu_ld=no
 239     else
 240       with_gnu_ld=$ac_cv_prog_gnu_ld
 241     fi
 242   fi
 243
 244   # Start by getting the version number.  I think the libtool test already
 245   # does some of this, but throws away the result.
 246   glibcxx_ld_is_gold=no
 247   if test x"$with_gnu_ld" = x"yes"; then
 248     AC_MSG_CHECKING([for ld version])
 249     changequote(,)
 250     if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
 251       glibcxx_ld_is_gold=yes
 252     fi
 253     ldver=`$LD --version 2>/dev/null |
 254            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'`
 255     changequote([,])
 256     glibcxx_gnu_ld_version=`echo $ldver | \
 257            $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
 258     AC_MSG_RESULT($glibcxx_gnu_ld_version)
 259   fi
 260
 261   # Set --gc-sections.
 262   glibcxx_have_gc_sections=no
 263   if test "$glibcxx_ld_is_gold" = "yes"; then
 264     if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
 265       glibcxx_have_gc_sections=yes
 266     fi
 267   else
 268     glibcxx_gcsections_min_ld=21602
 269     if test x"$with_gnu_ld" = x"yes" &&
 270         test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
 271       glibcxx_have_gc_sections=yes
 272     fi
 273   fi
 274   if test "$glibcxx_have_gc_sections" = "yes"; then
 275     # Sufficiently young GNU ld it is!  Joy and bunny rabbits!
 276     # NB: This flag only works reliably after 2.16.1. Configure tests
 277     # for this are difficult, so hard wire a value that should work.
 278
 279     ac_test_CFLAGS="${CFLAGS+set}"
 280     ac_save_CFLAGS="$CFLAGS"
 281     CFLAGS='-Wl,--gc-sections'
 282
 283     # Check for -Wl,--gc-sections
 284     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
 285     AC_TRY_LINK([ int one(void) { return 1; }
 286      int two(void) { return 2; }
 287         ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
 288     if test "$ac_gcsections" = "yes"; then
 289       rm -f conftest.c
 290       touch conftest.c
 291       if $CC -c conftest.c; then
 292         if $LD --gc-sections -o conftest conftest.o 2>&1 | \
 293            grep "Warning: gc-sections option ignored" > /dev/null; then
 294           ac_gcsections=no
 295         fi
 296       fi
 297       rm -f conftest.c conftest.o conftest
 298     fi
 299     if test "$ac_gcsections" = "yes"; then
 300       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
 301     fi
 302     AC_MSG_RESULT($ac_gcsections)
 303
 304     if test "$ac_test_CFLAGS" = set; then
 305       CFLAGS="$ac_save_CFLAGS"
 306     else
 307       # this is the suspicious part
 308       CFLAGS=''
 309     fi
 310   fi
 311
 312   # Set -z,relro.
 313   # Note this is only for shared objects.
 314   ac_ld_relro=no
 315   if test x"$with_gnu_ld" = x"yes"; then
 316     AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
 317     cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
 318     if test -n "$cxx_z_relo"; then
 319       OPT_LDFLAGS="-Wl,-z,relro"
 320       ac_ld_relro=yes
 321     fi
 322     AC_MSG_RESULT($ac_ld_relro)
 323   fi
 324
 325   # Set linker optimization flags.
 326   if test x"$with_gnu_ld" = x"yes"; then
 327     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
 328   fi
 329
 330   AC_SUBST(SECTION_LDFLAGS)
 331   AC_SUBST(OPT_LDFLAGS)
 332 ])
 333
 334
 335 dnl
 336 dnl Check for headers for, and arguments to, the setrlimit() function.
 337 dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
 338 dnl
 339 dnl Defines:
 340 dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits
 341 dnl  various HAVE_LIMIT_* for individual limit names
 342 dnl
 343 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
 344   AC_MSG_CHECKING([for RLIMIT_$1])
 345   AC_TRY_COMPILE(
 346     [#include <unistd.h>
 347      #include <sys/time.h>
 348      #include <sys/resource.h>
 349     ],
 350     [ int f = RLIMIT_$1 ; ],
 351     [glibcxx_mresult=1], [glibcxx_mresult=0])
 352   AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
 353                      [Only used in build directory testsuite_hooks.h.])
 354   if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
 355   AC_MSG_RESULT($res)
 356 ])
 357
 358 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
 359   setrlimit_have_headers=yes
 360   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
 361                    [],
 362                    [setrlimit_have_headers=no])
 363   # If don't have the headers, then we can't run the tests now, and we
 364   # won't be seeing any of these during testsuite compilation.
 365   if test $setrlimit_have_headers = yes; then
 366     # Can't do these in a loop, else the resulting syntax is wrong.
 367     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
 368     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
 369     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
 370     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
 371     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
 372
 373     # Check for rlimit, setrlimit.
 374     AC_CACHE_VAL(glibcxx_cv_setrlimit, [
 375       AC_TRY_COMPILE(
 376         [#include <unistd.h>
 377          #include <sys/time.h>
 378          #include <sys/resource.h>
 379         ],
 380         [struct rlimit r;
 381          setrlimit(0, &r);],
 382         [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
 383     ])
 384   fi
 385
 386   AC_MSG_CHECKING([for testsuite resource limits support])
 387   if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
 388     ac_res_limits=yes
 389     AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
 390               [Define if using setrlimit to set resource limits during
 391               "make check"])
 392   else
 393     ac_res_limits=no
 394   fi
 395   AC_MSG_RESULT($ac_res_limits)
 396 ])
 397
 398
 399 dnl
 400 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
 401 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
 402 dnl
 403 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
 404
 405   AC_LANG_SAVE
 406   AC_LANG_CPLUSPLUS
 407   ac_save_CXXFLAGS="$CXXFLAGS"
 408   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 409
 410   AC_MSG_CHECKING([for S_ISREG or S_IFREG])
 411   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
 412     GCC_TRY_COMPILE_OR_LINK(
 413       [#include <sys/stat.h>],
 414       [struct stat buffer;
 415        fstat(0, &buffer);
 416        S_ISREG(buffer.st_mode);],
 417       [glibcxx_cv_S_ISREG=yes],
 418       [glibcxx_cv_S_ISREG=no])
 419   ])
 420   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
 421     GCC_TRY_COMPILE_OR_LINK(
 422       [#include <sys/stat.h>],
 423       [struct stat buffer;
 424        fstat(0, &buffer);
 425        S_IFREG & buffer.st_mode;],
 426       [glibcxx_cv_S_IFREG=yes],
 427       [glibcxx_cv_S_IFREG=no])
 428   ])
 429   res=no
 430   if test $glibcxx_cv_S_ISREG = yes; then
 431     AC_DEFINE(HAVE_S_ISREG, 1,
 432               [Define if S_IFREG is available in <sys/stat.h>.])
 433     res=S_ISREG
 434   elif test $glibcxx_cv_S_IFREG = yes; then
 435     AC_DEFINE(HAVE_S_IFREG, 1,
 436               [Define if S_IFREG is available in <sys/stat.h>.])
 437     res=S_IFREG
 438   fi
 439   AC_MSG_RESULT($res)
 440
 441   CXXFLAGS="$ac_save_CXXFLAGS"
 442   AC_LANG_RESTORE
 443 ])
 444
 445
 446 dnl
 447 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
 448 dnl
 449 AC_DEFUN([GLIBCXX_CHECK_POLL], [
 450
 451   AC_LANG_SAVE
 452   AC_LANG_CPLUSPLUS
 453   ac_save_CXXFLAGS="$CXXFLAGS"
 454   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 455
 456   AC_MSG_CHECKING([for poll])
 457   AC_CACHE_VAL(glibcxx_cv_POLL, [
 458     GCC_TRY_COMPILE_OR_LINK(
 459       [#include <poll.h>],
 460       [struct pollfd pfd[1];
 461        pfd[0].events = POLLIN;
 462        poll(pfd, 1, 0);],
 463       [glibcxx_cv_POLL=yes],
 464       [glibcxx_cv_POLL=no])
 465   ])
 466   if test $glibcxx_cv_POLL = yes; then
 467     AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
 468   fi
 469   AC_MSG_RESULT($glibcxx_cv_POLL)
 470
 471   CXXFLAGS="$ac_save_CXXFLAGS"
 472   AC_LANG_RESTORE
 473 ])
 474
 475
 476 dnl
 477 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
 478 dnl
 479 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
 480
 481   AC_LANG_SAVE
 482   AC_LANG_CPLUSPLUS
 483   ac_save_CXXFLAGS="$CXXFLAGS"
 484   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 485
 486   AC_MSG_CHECKING([for writev])
 487   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
 488     GCC_TRY_COMPILE_OR_LINK(
 489       [#include <sys/uio.h>],
 490       [struct iovec iov[2];
 491        writev(0, iov, 0);],
 492       [glibcxx_cv_WRITEV=yes],
 493       [glibcxx_cv_WRITEV=no])
 494   ])
 495   if test $glibcxx_cv_WRITEV = yes; then
 496     AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
 497   fi
 498   AC_MSG_RESULT($glibcxx_cv_WRITEV)
 499
 500   CXXFLAGS="$ac_save_CXXFLAGS"
 501   AC_LANG_RESTORE
 502 ])
 503
 504
 505 dnl
 506 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
 507 dnl Also check whether int64_t is actually a typedef to long or long long.
 508 dnl
 509 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
 510
 511   AC_LANG_SAVE
 512   AC_LANG_CPLUSPLUS
 513
 514   AC_MSG_CHECKING([for int64_t])
 515   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
 516     AC_TRY_COMPILE(
 517       [#include <stdint.h>],
 518       [int64_t var;],
 519       [glibcxx_cv_INT64_T=yes],
 520       [glibcxx_cv_INT64_T=no])
 521   ])
 522
 523   if test $glibcxx_cv_INT64_T = yes; then
 524     AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
 525     AC_MSG_RESULT($glibcxx_cv_INT64_T)
 526
 527     AC_MSG_CHECKING([for int64_t as long])
 528     AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
 529       AC_TRY_COMPILE(
 530         [#include <stdint.h>
 531         template<typename, typename> struct same { enum { value = -1 }; };
 532         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
 533         int array[same<int64_t, long>::value];], [],
 534         [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
 535     ])
 536
 537     if test $glibcxx_cv_int64_t_long = yes; then
 538       AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
 539       AC_MSG_RESULT($glibcxx_cv_int64_t_long)
 540     fi
 541
 542     AC_MSG_CHECKING([for int64_t as long long])
 543     AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
 544       AC_TRY_COMPILE(
 545         [#include <stdint.h>
 546         template<typename, typename> struct same { enum { value = -1 }; };
 547         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
 548         int array[same<int64_t, long long>::value];], [],
 549         [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
 550     ])
 551
 552     if test $glibcxx_cv_int64_t_long_long = yes; then
 553       AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
 554       AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
 555     fi
 556   fi
 557
 558   AC_LANG_RESTORE
 559 ])
 560
 561
 562 dnl
 563 dnl Check whether LFS support is available.
 564 dnl
 565 AC_DEFUN([GLIBCXX_CHECK_LFS], [
 566   AC_LANG_SAVE
 567   AC_LANG_CPLUSPLUS
 568   ac_save_CXXFLAGS="$CXXFLAGS"
 569   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 570   AC_MSG_CHECKING([for LFS support])
 571   AC_CACHE_VAL(glibcxx_cv_LFS, [
 572     GCC_TRY_COMPILE_OR_LINK(
 573       [#include <unistd.h>
 574        #include <stdio.h>
 575        #include <sys/stat.h>
 576       ],
 577       [FILE* fp;
 578        fopen64("t", "w");
 579        fseeko64(fp, 0, SEEK_CUR);
 580        ftello64(fp);
 581        lseek64(1, 0, SEEK_CUR);
 582        struct stat64 buf;
 583        fstat64(1, &buf);],
 584       [glibcxx_cv_LFS=yes],
 585       [glibcxx_cv_LFS=no])
 586   ])
 587   if test $glibcxx_cv_LFS = yes; then
 588     AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
 589   fi
 590   AC_MSG_RESULT($glibcxx_cv_LFS)
 591   CXXFLAGS="$ac_save_CXXFLAGS"
 592   AC_LANG_RESTORE
 593 ])
 594
 595
 596 dnl
 597 dnl Check for whether a fully dynamic basic_string implementation should
 598 dnl be turned on, that does not put empty objects in per-process static
 599 dnl memory (mostly useful together with shared memory allocators, see PR
 600 dnl libstdc++/16612 for details).
 601 dnl
 602 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
 603 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
 604 dnl otherwise undefined
 605 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
 606 dnl       Where DEFAULT is either `yes' or `no'.
 607 dnl
 608 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
 609   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
 610   if test $enable_fully_dynamic_string = yes; then
 611     enable_fully_dynamic_string_def=1
 612   else
 613     enable_fully_dynamic_string_def=0
 614   fi
 615   AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
 616               [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
 617 ])
 618
 619
 620 dnl
 621 dnl Does any necessary configuration of the testsuite directory.  Generates
 622 dnl the testsuite_hooks.h header.
 623 dnl
 624 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
 625 dnl
 626 dnl Sets:
 627 dnl  enable_abi_check
 628 dnl  GLIBCXX_TEST_WCHAR_T
 629 dnl  GLIBCXX_TEST_THREAD
 630 dnl Substs:
 631 dnl  baseline_dir
 632 dnl  baseline_subdir_switch
 633 dnl
 634 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
 635   if $GLIBCXX_IS_NATIVE ; then
 636     # Do checks for resource limit functions.
 637     GLIBCXX_CHECK_SETRLIMIT
 638
 639     # Look for setenv, so that extended locale tests can be performed.
 640     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
 641   fi
 642
 643   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
 644      test $enable_symvers != no; then
 645     case "$host" in
 646       *-*-cygwin*)
 647         enable_abi_check=no ;;
 648       *)
 649         enable_abi_check=yes ;;
 650     esac
 651   else
 652     # Only build this as native, since automake does not understand
 653     # CXX_FOR_BUILD.
 654     enable_abi_check=no
 655   fi
 656
 657   # Export file names for ABI checking.
 658   baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
 659   AC_SUBST(baseline_dir)
 660   baseline_subdir_switch="$abi_baseline_subdir_switch"
 661   AC_SUBST(baseline_subdir_switch)
 662 ])
 663
 664
 665 dnl
 666 dnl Does any necessary configuration for docbook in the docs directory.
 667 dnl
 668 dnl XSLTPROC must be set before this
 669 dnl
 670 dnl Sets:
 671 dnl  glibcxx_stylesheets
 672 dnl Substs:
 673 dnl  XSL_STYLE_DIR
 674 dnl
 675 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
 676
 677 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
 678 glibcxx_stylesheets=no
 679 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then
 680   glibcxx_stylesheets=yes
 681 fi
 682 AC_MSG_RESULT($glibcxx_stylesheets)
 683
 684 AC_MSG_CHECKING([for local stylesheet directory])
 685 glibcxx_local_stylesheets=no
 686 if test x"$glibcxx_stylesheets" = x"yes"; then
 687   if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then
 688     glibcxx_local_stylesheets=yes
 689     XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets
 690   fi
 691   if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then
 692     glibcxx_local_stylesheets=yes
 693     XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
 694   fi
 695   if test -d /usr/share/xml/docbook/stylesheet/nwalsh5/current; then
 696     glibcxx_local_stylesheets=yes
 697     XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/nwalsh5/current
 698   fi
 699 fi
 700 AC_MSG_RESULT($glibcxx_local_stylesheets)
 701
 702 if test x"$glibcxx_local_stylesheets" = x"yes"; then
 703   AC_SUBST(XSL_STYLE_DIR)
 704   AC_MSG_NOTICE($XSL_STYLE_DIR)
 705 else
 706   glibcxx_stylesheets=no
 707 fi
 708
 709 # Check for epub3 dependencies.
 710 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
 711 glibcxx_epub_stylesheets=no
 712 if test x"$glibcxx_local_stylesheets" = x"yes"; then
 713    if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
 714       glibcxx_epub_stylesheets=yes
 715    fi
 716 fi
 717 AC_MSG_RESULT($glibcxx_epub_stylesheets)
 718 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
 719
 720 ])
 721
 722
 723 dnl
 724 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
 725 dnl
 726 dnl Substs:
 727 dnl  GLIBCXX_INCLUDES
 728 dnl  TOPLEVEL_INCLUDES
 729 dnl
 730 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
 731   # Used for every C++ compile we perform.
 732   GLIBCXX_INCLUDES="\
 733 -I$glibcxx_builddir/include/$host_alias \
 734 -I$glibcxx_builddir/include \
 735 -I$glibcxx_srcdir/libsupc++"
 736
 737   # For Canadian crosses, pick this up too.
 738   if test $CANADIAN = yes; then
 739     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
 740   fi
 741
 742   # Stuff in the actual top level.  Currently only used by libsupc++ to
 743   # get unwind* headers from the libgcc dir.
 744   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
 745   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
 746
 747   # Now, export this to all the little Makefiles....
 748   AC_SUBST(GLIBCXX_INCLUDES)
 749   AC_SUBST(TOPLEVEL_INCLUDES)
 750 ])
 751
 752
 753 dnl
 754 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
 755 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
 756 dnl
 757 dnl Substs:
 758 dnl  OPTIMIZE_CXXFLAGS
 759 dnl  WARN_FLAGS
 760 dnl
 761 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
 762   # Optimization flags that are probably a good idea for thrill-seekers. Just
 763   # uncomment the lines below and make, everything else is ready to go...
 764   # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
 765   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
 766   AC_SUBST(OPTIMIZE_CXXFLAGS)
 767
 768   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi'
 769   AC_SUBST(WARN_FLAGS)
 770 ])
 771
 772
 773 dnl
 774 dnl All installation directory information is determined here.
 775 dnl
 776 dnl Substs:
 777 dnl  gxx_install_dir
 778 dnl  glibcxx_prefixdir
 779 dnl  glibcxx_toolexecdir
 780 dnl  glibcxx_toolexeclibdir
 781 dnl
 782 dnl Assumes cross_compiling bits already done, and with_cross_host in
 783 dnl particular.
 784 dnl
 785 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
 786 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
 787 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
 788   glibcxx_toolexecdir=no
 789   glibcxx_toolexeclibdir=no
 790   glibcxx_prefixdir=$prefix
 791
 792   AC_MSG_CHECKING([for gxx-include-dir])
 793   AC_ARG_WITH([gxx-include-dir],
 794     AC_HELP_STRING([--with-gxx-include-dir=DIR],
 795                    [installation directory for include files]),
 796     [case "$withval" in
 797       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
 798       no)  gxx_include_dir=no ;;
 799       *)   gxx_include_dir=$withval ;;
 800      esac],
 801     [gxx_include_dir=no])
 802   AC_MSG_RESULT($gxx_include_dir)
 803
 804   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
 805   AC_ARG_ENABLE([version-specific-runtime-libs],
 806     AC_HELP_STRING([--enable-version-specific-runtime-libs],
 807                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
 808     [case "$enableval" in
 809       yes) version_specific_libs=yes ;;
 810       no)  version_specific_libs=no ;;
 811       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
 812      esac],
 813     [version_specific_libs=no])
 814   AC_MSG_RESULT($version_specific_libs)
 815
 816   # Default case for install directory for include files.
 817   if test $version_specific_libs = no && test $gxx_include_dir = no; then
 818     gxx_include_dir='include/c++/${gcc_version}'
 819     if test -n "$with_cross_host" &&
 820        test x"$with_cross_host" != x"no"; then
 821       gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
 822     else
 823       gxx_include_dir='${prefix}/'"$gxx_include_dir"
 824     fi
 825   fi
 826
 827   # Version-specific runtime libs processing.
 828   if test $version_specific_libs = yes; then
 829     # Need the gcc compiler version to know where to install libraries
 830     # and header files if --enable-version-specific-runtime-libs option
 831     # is selected.  FIXME: these variables are misnamed, there are
 832     # no executables installed in _toolexecdir or _toolexeclibdir.
 833     if test x"$gxx_include_dir" = x"no"; then
 834       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
 835     fi
 836     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 837     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
 838   fi
 839
 840   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
 841   # Install a library built with a cross compiler in tooldir, not libdir.
 842   if test x"$glibcxx_toolexecdir" = x"no"; then
 843     if test -n "$with_cross_host" &&
 844        test x"$with_cross_host" != x"no"; then
 845       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
 846       glibcxx_toolexeclibdir='${toolexecdir}/lib'
 847     else
 848       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 849       glibcxx_toolexeclibdir='${libdir}'
 850     fi
 851     multi_os_directory=`$CXX -print-multi-os-directory`
 852     case $multi_os_directory in
 853       .) ;; # Avoid trailing /.
 854       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
 855     esac
 856   fi
 857
 858   AC_MSG_CHECKING([for install location])
 859   AC_MSG_RESULT($gxx_include_dir)
 860
 861   AC_SUBST(glibcxx_prefixdir)
 862   AC_SUBST(gxx_include_dir)
 863   AC_SUBST(glibcxx_toolexecdir)
 864   AC_SUBST(glibcxx_toolexeclibdir)
 865 ])
 866
 867
 868 dnl
 869 dnl GLIBCXX_ENABLE
 870 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
 871 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
 872 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
 873 dnl
 874 dnl See manual/appendix_porting.html#appendix.porting.build_hacking for
 875 dnl documentation.
 876 dnl
 877 m4_define([GLIBCXX_ENABLE],[dnl
 878 m4_define([_g_switch],[--enable-$1])dnl
 879 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
 880  AC_ARG_ENABLE([$1],m4_dquote(_g_help),
 881   m4_bmatch([$5],
 882    [^permit ],
 883      [[
 884       case "$enableval" in
 885        m4_bpatsubst([$5],[permit ])) ;;
 886        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
 887           dnl Idea for future:  generate a URL pointing to
 888           dnl "onlinedocs/configopts.html#whatever"
 889       esac
 890      ]],
 891    [^$],
 892      [[
 893       case "$enableval" in
 894        yes|no) ;;
 895        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
 896       esac
 897      ]],
 898    [[$5]]),
 899   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
 900 m4_undefine([_g_switch])dnl
 901 m4_undefine([_g_help])dnl
 902 ])
 903
 904
 905 dnl
 906 dnl Check for ISO/IEC 9899:1999 "C99" support.
 907 dnl
 908 dnl --enable-c99 defines _GLIBCXX_USE_C99
 909 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
 910 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
 911 dnl       Where DEFAULT is either `yes' or `no'.
 912 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
 913 dnl
 914 AC_DEFUN([GLIBCXX_ENABLE_C99], [
 915   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
 916
 917   if test x"$enable_c99" = x"yes"; then
 918     AC_LANG_SAVE
 919     AC_LANG_CPLUSPLUS
 920
 921     # Use -std=c++98 (instead of -std=gnu++98) because leaving __STRICT_ANSI__
 922     # undefined may cause fake C99 facilities, like pre-standard snprintf,
 923     # to be spuriously enabled.
 924     ac_save_CXXFLAGS="$CXXFLAGS"
 925     CXXFLAGS="$CXXFLAGS -std=c++98"
 926     ac_save_LIBS="$LIBS"
 927     ac_save_gcc_no_link="$gcc_no_link"
 928
 929     if test x$gcc_no_link != xyes; then
 930       # Use -fno-exceptions to that the C driver can link these tests without
 931       # hitting undefined references to personality routines.
 932       CXXFLAGS="$CXXFLAGS -fno-exceptions"
 933       AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
 934         # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
 935         gcc_no_link=yes
 936       ])
 937     fi
 938
 939     # Check for the existence of <math.h> functions used if C99 is enabled.
 940     AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++98])
 941     AC_CACHE_VAL(glibcxx_cv_c99_math_cxx98, [
 942       GCC_TRY_COMPILE_OR_LINK(
 943         [#include <math.h>
 944          volatile double d1, d2;
 945          volatile int i;],
 946         [i = fpclassify(d1);
 947          i = isfinite(d1);
 948          i = isinf(d1);
 949          i = isnan(d1);
 950          i = isnormal(d1);
 951          i = signbit(d1);
 952          i = isgreater(d1, d2);
 953          i = isgreaterequal(d1, d2);
 954          i = isless(d1, d2);
 955          i = islessequal(d1, d2);
 956          i = islessgreater(d1, d2);
 957          i = islessgreater(d1, d2);
 958          i = isunordered(d1, d2);
 959         ], [glibcxx_cv_c99_math_cxx98=yes], [glibcxx_cv_c99_math_cxx98=no])
 960     ])
 961     AC_MSG_RESULT($glibcxx_cv_c99_math_cxx98)
 962     if test x"$glibcxx_cv_c99_math_cxx98" = x"yes"; then
 963       AC_DEFINE(_GLIBCXX98_USE_C99_MATH, 1,
 964         [Define if C99 functions or macros in <math.h> should be imported
 965         in <cmath> in namespace std for C++98.])
 966     fi
 967
 968     # Check for the existence of <complex.h> complex math functions.
 969     # This is necessary even though libstdc++ uses the builtin versions
 970     # of these functions, because if the builtin cannot be used, a reference
 971     # to the library function is emitted.
 972     AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
 973     AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 974     if test x"$ac_has_complex_h" = x"yes"; then
 975       AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++98])
 976       AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx98, [
 977         GCC_TRY_COMPILE_OR_LINK(
 978           [#include <complex.h>
 979            typedef __complex__ float float_type;
 980            typedef __complex__ double double_type;
 981            typedef __complex__ long double ld_type;
 982            volatile float_type tmpf;
 983            volatile double_type tmpd;
 984            volatile ld_type tmpld;
 985            volatile float f;
 986            volatile double d;
 987            volatile long double ld;],
 988           [f = cabsf(tmpf);
 989            f = cargf(tmpf);
 990            tmpf = ccosf(tmpf);
 991            tmpf = ccoshf(tmpf);
 992            tmpf = cexpf(tmpf);
 993            tmpf = clogf(tmpf);
 994            tmpf = csinf(tmpf);
 995            tmpf = csinhf(tmpf);
 996            tmpf = csqrtf(tmpf);
 997            tmpf = ctanf(tmpf);
 998            tmpf = ctanhf(tmpf);
 999            tmpf = cpowf(tmpf, tmpf);
1000            tmpf = cprojf(tmpf);
1001            d = cabs(tmpd);
1002            d = carg(tmpd);
1003            tmpd = ccos(tmpd);
1004            tmpd = ccosh(tmpd);
1005            tmpd = cexp(tmpd);
1006            tmpd = clog(tmpd);
1007            tmpd = csin(tmpd);
1008            tmpd = csinh(tmpd);
1009            tmpd = csqrt(tmpd);
1010            tmpd = ctan(tmpd);
1011            tmpd = ctanh(tmpd);
1012            tmpd = cpow(tmpd, tmpd);
1013            tmpd = cproj(tmpd);
1014            ld = cabsl(tmpld);
1015            ld = cargl(tmpld);
1016            tmpld = ccosl(tmpld);
1017            tmpld = ccoshl(tmpld);
1018            tmpld = cexpl(tmpld);
1019            tmpld = clogl(tmpld);
1020            tmpld = csinl(tmpld);
1021            tmpld = csinhl(tmpld);
1022            tmpld = csqrtl(tmpld);
1023            tmpld = ctanl(tmpld);
1024            tmpld = ctanhl(tmpld);
1025            tmpld = cpowl(tmpld, tmpld);
1026            tmpld = cprojl(tmpld);
1027           ], [glibcxx_cv_c99_complex_cxx98=yes], [glibcxx_cv_c99_complex_cxx98=no])
1028       ])
1029     fi
1030     AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx98)
1031     if test x"$glibcxx_cv_c99_complex_cxx98" = x"yes"; then
1032       AC_DEFINE(_GLIBCXX98_USE_C99_COMPLEX, 1,
1033         [Define if C99 functions in <complex.h> should be used in
1034         <complex> for C++98. Using compiler builtins for these functions
1035         requires corresponding C99 library functions to be present.])
1036     fi
1037
1038     # Check for the existence in <stdio.h> of vscanf, et. al.
1039     AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++98])
1040     AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx98, [
1041       GCC_TRY_COMPILE_OR_LINK(
1042         [#include <stdio.h>
1043          #include <stdarg.h>
1044          void foo(char* fmt, ...)
1045          {
1046            va_list args; va_start(args, fmt);
1047            vfscanf(stderr, "%i", args);
1048            vscanf("%i", args);
1049            vsnprintf(fmt, 0, "%i", args);
1050            vsscanf(fmt, "%i", args);
1051            snprintf(fmt, 0, "%i");
1052          }], [],
1053         [glibcxx_cv_c99_stdio_cxx98=yes], [glibcxx_cv_c99_stdio_cxx98=no])
1054     ])
1055     AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx98)
1056     if test x"$glibcxx_cv_c99_stdio_cxx98" = x"yes"; then
1057       AC_DEFINE(_GLIBCXX98_USE_C99_STDIO, 1,
1058         [Define if C99 functions or macros in <stdio.h> should be imported
1059         in <cstdio> in namespace std for C++98.])
1060     fi
1061
1062     # Check for the existence in <wchar.h> of wcstold, etc.
1063     if test x"$ac_has_wchar_h" = xyes &&
1064        test x"$ac_has_wctype_h" = xyes; then
1065       AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++98])
1066       AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx98, [
1067         AC_TRY_COMPILE([#include <wchar.h>
1068           namespace test
1069           {
1070             using ::wcstold;
1071             using ::wcstoll;
1072             using ::wcstoull;
1073           }
1074         ], [], [glibcxx_cv_c99_wchar_cxx98=yes], [glibcxx_cv_c99_wchar_cxx98=no])
1075       ])
1076
1077       # Checks for wide character functions that may not be present.
1078       # Injection of these is wrapped with guard macros.
1079       # NB: only put functions here, instead of immediately above, if
1080       # absolutely necessary.
1081       AC_TRY_COMPILE([#include <wchar.h>
1082         namespace test { using ::vfwscanf; }], [],
1083         [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1084
1085       AC_TRY_COMPILE([#include <wchar.h>
1086         namespace test { using ::vswscanf; }], [],
1087         [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1088
1089       AC_TRY_COMPILE([#include <wchar.h>
1090         namespace test { using ::vwscanf; }], [],
1091         [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1092
1093       AC_TRY_COMPILE([#include <wchar.h>
1094         namespace test { using ::wcstof; }], [],
1095         [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1096
1097       AC_TRY_COMPILE([#include <wctype.h>],
1098         [wint_t t; int i = iswblank(t);],
1099         [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1100
1101       AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx98)
1102       if test x"$glibcxx_cv_c99_wchar_cxx98" = x"yes"; then
1103         AC_DEFINE(_GLIBCXX98_USE_C99_WCHAR, 1,
1104           [Define if C99 functions or macros in <wchar.h> should be imported
1105           in <cwchar> in namespace std for C++98.])
1106       fi
1107     fi
1108
1109     # Option parsed, now set things appropriately.
1110     if test x"$glibcxx_cv_c99_math_cxx98" = x"no" ||
1111        test x"$glibcxx_cv_c99_complex_cxx98" = x"no" ||
1112        test x"$glibcxx_cv_c99_stdio_cxx98" = x"no" ||
1113        test x"$glibcxx_cv_c99_stdlib_cxx98" = x"no" ||
1114        test x"$glibcxx_cv_c99_wchar_cxx98" = x"no"; then
1115       enable_c99=no;
1116     else
1117       AC_DEFINE(_GLIBCXX_USE_C99, 1,
1118         [Define if C99 functions or macros from <wchar.h>, <math.h>,
1119         <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1120     fi
1121
1122     gcc_no_link="$ac_save_gcc_no_link"
1123     LIBS="$ac_save_LIBS"
1124     CXXFLAGS="$ac_save_CXXFLAGS"
1125     AC_LANG_RESTORE
1126
1127     AC_LANG_SAVE
1128     AC_LANG_CPLUSPLUS
1129
1130     # Use -std=c++11 and test again for C99 library feature in C++11 mode.
1131     # For the reasons given above we use -std=c++11 not -std=gnu++11.
1132     ac_save_CXXFLAGS="$CXXFLAGS"
1133     CXXFLAGS="$CXXFLAGS -std=c++11"
1134     ac_save_LIBS="$LIBS"
1135     ac_save_gcc_no_link="$gcc_no_link"
1136
1137     if test x$gcc_no_link != xyes; then
1138       # Use -fno-exceptions to that the C driver can link these tests without
1139       # hitting undefined references to personality routines.
1140       CXXFLAGS="$CXXFLAGS -fno-exceptions"
1141       AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
1142         # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
1143         gcc_no_link=yes
1144       ])
1145     fi
1146
1147     # Check for the existence of <math.h> functions used if C99 is enabled.
1148     AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++11])
1149     AC_CACHE_VAL(glibcxx_cv_c99_math_cxx11, [
1150       GCC_TRY_COMPILE_OR_LINK(
1151         [#include <math.h>
1152          volatile double d1, d2;
1153          volatile int i;],
1154         [i = fpclassify(d1);
1155          i = isfinite(d1);
1156          i = isinf(d1);
1157          i = isnan(d1);
1158          i = isnormal(d1);
1159          i = signbit(d1);
1160          i = isgreater(d1, d2);
1161          i = isgreaterequal(d1, d2);
1162          i = isless(d1, d2);
1163          i = islessequal(d1, d2);
1164          i = islessgreater(d1, d2);
1165          i = islessgreater(d1, d2);
1166          i = isunordered(d1, d2);
1167         ], [glibcxx_cv_c99_math_cxx11=yes], [glibcxx_cv_c99_math_cxx11=no])
1168     ])
1169     AC_MSG_RESULT($glibcxx_cv_c99_math_cxx11)
1170     if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
1171       AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
1172         [Define if C99 functions or macros in <math.h> should be imported
1173         in <cmath> in namespace std for C++11.])
1174     fi
1175
1176     # Check for the existence of <complex.h> complex math functions.
1177     # This is necessary even though libstdc++ uses the builtin versions
1178     # of these functions, because if the builtin cannot be used, a reference
1179     # to the library function is emitted.
1180     AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
1181     AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1182     if test x"$ac_has_complex_h" = x"yes"; then
1183       AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++11])
1184       AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx11, [
1185         GCC_TRY_COMPILE_OR_LINK(
1186           [#include <complex.h>
1187            typedef __complex__ float float_type;
1188            typedef __complex__ double double_type;
1189            typedef __complex__ long double ld_type;
1190            volatile float_type tmpf;
1191            volatile double_type tmpd;
1192            volatile ld_type tmpld;
1193            volatile float f;
1194            volatile double d;
1195            volatile long double ld;],
1196           [f = cabsf(tmpf);
1197            f = cargf(tmpf);
1198            tmpf = ccosf(tmpf);
1199            tmpf = ccoshf(tmpf);
1200            tmpf = cexpf(tmpf);
1201            tmpf = clogf(tmpf);
1202            tmpf = csinf(tmpf);
1203            tmpf = csinhf(tmpf);
1204            tmpf = csqrtf(tmpf);
1205            tmpf = ctanf(tmpf);
1206            tmpf = ctanhf(tmpf);
1207            tmpf = cpowf(tmpf, tmpf);
1208            tmpf = cprojf(tmpf);
1209            d = cabs(tmpd);
1210            d = carg(tmpd);
1211            tmpd = ccos(tmpd);
1212            tmpd = ccosh(tmpd);
1213            tmpd = cexp(tmpd);
1214            tmpd = clog(tmpd);
1215            tmpd = csin(tmpd);
1216            tmpd = csinh(tmpd);
1217            tmpd = csqrt(tmpd);
1218            tmpd = ctan(tmpd);
1219            tmpd = ctanh(tmpd);
1220            tmpd = cpow(tmpd, tmpd);
1221            tmpd = cproj(tmpd);
1222            ld = cabsl(tmpld);
1223            ld = cargl(tmpld);
1224            tmpld = ccosl(tmpld);
1225            tmpld = ccoshl(tmpld);
1226            tmpld = cexpl(tmpld);
1227            tmpld = clogl(tmpld);
1228            tmpld = csinl(tmpld);
1229            tmpld = csinhl(tmpld);
1230            tmpld = csqrtl(tmpld);
1231            tmpld = ctanl(tmpld);
1232            tmpld = ctanhl(tmpld);
1233            tmpld = cpowl(tmpld, tmpld);
1234            tmpld = cprojl(tmpld);
1235           ], [glibcxx_cv_c99_complex_cxx11=yes], [glibcxx_cv_c99_complex_cxx11=no])
1236       ])
1237     fi
1238     AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx11)
1239     if test x"$glibcxx_cv_c99_complex_cxx11" = x"yes"; then
1240       AC_DEFINE(_GLIBCXX11_USE_C99_COMPLEX, 1,
1241         [Define if C99 functions in <complex.h> should be used in
1242         <complex> for C++11. Using compiler builtins for these functions
1243         requires corresponding C99 library functions to be present.])
1244     fi
1245
1246     # Check for the existence in <stdio.h> of vscanf, et. al.
1247     AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++11])
1248     AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx11, [
1249       GCC_TRY_COMPILE_OR_LINK(
1250         [#include <stdio.h>
1251          #include <stdarg.h>
1252          void foo(char* fmt, ...)
1253          {
1254            va_list args; va_start(args, fmt);
1255            vfscanf(stderr, "%i", args);
1256            vscanf("%i", args);
1257            vsnprintf(fmt, 0, "%i", args);
1258            vsscanf(fmt, "%i", args);
1259            snprintf(fmt, 0, "%i");
1260          }], [],
1261         [glibcxx_cv_c99_stdio_cxx11=yes], [glibcxx_cv_c99_stdio_cxx11=no])
1262     ])
1263     AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx11)
1264     if test x"$glibcxx_cv_c99_stdio_cxx11" = x"yes"; then
1265       AC_DEFINE(_GLIBCXX11_USE_C99_STDIO, 1,
1266         [Define if C99 functions or macros in <stdio.h> should be imported
1267         in <cstdio> in namespace std for C++11.])
1268     fi
1269
1270     # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1271     AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++11])
1272     AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx11, [
1273       GCC_TRY_COMPILE_OR_LINK(
1274         [#include <stdlib.h>
1275          volatile float f;
1276          volatile long double ld;
1277          volatile unsigned long long ll;
1278          lldiv_t mydivt;],
1279         [char* tmp;
1280          f = strtof("gnu", &tmp);
1281          ld = strtold("gnu", &tmp);
1282          ll = strtoll("gnu", &tmp, 10);
1283          ll = strtoull("gnu", &tmp, 10);
1284          ll = llabs(10);
1285          mydivt = lldiv(10,1);
1286          ll = mydivt.quot;
1287          ll = mydivt.rem;
1288          ll = atoll("10");
1289          _Exit(0);
1290         ], [glibcxx_cv_c99_stdlib_cxx11=yes], [glibcxx_cv_c99_stdlib_cxx11=no])
1291     ])
1292     AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx11)
1293     if test x"$glibcxx_cv_c99_stdlib_cxx11" = x"yes"; then
1294       AC_DEFINE(_GLIBCXX11_USE_C99_STDLIB, 1,
1295         [Define if C99 functions or macros in <stdlib.h> should be imported
1296         in <cstdlib> in namespace std for C++11.])
1297     fi
1298
1299     # Check for the existence in <wchar.h> of wcstold, etc.
1300     if test x"$ac_has_wchar_h" = xyes &&
1301        test x"$ac_has_wctype_h" = xyes; then
1302       AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++11])
1303       AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx11, [
1304         AC_TRY_COMPILE([#include <wchar.h>
1305           namespace test
1306           {
1307             using ::wcstold;
1308             using ::wcstoll;
1309             using ::wcstoull;
1310           }
1311         ], [], [glibcxx_cv_c99_wchar_cxx11=yes], [glibcxx_cv_c99_wchar_cxx11=no])
1312       ])
1313
1314       # Checks for wide character functions that may not be present.
1315       # Injection of these is wrapped with guard macros.
1316       # NB: only put functions here, instead of immediately above, if
1317       # absolutely necessary.
1318       AC_TRY_COMPILE([#include <wchar.h>
1319         namespace test { using ::vfwscanf; }], [],
1320         [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1321
1322       AC_TRY_COMPILE([#include <wchar.h>
1323         namespace test { using ::vswscanf; }], [],
1324         [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1325
1326       AC_TRY_COMPILE([#include <wchar.h>
1327         namespace test { using ::vwscanf; }], [],
1328         [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1329
1330       AC_TRY_COMPILE([#include <wchar.h>
1331         namespace test { using ::wcstof; }], [],
1332         [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1333
1334       AC_TRY_COMPILE([#include <wctype.h>],
1335         [wint_t t; int i = iswblank(t);],
1336         [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1337
1338       AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx11)
1339       if test x"$glibcxx_cv_c99_wchar_cxx11" = x"yes"; then
1340         AC_DEFINE(_GLIBCXX11_USE_C99_WCHAR, 1,
1341           [Define if C99 functions or macros in <wchar.h> should be imported
1342           in <cwchar> in namespace std for C++11.])
1343       fi
1344     fi
1345
1346     gcc_no_link="$ac_save_gcc_no_link"
1347     LIBS="$ac_save_LIBS"
1348     CXXFLAGS="$ac_save_CXXFLAGS"
1349     AC_LANG_RESTORE
1350   fi
1351
1352   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1353   AC_MSG_RESULT($enable_c99)
1354 ])
1355
1356
1357 dnl
1358 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1359 dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this]
1360 dnl in the C++11 standard.
1361 dnl
1362 dnl --enable-libstdcxx-time
1363 dnl --enable-libstdcxx-time=yes
1364 dnl        checks for the availability of monotonic and realtime clocks,
1365 dnl        nanosleep and sched_yield in libc and libposix4 and, if needed,
1366 dnl        links in the latter.
1367 dnl --enable-libstdcxx-time=rt
1368 dnl        also searches (and, if needed, links) librt.  Note that this is
1369 dnl        not always desirable because, in glibc 2.16 and earlier, for
1370 dnl        example, in turn it triggers the linking of libpthread too,
1371 dnl        which activates locking,
1372 dnl        a large overhead for single-thread programs.
1373 dnl --enable-libstdcxx-time=no
1374 dnl --disable-libstdcxx-time
1375 dnl        disables the checks completely
1376 dnl
1377 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1378 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1379 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1380 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1381 dnl
1382 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1383
1384   GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]],
1385     [use KIND for check type],
1386     [permit yes|no|rt])
1387
1388   AC_LANG_SAVE
1389   AC_LANG_CPLUSPLUS
1390   ac_save_CXXFLAGS="$CXXFLAGS"
1391   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1392   ac_save_LIBS="$LIBS"
1393
1394   ac_has_clock_monotonic=no
1395   ac_has_clock_realtime=no
1396   ac_has_nanosleep=no
1397   ac_has_sched_yield=no
1398
1399   if test x"$enable_libstdcxx_time" = x"auto"; then
1400
1401     case "${target_os}" in
1402       cygwin*)
1403         ac_has_nanosleep=yes
1404         ;;
1405       darwin*)
1406         ac_has_nanosleep=yes
1407         ac_has_sched_yield=yes
1408         ;;
1409       gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
1410         AC_MSG_CHECKING([for at least GNU libc 2.17])
1411         AC_TRY_COMPILE(
1412           [#include <features.h>],
1413           [
1414           #if ! __GLIBC_PREREQ(2, 17)
1415           #error
1416           #endif
1417           ],
1418           [glibcxx_glibc217=yes], [glibcxx_glibc217=no])
1419         AC_MSG_RESULT($glibcxx_glibc217)
1420
1421         if test x"$glibcxx_glibc217" = x"yes"; then
1422           ac_has_clock_monotonic=yes
1423           ac_has_clock_realtime=yes
1424         fi
1425         ac_has_nanosleep=yes
1426         ac_has_sched_yield=yes
1427         ;;
1428       freebsd*|netbsd*|dragonfly*)
1429         ac_has_clock_monotonic=yes
1430         ac_has_clock_realtime=yes
1431         ac_has_nanosleep=yes
1432         ac_has_sched_yield=yes
1433         ;;
1434       openbsd*)
1435         ac_has_clock_monotonic=yes
1436         ac_has_clock_realtime=yes
1437         ac_has_nanosleep=yes
1438         ;;
1439       solaris*)
1440         GLIBCXX_LIBS="$GLIBCXX_LIBS -lrt"
1441         ac_has_clock_monotonic=yes
1442         ac_has_clock_realtime=yes
1443         ac_has_nanosleep=yes
1444         ac_has_sched_yield=yes
1445         ;;
1446     esac
1447
1448   elif test x"$enable_libstdcxx_time" != x"no"; then
1449
1450     if test x"$enable_libstdcxx_time" = x"rt"; then
1451       AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1452       AC_SEARCH_LIBS(nanosleep, [rt posix4])
1453     else
1454       AC_SEARCH_LIBS(clock_gettime, [posix4])
1455       AC_SEARCH_LIBS(nanosleep, [posix4])
1456     fi
1457
1458     case "$ac_cv_search_clock_gettime" in
1459       -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1460       ;;
1461     esac
1462     case "$ac_cv_search_nanosleep" in
1463       -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1464       ;;
1465     esac
1466
1467     AC_SEARCH_LIBS(sched_yield, [rt posix4])
1468
1469     case "$ac_cv_search_sched_yield" in
1470       -lposix4*)
1471       GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1472       ac_has_sched_yield=yes
1473       ;;
1474       -lrt*)
1475       if test x"$enable_libstdcxx_time" = x"rt"; then
1476         GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1477         ac_has_sched_yield=yes
1478       fi
1479       ;;
1480       *)
1481       ac_has_sched_yield=yes
1482       ;;
1483     esac
1484
1485     AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1486
1487     if test x"$ac_has_unistd_h" = x"yes"; then
1488       AC_MSG_CHECKING([for monotonic clock])
1489       AC_TRY_LINK(
1490         [#include <unistd.h>
1491          #include <time.h>
1492         ],
1493         [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1494           timespec tp;
1495          #endif
1496           clock_gettime(CLOCK_MONOTONIC, &tp);
1497         ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1498
1499       AC_MSG_RESULT($ac_has_clock_monotonic)
1500
1501       AC_MSG_CHECKING([for realtime clock])
1502       AC_TRY_LINK(
1503         [#include <unistd.h>
1504          #include <time.h>
1505         ],
1506         [#if _POSIX_TIMERS > 0
1507           timespec tp;
1508          #endif
1509           clock_gettime(CLOCK_REALTIME, &tp);
1510         ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1511
1512       AC_MSG_RESULT($ac_has_clock_realtime)
1513
1514       AC_MSG_CHECKING([for nanosleep])
1515       AC_TRY_LINK(
1516         [#include <unistd.h>
1517          #include <time.h>
1518         ],
1519         [#if _POSIX_TIMERS > 0
1520           timespec tp;
1521          #endif
1522           nanosleep(&tp, 0);
1523         ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1524
1525       AC_MSG_RESULT($ac_has_nanosleep)
1526     fi
1527   fi
1528
1529   if test x"$ac_has_clock_monotonic" != x"yes"; then
1530     case ${target_os} in
1531       linux*)
1532         AC_MSG_CHECKING([for clock_gettime syscall])
1533         AC_TRY_COMPILE(
1534           [#include <unistd.h>
1535            #include <time.h>
1536            #include <sys/syscall.h>
1537           ],
1538           [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1539             timespec tp;
1540            #endif
1541            syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp);
1542            syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp);
1543           ], [ac_has_clock_monotonic_syscall=yes], [ac_has_clock_monotonic_syscall=no])
1544         AC_MSG_RESULT($ac_has_clock_monotonic_syscall)
1545         if test x"$ac_has_clock_monotonic_syscall" = x"yes"; then
1546           AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1,
1547           [ Defined if clock_gettime syscall has monotonic and realtime clock support. ])
1548           ac_has_clock_monotonic=yes
1549           ac_has_clock_realtime=yes
1550         fi;;
1551     esac
1552   fi
1553
1554   if test x"$ac_has_clock_monotonic" = x"yes"; then
1555     AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1556       [ Defined if clock_gettime has monotonic clock support. ])
1557   fi
1558
1559   if test x"$ac_has_clock_realtime" = x"yes"; then
1560     AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1561       [ Defined if clock_gettime has realtime clock support. ])
1562   fi
1563
1564   if test x"$ac_has_sched_yield" = x"yes"; then
1565     AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1566               [ Defined if sched_yield is available. ])
1567   fi
1568
1569   if test x"$ac_has_nanosleep" = x"yes"; then
1570     AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1571       [ Defined if nanosleep is available. ])
1572   else
1573       AC_MSG_CHECKING([for sleep])
1574       AC_TRY_COMPILE([#include <unistd.h>],
1575                      [sleep(1)],
1576                      [ac_has_sleep=yes],[ac_has_sleep=no])
1577       if test x"$ac_has_sleep" = x"yes"; then
1578         AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.])
1579       fi
1580       AC_MSG_RESULT($ac_has_sleep)
1581       AC_MSG_CHECKING([for usleep])
1582       AC_TRY_COMPILE([#include <unistd.h>],
1583                      [sleep(1);
1584                       usleep(100);],
1585                      [ac_has_usleep=yes],[ac_has_usleep=no])
1586       if test x"$ac_has_usleep" = x"yes"; then
1587         AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.])
1588       fi
1589       AC_MSG_RESULT($ac_has_usleep)
1590   fi
1591
1592   if test x"$ac_has_nanosleep$ac_has_sleep" = x"nono"; then
1593       AC_MSG_CHECKING([for Sleep])
1594       AC_TRY_COMPILE([#include <windows.h>],
1595                      [Sleep(1)],
1596                      [ac_has_win32_sleep=yes],[ac_has_win32_sleep=no])
1597       if test x"$ac_has_win32_sleep" = x"yes"; then
1598         AC_DEFINE(HAVE_WIN32_SLEEP,1, [Defined if Sleep exists.])
1599       fi
1600       AC_MSG_RESULT($ac_has_win32_sleep)
1601   fi
1602
1603   AC_SUBST(GLIBCXX_LIBS)
1604
1605   CXXFLAGS="$ac_save_CXXFLAGS"
1606   LIBS="$ac_save_LIBS"
1607   AC_LANG_RESTORE
1608 ])
1609
1610 dnl
1611 dnl Check for gettimeofday, used in the implementation of 20.11.7
1612 dnl [time.clock] in the C++11 standard.
1613 dnl
1614 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1615
1616   AC_MSG_CHECKING([for gettimeofday])
1617
1618   AC_LANG_SAVE
1619   AC_LANG_CPLUSPLUS
1620   ac_save_CXXFLAGS="$CXXFLAGS"
1621   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1622
1623   ac_has_gettimeofday=no;
1624   AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1625   if test x"$ac_has_sys_time_h" = x"yes"; then
1626     AC_MSG_CHECKING([for gettimeofday])
1627     GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1628       [timeval tv; gettimeofday(&tv, 0);],
1629       [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1630
1631     AC_MSG_RESULT($ac_has_gettimeofday)
1632   fi
1633
1634   if test x"$ac_has_gettimeofday" = x"yes"; then
1635     AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1636       [ Defined if gettimeofday is available. ])
1637   fi
1638
1639   CXXFLAGS="$ac_save_CXXFLAGS"
1640   AC_LANG_RESTORE
1641 ])
1642
1643 dnl
1644 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1645 dnl facilities in Chapter 8, "C compatibility".
1646 dnl
1647 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1648
1649   AC_LANG_SAVE
1650   AC_LANG_CPLUSPLUS
1651
1652   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1653   # undefined and fake C99 facilities may be spuriously enabled.
1654   ac_save_CXXFLAGS="$CXXFLAGS"
1655   CXXFLAGS="$CXXFLAGS -std=c++98"
1656
1657   # Check for the existence of <complex.h> complex math functions used
1658   # by tr1/complex.
1659   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1660   ac_c99_complex_tr1=no;
1661   if test x"$ac_has_complex_h" = x"yes"; then
1662     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1663     AC_TRY_COMPILE([#include <complex.h>],
1664                    [typedef __complex__ float float_type; float_type tmpf;
1665                     cacosf(tmpf);
1666                     casinf(tmpf);
1667                     catanf(tmpf);
1668                     cacoshf(tmpf);
1669                     casinhf(tmpf);
1670                     catanhf(tmpf);
1671                     typedef __complex__ double double_type; double_type tmpd;
1672                     cacos(tmpd);
1673                     casin(tmpd);
1674                     catan(tmpd);
1675                     cacosh(tmpd);
1676                     casinh(tmpd);
1677                     catanh(tmpd);
1678                     typedef __complex__ long double ld_type; ld_type tmpld;
1679                     cacosl(tmpld);
1680                     casinl(tmpld);
1681                     catanl(tmpld);
1682                     cacoshl(tmpld);
1683                     casinhl(tmpld);
1684                     catanhl(tmpld);
1685                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1686   fi
1687   AC_MSG_RESULT($ac_c99_complex_tr1)
1688   if test x"$ac_c99_complex_tr1" = x"yes"; then
1689     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1690               [Define if C99 functions in <complex.h> should be used in
1691               <tr1/complex>. Using compiler builtins for these functions
1692               requires corresponding C99 library functions to be present.])
1693   fi
1694
1695   # Check for the existence of <ctype.h> functions.
1696   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1697   AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1698   AC_TRY_COMPILE([#include <ctype.h>],
1699                  [int ch;
1700                   int ret;
1701                   ret = isblank(ch);
1702                  ],[glibcxx_cv_c99_ctype_tr1=yes],
1703                    [glibcxx_cv_c99_ctype_tr1=no])
1704   ])
1705   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1706   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1707     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1708               [Define if C99 functions in <ctype.h> should be imported in
1709               <tr1/cctype> in namespace std::tr1.])
1710   fi
1711
1712   # Check for the existence of <fenv.h> functions.
1713   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1714   ac_c99_fenv_tr1=no;
1715   if test x"$ac_has_fenv_h" = x"yes"; then
1716     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1717     AC_TRY_COMPILE([#include <fenv.h>],
1718                    [int except, mode;
1719                     fexcept_t* pflag;
1720                     fenv_t* penv;
1721                     int ret;
1722                     ret = feclearexcept(except);
1723                     ret = fegetexceptflag(pflag, except);
1724                     ret = feraiseexcept(except);
1725                     ret = fesetexceptflag(pflag, except);
1726                     ret = fetestexcept(except);
1727                     ret = fegetround();
1728                     ret = fesetround(mode);
1729                     ret = fegetenv(penv);
1730                     ret = feholdexcept(penv);
1731                     ret = fesetenv(penv);
1732                     ret = feupdateenv(penv);
1733                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1734   fi
1735   AC_MSG_RESULT($ac_c99_fenv_tr1)
1736   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1737     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1738               [Define if C99 functions in <fenv.h> should be imported in
1739               <tr1/cfenv> in namespace std::tr1.])
1740   fi
1741
1742   # Check for the existence of <stdint.h> types.
1743   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1744   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1745   AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1746                   #define __STDC_CONSTANT_MACROS
1747                   #include <stdint.h>],
1748                  [typedef int8_t          my_int8_t;
1749                   my_int8_t               i8 = INT8_MIN;
1750                   i8 = INT8_MAX;
1751                   typedef int16_t         my_int16_t;
1752                   my_int16_t              i16 = INT16_MIN;
1753                   i16 = INT16_MAX;
1754                   typedef int32_t         my_int32_t;
1755                   my_int32_t              i32 = INT32_MIN;
1756                   i32 = INT32_MAX;
1757                   typedef int64_t         my_int64_t;
1758                   my_int64_t              i64 = INT64_MIN;
1759                   i64 = INT64_MAX;
1760                   typedef int_fast8_t     my_int_fast8_t;
1761                   my_int_fast8_t          if8 = INT_FAST8_MIN;
1762                   if8 = INT_FAST8_MAX;
1763                   typedef int_fast16_t    my_int_fast16_t;
1764                   my_int_fast16_t         if16 = INT_FAST16_MIN;
1765                   if16 = INT_FAST16_MAX;
1766                   typedef int_fast32_t    my_int_fast32_t;
1767                   my_int_fast32_t         if32 = INT_FAST32_MIN;
1768                   if32 = INT_FAST32_MAX;
1769                   typedef int_fast64_t    my_int_fast64_t;
1770                   my_int_fast64_t         if64 = INT_FAST64_MIN;
1771                   if64 = INT_FAST64_MAX;
1772                   typedef int_least8_t    my_int_least8_t;
1773                   my_int_least8_t         il8 = INT_LEAST8_MIN;
1774                   il8 = INT_LEAST8_MAX;
1775                   typedef int_least16_t   my_int_least16_t;
1776                   my_int_least16_t        il16 = INT_LEAST16_MIN;
1777                   il16 = INT_LEAST16_MAX;
1778                   typedef int_least32_t   my_int_least32_t;
1779                   my_int_least32_t        il32 = INT_LEAST32_MIN;
1780                   il32 = INT_LEAST32_MAX;
1781                   typedef int_least64_t   my_int_least64_t;
1782                   my_int_least64_t        il64 = INT_LEAST64_MIN;
1783                   il64 = INT_LEAST64_MAX;
1784                   typedef intmax_t        my_intmax_t;
1785                   my_intmax_t             im = INTMAX_MAX;
1786                   im = INTMAX_MIN;
1787                   typedef intptr_t        my_intptr_t;
1788                   my_intptr_t             ip = INTPTR_MAX;
1789                   ip = INTPTR_MIN;
1790                   typedef uint8_t         my_uint8_t;
1791                   my_uint8_t              ui8 = UINT8_MAX;
1792                   ui8 = UINT8_MAX;
1793                   typedef uint16_t        my_uint16_t;
1794                   my_uint16_t             ui16 = UINT16_MAX;
1795                   ui16 = UINT16_MAX;
1796                   typedef uint32_t        my_uint32_t;
1797                   my_uint32_t             ui32 = UINT32_MAX;
1798                   ui32 = UINT32_MAX;
1799                   typedef uint64_t        my_uint64_t;
1800                   my_uint64_t             ui64 = UINT64_MAX;
1801                   ui64 = UINT64_MAX;
1802                   typedef uint_fast8_t    my_uint_fast8_t;
1803                   my_uint_fast8_t         uif8 = UINT_FAST8_MAX;
1804                   uif8 = UINT_FAST8_MAX;
1805                   typedef uint_fast16_t   my_uint_fast16_t;
1806                   my_uint_fast16_t        uif16 = UINT_FAST16_MAX;
1807                   uif16 = UINT_FAST16_MAX;
1808                   typedef uint_fast32_t   my_uint_fast32_t;
1809                   my_uint_fast32_t        uif32 = UINT_FAST32_MAX;
1810                   uif32 = UINT_FAST32_MAX;
1811                   typedef uint_fast64_t   my_uint_fast64_t;
1812                   my_uint_fast64_t        uif64 = UINT_FAST64_MAX;
1813                   uif64 = UINT_FAST64_MAX;
1814                   typedef uint_least8_t   my_uint_least8_t;
1815                   my_uint_least8_t        uil8 = UINT_LEAST8_MAX;
1816                   uil8 = UINT_LEAST8_MAX;
1817                   typedef uint_least16_t  my_uint_least16_t;
1818                   my_uint_least16_t       uil16 = UINT_LEAST16_MAX;
1819                   uil16 = UINT_LEAST16_MAX;
1820                   typedef uint_least32_t  my_uint_least32_t;
1821                   my_uint_least32_t       uil32 = UINT_LEAST32_MAX;
1822                   uil32 = UINT_LEAST32_MAX;
1823                   typedef uint_least64_t  my_uint_least64_t;
1824                   my_uint_least64_t       uil64 = UINT_LEAST64_MAX;
1825                   uil64 = UINT_LEAST64_MAX;
1826                   typedef uintmax_t       my_uintmax_t;
1827                   my_uintmax_t            uim = UINTMAX_MAX;
1828                   uim = UINTMAX_MAX;
1829                   typedef uintptr_t       my_uintptr_t;
1830                   my_uintptr_t            uip = UINTPTR_MAX;
1831                   uip = UINTPTR_MAX;
1832                  ],[glibcxx_cv_c99_stdint_tr1=yes],
1833                    [glibcxx_cv_c99_stdint_tr1=no])
1834   ])
1835   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1836   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1837     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1838               [Define if C99 types in <stdint.h> should be imported in
1839               <tr1/cstdint> in namespace std::tr1.])
1840   fi
1841
1842   # Check for the existence of <math.h> functions.
1843   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1844   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1845   AC_TRY_COMPILE([#include <math.h>],
1846                  [typedef double_t  my_double_t;
1847                   typedef float_t   my_float_t;
1848                   acosh(0.0);
1849                   acoshf(0.0f);
1850                   acoshl(0.0l);
1851                   asinh(0.0);
1852                   asinhf(0.0f);
1853                   asinhl(0.0l);
1854                   atanh(0.0);
1855                   atanhf(0.0f);
1856                   atanhl(0.0l);
1857                   cbrt(0.0);
1858                   cbrtf(0.0f);
1859                   cbrtl(0.0l);
1860                   copysign(0.0, 0.0);
1861                   copysignf(0.0f, 0.0f);
1862                   copysignl(0.0l, 0.0l);
1863                   erf(0.0);
1864                   erff(0.0f);
1865                   erfl(0.0l);
1866                   erfc(0.0);
1867                   erfcf(0.0f);
1868                   erfcl(0.0l);
1869                   exp2(0.0);
1870                   exp2f(0.0f);
1871                   exp2l(0.0l);
1872                   expm1(0.0);
1873                   expm1f(0.0f);
1874                   expm1l(0.0l);
1875                   fdim(0.0, 0.0);
1876                   fdimf(0.0f, 0.0f);
1877                   fdiml(0.0l, 0.0l);
1878                   fma(0.0, 0.0, 0.0);
1879                   fmaf(0.0f, 0.0f, 0.0f);
1880                   fmal(0.0l, 0.0l, 0.0l);
1881                   fmax(0.0, 0.0);
1882                   fmaxf(0.0f, 0.0f);
1883                   fmaxl(0.0l, 0.0l);
1884                   fmin(0.0, 0.0);
1885                   fminf(0.0f, 0.0f);
1886                   fminl(0.0l, 0.0l);
1887                   hypot(0.0, 0.0);
1888                   hypotf(0.0f, 0.0f);
1889                   hypotl(0.0l, 0.0l);
1890                   ilogb(0.0);
1891                   ilogbf(0.0f);
1892                   ilogbl(0.0l);
1893                   lgamma(0.0);
1894                   lgammaf(0.0f);
1895                   lgammal(0.0l);
1896                   llrint(0.0);
1897                   llrintf(0.0f);
1898                   llrintl(0.0l);
1899                   llround(0.0);
1900                   llroundf(0.0f);
1901                   llroundl(0.0l);
1902                   log1p(0.0);
1903                   log1pf(0.0f);
1904                   log1pl(0.0l);
1905                   log2(0.0);
1906                   log2f(0.0f);
1907                   log2l(0.0l);
1908                   logb(0.0);
1909                   logbf(0.0f);
1910                   logbl(0.0l);
1911                   lrint(0.0);
1912                   lrintf(0.0f);
1913                   lrintl(0.0l);
1914                   lround(0.0);
1915                   lroundf(0.0f);
1916                   lroundl(0.0l);
1917                   nan(0);
1918                   nanf(0);
1919                   nanl(0);
1920                   nearbyint(0.0);
1921                   nearbyintf(0.0f);
1922                   nearbyintl(0.0l);
1923                   nextafter(0.0, 0.0);
1924                   nextafterf(0.0f, 0.0f);
1925                   nextafterl(0.0l, 0.0l);
1926                   nexttoward(0.0, 0.0);
1927                   nexttowardf(0.0f, 0.0f);
1928                   nexttowardl(0.0l, 0.0l);
1929                   remainder(0.0, 0.0);
1930                   remainderf(0.0f, 0.0f);
1931                   remainderl(0.0l, 0.0l);
1932                   remquo(0.0, 0.0, 0);
1933                   remquof(0.0f, 0.0f, 0);
1934                   remquol(0.0l, 0.0l, 0);
1935                   rint(0.0);
1936                   rintf(0.0f);
1937                   rintl(0.0l);
1938                   round(0.0);
1939                   roundf(0.0f);
1940                   roundl(0.0l);
1941                   scalbln(0.0, 0l);
1942                   scalblnf(0.0f, 0l);
1943                   scalblnl(0.0l, 0l);
1944                   scalbn(0.0, 0);
1945                   scalbnf(0.0f, 0);
1946                   scalbnl(0.0l, 0);
1947                   tgamma(0.0);
1948                   tgammaf(0.0f);
1949                   tgammal(0.0l);
1950                   trunc(0.0);
1951                   truncf(0.0f);
1952                   truncl(0.0l);
1953                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1954   ])
1955   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1956   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1957     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1958               [Define if C99 functions or macros in <math.h> should be imported
1959               in <tr1/cmath> in namespace std::tr1.])
1960   fi
1961
1962   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1963   # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1964   ac_c99_inttypes_tr1=no;
1965   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1966     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1967     AC_TRY_COMPILE([#include <inttypes.h>],
1968                    [intmax_t i, numer, denom, base;
1969                     const char* s;
1970                     char** endptr;
1971                     intmax_t ret = imaxabs(i);
1972                     imaxdiv_t dret = imaxdiv(numer, denom);
1973                     ret = strtoimax(s, endptr, base);
1974                     uintmax_t uret = strtoumax(s, endptr, base);
1975                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1976   fi
1977   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1978   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1979     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1980               [Define if C99 functions in <inttypes.h> should be imported in
1981               <tr1/cinttypes> in namespace std::tr1.])
1982   fi
1983
1984   # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
1985   # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1986   ac_c99_inttypes_wchar_t_tr1=no;
1987   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1988     AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1989     AC_TRY_COMPILE([#include <inttypes.h>],
1990                    [intmax_t base;
1991                     const wchar_t* s;
1992                     wchar_t** endptr;
1993                     intmax_t ret = wcstoimax(s, endptr, base);
1994                     uintmax_t uret = wcstoumax(s, endptr, base);
1995                    ],[ac_c99_inttypes_wchar_t_tr1=yes],
1996                      [ac_c99_inttypes_wchar_t_tr1=no])
1997   fi
1998   AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1999   if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
2000     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
2001               [Define if wchar_t C99 functions in <inttypes.h> should be
2002               imported in <tr1/cinttypes> in namespace std::tr1.])
2003   fi
2004
2005   # Check for the existence of the <stdbool.h> header.
2006   AC_CHECK_HEADERS(stdbool.h)
2007
2008   # Check for the existence of the <stdalign.h> header.
2009   AC_CHECK_HEADERS(stdalign.h)
2010
2011   CXXFLAGS="$ac_save_CXXFLAGS"
2012   AC_LANG_RESTORE
2013 ])
2014
2015 dnl
2016 dnl Check for uchar.h and usability.
2017 dnl
2018 AC_DEFUN([GLIBCXX_CHECK_UCHAR_H], [
2019
2020   # Test uchar.h.
2021   AC_CHECK_HEADERS(uchar.h, ac_has_uchar_h=yes, ac_has_uchar_h=no)
2022
2023   AC_LANG_SAVE
2024   AC_LANG_CPLUSPLUS
2025   ac_save_CXXFLAGS="$CXXFLAGS"
2026   CXXFLAGS="$CXXFLAGS -std=c++11"
2027
2028   if test x"$ac_has_uchar_h" = x"yes"; then
2029     AC_MSG_CHECKING([for ISO C11 support for <uchar.h>])
2030     AC_TRY_COMPILE([#include <uchar.h>
2031                     #ifdef __STDC_UTF_16__
2032                     long i = __STDC_UTF_16__;
2033                     #endif
2034                     #ifdef __STDC_UTF_32__
2035                     long j = __STDC_UTF_32__;
2036                     #endif
2037                     namespace test
2038                     {
2039                       using ::c16rtomb;
2040                       using ::c32rtomb;
2041                       using ::mbrtoc16;
2042                       using ::mbrtoc32;
2043                     }
2044                    ],
2045                    [], [ac_c11_uchar_cxx11=yes], [ac_c11_uchar_cxx11=no])
2046   else
2047     ac_c11_uchar_cxx11=no
2048   fi
2049   AC_MSG_RESULT($ac_c11_uchar_cxx11)
2050   if test x"$ac_c11_uchar_cxx11" = x"yes"; then
2051     AC_DEFINE(_GLIBCXX_USE_C11_UCHAR_CXX11, 1,
2052               [Define if C11 functions in <uchar.h> should be imported into
2053               namespace std in <cuchar>.])
2054   fi
2055
2056   CXXFLAGS="$ac_save_CXXFLAGS"
2057   AC_LANG_RESTORE
2058 ])
2059
2060
2061 dnl
2062 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
2063 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
2064 dnl
2065 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
2066
2067   AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
2068   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
2069     if test -r /dev/random && test -r /dev/urandom; then
2070   ## For MSys environment the test above is detect as false-positive
2071   ## on mingw-targets.  So disable it explicit for them.
2072       case ${target_os} in
2073         *mingw*) glibcxx_cv_random_tr1=no ;;
2074         *) glibcxx_cv_random_tr1=yes ;;
2075       esac
2076     else
2077       glibcxx_cv_random_tr1=no;
2078     fi
2079   ])
2080   AC_MSG_RESULT($glibcxx_cv_random_tr1)
2081
2082   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
2083     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
2084               [Define if /dev/random and /dev/urandom are available for
2085                the random_device of TR1 (Chapter 5.1).])
2086   fi
2087
2088 ])
2089
2090 dnl
2091 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
2092 dnl
2093 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
2094
2095   AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
2096   AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
2097                  [#include <stdio.h>],
2098                  [AC_MSG_ERROR([computing EOF failed])])
2099   ])
2100   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
2101                      [Define to the value of the EOF integer constant.])
2102
2103   AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
2104   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
2105                  [#include <stdio.h>],
2106                  [AC_MSG_ERROR([computing SEEK_CUR failed])])
2107   ])
2108   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
2109                      [Define to the value of the SEEK_CUR integer constant.])
2110
2111   AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
2112   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
2113                  [#include <stdio.h>],
2114                  [AC_MSG_ERROR([computing SEEK_END failed])])
2115   ])
2116   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
2117                      [Define to the value of the SEEK_END integer constant.])
2118 ])
2119
2120 dnl
2121 dnl Check whether required C++ overloads are present in <stdio.h>.
2122 dnl
2123 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
2124
2125   AC_LANG_SAVE
2126   AC_LANG_CPLUSPLUS
2127
2128   AC_MSG_CHECKING([for gets declaration])
2129   AC_CACHE_VAL(glibcxx_cv_gets, [
2130   AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2131           [#include <stdio.h>
2132            namespace test
2133            {
2134               using ::gets;
2135            }
2136         ])],
2137         [glibcxx_cv_gets=yes],
2138         [glibcxx_cv_gets=no]
2139       )])
2140
2141   if test $glibcxx_cv_gets = yes; then
2142     AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h>.])
2143   fi
2144   AC_MSG_RESULT($glibcxx_cv_gets)
2145
2146   AC_LANG_RESTORE
2147 ])
2148
2149 dnl
2150 dnl Check whether macros, etc are present for <system_error>
2151 dnl
2152 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
2153
2154 m4_pushdef([n_syserr], [1])dnl
2155 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
2156                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
2157                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
2158                       ECHILD, ENOSPC, EPERM,
2159                       ETIMEDOUT, EWOULDBLOCK],
2160 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
2161 AC_MSG_CHECKING([for syserr])
2162 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
2163 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
2164                                    [int i = syserr;])],
2165                   [glibcxx_cv_system_error[]n_syserr=yes],
2166                   [glibcxx_cv_system_error[]n_syserr=no])
2167 ])
2168 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
2169 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
2170   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
2171 fi
2172 m4_define([n_syserr], m4_incr(n_syserr))dnl
2173 m4_popdef([SYSERR])dnl
2174 ])
2175 m4_popdef([n_syserr])dnl
2176 ])
2177
2178 dnl
2179 dnl Check for what type of C headers to use.
2180 dnl
2181 dnl --enable-cheaders= [does stuff].
2182 dnl --disable-cheaders [does not do anything, really].
2183 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
2184 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
2185 dnl
2186 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
2187   GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
2188     [construct "C" headers for g++], [permit c|c_std|c_global])
2189   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
2190
2191   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
2192
2193   # Allow overrides to configure.host here.
2194   if test $enable_cheaders = c_global; then
2195      c_compatibility=yes
2196   fi
2197
2198   AC_SUBST(C_INCLUDE_DIR)
2199   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
2200   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
2201   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
2202   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
2203 ])
2204
2205
2206 dnl
2207 dnl Check for which locale library to use.  The choice is mapped to
2208 dnl a subdirectory of config/locale.
2209 dnl
2210 dnl Default is generic.
2211 dnl
2212 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
2213   GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
2214     [use MODEL for target locale package],
2215     [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
2216
2217   # Deal with gettext issues.  Default to not using it (=no) until we detect
2218   # support for it later.  Let the user turn it off via --e/d, but let that
2219   # default to on for easier handling.
2220   USE_NLS=no
2221   AC_ARG_ENABLE(nls,
2222     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
2223     [],
2224     [enable_nls=yes])
2225
2226   # Either a known package, or "auto"
2227   if test $enable_clocale = no || test $enable_clocale = yes; then
2228      enable_clocale=auto
2229   fi
2230   enable_clocale_flag=$enable_clocale
2231
2232   # Probe for locale model to use if none specified.
2233   # Default to "generic".
2234   if test $enable_clocale_flag = auto; then
2235     case ${target_os} in
2236       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2237         enable_clocale_flag=gnu
2238         ;;
2239       darwin* | freebsd*)
2240         enable_clocale_flag=darwin
2241         ;;
2242       dragonfly*)
2243         enable_clocale_flag=dragonfly
2244         ;;
2245       openbsd*)
2246         enable_clocale_flag=newlib
2247         ;;
2248       *)
2249         if test x"$with_newlib" = x"yes"; then
2250           enable_clocale_flag=newlib
2251         else
2252           enable_clocale_flag=generic
2253         fi
2254         ;;
2255     esac
2256   fi
2257
2258   # Sanity check model, and test for special functionality.
2259   if test $enable_clocale_flag = gnu; then
2260     AC_EGREP_CPP([_GLIBCXX_ok], [
2261     #include <features.h>
2262     #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
2263       _GLIBCXX_ok
2264     #endif
2265     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
2266
2267     # Set it to scream when it hurts.
2268     ac_save_CFLAGS="$CFLAGS"
2269     CFLAGS="-Wimplicit-function-declaration -Werror"
2270
2271     # Use strxfrm_l if available.
2272     AC_TRY_COMPILE([#define _GNU_SOURCE 1
2273                     #include <string.h>
2274                     #include <locale.h>],
2275                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
2276                     AC_DEFINE(HAVE_STRXFRM_L, 1,
2277                     [Define if strxfrm_l is available in <string.h>.]),)
2278
2279     # Use strerror_l if available.
2280     AC_TRY_COMPILE([#define _GNU_SOURCE 1
2281                     #include <string.h>
2282                     #include <locale.h>],
2283                     [__locale_t loc; strerror_l(5, loc);],
2284                     AC_DEFINE(HAVE_STRERROR_L, 1,
2285                     [Define if strerror_l is available in <string.h>.]),)
2286
2287     CFLAGS="$ac_save_CFLAGS"
2288   fi
2289
2290   # Perhaps use strerror_r if available, and strerror_l isn't.
2291   ac_save_CFLAGS="$CFLAGS"
2292   CFLAGS="-Wimplicit-function-declaration -Werror"
2293   AC_TRY_COMPILE([#define _GNU_SOURCE 1
2294                   #include <string.h>
2295                   #include <locale.h>],
2296                   [char s[128]; strerror_r(5, s, 128);],
2297                   AC_DEFINE(HAVE_STRERROR_R, 1,
2298                   [Define if strerror_r is available in <string.h>.]),)
2299   CFLAGS="$ac_save_CFLAGS"
2300
2301   # Set configure bits for specified locale package
2302   AC_MSG_CHECKING([for C locale to use])
2303   case ${enable_clocale_flag} in
2304     generic)
2305       AC_MSG_RESULT(generic)
2306
2307       CLOCALE_H=config/locale/generic/c_locale.h
2308       CLOCALE_CC=config/locale/generic/c_locale.cc
2309       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2310       CCOLLATE_CC=config/locale/generic/collate_members.cc
2311       CCTYPE_CC=config/locale/generic/ctype_members.cc
2312       CMESSAGES_H=config/locale/generic/messages_members.h
2313       CMESSAGES_CC=config/locale/generic/messages_members.cc
2314       CMONEY_CC=config/locale/generic/monetary_members.cc
2315       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2316       CTIME_H=config/locale/generic/time_members.h
2317       CTIME_CC=config/locale/generic/time_members.cc
2318       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2319       ;;
2320     darwin)
2321       AC_MSG_RESULT(darwin or freebsd)
2322
2323       CLOCALE_H=config/locale/generic/c_locale.h
2324       CLOCALE_CC=config/locale/generic/c_locale.cc
2325       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2326       CCOLLATE_CC=config/locale/generic/collate_members.cc
2327       CCTYPE_CC=config/locale/darwin/ctype_members.cc
2328       CMESSAGES_H=config/locale/generic/messages_members.h
2329       CMESSAGES_CC=config/locale/generic/messages_members.cc
2330       CMONEY_CC=config/locale/generic/monetary_members.cc
2331       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2332       CTIME_H=config/locale/generic/time_members.h
2333       CTIME_CC=config/locale/generic/time_members.cc
2334       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2335       ;;
2336
2337     dragonfly)
2338       AC_MSG_RESULT(dragonfly)
2339
2340       CLOCALE_H=config/locale/dragonfly/c_locale.h
2341       CLOCALE_CC=config/locale/dragonfly/c_locale.cc
2342       CCODECVT_CC=config/locale/dragonfly/codecvt_members.cc
2343       CCOLLATE_CC=config/locale/dragonfly/collate_members.cc
2344       CCTYPE_CC=config/locale/dragonfly/ctype_members.cc
2345       CMESSAGES_H=config/locale/generic/messages_members.h
2346       CMESSAGES_CC=config/locale/generic/messages_members.cc
2347       CMONEY_CC=config/locale/dragonfly/monetary_members.cc
2348       CNUMERIC_CC=config/locale/dragonfly/numeric_members.cc
2349       CTIME_H=config/locale/dragonfly/time_members.h
2350       CTIME_CC=config/locale/dragonfly/time_members.cc
2351       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2352       ;;
2353
2354     gnu)
2355       AC_MSG_RESULT(gnu)
2356
2357       # Declare intention to use gettext, and add support for specific
2358       # languages.
2359       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2360       ALL_LINGUAS="de fr"
2361
2362       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2363       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2364       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2365         USE_NLS=yes
2366       fi
2367       # Export the build objects.
2368       for ling in $ALL_LINGUAS; do \
2369         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2370         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2371       done
2372       AC_SUBST(glibcxx_MOFILES)
2373       AC_SUBST(glibcxx_POFILES)
2374
2375       CLOCALE_H=config/locale/gnu/c_locale.h
2376       CLOCALE_CC=config/locale/gnu/c_locale.cc
2377       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2378       CCOLLATE_CC=config/locale/gnu/collate_members.cc
2379       CCTYPE_CC=config/locale/gnu/ctype_members.cc
2380       CMESSAGES_H=config/locale/gnu/messages_members.h
2381       CMESSAGES_CC=config/locale/gnu/messages_members.cc
2382       CMONEY_CC=config/locale/gnu/monetary_members.cc
2383       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2384       CTIME_H=config/locale/gnu/time_members.h
2385       CTIME_CC=config/locale/gnu/time_members.cc
2386       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2387       ;;
2388     ieee_1003.1-2001)
2389       AC_MSG_RESULT(IEEE 1003.1)
2390
2391       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2392       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2393       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2394       CCOLLATE_CC=config/locale/generic/collate_members.cc
2395       CCTYPE_CC=config/locale/generic/ctype_members.cc
2396       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2397       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2398       CMONEY_CC=config/locale/generic/monetary_members.cc
2399       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2400       CTIME_H=config/locale/generic/time_members.h
2401       CTIME_CC=config/locale/generic/time_members.cc
2402       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2403       ;;
2404     newlib)
2405       AC_MSG_RESULT(newlib)
2406
2407       CLOCALE_H=config/locale/generic/c_locale.h
2408       CLOCALE_CC=config/locale/generic/c_locale.cc
2409       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2410       CCOLLATE_CC=config/locale/generic/collate_members.cc
2411       CCTYPE_CC=config/locale/newlib/ctype_members.cc
2412       CMESSAGES_H=config/locale/generic/messages_members.h
2413       CMESSAGES_CC=config/locale/generic/messages_members.cc
2414       CMONEY_CC=config/locale/generic/monetary_members.cc
2415       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2416       CTIME_H=config/locale/generic/time_members.h
2417       CTIME_CC=config/locale/generic/time_members.cc
2418       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2419       ;;
2420   esac
2421
2422   # This is where the testsuite looks for locale catalogs, using the
2423   # -DLOCALEDIR define during testsuite compilation.
2424   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2425   AC_SUBST(glibcxx_localedir)
2426
2427   # A standalone libintl (e.g., GNU libintl) may be in use.
2428   if test $USE_NLS = yes; then
2429     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2430     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2431   fi
2432   if test $USE_NLS = yes; then
2433     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2434               [Define if NLS translations are to be used.])
2435   fi
2436
2437   AC_SUBST(USE_NLS)
2438   AC_SUBST(CLOCALE_H)
2439   AC_SUBST(CMESSAGES_H)
2440   AC_SUBST(CCODECVT_CC)
2441   AC_SUBST(CCOLLATE_CC)
2442   AC_SUBST(CCTYPE_CC)
2443   AC_SUBST(CMESSAGES_CC)
2444   AC_SUBST(CMONEY_CC)
2445   AC_SUBST(CNUMERIC_CC)
2446   AC_SUBST(CTIME_H)
2447   AC_SUBST(CTIME_CC)
2448   AC_SUBST(CLOCALE_CC)
2449   AC_SUBST(CLOCALE_INTERNAL_H)
2450 ])
2451
2452
2453 dnl
2454 dnl Check for which std::allocator base class to use.  The choice is
2455 dnl mapped from a subdirectory of include/ext.
2456 dnl
2457 dnl Default is new.
2458 dnl
2459 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2460   AC_MSG_CHECKING([for std::allocator base class])
2461   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2462     [use KIND for target std::allocator base],
2463     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2464
2465   # If they didn't use this option switch, or if they specified --enable
2466   # with no specific model, we'll have to look for one.  If they
2467   # specified --disable (???), do likewise.
2468   if test $enable_libstdcxx_allocator = no ||
2469      test $enable_libstdcxx_allocator = yes;
2470   then
2471      enable_libstdcxx_allocator=auto
2472   fi
2473
2474   # Either a known package, or "auto". Auto implies the default choice
2475   # for a particular platform.
2476   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2477
2478   # Probe for host-specific support if no specific model is specified.
2479   # Default to "new".
2480   if test $enable_libstdcxx_allocator_flag = auto; then
2481     case ${target_os} in
2482       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2483         enable_libstdcxx_allocator_flag=new
2484         ;;
2485       *)
2486         enable_libstdcxx_allocator_flag=new
2487         ;;
2488     esac
2489   fi
2490   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2491
2492
2493   # Set configure bits for specified locale package
2494   case ${enable_libstdcxx_allocator_flag} in
2495     bitmap)
2496       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2497       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2498       ;;
2499     malloc)
2500       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2501       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2502       ;;
2503     mt)
2504       ALLOCATOR_H=config/allocator/mt_allocator_base.h
2505       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2506       ;;
2507     new)
2508       ALLOCATOR_H=config/allocator/new_allocator_base.h
2509       ALLOCATOR_NAME=__gnu_cxx::new_allocator
2510       ;;
2511     pool)
2512       ALLOCATOR_H=config/allocator/pool_allocator_base.h
2513       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2514       ;;
2515   esac
2516
2517   AC_SUBST(ALLOCATOR_H)
2518   AC_SUBST(ALLOCATOR_NAME)
2519 ])
2520
2521
2522 dnl
2523 dnl Check for whether the Boost-derived checks should be turned on.
2524 dnl
2525 dnl --enable-concept-checks turns them on.
2526 dnl --disable-concept-checks leaves them off.
2527 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2528 dnl       Where DEFAULT is either `yes' or `no'.
2529 dnl
2530 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2531   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2532   if test $enable_concept_checks = yes; then
2533     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2534               [Define to use concept checking code from the boost libraries.])
2535   fi
2536 ])
2537
2538 dnl
2539 dnl Use extern templates.
2540 dnl
2541 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2542 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2543
2544 dnl  +  Usage:  GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2545 dnl       Where DEFAULT is `yes' or `no'.
2546 dnl
2547 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2548
2549   GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2550
2551   AC_MSG_CHECKING([for extern template support])
2552   AC_MSG_RESULT([$enable_extern_template])
2553
2554   GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2555 ])
2556
2557 dnl
2558 dnl Use vtable verification.
2559 dnl
2560 dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1
2561 dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0
2562
2563 dnl  +  Usage:  GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)]
2564 dnl       Where DEFAULT is `yes' or `no'.
2565 dnl
2566 AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [
2567
2568   GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify])
2569
2570   AC_MSG_CHECKING([for vtable verify support])
2571   AC_MSG_RESULT([$enable_vtable_verify])
2572
2573   vtv_cygmin=no
2574   if test $enable_vtable_verify = yes; then
2575     case ${target_os} in
2576       cygwin*|mingw32*)
2577         VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2578         VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2579         vtv_cygmin=yes
2580         ;;
2581       darwin*)
2582         VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u,_vtable_map_vars_start -Wl,-u,_vtable_map_vars_end"
2583         VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-rpath,${toplevel_builddir}/libvtv/.libs"
2584         ;;
2585       *)
2586         VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2587         VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2588         ;;
2589     esac
2590     VTV_PCH_CXXFLAGS="-fvtable-verify=std"
2591   else
2592     VTV_CXXFLAGS=
2593     VTV_PCH_CXXFLAGS=
2594     VTV_CXXLINKFLAGS=
2595   fi
2596
2597   AC_SUBST(VTV_CXXFLAGS)
2598   AC_SUBST(VTV_PCH_CXXFLAGS)
2599   AC_SUBST(VTV_CXXLINKFLAGS)
2600   AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes)
2601   GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes)
2602 ])
2603
2604 dnl
2605 dnl Check for parallel mode pre-requisites, including OpenMP support.
2606 dnl
2607 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
2608 dnl
2609 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2610
2611   enable_parallel=no;
2612
2613   # See if configured libgomp/omp.h exists. (libgomp may be in
2614   # noconfigdirs but not explicitly disabled.)
2615   if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2616     enable_parallel=yes;
2617   else
2618     AC_MSG_NOTICE([target-libgomp not built])
2619   fi
2620
2621   AC_MSG_CHECKING([for parallel mode support])
2622   AC_MSG_RESULT([$enable_parallel])
2623 ])
2624
2625
2626 dnl
2627 dnl Check for which I/O library to use:  stdio, or something specific.
2628 dnl
2629 dnl Default is stdio.
2630 dnl
2631 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2632   AC_MSG_CHECKING([for underlying I/O to use])
2633   GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2634     [use target-specific I/O package], [permit stdio])
2635
2636   # Now that libio has been removed, you can have any color you want as long
2637   # as it's black.  This is one big no-op until other packages are added, but
2638   # showing the framework never hurts.
2639   case ${enable_cstdio} in
2640     stdio)
2641       CSTDIO_H=config/io/c_io_stdio.h
2642       BASIC_FILE_H=config/io/basic_file_stdio.h
2643       BASIC_FILE_CC=config/io/basic_file_stdio.cc
2644       AC_MSG_RESULT(stdio)
2645       ;;
2646   esac
2647
2648   AC_SUBST(CSTDIO_H)
2649   AC_SUBST(BASIC_FILE_H)
2650   AC_SUBST(BASIC_FILE_CC)
2651 ])
2652
2653
2654 dnl
2655 dnl Check for "unusual" flags to pass to the compiler while building.
2656 dnl
2657 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2658 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2659 dnl --disable-cxx-flags passes nothing.
2660 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2661 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2662 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2663 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2664 dnl       If "default flags" is an empty string, the effect is the same
2665 dnl       as --disable or --enable=no.
2666 dnl
2667 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2668   AC_MSG_CHECKING([for extra compiler flags for building])
2669   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2670     [pass compiler FLAGS when building library],
2671     [case "x$enable_cxx_flags" in
2672       xno | x)   enable_cxx_flags= ;;
2673       x-*)       ;;
2674       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2675      esac])
2676
2677   # Run through flags (either default or command-line) and set anything
2678   # extra (e.g., #defines) that must accompany particular g++ options.
2679   if test -n "$enable_cxx_flags"; then
2680     for f in $enable_cxx_flags; do
2681       case "$f" in
2682         -fhonor-std)  ;;
2683         -*)  ;;
2684         *)   # and we're trying to pass /what/ exactly?
2685              AC_MSG_ERROR([compiler flags start with a -]) ;;
2686       esac
2687     done
2688   fi
2689
2690   EXTRA_CXX_FLAGS="$enable_cxx_flags"
2691   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2692   AC_SUBST(EXTRA_CXX_FLAGS)
2693 ])
2694
2695
2696 dnl
2697 dnl Check to see if debugging libraries are to be built.
2698 dnl
2699 dnl --enable-libstdcxx-debug
2700 dnl builds a separate set of debugging libraries in addition to the
2701 dnl normal (shared, static) libstdc++ binaries.
2702 dnl
2703 dnl --disable-libstdcxx-debug
2704 dnl builds only one (non-debug) version of libstdc++.
2705 dnl
2706 dnl --enable-libstdcxx-debug-flags=FLAGS
2707 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2708 dnl
2709 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2710 dnl       Where DEFAULT is either `yes' or `no'.
2711 dnl
2712 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2713   AC_MSG_CHECKING([for additional debug build])
2714   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2715   AC_MSG_RESULT($enable_libstdcxx_debug)
2716   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2717 ])
2718
2719
2720 dnl
2721 dnl Check for explicit debug flags.
2722 dnl
2723 dnl --enable-libstdcxx-debug-flags='-O1'
2724 dnl is a general method for passing flags to be used when
2725 dnl building debug libraries with --enable-libstdcxx-debug.
2726 dnl
2727 dnl --disable-libstdcxx-debug-flags does nothing.
2728 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2729 dnl       If "default flags" is an empty string, the effect is the same
2730 dnl       as --disable or --enable=no.
2731 dnl
2732 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2733   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2734     [pass compiler FLAGS when building debug library],
2735     [case "x$enable_libstdcxx_debug_flags" in
2736       xno | x)    enable_libstdcxx_debug_flags= ;;
2737       x-*)        ;;
2738       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2739      esac])
2740
2741   # Option parsed, now set things appropriately
2742   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2743   AC_SUBST(DEBUG_FLAGS)
2744
2745   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2746 ])
2747
2748
2749 dnl
2750 dnl Check if the user only wants a freestanding library implementation.
2751 dnl
2752 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2753 dnl installing only the headers required by [17.4.1.3] and the language
2754 dnl support library.  More than that will be built (to keep the Makefiles
2755 dnl conveniently clean), but not installed.
2756 dnl
2757 dnl Sets:
2758 dnl  is_hosted  (yes/no)
2759 dnl
2760 dnl Defines:
2761 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2762 dnl
2763 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2764   AC_ARG_ENABLE([hosted-libstdcxx],
2765     AC_HELP_STRING([--disable-hosted-libstdcxx],
2766                    [only build freestanding C++ runtime support]),,
2767     [case "$host" in
2768         arm*-*-symbianelf*)
2769             enable_hosted_libstdcxx=no
2770             ;;
2771         *)
2772             enable_hosted_libstdcxx=yes
2773             ;;
2774      esac])
2775   if test "$enable_hosted_libstdcxx" = no; then
2776     AC_MSG_NOTICE([Only freestanding libraries will be built])
2777     is_hosted=no
2778     hosted_define=0
2779     enable_abi_check=no
2780     enable_libstdcxx_pch=no
2781   else
2782     is_hosted=yes
2783     hosted_define=1
2784   fi
2785   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2786   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2787     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2788 ])
2789
2790
2791 dnl
2792 dnl Check if the user wants a non-verbose library implementation.
2793 dnl
2794 dnl --disable-libstdcxx-verbose will turn off descriptive messages to
2795 dnl standard error on termination.
2796 dnl
2797 dnl Defines:
2798 dnl  _GLIBCXX_VERBOSE (always defined, either to 1 or 0)
2799 dnl
2800 AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [
2801   AC_ARG_ENABLE([libstdcxx-verbose],
2802     AC_HELP_STRING([--disable-libstdcxx-verbose],
2803                    [disable termination messages to standard error]),,
2804                    [enable_libstdcxx_verbose=yes])
2805   if test x"$enable_libstdcxx_verbose" = xyes; then
2806     verbose_define=1
2807   else
2808     AC_MSG_NOTICE([verbose termination messages are disabled])
2809     verbose_define=0
2810   fi
2811   AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define,
2812     [Define to 1 if a verbose library is built, or 0 otherwise.])
2813 ])
2814
2815
2816 dnl
2817 dnl Check for template specializations for the 'long long' type.
2818 dnl The result determines only whether 'long long' I/O is enabled; things
2819 dnl like numeric_limits<> specializations are always available.
2820 dnl
2821 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2822 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2823 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2824 dnl       Where DEFAULT is either `yes' or `no'.
2825 dnl
2826 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2827   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2828   if test $enable_long_long = yes; then
2829     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2830               [Define if code specialized for long long should be used.])
2831   fi
2832   AC_MSG_CHECKING([for enabled long long specializations])
2833   AC_MSG_RESULT([$enable_long_long])
2834 ])
2835
2836
2837 dnl
2838 dnl Check for decimal floating point.
2839 dnl See:
2840 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2841 dnl
2842 dnl This checks to see if the host supports decimal floating point types.
2843 dnl
2844 dnl Defines:
2845 dnl  _GLIBCXX_USE_DECIMAL_FLOAT
2846 dnl
2847 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2848
2849   # Fake what AC_TRY_COMPILE does, without linking as this is
2850   # unnecessary for this test.
2851
2852     cat > conftest.$ac_ext << EOF
2853 [#]line __oline__ "configure"
2854 int main()
2855 {
2856   _Decimal32 d1;
2857   _Decimal64 d2;
2858   _Decimal128 d3;
2859   return 0;
2860 }
2861 EOF
2862
2863     AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2864     if AC_TRY_EVAL(ac_compile); then
2865       AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2866       [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2867       enable_dfp=yes
2868     else
2869       enable_dfp=no
2870     fi
2871     AC_MSG_RESULT($enable_dfp)
2872     rm -f conftest*
2873 ])
2874
2875 dnl
2876 dnl Check for GNU 128-bit integer and floating point types.
2877 dnl
2878 dnl Note: also checks that the types aren't standard types.
2879 dnl
2880 dnl Defines:
2881 dnl  _GLIBCXX_USE_INT128
2882 dnl  _GLIBCXX_USE_FLOAT128
2883 dnl
2884 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
2885
2886   AC_LANG_SAVE
2887   AC_LANG_CPLUSPLUS
2888
2889   # Fake what AC_TRY_COMPILE does, without linking as this is
2890   # unnecessary for this test.
2891
2892     cat > conftest.$ac_ext << EOF
2893 [#]line __oline__ "configure"
2894 template<typename T1, typename T2>
2895   struct same
2896   { typedef T2 type; };
2897
2898 template<typename T>
2899   struct same<T, T>;
2900
2901 int main()
2902 {
2903   typename same<long, __int128>::type                i1;
2904   typename same<long long, __int128>::type           i2;
2905 }
2906 EOF
2907
2908     AC_MSG_CHECKING([for __int128])
2909     if AC_TRY_EVAL(ac_compile); then
2910       AC_DEFINE(_GLIBCXX_USE_INT128, 1,
2911       [Define if __int128 is supported on this host.])
2912       enable_int128=yes
2913     else
2914       enable_int128=no
2915     fi
2916     AC_MSG_RESULT($enable_int128)
2917     rm -f conftest*
2918
2919     cat > conftest.$ac_ext << EOF
2920 [#]line __oline__ "configure"
2921 template<typename T1, typename T2>
2922   struct same
2923   { typedef T2 type; };
2924
2925 template<typename T>
2926   struct same<T, T>;
2927
2928 int main()
2929 {
2930   typename same<double, __float128>::type      f1;
2931   typename same<long double, __float128>::type f2;
2932 }
2933 EOF
2934
2935     AC_MSG_CHECKING([for __float128])
2936     if AC_TRY_EVAL(ac_compile); then
2937       AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
2938       [Define if __float128 is supported on this host.])
2939       enable_float128=yes
2940     else
2941       enable_float128=no
2942     fi
2943     AC_MSG_RESULT($enable_float128)
2944     rm -f conftest*
2945
2946   AC_LANG_RESTORE
2947 ])
2948
2949 dnl
2950 dnl Check for template specializations for the 'wchar_t' type.
2951 dnl
2952 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2953 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2954 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2955 dnl       Where DEFAULT is either `yes' or `no'.
2956 dnl
2957 dnl Necessary support must also be present.
2958 dnl
2959 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2960   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2961
2962   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2963   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2964   AC_MSG_CHECKING([for mbstate_t])
2965   AC_TRY_COMPILE([#include <wchar.h>],
2966   [mbstate_t teststate;],
2967   have_mbstate_t=yes, have_mbstate_t=no)
2968   AC_MSG_RESULT($have_mbstate_t)
2969   if test x"$have_mbstate_t" = xyes; then
2970     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2971   fi
2972
2973   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2974   # ac_has_wchar_h.
2975   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2976
2977   if test x"$enable_wchar_t" = x"yes"; then
2978
2979     AC_LANG_SAVE
2980     AC_LANG_CPLUSPLUS
2981
2982     if test x"$ac_has_wchar_h" = xyes &&
2983        test x"$ac_has_wctype_h" = xyes; then
2984       AC_TRY_COMPILE([#include <wchar.h>
2985                       #include <stddef.h>
2986                       wint_t i;
2987                       long l = WEOF;
2988                       long j = WCHAR_MIN;
2989                       long k = WCHAR_MAX;
2990                       namespace test
2991                       {
2992                         using ::btowc;
2993                         using ::fgetwc;
2994                         using ::fgetws;
2995                         using ::fputwc;
2996                         using ::fputws;
2997                         using ::fwide;
2998                         using ::fwprintf;
2999                         using ::fwscanf;
3000                         using ::getwc;
3001                         using ::getwchar;
3002                         using ::mbrlen;
3003                         using ::mbrtowc;
3004                         using ::mbsinit;
3005                         using ::mbsrtowcs;
3006                         using ::putwc;
3007                         using ::putwchar;
3008                         using ::swprintf;
3009                         using ::swscanf;
3010                         using ::ungetwc;
3011                         using ::vfwprintf;
3012                         using ::vswprintf;
3013                         using ::vwprintf;
3014                         using ::wcrtomb;
3015                         using ::wcscat;
3016                         using ::wcschr;
3017                         using ::wcscmp;
3018                         using ::wcscoll;
3019                         using ::wcscpy;
3020                         using ::wcscspn;
3021                         using ::wcsftime;
3022                         using ::wcslen;
3023                         using ::wcsncat;
3024                         using ::wcsncmp;
3025                         using ::wcsncpy;
3026                         using ::wcspbrk;
3027                         using ::wcsrchr;
3028                         using ::wcsrtombs;
3029                         using ::wcsspn;
3030                         using ::wcsstr;
3031                         using ::wcstod;
3032                         using ::wcstok;
3033                         using ::wcstol;
3034                         using ::wcstoul;
3035                         using ::wcsxfrm;
3036                         using ::wctob;
3037                         using ::wmemchr;
3038                         using ::wmemcmp;
3039                         using ::wmemcpy;
3040                         using ::wmemmove;
3041                         using ::wmemset;
3042                         using ::wprintf;
3043                         using ::wscanf;
3044                       }
3045                      ],[],[], [enable_wchar_t=no])
3046     else
3047       enable_wchar_t=no
3048     fi
3049
3050     AC_LANG_RESTORE
3051   fi
3052
3053   if test x"$enable_wchar_t" = x"yes"; then
3054     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
3055               [Define if code specialized for wchar_t should be used.])
3056   fi
3057
3058   AC_MSG_CHECKING([for enabled wchar_t specializations])
3059   AC_MSG_RESULT([$enable_wchar_t])
3060 ])
3061
3062
3063 dnl
3064 dnl Check to see if building and using a C++ precompiled header can be done.
3065 dnl
3066 dnl --enable-libstdcxx-pch=yes
3067 dnl default, this shows intent to use stdc++.h.gch If it looks like it
3068 dnl may work, after some light-hearted attempts to puzzle out compiler
3069 dnl support, flip bits on in include/Makefile.am
3070 dnl
3071 dnl --disable-libstdcxx-pch
3072 dnl turns off attempts to use or build stdc++.h.gch.
3073 dnl
3074 dnl Substs:
3075 dnl  glibcxx_PCHFLAGS
3076 dnl
3077 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
3078   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
3079   if test $enable_libstdcxx_pch = yes; then
3080     AC_CACHE_CHECK([for compiler with PCH support],
3081       [glibcxx_cv_prog_CXX_pch],
3082       [ac_save_CXXFLAGS="$CXXFLAGS"
3083        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
3084        AC_LANG_SAVE
3085        AC_LANG_CPLUSPLUS
3086        echo '#include <math.h>' > conftest.h
3087        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
3088                           -o conftest.h.gch 1>&5 2>&1 &&
3089                 echo '#error "pch failed"' > conftest.h &&
3090           echo '#include "conftest.h"' > conftest.cc &&
3091                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
3092        then
3093          glibcxx_cv_prog_CXX_pch=yes
3094        else
3095          glibcxx_cv_prog_CXX_pch=no
3096        fi
3097        rm -f conftest*
3098        CXXFLAGS=$ac_save_CXXFLAGS
3099        AC_LANG_RESTORE
3100       ])
3101     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
3102   fi
3103
3104   AC_MSG_CHECKING([for enabled PCH])
3105   AC_MSG_RESULT([$enable_libstdcxx_pch])
3106
3107   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
3108   if test $enable_libstdcxx_pch = yes; then
3109     glibcxx_PCHFLAGS="-include bits/stdc++.h"
3110   else
3111     glibcxx_PCHFLAGS=""
3112   fi
3113   AC_SUBST(glibcxx_PCHFLAGS)
3114 ])
3115
3116
3117 dnl
3118 dnl Check for atomic builtins.
3119 dnl See:
3120 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
3121 dnl
3122 dnl This checks to see if the host supports the compiler-generated
3123 dnl builtins for atomic operations for various integral sizes. Note, this
3124 dnl is intended to be an all-or-nothing switch, so all the atomic operations
3125 dnl that are used should be checked.
3126 dnl
3127 dnl Note:
3128 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
3129 dnl
3130 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
3131   AC_LANG_SAVE
3132   AC_LANG_CPLUSPLUS
3133   old_CXXFLAGS="$CXXFLAGS"
3134
3135   # Do link tests if possible, instead asm tests, limited to some platforms
3136   # see discussion in PR target/40134, PR libstdc++/40133 and the thread
3137   # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
3138   atomic_builtins_link_tests=no
3139   if test x$gcc_no_link != xyes; then
3140     # Can do link tests. Limit to some tested platforms
3141     case "$host" in
3142       *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
3143         atomic_builtins_link_tests=yes
3144         ;;
3145     esac
3146   fi
3147
3148   if test x$atomic_builtins_link_tests = xyes; then
3149
3150   # Do link tests.
3151
3152   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3153
3154   AC_MSG_CHECKING([for atomic builtins for bool])
3155   AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
3156     AC_TRY_LINK(
3157       [ ],
3158       [typedef bool atomic_type;
3159        atomic_type c1;
3160        atomic_type c2;
3161        atomic_type c3(0);
3162        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3163        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3164                                    __ATOMIC_RELAXED);
3165        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3166        __atomic_load_n(&c1, __ATOMIC_RELAXED);
3167       ],
3168       [glibcxx_cv_atomic_bool=yes],
3169       [glibcxx_cv_atomic_bool=no])
3170   ])
3171   AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3172
3173   AC_MSG_CHECKING([for atomic builtins for short])
3174   AC_CACHE_VAL(glibcxx_cv_atomic_short, [
3175     AC_TRY_LINK(
3176       [ ],
3177       [typedef short atomic_type;
3178        atomic_type c1;
3179        atomic_type c2;
3180        atomic_type c3(0);
3181        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3182        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3183                                    __ATOMIC_RELAXED);
3184        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3185        __atomic_load_n(&c1, __ATOMIC_RELAXED);
3186       ],
3187       [glibcxx_cv_atomic_short=yes],
3188       [glibcxx_cv_atomic_short=no])
3189   ])
3190   AC_MSG_RESULT($glibcxx_cv_atomic_short)
3191
3192   AC_MSG_CHECKING([for atomic builtins for int])
3193   AC_CACHE_VAL(glibcxx_cv_atomic_int, [
3194     AC_TRY_LINK(
3195       [ ],
3196       [typedef int atomic_type;
3197        atomic_type c1;
3198        atomic_type c2;
3199        atomic_type c3(0);
3200        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3201        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3202                                    __ATOMIC_RELAXED);
3203        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3204        __atomic_load_n(&c1, __ATOMIC_RELAXED);
3205       ],
3206       [glibcxx_cv_atomic_int=yes],
3207       [glibcxx_cv_atomic_int=no])
3208   ])
3209   AC_MSG_RESULT($glibcxx_cv_atomic_int)
3210
3211   AC_MSG_CHECKING([for atomic builtins for long long])
3212   AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
3213     AC_TRY_LINK(
3214       [ ],
3215       [typedef long long atomic_type;
3216        atomic_type c1;
3217        atomic_type c2;
3218        atomic_type c3(0);
3219        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3220        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3221                                    __ATOMIC_RELAXED);
3222        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3223        __atomic_load_n(&c1, __ATOMIC_RELAXED);
3224       ],
3225       [glibcxx_cv_atomic_long_long=yes],
3226       [glibcxx_cv_atomic_long_long=no])
3227   ])
3228   AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3229
3230   else
3231
3232   # Do asm tests.
3233
3234   # Compile unoptimized.
3235   CXXFLAGS='-O0 -S'
3236
3237   # Fake what AC_TRY_COMPILE does.
3238
3239     cat > conftest.$ac_ext << EOF
3240 [#]line __oline__ "configure"
3241 int main()
3242 {
3243   typedef bool atomic_type;
3244   atomic_type c1;
3245   atomic_type c2;
3246   atomic_type c3(0);
3247   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3248   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3249                               __ATOMIC_RELAXED);
3250   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3251   __atomic_load_n(&c1, __ATOMIC_RELAXED);
3252
3253   return 0;
3254 }
3255 EOF
3256
3257     AC_MSG_CHECKING([for atomic builtins for bool])
3258     if AC_TRY_EVAL(ac_compile); then
3259       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3260         glibcxx_cv_atomic_bool=no
3261       else
3262         glibcxx_cv_atomic_bool=yes
3263       fi
3264     fi
3265     AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3266     rm -f conftest*
3267
3268     cat > conftest.$ac_ext << EOF
3269 [#]line __oline__ "configure"
3270 int main()
3271 {
3272   typedef short atomic_type;
3273   atomic_type c1;
3274   atomic_type c2;
3275   atomic_type c3(0);
3276   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3277   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3278                               __ATOMIC_RELAXED);
3279   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3280   __atomic_load_n(&c1, __ATOMIC_RELAXED);
3281
3282   return 0;
3283 }
3284 EOF
3285
3286     AC_MSG_CHECKING([for atomic builtins for short])
3287     if AC_TRY_EVAL(ac_compile); then
3288       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3289         glibcxx_cv_atomic_short=no
3290       else
3291         glibcxx_cv_atomic_short=yes
3292       fi
3293     fi
3294     AC_MSG_RESULT($glibcxx_cv_atomic_short)
3295     rm -f conftest*
3296
3297     cat > conftest.$ac_ext << EOF
3298 [#]line __oline__ "configure"
3299 int main()
3300 {
3301   // NB: _Atomic_word not necessarily int.
3302   typedef int atomic_type;
3303   atomic_type c1;
3304   atomic_type c2;
3305   atomic_type c3(0);
3306   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3307   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3308                               __ATOMIC_RELAXED);
3309   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3310   __atomic_load_n(&c1, __ATOMIC_RELAXED);
3311
3312   return 0;
3313 }
3314 EOF
3315
3316     AC_MSG_CHECKING([for atomic builtins for int])
3317     if AC_TRY_EVAL(ac_compile); then
3318       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3319         glibcxx_cv_atomic_int=no
3320       else
3321         glibcxx_cv_atomic_int=yes
3322       fi
3323     fi
3324     AC_MSG_RESULT($glibcxx_cv_atomic_int)
3325     rm -f conftest*
3326
3327     cat > conftest.$ac_ext << EOF
3328 [#]line __oline__ "configure"
3329 int main()
3330 {
3331   typedef long long atomic_type;
3332   atomic_type c1;
3333   atomic_type c2;
3334   atomic_type c3(0);
3335   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3336   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3337                               __ATOMIC_RELAXED);
3338   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3339   __atomic_load_n(&c1, __ATOMIC_RELAXED);
3340
3341   return 0;
3342 }
3343 EOF
3344
3345     AC_MSG_CHECKING([for atomic builtins for long long])
3346     if AC_TRY_EVAL(ac_compile); then
3347       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3348         glibcxx_cv_atomic_long_long=no
3349       else
3350         glibcxx_cv_atomic_long_long=yes
3351       fi
3352     fi
3353     AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3354     rm -f conftest*
3355
3356   fi
3357
3358   CXXFLAGS="$old_CXXFLAGS"
3359   AC_LANG_RESTORE
3360
3361   # Set atomicity_dir to builtins if all but the long long test above passes.
3362   if test $glibcxx_cv_atomic_bool = yes \
3363      && test $glibcxx_cv_atomic_short = yes \
3364      && test $glibcxx_cv_atomic_int = yes; then
3365     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
3366     [Define if the compiler supports C++11 atomics.])
3367     atomicity_dir=cpu/generic/atomicity_builtins
3368   fi
3369
3370   # If still generic, set to mutex.
3371   if test $atomicity_dir = "cpu/generic" ; then
3372     atomicity_dir=cpu/generic/atomicity_mutex
3373     AC_MSG_WARN([No native atomic operations are provided for this platform.])
3374       if test "x$target_thread_file" = xsingle; then
3375         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
3376         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
3377       else
3378         AC_MSG_WARN([They will be faked using a mutex.])
3379         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
3380       fi
3381   fi
3382
3383 ])
3384
3385
3386 dnl
3387 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3388 dnl
3389 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3390 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3391 dnl  +  Usage:  GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3392 dnl       Where DEFAULT is 'yes'.
3393 dnl
3394 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3395 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3396
3397 if test x$enable_libstdcxx_visibility = xyes ; then
3398   dnl all hail libgfortran
3399   dnl Check whether the target supports hidden visibility.
3400   AC_CACHE_CHECK([whether the target supports hidden visibility],
3401                  glibcxx_cv_have_attribute_visibility, [
3402   save_CFLAGS="$CFLAGS"
3403   CFLAGS="$CFLAGS -Werror"
3404   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3405                  [], glibcxx_cv_have_attribute_visibility=yes,
3406                  glibcxx_cv_have_attribute_visibility=no)
3407   CFLAGS="$save_CFLAGS"])
3408   if test $glibcxx_cv_have_attribute_visibility = no; then
3409     enable_libstdcxx_visibility=no
3410   fi
3411 fi
3412
3413 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3414 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3415 ])
3416
3417
3418 dnl
3419 dnl Add version tags to symbols in shared library (or not), additionally
3420 dnl marking other symbols as private/local (or not).
3421 dnl
3422 dnl Sets libtool_VERSION, and determines shared library SONAME.
3423 dnl
3424 dnl  This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3425 dnl
3426 dnl --enable-symvers=style adds a version script to the linker call when
3427 dnl       creating the shared library.  The choice of version script is
3428 dnl       controlled by 'style'.
3429 dnl --disable-symvers does not.
3430 dnl
3431 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3432 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
3433 dnl       choose a default style based on linker characteristics.  Passing
3434 dnl       'no' disables versioning.
3435 dnl
3436 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3437
3438 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3439   [enables symbol versioning of the shared library],
3440   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3441
3442 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3443 # don't know enough about $LD to do tricks...
3444 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3445 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3446 # with extern "C++" in version scripts.
3447 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3448
3449 # Turn a 'yes' into a suitable default.
3450 if test x$enable_symvers = xyes ; then
3451   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3452     enable_symvers=no
3453   else
3454     if test $with_gnu_ld = yes ; then
3455       case ${target_os} in
3456         hpux*)
3457           enable_symvers=no ;;
3458         *)
3459           enable_symvers=gnu ;;
3460       esac
3461     else
3462       case ${target_os} in
3463         darwin*)
3464           enable_symvers=darwin ;;
3465         # Sun symbol versioning exists since Solaris 2.5.
3466         solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3467           # make_sunver.pl needs GNU c++filt to support extern "C++" in
3468           # version scripts, so disable symbol versioning if none can be
3469           # found.
3470           if test -z "$ac_cv_path_CXXFILT"; then
3471             AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3472             AC_MSG_WARN([=== no GNU c++filt could  be found.])
3473             AC_MSG_WARN([=== Symbol versioning will be disabled.])
3474             enable_symvers=no
3475           else
3476             enable_symvers=sun
3477           fi
3478           ;;
3479         *)
3480           enable_symvers=no ;;
3481       esac
3482     fi
3483   fi
3484 fi
3485
3486 # Check to see if 'darwin' or 'darwin-export' can win.
3487 if test x$enable_symvers = xdarwin-export ; then
3488     enable_symvers=darwin
3489 fi
3490
3491 # Check if 'sun' was requested on non-Solaris 2 platforms.
3492 if test x$enable_symvers = xsun ; then
3493   case ${target_os} in
3494     solaris2*)
3495       # All fine.
3496       ;;
3497     *)
3498       # Unlikely to work.
3499       AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3500       AC_MSG_WARN([=== you are not targetting Solaris 2.])
3501       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3502       enable_symvers=no
3503       ;;
3504   esac
3505 fi
3506
3507 # Check to see if 'gnu' can win.
3508 if test $enable_symvers = gnu ||
3509   test $enable_symvers = gnu-versioned-namespace ||
3510   test $enable_symvers = sun; then
3511   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3512   AC_MSG_CHECKING([for shared libgcc])
3513   ac_save_CFLAGS="$CFLAGS"
3514   CFLAGS=' -lgcc_s'
3515   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3516   CFLAGS="$ac_save_CFLAGS"
3517   if test $glibcxx_shared_libgcc = no; then
3518     cat > conftest.c <<EOF
3519 int main (void) { return 0; }
3520 EOF
3521 changequote(,)dnl
3522     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3523                              -shared -shared-libgcc -o conftest.so \
3524                              conftest.c -v 2>&1 >/dev/null \
3525                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3526 changequote([,])dnl
3527     rm -f conftest.c conftest.so
3528     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3529       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3530       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3531       CFLAGS="$ac_save_CFLAGS"
3532     fi
3533   fi
3534   AC_MSG_RESULT($glibcxx_shared_libgcc)
3535
3536   # For GNU ld, we need at least this version.  The format is described in
3537   # GLIBCXX_CHECK_LINKER_FEATURES above.
3538   glibcxx_min_gnu_ld_version=21400
3539
3540   # If no shared libgcc, can't win.
3541   if test $glibcxx_shared_libgcc != yes; then
3542       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3543       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3544       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3545       enable_symvers=no
3546   elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3547     : All interesting versions of Sun ld support sun style symbol versioning.
3548   elif test $with_gnu_ld != yes ; then
3549     # just fail for now
3550     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3551     AC_MSG_WARN([=== you are not using the GNU linker.])
3552     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3553     enable_symvers=no
3554   elif test $glibcxx_ld_is_gold = yes ; then
3555     : All versions of gold support symbol versioning.
3556   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3557     # The right tools, the right setup, but too old.  Fallbacks?
3558     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3559     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3560     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3561     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3562     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3563     enable_symvers=no
3564   fi
3565 fi
3566
3567 # For libtool versioning info, format is CURRENT:REVISION:AGE
3568 libtool_VERSION=6:22:0
3569
3570 # Everything parsed; figure out what files and settings to use.
3571 case $enable_symvers in
3572   no)
3573     SYMVER_FILE=config/abi/pre/none.ver
3574     ;;
3575   gnu)
3576     SYMVER_FILE=config/abi/pre/gnu.ver
3577     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3578               [Define to use GNU versioning in the shared library.])
3579     ;;
3580   gnu-versioned-namespace)
3581     libtool_VERSION=7:0:0
3582     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3583     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3584               [Define to use GNU namespace versioning in the shared library.])
3585     ;;
3586   darwin)
3587     SYMVER_FILE=config/abi/pre/gnu.ver
3588     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3589               [Define to use darwin versioning in the shared library.])
3590     ;;
3591   sun)
3592     SYMVER_FILE=config/abi/pre/gnu.ver
3593     AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3594               [Define to use Sun versioning in the shared library.])
3595     ;;
3596 esac
3597
3598 if test x$enable_symvers != xno ; then
3599   AC_DEFINE(_GLIBCXX_SYMVER, 1,
3600          [Define to use symbol versioning in the shared library.])
3601 fi
3602
3603 AC_CACHE_CHECK([whether the target supports .symver directive],
3604                glibcxx_cv_have_as_symver_directive, [
3605   AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3606                  [], glibcxx_cv_have_as_symver_directive=yes,
3607                  glibcxx_cv_have_as_symver_directive=no)])
3608 if test $glibcxx_cv_have_as_symver_directive = yes; then
3609   AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3610     [Define to 1 if the target assembler supports .symver directive.])
3611 fi
3612
3613 AC_SUBST(SYMVER_FILE)
3614 AC_SUBST(port_specific_symbol_files)
3615 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3616 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3617 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3618 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3619 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3620 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3621
3622 if test $enable_symvers != no ; then
3623    case ${target_os} in
3624      # The Solaris 2 runtime linker doesn't support the GNU extension of
3625      # binding the same symbol to different versions
3626      solaris2*)
3627        ;;
3628      # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3629      *)
3630        AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3631          [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3632        ;;
3633     esac
3634 fi
3635
3636 # Now, set up compatibility support, if any.
3637 # In addition, need this to deal with std::size_t mangling in
3638 # src/compatibility.cc.  In a perfect world, could use
3639 # typeid(std::size_t).name()[0] to do direct substitution.
3640 AC_MSG_CHECKING([for size_t as unsigned int])
3641 ac_save_CFLAGS="$CFLAGS"
3642 CFLAGS="-Werror"
3643 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3644                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3645 CFLAGS=$ac_save_CFLAGS
3646 if test "$glibcxx_size_t_is_i" = yes; then
3647   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3648 fi
3649 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3650
3651 AC_MSG_CHECKING([for ptrdiff_t as int])
3652 ac_save_CFLAGS="$CFLAGS"
3653 CFLAGS="-Werror"
3654 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3655                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3656 CFLAGS=$ac_save_CFLAGS
3657 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3658   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3659 fi
3660 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3661 ])
3662
3663
3664 dnl
3665 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3666 dnl We must stage the required headers so that they will be installed
3667 dnl with the library (unlike libgcc, the STL implementation is provided
3668 dnl solely within headers).  Since we must not inject random user-space
3669 dnl macro names into user-provided C++ code, we first stage into <file>-in
3670 dnl and process to <file> with an output command.  The reason for a two-
3671 dnl stage process here is to correctly handle $srcdir!=$objdir without
3672 dnl having to write complex code (the sed commands to clean the macro
3673 dnl namespace are complex and fragile enough as it is).  We must also
3674 dnl add a relative path so that -I- is supported properly.
3675 dnl
3676 dnl Substs:
3677 dnl  thread_header
3678 dnl
3679 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3680   AC_MSG_CHECKING([for thread model used by GCC])
3681   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3682   AC_MSG_RESULT([$target_thread_file])
3683   GCC_AC_THREAD_HEADER([$target_thread_file])
3684 ])
3685
3686
3687 dnl
3688 dnl Check if gthread implementation defines the types and functions
3689 dnl required by the c++0x thread library.  Conforming gthread
3690 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3691 dnl
3692 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3693 dnl
3694 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3695   GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3696
3697   if test x$enable_libstdcxx_threads = xauto ||
3698      test x$enable_libstdcxx_threads = xyes; then
3699
3700   AC_LANG_SAVE
3701   AC_LANG_CPLUSPLUS
3702
3703   ac_save_CXXFLAGS="$CXXFLAGS"
3704   CXXFLAGS="$CXXFLAGS -fno-exceptions \
3705         -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3706
3707   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3708   case $target_thread_file in
3709     posix)
3710       CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3711   esac
3712
3713   AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3714
3715   AC_TRY_COMPILE([#include <unistd.h>],
3716     [
3717       // In case of POSIX threads check _POSIX_TIMEOUTS.
3718       #if (defined(_PTHREADS) \
3719           && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3720       #error
3721       #endif
3722     ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3723
3724   AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3725                      [Define to 1 if mutex_timedlock is available.])
3726
3727   if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3728   else res_mutex_timedlock=no ; fi
3729   AC_MSG_RESULT([$res_mutex_timedlock])
3730
3731   AC_MSG_CHECKING([for gthreads library])
3732
3733   AC_TRY_COMPILE([#include "gthr.h"],
3734     [
3735       #ifndef __GTHREADS_CXX0X
3736       #error
3737       #endif
3738     ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
3739   else
3740     ac_has_gthreads=no
3741   fi
3742
3743   AC_MSG_RESULT([$ac_has_gthreads])
3744
3745   if test x"$ac_has_gthreads" = x"yes"; then
3746     AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3747               [Define if gthreads library is available.])
3748
3749     # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14
3750     AC_CHECK_TYPE([pthread_rwlock_t],
3751             [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1,
3752             [Define if POSIX read/write locks are available in <gthr.h>.])],
3753             [],
3754             [#include "gthr.h"])
3755   fi
3756
3757   CXXFLAGS="$ac_save_CXXFLAGS"
3758   AC_LANG_RESTORE
3759 ])
3760
3761
3762 # Check whether LC_MESSAGES is available in <locale.h>.
3763 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3764 #
3765 # This file file be copied and used freely without restrictions.  It can
3766 # be used in projects which are not available under the GNU Public License
3767 # but which still want to provide support for the GNU gettext functionality.
3768 # Please note that the actual code is *not* freely available.
3769 AC_DEFUN([AC_LC_MESSAGES], [
3770   AC_CHECK_HEADER(locale.h, [
3771     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3772       [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3773        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3774     if test $ac_cv_val_LC_MESSAGES = yes; then
3775       AC_DEFINE(HAVE_LC_MESSAGES, 1,
3776                 [Define if LC_MESSAGES is available in <locale.h>.])
3777     fi
3778   ])
3779 ])
3780
3781 dnl
3782 dnl Check whether rdrand is supported in the assembler.
3783 AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [
3784   AC_MSG_CHECKING([for rdrand support in assembler])
3785   AC_CACHE_VAL(ac_cv_x86_rdrand, [
3786   ac_cv_x86_rdrand=no
3787   case "$target" in
3788     i?86-*-* | \
3789     x86_64-*-*)
3790     AC_TRY_COMPILE(, [asm("rdrand %eax");],
3791                 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no])
3792   esac
3793   ])
3794   if test $ac_cv_x86_rdrand = yes; then
3795     AC_DEFINE(_GLIBCXX_X86_RDRAND, 1,
3796                 [ Defined if as can handle rdrand. ])
3797   fi
3798   AC_MSG_RESULT($ac_cv_x86_rdrand)
3799 ])
3800
3801 dnl
3802 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
3803 dnl
3804 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
3805
3806   AC_LANG_SAVE
3807   AC_LANG_CPLUSPLUS
3808   ac_save_CXXFLAGS="$CXXFLAGS"
3809   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3810
3811   AC_MSG_CHECKING([for get_nprocs])
3812   AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
3813     GCC_TRY_COMPILE_OR_LINK(
3814       [#include <sys/sysinfo.h>],
3815       [int n = get_nprocs();],
3816       [glibcxx_cv_GET_NPROCS=yes],
3817       [glibcxx_cv_GET_NPROCS=no])
3818   ])
3819   if test $glibcxx_cv_GET_NPROCS = yes; then
3820     AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
3821   fi
3822   AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
3823
3824   CXXFLAGS="$ac_save_CXXFLAGS"
3825   AC_LANG_RESTORE
3826 ])
3827
3828 dnl
3829 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
3830 dnl
3831 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
3832
3833   AC_LANG_SAVE
3834   AC_LANG_CPLUSPLUS
3835   ac_save_CXXFLAGS="$CXXFLAGS"
3836   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3837
3838   AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
3839   AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
3840     GCC_TRY_COMPILE_OR_LINK(
3841       [#include <unistd.h>],
3842       [int n = sysconf(_SC_NPROCESSORS_ONLN);],
3843       [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
3844       [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
3845   ])
3846   if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
3847     AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN  is available in <unistd.h>.])
3848   fi
3849   AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
3850
3851   CXXFLAGS="$ac_save_CXXFLAGS"
3852   AC_LANG_RESTORE
3853 ])
3854
3855 dnl
3856 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
3857 dnl
3858 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
3859
3860   AC_LANG_SAVE
3861   AC_LANG_CPLUSPLUS
3862   ac_save_CXXFLAGS="$CXXFLAGS"
3863   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3864
3865   AC_MSG_CHECKING([for _SC_NPROC_ONLN])
3866   AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [
3867     GCC_TRY_COMPILE_OR_LINK(
3868       [#include <unistd.h>],
3869       [int n = sysconf(_SC_NPROC_ONLN);],
3870       [glibcxx_cv_SC_NPROC_ONLN=yes],
3871       [glibcxx_cv_SC_NPROC_ONLN=no])
3872   ])
3873   if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
3874     AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN  is available in <unistd.h>.])
3875   fi
3876   AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN)
3877
3878   CXXFLAGS="$ac_save_CXXFLAGS"
3879   AC_LANG_RESTORE
3880 ])
3881
3882 dnl
3883 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
3884 dnl
3885 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
3886
3887   AC_LANG_SAVE
3888   AC_LANG_CPLUSPLUS
3889   ac_save_CXXFLAGS="$CXXFLAGS"
3890   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3891
3892   AC_MSG_CHECKING([for pthreads_num_processors_np])
3893   AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
3894     GCC_TRY_COMPILE_OR_LINK(
3895       [#include <pthread.h>],
3896       [int n = pthread_num_processors_np();],
3897       [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
3898       [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
3899   ])
3900   if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
3901     AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
3902   fi
3903   AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP)
3904
3905   CXXFLAGS="$ac_save_CXXFLAGS"
3906   AC_LANG_RESTORE
3907 ])
3908
3909 dnl
3910 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
3911 dnl
3912 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
3913
3914   AC_LANG_SAVE
3915   AC_LANG_CPLUSPLUS
3916   ac_save_CXXFLAGS="$CXXFLAGS"
3917   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3918
3919   AC_MSG_CHECKING([for hw.ncpu sysctl])
3920   AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [
3921     GCC_TRY_COMPILE_OR_LINK(
3922       [
3923        #include <stddef.h>
3924        #include <sys/sysctl.h>
3925        ],
3926       [
3927        int count;
3928        size_t size = sizeof(count);
3929        int mib[] = { CTL_HW, HW_NCPU };
3930        sysctl(mib, 2, &count, &size, NULL, 0);
3931       ],
3932       [glibcxx_cv_SYSCTL_HW_NCPU=yes],
3933       [glibcxx_cv_SYSCTL_HW_NCPU=no])
3934   ])
3935   if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
3936     AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
3937   fi
3938   AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU)
3939
3940   CXXFLAGS="$ac_save_CXXFLAGS"
3941   AC_LANG_RESTORE
3942 ])
3943
3944 dnl
3945 dnl Check to see if python pretty printing can be activated.
3946 dnl
3947 dnl --with-python-dir=dir
3948 dnl installs directory into $prefix/dir
3949 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
3950
3951 AC_MSG_CHECKING([for custom python install directory])
3952 AC_ARG_WITH([python-dir],
3953             AS_HELP_STRING([--with-python-dir],
3954                            [the location to install Python modules. This path is relative starting from the prefix.]),
3955             [with_python_dir=$withval], [with_python_dir="no"])
3956 AC_MSG_RESULT(${with_python_dir})
3957
3958 # Needed for installing Python modules during make install.
3959 python_mod_dir="${with_python_dir}"
3960 AC_SUBST(python_mod_dir)
3961 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
3962 ])
3963
3964 dnl
3965 dnl Check to see if -Werror is disabled.
3966 dnl
3967 dnl --enable-werror/--disable-werror
3968 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
3969   AC_MSG_CHECKING([for -Werror])
3970   GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
3971   AC_MSG_RESULT($enable_werror)
3972   GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
3973 ])
3974
3975 dnl
3976 dnl Check whether obsolescent tmpnam is available in <stdio.h>,
3977 dnl and define _GLIBCXX_USE_TMPNAM.
3978 dnl
3979 AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl
3980 dnl
3981   AC_LANG_SAVE
3982   AC_LANG_CPLUSPLUS
3983   ac_save_CXXFLAGS="$CXXFLAGS"
3984   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3985 dnl
3986   AC_MSG_CHECKING([for tmpnam])
3987   AC_CACHE_VAL(glibcxx_cv_TMPNAM, [dnl
3988     GCC_TRY_COMPILE_OR_LINK(
3989       [#include <stdio.h>],
3990       [char *tmp = tmpnam(NULL);],
3991       [glibcxx_cv_TMPNAM=yes],
3992       [glibcxx_cv_TMPNAM=no])
3993   ])
3994   if test $glibcxx_cv_TMPNAM = yes; then
3995     AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.])
3996   fi
3997   AC_MSG_RESULT($glibcxx_cv_TMPNAM)
3998 dnl
3999   CXXFLAGS="$ac_save_CXXFLAGS"
4000   AC_LANG_RESTORE
4001 ])
4002
4003 dnl
4004 dnl Check to see if sys/sdt.h exists and that it is suitable for use.
4005 dnl Some versions of sdt.h were not compatible with C++11.
4006 dnl
4007 AC_DEFUN([GLIBCXX_CHECK_SDT_H], [
4008   AC_MSG_CHECKING([for suitable sys/sdt.h])
4009   # Note that this test has to be run with the C language.
4010   # Otherwise, sdt.h will try to include some headers from
4011   # libstdc++ itself.
4012   AC_LANG_SAVE
4013   AC_LANG_C
4014   AC_CACHE_VAL(glibcxx_cv_sys_sdt_h, [
4015     # Because we have to run the test in C, we use grep rather
4016     # than the compiler to check for the bug.  The bug is that
4017     # were strings without trailing whitespace, causing g++
4018     # to look for operator"".  The pattern searches for the fixed
4019     # output.
4020     AC_EGREP_CPP([ \",\" ], [
4021       #include <sys/sdt.h>
4022       int f() { STAP_PROBE(hi, bob); }
4023     ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no])
4024   ])
4025   AC_LANG_RESTORE
4026   if test $glibcxx_cv_sys_sdt_h = yes; then
4027     AC_DEFINE(HAVE_SYS_SDT_H, 1,
4028               [Define to 1 if you have a suitable <sys/sdt.h> header file])
4029   fi
4030   AC_MSG_RESULT($glibcxx_cv_sys_sdt_h)
4031 ])
4032
4033 dnl
4034 dnl Control whether the library should define symbols for old and new ABIs.
4035 dnl This affects definitions of strings, stringstreams and locale facets.
4036 dnl
4037 dnl --disable-libstdcxx-dual-abi will use old ABI for all types.
4038 dnl
4039 dnl Defines:
4040 dnl  _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0)
4041 dnl
4042 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [
4043   GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string])
4044   if test x$enable_symvers = xgnu-versioned-namespace; then
4045     # gnu-versioned-namespace is incompatible with the dual ABI.
4046     enable_libstdcxx_dual_abi="no"
4047   fi
4048   if test x"$enable_libstdcxx_dual_abi" != xyes; then
4049     AC_MSG_NOTICE([dual ABI is disabled])
4050     default_libstdcxx_abi="gcc4-compatible"
4051   fi
4052   GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes)
4053 ])
4054
4055 dnl
4056 dnl Check to see which ABI should be enabled by default.
4057 dnl
4058 dnl --with-default-libstdcxx-abi={gcc4-compatible,new}
4059 dnl
4060 dnl Defines:
4061 dnl  _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
4062 dnl
4063 AC_DEFUN([GLIBCXX_DEFAULT_ABI], [
4064   if test x$enable_libstdcxx_dual_abi = xyes; then
4065   AC_MSG_CHECKING([for default std::string ABI to use])
4066   AC_ARG_WITH([default-libstdcxx-abi],
4067     AS_HELP_STRING([--with-default-libstdcxx-abi],
4068                    [set the std::string ABI to use by default]),
4069     [case "$withval" in
4070       gcc4-compatible)  default_libstdcxx_abi="gcc4-compatible" ;;
4071       new|cxx11)  default_libstdcxx_abi="new" ;;
4072       c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;;
4073       *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
4074      esac
4075      ],
4076     [default_libstdcxx_abi="new"])
4077   AC_MSG_RESULT(${default_libstdcxx_abi})
4078   fi
4079   if test $default_libstdcxx_abi = "new"; then
4080     glibcxx_cxx11_abi=1
4081     glibcxx_cxx98_abi=0
4082   else
4083     glibcxx_cxx11_abi=0
4084     glibcxx_cxx98_abi=1
4085   fi
4086   AC_SUBST(glibcxx_cxx98_abi)
4087   GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1)
4088 ])
4089
4090 dnl
4091 dnl Check to see whether to build libstdc++fs.a
4092 dnl
4093 dnl --enable-libstdcxx-filesystem-ts
4094 dnl
4095 AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [
4096   GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,,
4097     [turns on ISO/IEC TS 18822 support],
4098     [permit yes|no|auto])
4099
4100   AC_MSG_CHECKING([whether to build Filesystem TS support])
4101   if test x"$ac_cv_header_dirent_h" != x"yes"; then
4102     enable_libstdcxx_filesystem_ts=no
4103   fi
4104   if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then
4105     case "${target_os}" in
4106       freebsd*|netbsd*|openbsd*|dragonfly*|darwin*)
4107         enable_libstdcxx_filesystem_ts=yes
4108         ;;
4109       gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
4110         enable_libstdcxx_filesystem_ts=yes
4111         ;;
4112       solaris*)
4113         enable_libstdcxx_filesystem_ts=yes
4114         ;;
4115       *)
4116         enable_libstdcxx_filesystem_ts=no
4117         ;;
4118     esac
4119   fi
4120   AC_MSG_RESULT($enable_libstdcxx_filesystem_ts)
4121   GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes)
4122 ])
4123
4124 dnl
4125 dnl Check whether the library calls required by the Filesystem TS are present
4126 dnl and define _GLIBCXX_USE_REALPATH and _GLIBCXX_USE_UTIMENSAT.
4127 dnl
4128 AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
4129 dnl
4130   AC_LANG_SAVE
4131   AC_LANG_CPLUSPLUS
4132   ac_save_CXXFLAGS="$CXXFLAGS"
4133   CXXFLAGS="$CXXFLAGS -fno-exceptions"
4134 dnl
4135   AC_MSG_CHECKING([for struct dirent.d_type])
4136   AC_CACHE_VAL(glibcxx_cv_dirent_d_type, [dnl
4137     GCC_TRY_COMPILE_OR_LINK(
4138       [#include <dirent.h>],
4139       [
4140        struct dirent d;
4141        if (sizeof d.d_type) return 0;
4142       ],
4143       [glibcxx_cv_dirent_d_type=yes],
4144       [glibcxx_cv_dirent_d_type=no])
4145   ])
4146   if test $glibcxx_cv_dirent_d_type = yes; then
4147     AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.])
4148   fi
4149   AC_MSG_RESULT($glibcxx_cv_dirent_d_type)
4150 dnl
4151   AC_MSG_CHECKING([for realpath])
4152   AC_CACHE_VAL(glibcxx_cv_realpath, [dnl
4153     GCC_TRY_COMPILE_OR_LINK(
4154       [
4155        #include <stdlib.h>
4156        #include <unistd.h>
4157       ],
4158       [
4159        #if _XOPEN_VERSION < 500
4160        #error
4161        #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX)
4162        char *tmp = realpath((const char*)NULL, (char*)NULL);
4163        #else
4164        #error
4165        #endif
4166       ],
4167       [glibcxx_cv_realpath=yes],
4168       [glibcxx_cv_realpath=no])
4169   ])
4170   if test $glibcxx_cv_realpath = yes; then
4171     AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.])
4172   fi
4173   AC_MSG_RESULT($glibcxx_cv_realpath)
4174 dnl
4175   AC_MSG_CHECKING([for utimensat])
4176   AC_CACHE_VAL(glibcxx_cv_utimensat, [dnl
4177     GCC_TRY_COMPILE_OR_LINK(
4178       [
4179         #include <fcntl.h>
4180         #include <sys/stat.h>
4181       ],
4182       [
4183         struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } };
4184         int i = utimensat(AT_FDCWD, "path", ts, 0);
4185       ],
4186       [glibcxx_cv_utimensat=yes],
4187       [glibcxx_cv_utimensat=no])
4188   ])
4189   if test $glibcxx_cv_utimensat = yes; then
4190     AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.])
4191   fi
4192   AC_MSG_RESULT($glibcxx_cv_utimensat)
4193 dnl
4194   AC_MSG_CHECKING([for struct stat.st_mtim.tv_nsec])
4195   AC_CACHE_VAL(glibcxx_cv_st_mtim, [dnl
4196     GCC_TRY_COMPILE_OR_LINK(
4197       [ #include <sys/stat.h> ],
4198       [
4199         struct stat st;
4200         return st.st_mtim.tv_nsec;
4201       ],
4202       [glibcxx_cv_st_mtim=yes],
4203       [glibcxx_cv_st_mtim=no])
4204   ])
4205   if test $glibcxx_cv_st_mtim = yes; then
4206     AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.])
4207   fi
4208   AC_MSG_RESULT($glibcxx_cv_st_mtim)
4209 dnl
4210   AC_MSG_CHECKING([for fchmod])
4211   AC_CACHE_VAL(glibcxx_cv_fchmod, [dnl
4212     GCC_TRY_COMPILE_OR_LINK(
4213       [#include <sys/stat.h>],
4214       [fchmod(1, S_IWUSR);],
4215       [glibcxx_cv_fchmod=yes],
4216       [glibcxx_cv_fchmod=no])
4217   ])
4218   if test $glibcxx_cv_fchmod = yes; then
4219     AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.])
4220   fi
4221   AC_MSG_RESULT($glibcxx_cv_fchmod)
4222 dnl
4223   AC_MSG_CHECKING([for fchmodat])
4224   AC_CACHE_VAL(glibcxx_cv_fchmodat, [dnl
4225     GCC_TRY_COMPILE_OR_LINK(
4226       [
4227         #include <fcntl.h>
4228         #include <sys/stat.h>
4229       ],
4230       [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);],
4231       [glibcxx_cv_fchmodat=yes],
4232       [glibcxx_cv_fchmodat=no])
4233   ])
4234   if test $glibcxx_cv_fchmodat = yes; then
4235     AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.])
4236   fi
4237   AC_MSG_RESULT($glibcxx_cv_fchmodat)
4238 dnl
4239   AC_MSG_CHECKING([for sendfile that can copy files])
4240   AC_CACHE_VAL(glibcxx_cv_sendfile, [dnl
4241     case "${target_os}" in
4242       gnu* | linux* | solaris*)
4243         GCC_TRY_COMPILE_OR_LINK(
4244           [#include <sys/sendfile.h>],
4245           [sendfile(1, 2, (off_t*)NULL, sizeof 1);],
4246           [glibcxx_cv_sendfile=yes],
4247           [glibcxx_cv_sendfile=no])
4248         ;;
4249       *)
4250         glibcxx_cv_sendfile=no
4251         ;;
4252     esac
4253   ])
4254   if test $glibcxx_cv_sendfile = yes; then
4255     AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/stat.h>.])
4256   fi
4257   AC_MSG_RESULT($glibcxx_cv_sendfile)
4258 dnl
4259   CXXFLAGS="$ac_save_CXXFLAGS"
4260   AC_LANG_RESTORE
4261 ])
4262
4263 # Macros from the top-level gcc directory.
4264 m4_include([../config/gc++filt.m4])
4265 m4_include([../config/tls.m4])
4266 m4_include([../config/gthr.m4])