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