libstdc++-v3/acinclude.m4

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