libstdc++-v3/acinclude.m4

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