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