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++ python src src/c++98 src/c++11 doc po testsuite])
  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_IFREG 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   if $GLIBCXX_IS_NATIVE ; then
 604     # Do checks for resource limit functions.
 605     GLIBCXX_CHECK_SETRLIMIT
 606
 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 fi
 664 AC_MSG_RESULT($glibcxx_local_stylesheets)
 665
 666 if test x"$glibcxx_local_stylesheets" = x"yes"; then
 667   AC_SUBST(XSL_STYLE_DIR)
 668   AC_MSG_NOTICE($XSL_STYLE_DIR)
 669 else
 670   glibcxx_stylesheets=no
 671 fi
 672
 673 # Check for epub3 dependencies.
 674 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
 675 glibcxx_epub_stylesheets=no
 676 if test x"$glibcxx_local_stylesheets" = x"yes"; then
 677    if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
 678       glibcxx_epub_stylesheets=yes
 679    fi
 680 fi
 681 AC_MSG_RESULT($glibcxx_epub_stylesheets)
 682 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
 683
 684 ])
 685
 686
 687 dnl
 688 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
 689 dnl
 690 dnl Substs:
 691 dnl  GLIBCXX_INCLUDES
 692 dnl  TOPLEVEL_INCLUDES
 693 dnl
 694 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
 695   # Used for every C++ compile we perform.
 696   GLIBCXX_INCLUDES="\
 697 -I$glibcxx_builddir/include/$host_alias \
 698 -I$glibcxx_builddir/include \
 699 -I$glibcxx_srcdir/libsupc++"
 700
 701   # For Canadian crosses, pick this up too.
 702   if test $CANADIAN = yes; then
 703     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
 704   fi
 705
 706   # Stuff in the actual top level.  Currently only used by libsupc++ to
 707   # get unwind* headers from the libgcc dir.
 708   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
 709   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
 710
 711   # Now, export this to all the little Makefiles....
 712   AC_SUBST(GLIBCXX_INCLUDES)
 713   AC_SUBST(TOPLEVEL_INCLUDES)
 714 ])
 715
 716
 717 dnl
 718 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
 719 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
 720 dnl
 721 dnl Substs:
 722 dnl  OPTIMIZE_CXXFLAGS
 723 dnl  WARN_FLAGS
 724 dnl
 725 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
 726   # Optimization flags that are probably a good idea for thrill-seekers. Just
 727   # uncomment the lines below and make, everything else is ready to go...
 728   # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
 729   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
 730   AC_SUBST(OPTIMIZE_CXXFLAGS)
 731
 732   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi'
 733   AC_SUBST(WARN_FLAGS)
 734 ])
 735
 736
 737 dnl
 738 dnl All installation directory information is determined here.
 739 dnl
 740 dnl Substs:
 741 dnl  gxx_install_dir
 742 dnl  glibcxx_prefixdir
 743 dnl  glibcxx_toolexecdir
 744 dnl  glibcxx_toolexeclibdir
 745 dnl
 746 dnl Assumes cross_compiling bits already done, and with_cross_host in
 747 dnl particular.
 748 dnl
 749 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
 750 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
 751 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
 752   glibcxx_toolexecdir=no
 753   glibcxx_toolexeclibdir=no
 754   glibcxx_prefixdir=$prefix
 755
 756   AC_MSG_CHECKING([for gxx-include-dir])
 757   AC_ARG_WITH([gxx-include-dir],
 758     AC_HELP_STRING([--with-gxx-include-dir=DIR],
 759                    [installation directory for include files]),
 760     [case "$withval" in
 761       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
 762       no)  gxx_include_dir=no ;;
 763       *)   gxx_include_dir=$withval ;;
 764      esac],
 765     [gxx_include_dir=no])
 766   AC_MSG_RESULT($gxx_include_dir)
 767
 768   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
 769   AC_ARG_ENABLE([version-specific-runtime-libs],
 770     AC_HELP_STRING([--enable-version-specific-runtime-libs],
 771                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
 772     [case "$enableval" in
 773       yes) version_specific_libs=yes ;;
 774       no)  version_specific_libs=no ;;
 775       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
 776      esac],
 777     [version_specific_libs=no])
 778   AC_MSG_RESULT($version_specific_libs)
 779
 780   # Default case for install directory for include files.
 781   if test $version_specific_libs = no && test $gxx_include_dir = no; then
 782     gxx_include_dir='include/c++/${gcc_version}'
 783     if test -n "$with_cross_host" &&
 784        test x"$with_cross_host" != x"no"; then
 785       gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
 786     else
 787       gxx_include_dir='${prefix}/'"$gxx_include_dir"
 788     fi
 789   fi
 790
 791   # Version-specific runtime libs processing.
 792   if test $version_specific_libs = yes; then
 793     # Need the gcc compiler version to know where to install libraries
 794     # and header files if --enable-version-specific-runtime-libs option
 795     # is selected.  FIXME: these variables are misnamed, there are
 796     # no executables installed in _toolexecdir or _toolexeclibdir.
 797     if test x"$gxx_include_dir" = x"no"; then
 798       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
 799     fi
 800     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 801     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
 802   fi
 803
 804   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
 805   # Install a library built with a cross compiler in tooldir, not libdir.
 806   if test x"$glibcxx_toolexecdir" = x"no"; then
 807     if test -n "$with_cross_host" &&
 808        test x"$with_cross_host" != x"no"; then
 809       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
 810       glibcxx_toolexeclibdir='${toolexecdir}/lib'
 811     else
 812       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 813       glibcxx_toolexeclibdir='${libdir}'
 814     fi
 815     multi_os_directory=`$CXX -print-multi-os-directory`
 816     case $multi_os_directory in
 817       .) ;; # Avoid trailing /.
 818       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
 819     esac
 820   fi
 821
 822   AC_MSG_CHECKING([for install location])
 823   AC_MSG_RESULT($gxx_include_dir)
 824
 825   AC_SUBST(glibcxx_prefixdir)
 826   AC_SUBST(gxx_include_dir)
 827   AC_SUBST(glibcxx_toolexecdir)
 828   AC_SUBST(glibcxx_toolexeclibdir)
 829 ])
 830
 831
 832 dnl
 833 dnl GLIBCXX_ENABLE
 834 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
 835 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
 836 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
 837 dnl
 838 dnl See docs/html/17_intro/configury.html#enable for documentation.
 839 dnl
 840 m4_define([GLIBCXX_ENABLE],[dnl
 841 m4_define([_g_switch],[--enable-$1])dnl
 842 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
 843  AC_ARG_ENABLE([$1],m4_dquote(_g_help),
 844   m4_bmatch([$5],
 845    [^permit ],
 846      [[
 847       case "$enableval" in
 848        m4_bpatsubst([$5],[permit ])) ;;
 849        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
 850           dnl Idea for future:  generate a URL pointing to
 851           dnl "onlinedocs/configopts.html#whatever"
 852       esac
 853      ]],
 854    [^$],
 855      [[
 856       case "$enableval" in
 857        yes|no) ;;
 858        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
 859       esac
 860      ]],
 861    [[$5]]),
 862   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
 863 m4_undefine([_g_switch])dnl
 864 m4_undefine([_g_help])dnl
 865 ])
 866
 867
 868 dnl
 869 dnl Check for ISO/IEC 9899:1999 "C99" support.
 870 dnl
 871 dnl --enable-c99 defines _GLIBCXX_USE_C99
 872 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
 873 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
 874 dnl       Where DEFAULT is either `yes' or `no'.
 875 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
 876 dnl
 877 AC_DEFUN([GLIBCXX_ENABLE_C99], [
 878   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
 879
 880   if test x"$enable_c99" = x"yes"; then
 881
 882   AC_LANG_SAVE
 883   AC_LANG_CPLUSPLUS
 884
 885   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
 886   # undefined and fake C99 facilities - like pre-standard snprintf - may be
 887   # spuriously enabled.
 888   # Long term, -std=c++0x could be even better, could manage to explicitely
 889   # request C99 facilities to the underlying C headers.
 890   ac_save_CXXFLAGS="$CXXFLAGS"
 891   CXXFLAGS="$CXXFLAGS -std=c++98"
 892   ac_save_LIBS="$LIBS"
 893   ac_save_gcc_no_link="$gcc_no_link"
 894
 895   if test x$gcc_no_link != xyes; then
 896     # Use -fno-exceptions to that the C driver can link these tests without
 897     # hitting undefined references to personality routines.
 898     CXXFLAGS="$CXXFLAGS -fno-exceptions"
 899     AC_CHECK_LIB(m, sin, [
 900       LIBS="$LIBS -lm"
 901     ], [
 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>])
 909   AC_CACHE_VAL(glibcxx_cv_c99_math, [
 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=yes], [glibcxx_cv_c99_math=no])
 928   ])
 929   AC_MSG_RESULT($glibcxx_cv_c99_math)
 930   if test x"$glibcxx_cv_c99_math" = x"yes"; then
 931     AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
 932               [Define if C99 functions or macros in <math.h> should be imported
 933               in <cmath> in namespace std.])
 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   glibcxx_cv_c99_complex=no;
 943   if test x"$ac_has_complex_h" = x"yes"; then
 944     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
 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=yes], [glibcxx_cv_c99_complex=no])
 996   fi
 997   AC_MSG_RESULT($glibcxx_cv_c99_complex)
 998   if test x"$glibcxx_cv_c99_complex" = x"yes"; then
 999     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
1000               [Define if C99 functions in <complex.h> should be used in
1001               <complex>. Using compiler builtins for these functions requires
1002               corresponding C99 library functions to be present.])
1003   fi
1004
1005   # Check for the existence in <stdio.h> of vscanf, et. al.
1006   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1007   AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
1008   GCC_TRY_COMPILE_OR_LINK(
1009      [#include <stdio.h>
1010       #include <stdarg.h>
1011       void foo(char* fmt, ...)
1012       {
1013         va_list args; va_start(args, fmt);
1014         vfscanf(stderr, "%i", args);
1015         vscanf("%i", args);
1016         vsnprintf(fmt, 0, "%i", args);
1017         vsscanf(fmt, "%i", args);
1018       }],
1019      [snprintf("12", 0, "%i");],
1020      [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
1021   ])
1022   AC_MSG_RESULT($glibcxx_cv_c99_stdio)
1023
1024   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1025   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1026   AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
1027   GCC_TRY_COMPILE_OR_LINK(
1028      [#include <stdlib.h>
1029       volatile float f;
1030       volatile long double ld;
1031       volatile unsigned long long ll;
1032       lldiv_t mydivt;],
1033      [char* tmp;
1034       f = strtof("gnu", &tmp);
1035       ld = strtold("gnu", &tmp);
1036       ll = strtoll("gnu", &tmp, 10);
1037       ll = strtoull("gnu", &tmp, 10);
1038       ll = llabs(10);
1039       mydivt = lldiv(10,1);
1040       ll = mydivt.quot;
1041       ll = mydivt.rem;
1042       ll = atoll("10");
1043       _Exit(0);
1044       ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
1045   ])
1046   AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
1047
1048   # Check for the existence in <wchar.h> of wcstold, etc.
1049   glibcxx_cv_c99_wchar=no;
1050   if test x"$ac_has_wchar_h" = xyes &&
1051      test x"$ac_has_wctype_h" = xyes; then
1052     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1053     AC_TRY_COMPILE([#include <wchar.h>
1054                     namespace test
1055                     {
1056                       using ::wcstold;
1057                       using ::wcstoll;
1058                       using ::wcstoull;
1059                     }
1060                    ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
1061
1062     # Checks for wide character functions that may not be present.
1063     # Injection of these is wrapped with guard macros.
1064     # NB: only put functions here, instead of immediately above, if
1065     # absolutely necessary.
1066     AC_TRY_COMPILE([#include <wchar.h>
1067                     namespace test { using ::vfwscanf; } ], [],
1068                    [AC_DEFINE(HAVE_VFWSCANF,1,
1069                         [Defined if vfwscanf exists.])],[])
1070
1071     AC_TRY_COMPILE([#include <wchar.h>
1072                     namespace test { using ::vswscanf; } ], [],
1073                    [AC_DEFINE(HAVE_VSWSCANF,1,
1074                         [Defined if vswscanf exists.])],[])
1075
1076     AC_TRY_COMPILE([#include <wchar.h>
1077                     namespace test { using ::vwscanf; } ], [],
1078                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1079
1080     AC_TRY_COMPILE([#include <wchar.h>
1081                     namespace test { using ::wcstof; } ], [],
1082                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1083
1084     AC_TRY_COMPILE([#include <wctype.h>],
1085                    [ wint_t t; int i = iswblank(t);],
1086                    [AC_DEFINE(HAVE_ISWBLANK,1,
1087                         [Defined if iswblank exists.])],[])
1088
1089     AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1090   fi
1091
1092   # Option parsed, now set things appropriately.
1093   if test x"$glibcxx_cv_c99_math" = x"no" ||
1094      test x"$glibcxx_cv_c99_complex" = x"no" ||
1095      test x"$glibcxx_cv_c99_stdio" = x"no" ||
1096      test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1097      test x"$glibcxx_cv_c99_wchar" = x"no"; then
1098     enable_c99=no;
1099   else
1100     AC_DEFINE(_GLIBCXX_USE_C99, 1,
1101     [Define if C99 functions or macros from <wchar.h>, <math.h>,
1102     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1103   fi
1104
1105   gcc_no_link="$ac_save_gcc_no_link"
1106   LIBS="$ac_save_LIBS"
1107   CXXFLAGS="$ac_save_CXXFLAGS"
1108   AC_LANG_RESTORE
1109   fi
1110
1111   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1112   AC_MSG_RESULT($enable_c99)
1113 ])
1114
1115
1116 dnl
1117 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1118 dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this]
1119 dnl in the C++11 standard.
1120 dnl
1121 dnl --enable-libstdcxx-time
1122 dnl --enable-libstdcxx-time=yes
1123 dnl        checks for the availability of monotonic and realtime clocks,
1124 dnl        nanosleep and sched_yield in libc and libposix4 and, if needed,
1125 dnl        links in the latter.
1126 dnl --enable-libstdcxx-time=rt
1127 dnl        also searches (and, if needed, links) librt.  Note that this is
1128 dnl        not always desirable because, in glibc, for example, in turn it
1129 dnl        triggers the linking of libpthread too, which activates locking,
1130 dnl        a large overhead for single-thread programs.
1131 dnl --enable-libstdcxx-time=no
1132 dnl --disable-libstdcxx-time
1133 dnl        disables the checks completely
1134 dnl
1135 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1136
1137   AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1138   GLIBCXX_ENABLE(libstdcxx-time,$1,[[[=KIND]]],
1139     [use KIND for check type],
1140     [permit yes|no|rt])
1141
1142   AC_LANG_SAVE
1143   AC_LANG_CPLUSPLUS
1144   ac_save_CXXFLAGS="$CXXFLAGS"
1145   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1146   ac_save_LIBS="$LIBS"
1147
1148   ac_has_clock_monotonic=no
1149   ac_has_clock_realtime=no
1150   AC_MSG_RESULT($enable_libstdcxx_time)
1151
1152   if test x"$enable_libstdcxx_time" != x"no"; then
1153
1154     if test x"$enable_libstdcxx_time" = x"rt"; then
1155       AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1156       AC_SEARCH_LIBS(nanosleep, [rt posix4])
1157     else
1158       AC_SEARCH_LIBS(clock_gettime, [posix4])
1159       AC_SEARCH_LIBS(nanosleep, [posix4])
1160     fi
1161
1162     case "$ac_cv_search_clock_gettime" in
1163       -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1164       ;;
1165     esac
1166     case "$ac_cv_search_nanosleep" in
1167       -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1168       ;;
1169     esac
1170
1171     AC_SEARCH_LIBS(sched_yield, [rt posix4])
1172
1173     case "$ac_cv_search_sched_yield" in
1174       -lposix4*)
1175       GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1176       AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1177                 [ Defined if sched_yield is available. ])
1178       ;;
1179       -lrt*)
1180       if test x"$enable_libstdcxx_time" = x"rt"; then
1181         GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1182         AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1183                   [ Defined if sched_yield is available. ])
1184       fi
1185       ;;
1186       *)
1187       AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1188                 [ Defined if sched_yield is available. ])
1189       ;;
1190     esac
1191
1192     AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1193
1194     if test x"$ac_has_unistd_h" = x"yes"; then
1195       AC_MSG_CHECKING([for monotonic clock])
1196       AC_TRY_LINK(
1197         [#include <unistd.h>
1198          #include <time.h>
1199         ],
1200         [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1201           timespec tp;
1202          #endif
1203           clock_gettime(CLOCK_MONOTONIC, &tp);
1204         ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1205
1206       AC_MSG_RESULT($ac_has_clock_monotonic)
1207
1208       AC_MSG_CHECKING([for realtime clock])
1209       AC_TRY_LINK(
1210         [#include <unistd.h>
1211          #include <time.h>
1212         ],
1213         [#if _POSIX_TIMERS > 0
1214           timespec tp;
1215          #endif
1216           clock_gettime(CLOCK_REALTIME, &tp);
1217         ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1218
1219       AC_MSG_RESULT($ac_has_clock_realtime)
1220
1221       AC_MSG_CHECKING([for nanosleep])
1222       AC_TRY_LINK(
1223         [#include <unistd.h>
1224          #include <time.h>
1225         ],
1226         [#if _POSIX_TIMERS > 0
1227           timespec tp;
1228          #endif
1229           nanosleep(&tp, 0);
1230         ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1231
1232       AC_MSG_RESULT($ac_has_nanosleep)
1233     fi
1234   fi
1235
1236   if test x"$ac_has_clock_monotonic" = x"yes"; then
1237     AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1238       [ Defined if clock_gettime has monotonic clock support. ])
1239   fi
1240
1241   if test x"$ac_has_clock_realtime" = x"yes"; then
1242     AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1243       [ Defined if clock_gettime has realtime clock support. ])
1244   fi
1245
1246   if test x"$ac_has_nanosleep" = x"yes"; then
1247     AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1248       [ Defined if nanosleep is available. ])
1249   fi
1250
1251   AC_SUBST(GLIBCXX_LIBS)
1252
1253   CXXFLAGS="$ac_save_CXXFLAGS"
1254   LIBS="$ac_save_LIBS"
1255   AC_LANG_RESTORE
1256 ])
1257
1258 dnl
1259 dnl Check for gettimeofday, used in the implementation of 20.11.7
1260 dnl [time.clock] in the C++11 standard.
1261 dnl
1262 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1263
1264   AC_MSG_CHECKING([for gettimeofday])
1265
1266   AC_LANG_SAVE
1267   AC_LANG_CPLUSPLUS
1268   ac_save_CXXFLAGS="$CXXFLAGS"
1269   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1270
1271   ac_has_gettimeofday=no;
1272   AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1273   if test x"$ac_has_sys_time_h" = x"yes"; then
1274     AC_MSG_CHECKING([for gettimeofday])
1275     GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1276       [timeval tv; gettimeofday(&tv, 0);],
1277       [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1278
1279     AC_MSG_RESULT($ac_has_gettimeofday)
1280   fi
1281
1282   if test x"$ac_has_gettimeofday" = x"yes"; then
1283     AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1284       [ Defined if gettimeofday is available. ])
1285   fi
1286
1287   CXXFLAGS="$ac_save_CXXFLAGS"
1288   AC_LANG_RESTORE
1289 ])
1290
1291 dnl
1292 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1293 dnl facilities in Chapter 8, "C compatibility".
1294 dnl
1295 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1296
1297   AC_LANG_SAVE
1298   AC_LANG_CPLUSPLUS
1299
1300   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1301   # undefined and fake C99 facilities may be spuriously enabled.
1302   ac_save_CXXFLAGS="$CXXFLAGS"
1303   CXXFLAGS="$CXXFLAGS -std=c++98"
1304
1305   # Check for the existence of <complex.h> complex math functions used
1306   # by tr1/complex.
1307   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1308   ac_c99_complex_tr1=no;
1309   if test x"$ac_has_complex_h" = x"yes"; then
1310     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1311     AC_TRY_COMPILE([#include <complex.h>],
1312                    [typedef __complex__ float float_type; float_type tmpf;
1313                     cacosf(tmpf);
1314                     casinf(tmpf);
1315                     catanf(tmpf);
1316                     cacoshf(tmpf);
1317                     casinhf(tmpf);
1318                     catanhf(tmpf);
1319                     typedef __complex__ double double_type; double_type tmpd;
1320                     cacos(tmpd);
1321                     casin(tmpd);
1322                     catan(tmpd);
1323                     cacosh(tmpd);
1324                     casinh(tmpd);
1325                     catanh(tmpd);
1326                     typedef __complex__ long double ld_type; ld_type tmpld;
1327                     cacosl(tmpld);
1328                     casinl(tmpld);
1329                     catanl(tmpld);
1330                     cacoshl(tmpld);
1331                     casinhl(tmpld);
1332                     catanhl(tmpld);
1333                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1334   fi
1335   AC_MSG_RESULT($ac_c99_complex_tr1)
1336   if test x"$ac_c99_complex_tr1" = x"yes"; then
1337     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1338               [Define if C99 functions in <complex.h> should be used in
1339               <tr1/complex>. Using compiler builtins for these functions
1340               requires corresponding C99 library functions to be present.])
1341   fi
1342
1343   # Check for the existence of <ctype.h> functions.
1344   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1345   AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1346   AC_TRY_COMPILE([#include <ctype.h>],
1347                  [int ch;
1348                   int ret;
1349                   ret = isblank(ch);
1350                  ],[glibcxx_cv_c99_ctype_tr1=yes],
1351                    [glibcxx_cv_c99_ctype_tr1=no])
1352   ])
1353   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1354   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1355     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1356               [Define if C99 functions in <ctype.h> should be imported in
1357               <tr1/cctype> in namespace std::tr1.])
1358   fi
1359
1360   # Check for the existence of <fenv.h> functions.
1361   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1362   ac_c99_fenv_tr1=no;
1363   if test x"$ac_has_fenv_h" = x"yes"; then
1364     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1365     AC_TRY_COMPILE([#include <fenv.h>],
1366                    [int except, mode;
1367                     fexcept_t* pflag;
1368                     fenv_t* penv;
1369                     int ret;
1370                     ret = feclearexcept(except);
1371                     ret = fegetexceptflag(pflag, except);
1372                     ret = feraiseexcept(except);
1373                     ret = fesetexceptflag(pflag, except);
1374                     ret = fetestexcept(except);
1375                     ret = fegetround();
1376                     ret = fesetround(mode);
1377                     ret = fegetenv(penv);
1378                     ret = feholdexcept(penv);
1379                     ret = fesetenv(penv);
1380                     ret = feupdateenv(penv);
1381                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1382   fi
1383   AC_MSG_RESULT($ac_c99_fenv_tr1)
1384   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1385     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1386               [Define if C99 functions in <fenv.h> should be imported in
1387               <tr1/cfenv> in namespace std::tr1.])
1388   fi
1389
1390   # Check for the existence of <stdint.h> types.
1391   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1392   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1393   AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1394                   #define __STDC_CONSTANT_MACROS
1395                   #include <stdint.h>],
1396                  [typedef int8_t          my_int8_t;
1397                   my_int8_t               i8 = INT8_MIN;
1398                   i8 = INT8_MAX;
1399                   typedef int16_t         my_int16_t;
1400                   my_int16_t              i16 = INT16_MIN;
1401                   i16 = INT16_MAX;
1402                   typedef int32_t         my_int32_t;
1403                   my_int32_t              i32 = INT32_MIN;
1404                   i32 = INT32_MAX;
1405                   typedef int64_t         my_int64_t;
1406                   my_int64_t              i64 = INT64_MIN;
1407                   i64 = INT64_MAX;
1408                   typedef int_fast8_t     my_int_fast8_t;
1409                   my_int_fast8_t          if8 = INT_FAST8_MIN;
1410                   if8 = INT_FAST8_MAX;
1411                   typedef int_fast16_t    my_int_fast16_t;
1412                   my_int_fast16_t         if16 = INT_FAST16_MIN;
1413                   if16 = INT_FAST16_MAX;
1414                   typedef int_fast32_t    my_int_fast32_t;
1415                   my_int_fast32_t         if32 = INT_FAST32_MIN;
1416                   if32 = INT_FAST32_MAX;
1417                   typedef int_fast64_t    my_int_fast64_t;
1418                   my_int_fast64_t         if64 = INT_FAST64_MIN;
1419                   if64 = INT_FAST64_MAX;
1420                   typedef int_least8_t    my_int_least8_t;
1421                   my_int_least8_t         il8 = INT_LEAST8_MIN;
1422                   il8 = INT_LEAST8_MAX;
1423                   typedef int_least16_t   my_int_least16_t;
1424                   my_int_least16_t        il16 = INT_LEAST16_MIN;
1425                   il16 = INT_LEAST16_MAX;
1426                   typedef int_least32_t   my_int_least32_t;
1427                   my_int_least32_t        il32 = INT_LEAST32_MIN;
1428                   il32 = INT_LEAST32_MAX;
1429                   typedef int_least64_t   my_int_least64_t;
1430                   my_int_least64_t        il64 = INT_LEAST64_MIN;
1431                   il64 = INT_LEAST64_MAX;
1432                   typedef intmax_t        my_intmax_t;
1433                   my_intmax_t             im = INTMAX_MAX;
1434                   im = INTMAX_MIN;
1435                   typedef intptr_t        my_intptr_t;
1436                   my_intptr_t             ip = INTPTR_MAX;
1437                   ip = INTPTR_MIN;
1438                   typedef uint8_t         my_uint8_t;
1439                   my_uint8_t              ui8 = UINT8_MAX;
1440                   ui8 = UINT8_MAX;
1441                   typedef uint16_t        my_uint16_t;
1442                   my_uint16_t             ui16 = UINT16_MAX;
1443                   ui16 = UINT16_MAX;
1444                   typedef uint32_t        my_uint32_t;
1445                   my_uint32_t             ui32 = UINT32_MAX;
1446                   ui32 = UINT32_MAX;
1447                   typedef uint64_t        my_uint64_t;
1448                   my_uint64_t             ui64 = UINT64_MAX;
1449                   ui64 = UINT64_MAX;
1450                   typedef uint_fast8_t    my_uint_fast8_t;
1451                   my_uint_fast8_t         uif8 = UINT_FAST8_MAX;
1452                   uif8 = UINT_FAST8_MAX;
1453                   typedef uint_fast16_t   my_uint_fast16_t;
1454                   my_uint_fast16_t        uif16 = UINT_FAST16_MAX;
1455                   uif16 = UINT_FAST16_MAX;
1456                   typedef uint_fast32_t   my_uint_fast32_t;
1457                   my_uint_fast32_t        uif32 = UINT_FAST32_MAX;
1458                   uif32 = UINT_FAST32_MAX;
1459                   typedef uint_fast64_t   my_uint_fast64_t;
1460                   my_uint_fast64_t        uif64 = UINT_FAST64_MAX;
1461                   uif64 = UINT_FAST64_MAX;
1462                   typedef uint_least8_t   my_uint_least8_t;
1463                   my_uint_least8_t        uil8 = UINT_LEAST8_MAX;
1464                   uil8 = UINT_LEAST8_MAX;
1465                   typedef uint_least16_t  my_uint_least16_t;
1466                   my_uint_least16_t       uil16 = UINT_LEAST16_MAX;
1467                   uil16 = UINT_LEAST16_MAX;
1468                   typedef uint_least32_t  my_uint_least32_t;
1469                   my_uint_least32_t       uil32 = UINT_LEAST32_MAX;
1470                   uil32 = UINT_LEAST32_MAX;
1471                   typedef uint_least64_t  my_uint_least64_t;
1472                   my_uint_least64_t       uil64 = UINT_LEAST64_MAX;
1473                   uil64 = UINT_LEAST64_MAX;
1474                   typedef uintmax_t       my_uintmax_t;
1475                   my_uintmax_t            uim = UINTMAX_MAX;
1476                   uim = UINTMAX_MAX;
1477                   typedef uintptr_t       my_uintptr_t;
1478                   my_uintptr_t            uip = UINTPTR_MAX;
1479                   uip = UINTPTR_MAX;
1480                  ],[glibcxx_cv_c99_stdint_tr1=yes],
1481                    [glibcxx_cv_c99_stdint_tr1=no])
1482   ])
1483   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1484   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1485     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1486               [Define if C99 types in <stdint.h> should be imported in
1487               <tr1/cstdint> in namespace std::tr1.])
1488   fi
1489
1490   # Check for the existence of <math.h> functions.
1491   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1492   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1493   AC_TRY_COMPILE([#include <math.h>],
1494                  [typedef double_t  my_double_t;
1495                   typedef float_t   my_float_t;
1496                   acosh(0.0);
1497                   acoshf(0.0f);
1498                   acoshl(0.0l);
1499                   asinh(0.0);
1500                   asinhf(0.0f);
1501                   asinhl(0.0l);
1502                   atanh(0.0);
1503                   atanhf(0.0f);
1504                   atanhl(0.0l);
1505                   cbrt(0.0);
1506                   cbrtf(0.0f);
1507                   cbrtl(0.0l);
1508                   copysign(0.0, 0.0);
1509                   copysignf(0.0f, 0.0f);
1510                   copysignl(0.0l, 0.0l);
1511                   erf(0.0);
1512                   erff(0.0f);
1513                   erfl(0.0l);
1514                   erfc(0.0);
1515                   erfcf(0.0f);
1516                   erfcl(0.0l);
1517                   exp2(0.0);
1518                   exp2f(0.0f);
1519                   exp2l(0.0l);
1520                   expm1(0.0);
1521                   expm1f(0.0f);
1522                   expm1l(0.0l);
1523                   fdim(0.0, 0.0);
1524                   fdimf(0.0f, 0.0f);
1525                   fdiml(0.0l, 0.0l);
1526                   fma(0.0, 0.0, 0.0);
1527                   fmaf(0.0f, 0.0f, 0.0f);
1528                   fmal(0.0l, 0.0l, 0.0l);
1529                   fmax(0.0, 0.0);
1530                   fmaxf(0.0f, 0.0f);
1531                   fmaxl(0.0l, 0.0l);
1532                   fmin(0.0, 0.0);
1533                   fminf(0.0f, 0.0f);
1534                   fminl(0.0l, 0.0l);
1535                   hypot(0.0, 0.0);
1536                   hypotf(0.0f, 0.0f);
1537                   hypotl(0.0l, 0.0l);
1538                   ilogb(0.0);
1539                   ilogbf(0.0f);
1540                   ilogbl(0.0l);
1541                   lgamma(0.0);
1542                   lgammaf(0.0f);
1543                   lgammal(0.0l);
1544                   llrint(0.0);
1545                   llrintf(0.0f);
1546                   llrintl(0.0l);
1547                   llround(0.0);
1548                   llroundf(0.0f);
1549                   llroundl(0.0l);
1550                   log1p(0.0);
1551                   log1pf(0.0f);
1552                   log1pl(0.0l);
1553                   log2(0.0);
1554                   log2f(0.0f);
1555                   log2l(0.0l);
1556                   logb(0.0);
1557                   logbf(0.0f);
1558                   logbl(0.0l);
1559                   lrint(0.0);
1560                   lrintf(0.0f);
1561                   lrintl(0.0l);
1562                   lround(0.0);
1563                   lroundf(0.0f);
1564                   lroundl(0.0l);
1565                   nan(0);
1566                   nanf(0);
1567                   nanl(0);
1568                   nearbyint(0.0);
1569                   nearbyintf(0.0f);
1570                   nearbyintl(0.0l);
1571                   nextafter(0.0, 0.0);
1572                   nextafterf(0.0f, 0.0f);
1573                   nextafterl(0.0l, 0.0l);
1574                   nexttoward(0.0, 0.0);
1575                   nexttowardf(0.0f, 0.0f);
1576                   nexttowardl(0.0l, 0.0l);
1577                   remainder(0.0, 0.0);
1578                   remainderf(0.0f, 0.0f);
1579                   remainderl(0.0l, 0.0l);
1580                   remquo(0.0, 0.0, 0);
1581                   remquof(0.0f, 0.0f, 0);
1582                   remquol(0.0l, 0.0l, 0);
1583                   rint(0.0);
1584                   rintf(0.0f);
1585                   rintl(0.0l);
1586                   round(0.0);
1587                   roundf(0.0f);
1588                   roundl(0.0l);
1589                   scalbln(0.0, 0l);
1590                   scalblnf(0.0f, 0l);
1591                   scalblnl(0.0l, 0l);
1592                   scalbn(0.0, 0);
1593                   scalbnf(0.0f, 0);
1594                   scalbnl(0.0l, 0);
1595                   tgamma(0.0);
1596                   tgammaf(0.0f);
1597                   tgammal(0.0l);
1598                   trunc(0.0);
1599                   truncf(0.0f);
1600                   truncl(0.0l);
1601                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1602   ])
1603   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1604   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1605     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1606               [Define if C99 functions or macros in <math.h> should be imported
1607               in <tr1/cmath> in namespace std::tr1.])
1608   fi
1609
1610   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1611   # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1612   ac_c99_inttypes_tr1=no;
1613   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1614     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1615     AC_TRY_COMPILE([#include <inttypes.h>],
1616                    [intmax_t i, numer, denom, base;
1617                     const char* s;
1618                     char** endptr;
1619                     intmax_t ret = imaxabs(i);
1620                     imaxdiv_t dret = imaxdiv(numer, denom);
1621                     ret = strtoimax(s, endptr, base);
1622                     uintmax_t uret = strtoumax(s, endptr, base);
1623                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1624   fi
1625   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1626   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1627     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1628               [Define if C99 functions in <inttypes.h> should be imported in
1629               <tr1/cinttypes> in namespace std::tr1.])
1630   fi
1631
1632   # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1633   # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1634   ac_c99_inttypes_wchar_t_tr1=no;
1635   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1636     AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1637     AC_TRY_COMPILE([#include <inttypes.h>],
1638                    [intmax_t base;
1639                     const wchar_t* s;
1640                     wchar_t** endptr;
1641                     intmax_t ret = wcstoimax(s, endptr, base);
1642                     uintmax_t uret = wcstoumax(s, endptr, base);
1643                    ],[ac_c99_inttypes_wchar_t_tr1=yes],
1644                      [ac_c99_inttypes_wchar_t_tr1=no])
1645   fi
1646   AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1647   if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1648     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1649               [Define if wchar_t C99 functions in <inttypes.h> should be
1650               imported in <tr1/cinttypes> in namespace std::tr1.])
1651   fi
1652
1653   # Check for the existence of the <stdbool.h> header.
1654   AC_CHECK_HEADERS(stdbool.h)
1655
1656   # Check for the existence of the <stdalign.h> header.
1657   AC_CHECK_HEADERS(stdalign.h)
1658
1659   CXXFLAGS="$ac_save_CXXFLAGS"
1660   AC_LANG_RESTORE
1661 ])
1662
1663 dnl
1664 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1665 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1666 dnl
1667 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1668
1669   AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1670   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1671     if test -r /dev/random && test -r /dev/urandom; then
1672       glibcxx_cv_random_tr1=yes;
1673     else
1674       glibcxx_cv_random_tr1=no;
1675     fi
1676   ])
1677   AC_MSG_RESULT($glibcxx_cv_random_tr1)
1678
1679   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1680     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1681               [Define if /dev/random and /dev/urandom are available for
1682                the random_device of TR1 (Chapter 5.1).])
1683   fi
1684
1685 ])
1686
1687 dnl
1688 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
1689 dnl
1690 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
1691
1692   AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
1693   AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
1694                  [#include <stdio.h>],
1695                  [AC_MSG_ERROR([computing EOF failed])])
1696   ])
1697   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
1698                      [Define to the value of the EOF integer constant.])
1699
1700   AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
1701   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
1702                  [#include <stdio.h>],
1703                  [AC_MSG_ERROR([computing SEEK_CUR failed])])
1704   ])
1705   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
1706                      [Define to the value of the SEEK_CUR integer constant.])
1707
1708   AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
1709   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
1710                  [#include <stdio.h>],
1711                  [AC_MSG_ERROR([computing SEEK_END failed])])
1712   ])
1713   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
1714                      [Define to the value of the SEEK_END integer constant.])
1715 ])
1716
1717 dnl
1718 dnl Check whether required C++ overloads are present in <stdio.h>.
1719 dnl
1720 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
1721
1722   AC_LANG_SAVE
1723   AC_LANG_CPLUSPLUS
1724
1725   AC_MSG_CHECKING([for gets declaration])
1726   AC_CACHE_VAL(glibcxx_cv_gets, [
1727   AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1728           [#include <stdio.h>
1729            namespace test
1730            {
1731               using ::gets;
1732            }
1733         ])],
1734         [glibcxx_cv_gets=yes],
1735         [glibcxx_cv_gets=no]
1736       )])
1737
1738   if test $glibcxx_cv_gets = yes; then
1739     AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h>.])
1740   fi
1741   AC_MSG_RESULT($glibcxx_cv_gets)
1742
1743   AC_LANG_RESTORE
1744 ])
1745
1746 dnl
1747 dnl Check whether macros, etc are present for <system_error>
1748 dnl
1749 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1750
1751 m4_pushdef([n_syserr], [1])dnl
1752 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1753                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1754                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
1755                       ECHILD, ENOSPC, EPERM,
1756                       ETIMEDOUT, EWOULDBLOCK],
1757 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1758 AC_MSG_CHECKING([for syserr])
1759 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1760 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1761                                    [int i = syserr;])],
1762                   [glibcxx_cv_system_error[]n_syserr=yes],
1763                   [glibcxx_cv_system_error[]n_syserr=no])
1764 ])
1765 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1766 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1767   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1768 fi
1769 m4_define([n_syserr], m4_incr(n_syserr))dnl
1770 m4_popdef([SYSERR])dnl
1771 ])
1772 m4_popdef([n_syserr])dnl
1773 ])
1774
1775 dnl
1776 dnl Check for what type of C headers to use.
1777 dnl
1778 dnl --enable-cheaders= [does stuff].
1779 dnl --disable-cheaders [does not do anything, really].
1780 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1781 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1782 dnl
1783 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1784   GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
1785     [construct "C" headers for g++], [permit c|c_std|c_global])
1786   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1787
1788   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1789
1790   # Allow overrides to configure.host here.
1791   if test $enable_cheaders = c_global; then
1792      c_compatibility=yes
1793   fi
1794
1795   AC_SUBST(C_INCLUDE_DIR)
1796   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1797   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1798   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1799   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1800 ])
1801
1802
1803 dnl
1804 dnl Check for which locale library to use.  The choice is mapped to
1805 dnl a subdirectory of config/locale.
1806 dnl
1807 dnl Default is generic.
1808 dnl
1809 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1810   GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
1811     [use MODEL for target locale package],
1812     [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
1813
1814   # Deal with gettext issues.  Default to not using it (=no) until we detect
1815   # support for it later.  Let the user turn it off via --e/d, but let that
1816   # default to on for easier handling.
1817   USE_NLS=no
1818   AC_ARG_ENABLE(nls,
1819     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1820     [],
1821     [enable_nls=yes])
1822
1823   # Either a known package, or "auto"
1824   if test $enable_clocale = no || test $enable_clocale = yes; then
1825      enable_clocale=auto
1826   fi
1827   enable_clocale_flag=$enable_clocale
1828
1829   # Probe for locale model to use if none specified.
1830   # Default to "generic".
1831   if test $enable_clocale_flag = auto; then
1832     case ${target_os} in
1833       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1834         enable_clocale_flag=gnu
1835         ;;
1836       darwin* | freebsd*)
1837         enable_clocale_flag=darwin
1838         ;;
1839       *)
1840         if test x"$with_newlib" = x"yes"; then
1841           enable_clocale_flag=newlib
1842         else
1843           enable_clocale_flag=generic
1844         fi
1845         ;;
1846     esac
1847   fi
1848
1849   # Sanity check model, and test for special functionality.
1850   if test $enable_clocale_flag = gnu; then
1851     AC_EGREP_CPP([_GLIBCXX_ok], [
1852     #include <features.h>
1853     #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1854       _GLIBCXX_ok
1855     #endif
1856     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1857
1858     # Set it to scream when it hurts.
1859     ac_save_CFLAGS="$CFLAGS"
1860     CFLAGS="-Wimplicit-function-declaration -Werror"
1861
1862     # Use strxfrm_l if available.
1863     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1864                     #include <string.h>
1865                     #include <locale.h>],
1866                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1867                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1868                     [Define if strxfrm_l is available in <string.h>.]),)
1869
1870     # Use strerror_l if available.
1871     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1872                     #include <string.h>
1873                     #include <locale.h>],
1874                     [__locale_t loc; strerror_l(5, loc);],
1875                     AC_DEFINE(HAVE_STRERROR_L, 1,
1876                     [Define if strerror_l is available in <string.h>.]),)
1877
1878     CFLAGS="$ac_save_CFLAGS"
1879   fi
1880
1881   # Perhaps use strerror_r if available, and strerror_l isn't.
1882   ac_save_CFLAGS="$CFLAGS"
1883   CFLAGS="-Wimplicit-function-declaration -Werror"
1884   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1885                   #include <string.h>
1886                   #include <locale.h>],
1887                   [char s[128]; strerror_r(5, s, 128);],
1888                   AC_DEFINE(HAVE_STRERROR_R, 1,
1889                   [Define if strerror_r is available in <string.h>.]),)
1890   CFLAGS="$ac_save_CFLAGS"
1891
1892   # Set configure bits for specified locale package
1893   AC_MSG_CHECKING([for C locale to use])
1894   case ${enable_clocale_flag} in
1895     generic)
1896       AC_MSG_RESULT(generic)
1897
1898       CLOCALE_H=config/locale/generic/c_locale.h
1899       CLOCALE_CC=config/locale/generic/c_locale.cc
1900       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1901       CCOLLATE_CC=config/locale/generic/collate_members.cc
1902       CCTYPE_CC=config/locale/generic/ctype_members.cc
1903       CMESSAGES_H=config/locale/generic/messages_members.h
1904       CMESSAGES_CC=config/locale/generic/messages_members.cc
1905       CMONEY_CC=config/locale/generic/monetary_members.cc
1906       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1907       CTIME_H=config/locale/generic/time_members.h
1908       CTIME_CC=config/locale/generic/time_members.cc
1909       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1910       ;;
1911     darwin)
1912       AC_MSG_RESULT(darwin or freebsd)
1913
1914       CLOCALE_H=config/locale/generic/c_locale.h
1915       CLOCALE_CC=config/locale/generic/c_locale.cc
1916       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1917       CCOLLATE_CC=config/locale/generic/collate_members.cc
1918       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1919       CMESSAGES_H=config/locale/generic/messages_members.h
1920       CMESSAGES_CC=config/locale/generic/messages_members.cc
1921       CMONEY_CC=config/locale/generic/monetary_members.cc
1922       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1923       CTIME_H=config/locale/generic/time_members.h
1924       CTIME_CC=config/locale/generic/time_members.cc
1925       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1926       ;;
1927
1928     gnu)
1929       AC_MSG_RESULT(gnu)
1930
1931       # Declare intention to use gettext, and add support for specific
1932       # languages.
1933       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1934       ALL_LINGUAS="de fr"
1935
1936       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1937       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1938       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1939         USE_NLS=yes
1940       fi
1941       # Export the build objects.
1942       for ling in $ALL_LINGUAS; do \
1943         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1944         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1945       done
1946       AC_SUBST(glibcxx_MOFILES)
1947       AC_SUBST(glibcxx_POFILES)
1948
1949       CLOCALE_H=config/locale/gnu/c_locale.h
1950       CLOCALE_CC=config/locale/gnu/c_locale.cc
1951       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1952       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1953       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1954       CMESSAGES_H=config/locale/gnu/messages_members.h
1955       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1956       CMONEY_CC=config/locale/gnu/monetary_members.cc
1957       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1958       CTIME_H=config/locale/gnu/time_members.h
1959       CTIME_CC=config/locale/gnu/time_members.cc
1960       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1961       ;;
1962     ieee_1003.1-2001)
1963       AC_MSG_RESULT(IEEE 1003.1)
1964
1965       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1966       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1967       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1968       CCOLLATE_CC=config/locale/generic/collate_members.cc
1969       CCTYPE_CC=config/locale/generic/ctype_members.cc
1970       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1971       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1972       CMONEY_CC=config/locale/generic/monetary_members.cc
1973       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1974       CTIME_H=config/locale/generic/time_members.h
1975       CTIME_CC=config/locale/generic/time_members.cc
1976       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1977       ;;
1978     newlib)
1979       AC_MSG_RESULT(newlib)
1980
1981       CLOCALE_H=config/locale/generic/c_locale.h
1982       CLOCALE_CC=config/locale/generic/c_locale.cc
1983       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1984       CCOLLATE_CC=config/locale/generic/collate_members.cc
1985       CCTYPE_CC=config/locale/newlib/ctype_members.cc
1986       CMESSAGES_H=config/locale/generic/messages_members.h
1987       CMESSAGES_CC=config/locale/generic/messages_members.cc
1988       CMONEY_CC=config/locale/generic/monetary_members.cc
1989       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1990       CTIME_H=config/locale/generic/time_members.h
1991       CTIME_CC=config/locale/generic/time_members.cc
1992       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1993       ;;
1994   esac
1995
1996   # This is where the testsuite looks for locale catalogs, using the
1997   # -DLOCALEDIR define during testsuite compilation.
1998   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1999   AC_SUBST(glibcxx_localedir)
2000
2001   # A standalone libintl (e.g., GNU libintl) may be in use.
2002   if test $USE_NLS = yes; then
2003     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2004     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2005   fi
2006   if test $USE_NLS = yes; then
2007     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2008               [Define if NLS translations are to be used.])
2009   fi
2010
2011   AC_SUBST(USE_NLS)
2012   AC_SUBST(CLOCALE_H)
2013   AC_SUBST(CMESSAGES_H)
2014   AC_SUBST(CCODECVT_CC)
2015   AC_SUBST(CCOLLATE_CC)
2016   AC_SUBST(CCTYPE_CC)
2017   AC_SUBST(CMESSAGES_CC)
2018   AC_SUBST(CMONEY_CC)
2019   AC_SUBST(CNUMERIC_CC)
2020   AC_SUBST(CTIME_H)
2021   AC_SUBST(CTIME_CC)
2022   AC_SUBST(CLOCALE_CC)
2023   AC_SUBST(CLOCALE_INTERNAL_H)
2024 ])
2025
2026
2027 dnl
2028 dnl Check for which std::allocator base class to use.  The choice is
2029 dnl mapped from a subdirectory of include/ext.
2030 dnl
2031 dnl Default is new.
2032 dnl
2033 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2034   AC_MSG_CHECKING([for std::allocator base class])
2035   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2036     [use KIND for target std::allocator base],
2037     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2038
2039   # If they didn't use this option switch, or if they specified --enable
2040   # with no specific model, we'll have to look for one.  If they
2041   # specified --disable (???), do likewise.
2042   if test $enable_libstdcxx_allocator = no ||
2043      test $enable_libstdcxx_allocator = yes;
2044   then
2045      enable_libstdcxx_allocator=auto
2046   fi
2047
2048   # Either a known package, or "auto". Auto implies the default choice
2049   # for a particular platform.
2050   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2051
2052   # Probe for host-specific support if no specific model is specified.
2053   # Default to "new".
2054   if test $enable_libstdcxx_allocator_flag = auto; then
2055     case ${target_os} in
2056       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2057         enable_libstdcxx_allocator_flag=new
2058         ;;
2059       *)
2060         enable_libstdcxx_allocator_flag=new
2061         ;;
2062     esac
2063   fi
2064   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2065
2066
2067   # Set configure bits for specified locale package
2068   case ${enable_libstdcxx_allocator_flag} in
2069     bitmap)
2070       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2071       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2072       ;;
2073     malloc)
2074       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2075       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2076       ;;
2077     mt)
2078       ALLOCATOR_H=config/allocator/mt_allocator_base.h
2079       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2080       ;;
2081     new)
2082       ALLOCATOR_H=config/allocator/new_allocator_base.h
2083       ALLOCATOR_NAME=__gnu_cxx::new_allocator
2084       ;;
2085     pool)
2086       ALLOCATOR_H=config/allocator/pool_allocator_base.h
2087       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2088       ;;
2089   esac
2090
2091   AC_SUBST(ALLOCATOR_H)
2092   AC_SUBST(ALLOCATOR_NAME)
2093 ])
2094
2095
2096 dnl
2097 dnl Check for whether the Boost-derived checks should be turned on.
2098 dnl
2099 dnl --enable-concept-checks turns them on.
2100 dnl --disable-concept-checks leaves them off.
2101 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2102 dnl       Where DEFAULT is either `yes' or `no'.
2103 dnl
2104 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2105   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2106   if test $enable_concept_checks = yes; then
2107     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2108               [Define to use concept checking code from the boost libraries.])
2109   fi
2110 ])
2111
2112 dnl
2113 dnl Use extern templates.
2114 dnl
2115 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2116 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2117
2118 dnl  +  Usage:  GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2119 dnl       Where DEFAULT is `yes' or `no'.
2120 dnl
2121 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2122
2123   GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2124
2125   AC_MSG_CHECKING([for extern template support])
2126   AC_MSG_RESULT([$enable_extern_template])
2127
2128   GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2129 ])
2130
2131 dnl
2132 dnl Check for parallel mode pre-requisites, including OpenMP support.
2133 dnl
2134 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
2135 dnl
2136 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2137
2138   enable_parallel=no;
2139
2140   # See if configured libgomp/omp.h exists. (libgomp may be in
2141   # noconfigdirs but not explicitly disabled.)
2142   if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2143     enable_parallel=yes;
2144   else
2145     AC_MSG_NOTICE([target-libgomp not built])
2146   fi
2147
2148   AC_MSG_CHECKING([for parallel mode support])
2149   AC_MSG_RESULT([$enable_parallel])
2150   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2151 ])
2152
2153
2154 dnl
2155 dnl Check for which I/O library to use:  stdio, or something specific.
2156 dnl
2157 dnl Default is stdio.
2158 dnl
2159 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2160   AC_MSG_CHECKING([for underlying I/O to use])
2161   GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2162     [use target-specific I/O package], [permit stdio])
2163
2164   # Now that libio has been removed, you can have any color you want as long
2165   # as it's black.  This is one big no-op until other packages are added, but
2166   # showing the framework never hurts.
2167   case ${enable_cstdio} in
2168     stdio)
2169       CSTDIO_H=config/io/c_io_stdio.h
2170       BASIC_FILE_H=config/io/basic_file_stdio.h
2171       BASIC_FILE_CC=config/io/basic_file_stdio.cc
2172       AC_MSG_RESULT(stdio)
2173       ;;
2174   esac
2175
2176   AC_SUBST(CSTDIO_H)
2177   AC_SUBST(BASIC_FILE_H)
2178   AC_SUBST(BASIC_FILE_CC)
2179 ])
2180
2181
2182 dnl
2183 dnl Check for "unusual" flags to pass to the compiler while building.
2184 dnl
2185 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2186 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2187 dnl --disable-cxx-flags passes nothing.
2188 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2189 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2190 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2191 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2192 dnl       If "default flags" is an empty string, the effect is the same
2193 dnl       as --disable or --enable=no.
2194 dnl
2195 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2196   AC_MSG_CHECKING([for extra compiler flags for building])
2197   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2198     [pass compiler FLAGS when building library],
2199     [case "x$enable_cxx_flags" in
2200       xno | x)   enable_cxx_flags= ;;
2201       x-*)       ;;
2202       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2203      esac])
2204
2205   # Run through flags (either default or command-line) and set anything
2206   # extra (e.g., #defines) that must accompany particular g++ options.
2207   if test -n "$enable_cxx_flags"; then
2208     for f in $enable_cxx_flags; do
2209       case "$f" in
2210         -fhonor-std)  ;;
2211         -*)  ;;
2212         *)   # and we're trying to pass /what/ exactly?
2213              AC_MSG_ERROR([compiler flags start with a -]) ;;
2214       esac
2215     done
2216   fi
2217
2218   EXTRA_CXX_FLAGS="$enable_cxx_flags"
2219   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2220   AC_SUBST(EXTRA_CXX_FLAGS)
2221 ])
2222
2223
2224 dnl
2225 dnl Check to see if debugging libraries are to be built.
2226 dnl
2227 dnl --enable-libstdcxx-debug
2228 dnl builds a separate set of debugging libraries in addition to the
2229 dnl normal (shared, static) libstdc++ binaries.
2230 dnl
2231 dnl --disable-libstdcxx-debug
2232 dnl builds only one (non-debug) version of libstdc++.
2233 dnl
2234 dnl --enable-libstdcxx-debug-flags=FLAGS
2235 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2236 dnl
2237 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2238 dnl       Where DEFAULT is either `yes' or `no'.
2239 dnl
2240 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2241   AC_MSG_CHECKING([for additional debug build])
2242   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2243   AC_MSG_RESULT($enable_libstdcxx_debug)
2244   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2245 ])
2246
2247
2248 dnl
2249 dnl Check for explicit debug flags.
2250 dnl
2251 dnl --enable-libstdcxx-debug-flags='-O1'
2252 dnl is a general method for passing flags to be used when
2253 dnl building debug libraries with --enable-debug.
2254 dnl
2255 dnl --disable-libstdcxx-debug-flags does nothing.
2256 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2257 dnl       If "default flags" is an empty string, the effect is the same
2258 dnl       as --disable or --enable=no.
2259 dnl
2260 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2261   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2262     [pass compiler FLAGS when building debug library],
2263     [case "x$enable_libstdcxx_debug_flags" in
2264       xno | x)    enable_libstdcxx_debug_flags= ;;
2265       x-*)        ;;
2266       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2267      esac])
2268
2269   # Option parsed, now set things appropriately
2270   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2271   AC_SUBST(DEBUG_FLAGS)
2272
2273   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2274 ])
2275
2276
2277 dnl
2278 dnl Check if the user only wants a freestanding library implementation.
2279 dnl
2280 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2281 dnl installing only the headers required by [17.4.1.3] and the language
2282 dnl support library.  More than that will be built (to keep the Makefiles
2283 dnl conveniently clean), but not installed.
2284 dnl
2285 dnl Sets:
2286 dnl  is_hosted  (yes/no)
2287 dnl
2288 dnl Defines:
2289 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2290 dnl
2291 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2292   AC_ARG_ENABLE([hosted-libstdcxx],
2293     AC_HELP_STRING([--disable-hosted-libstdcxx],
2294                    [only build freestanding C++ runtime support]),,
2295     [case "$host" in
2296         arm*-*-symbianelf*)
2297             enable_hosted_libstdcxx=no
2298             ;;
2299         *)
2300             enable_hosted_libstdcxx=yes
2301             ;;
2302      esac])
2303   if test "$enable_hosted_libstdcxx" = no; then
2304     AC_MSG_NOTICE([Only freestanding libraries will be built])
2305     is_hosted=no
2306     hosted_define=0
2307     enable_abi_check=no
2308     enable_libstdcxx_pch=no
2309   else
2310     is_hosted=yes
2311     hosted_define=1
2312   fi
2313   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2314   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2315     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2316 ])
2317
2318
2319 dnl
2320 dnl Check if the user wants a non-verbose library implementation.
2321 dnl
2322 dnl --disable-libstdcxx-verbose will turn off descriptive messages to
2323 dnl standard error on termination.
2324 dnl
2325 dnl Defines:
2326 dnl  _GLIBCXX_VERBOSE (always defined, either to 1 or 0)
2327 dnl
2328 AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [
2329   AC_ARG_ENABLE([libstdcxx-verbose],
2330     AC_HELP_STRING([--disable-libstdcxx-verbose],
2331                    [disable termination messages to standard error]),,
2332                    [enable_libstdcxx_verbose=yes])
2333   if test x"$enable_libstdcxx_verbose" = xyes; then
2334     verbose_define=1
2335   else
2336     AC_MSG_NOTICE([verbose termination messages are disabled])
2337     verbose_define=0
2338   fi
2339   AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define,
2340     [Define to 1 if a verbose library is built, or 0 otherwise.])
2341 ])
2342
2343
2344 dnl
2345 dnl Check for template specializations for the 'long long' type.
2346 dnl The result determines only whether 'long long' I/O is enabled; things
2347 dnl like numeric_limits<> specializations are always available.
2348 dnl
2349 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2350 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2351 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2352 dnl       Where DEFAULT is either `yes' or `no'.
2353 dnl
2354 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2355   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2356   if test $enable_long_long = yes; then
2357     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2358               [Define if code specialized for long long should be used.])
2359   fi
2360   AC_MSG_CHECKING([for enabled long long specializations])
2361   AC_MSG_RESULT([$enable_long_long])
2362 ])
2363
2364
2365 dnl
2366 dnl Check for decimal floating point.
2367 dnl See:
2368 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2369 dnl
2370 dnl This checks to see if the host supports decimal floating point types.
2371 dnl
2372 dnl Defines:
2373 dnl  _GLIBCXX_USE_DECIMAL_FLOAT
2374 dnl
2375 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2376
2377   # Fake what AC_TRY_COMPILE does, without linking as this is
2378   # unnecessary for this test.
2379
2380     cat > conftest.$ac_ext << EOF
2381 [#]line __oline__ "configure"
2382 int main()
2383 {
2384   _Decimal32 d1;
2385   _Decimal64 d2;
2386   _Decimal128 d3;
2387   return 0;
2388 }
2389 EOF
2390
2391     AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2392     if AC_TRY_EVAL(ac_compile); then
2393       AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2394       [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2395       enable_dfp=yes
2396     else
2397       enable_dfp=no
2398     fi
2399     AC_MSG_RESULT($enable_dfp)
2400     rm -f conftest*
2401 ])
2402
2403 dnl
2404 dnl Check for GNU 128-bit integer and floating point types.
2405 dnl
2406 dnl Note: also checks that the types aren't standard types.
2407 dnl
2408 dnl Defines:
2409 dnl  _GLIBCXX_USE_INT128
2410 dnl  _GLIBCXX_USE_FLOAT128
2411 dnl
2412 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
2413
2414   AC_LANG_SAVE
2415   AC_LANG_CPLUSPLUS
2416
2417   # Fake what AC_TRY_COMPILE does, without linking as this is
2418   # unnecessary for this test.
2419
2420     cat > conftest.$ac_ext << EOF
2421 [#]line __oline__ "configure"
2422 template<typename T1, typename T2>
2423   struct same
2424   { typedef T2 type; };
2425
2426 template<typename T>
2427   struct same<T, T>;
2428
2429 int main()
2430 {
2431   typename same<long, __int128>::type                i1;
2432   typename same<long long, __int128>::type           i2;
2433 }
2434 EOF
2435
2436     AC_MSG_CHECKING([for __int128])
2437     if AC_TRY_EVAL(ac_compile); then
2438       AC_DEFINE(_GLIBCXX_USE_INT128, 1,
2439       [Define if __int128 is supported on this host.])
2440       enable_int128=yes
2441     else
2442       enable_int128=no
2443     fi
2444     AC_MSG_RESULT($enable_int128)
2445     rm -f conftest*
2446
2447     cat > conftest.$ac_ext << EOF
2448 [#]line __oline__ "configure"
2449 template<typename T1, typename T2>
2450   struct same
2451   { typedef T2 type; };
2452
2453 template<typename T>
2454   struct same<T, T>;
2455
2456 int main()
2457 {
2458   typename same<double, __float128>::type      f1;
2459   typename same<long double, __float128>::type f2;
2460 }
2461 EOF
2462
2463     AC_MSG_CHECKING([for __float128])
2464     if AC_TRY_EVAL(ac_compile); then
2465       AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
2466       [Define if __float128 is supported on this host.])
2467       enable_float128=yes
2468     else
2469       enable_float128=no
2470     fi
2471     AC_MSG_RESULT($enable_float128)
2472     rm -f conftest*
2473
2474   AC_LANG_RESTORE
2475 ])
2476
2477 dnl
2478 dnl Check for template specializations for the 'wchar_t' type.
2479 dnl
2480 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2481 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2482 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2483 dnl       Where DEFAULT is either `yes' or `no'.
2484 dnl
2485 dnl Necessary support must also be present.
2486 dnl
2487 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2488   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2489
2490   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2491   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2492   AC_MSG_CHECKING([for mbstate_t])
2493   AC_TRY_COMPILE([#include <wchar.h>],
2494   [mbstate_t teststate;],
2495   have_mbstate_t=yes, have_mbstate_t=no)
2496   AC_MSG_RESULT($have_mbstate_t)
2497   if test x"$have_mbstate_t" = xyes; then
2498     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2499   fi
2500
2501   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2502   # ac_has_wchar_h.
2503   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2504
2505   if test x"$enable_wchar_t" = x"yes"; then
2506
2507     AC_LANG_SAVE
2508     AC_LANG_CPLUSPLUS
2509
2510     if test x"$ac_has_wchar_h" = xyes &&
2511        test x"$ac_has_wctype_h" = xyes; then
2512       AC_TRY_COMPILE([#include <wchar.h>
2513                       #include <stddef.h>
2514                       wint_t i;
2515                       long l = WEOF;
2516                       long j = WCHAR_MIN;
2517                       long k = WCHAR_MAX;
2518                       namespace test
2519                       {
2520                         using ::btowc;
2521                         using ::fgetwc;
2522                         using ::fgetws;
2523                         using ::fputwc;
2524                         using ::fputws;
2525                         using ::fwide;
2526                         using ::fwprintf;
2527                         using ::fwscanf;
2528                         using ::getwc;
2529                         using ::getwchar;
2530                         using ::mbrlen;
2531                         using ::mbrtowc;
2532                         using ::mbsinit;
2533                         using ::mbsrtowcs;
2534                         using ::putwc;
2535                         using ::putwchar;
2536                         using ::swprintf;
2537                         using ::swscanf;
2538                         using ::ungetwc;
2539                         using ::vfwprintf;
2540                         using ::vswprintf;
2541                         using ::vwprintf;
2542                         using ::wcrtomb;
2543                         using ::wcscat;
2544                         using ::wcschr;
2545                         using ::wcscmp;
2546                         using ::wcscoll;
2547                         using ::wcscpy;
2548                         using ::wcscspn;
2549                         using ::wcsftime;
2550                         using ::wcslen;
2551                         using ::wcsncat;
2552                         using ::wcsncmp;
2553                         using ::wcsncpy;
2554                         using ::wcspbrk;
2555                         using ::wcsrchr;
2556                         using ::wcsrtombs;
2557                         using ::wcsspn;
2558                         using ::wcsstr;
2559                         using ::wcstod;
2560                         using ::wcstok;
2561                         using ::wcstol;
2562                         using ::wcstoul;
2563                         using ::wcsxfrm;
2564                         using ::wctob;
2565                         using ::wmemchr;
2566                         using ::wmemcmp;
2567                         using ::wmemcpy;
2568                         using ::wmemmove;
2569                         using ::wmemset;
2570                         using ::wprintf;
2571                         using ::wscanf;
2572                       }
2573                      ],[],[], [enable_wchar_t=no])
2574     else
2575       enable_wchar_t=no
2576     fi
2577
2578     AC_LANG_RESTORE
2579   fi
2580
2581   if test x"$enable_wchar_t" = x"yes"; then
2582     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2583               [Define if code specialized for wchar_t should be used.])
2584   fi
2585
2586   AC_MSG_CHECKING([for enabled wchar_t specializations])
2587   AC_MSG_RESULT([$enable_wchar_t])
2588 ])
2589
2590
2591 dnl
2592 dnl Check to see if building and using a C++ precompiled header can be done.
2593 dnl
2594 dnl --enable-libstdcxx-pch=yes
2595 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2596 dnl may work, after some light-hearted attempts to puzzle out compiler
2597 dnl support, flip bits on in include/Makefile.am
2598 dnl
2599 dnl --disable-libstdcxx-pch
2600 dnl turns off attempts to use or build stdc++.h.gch.
2601 dnl
2602 dnl Substs:
2603 dnl  glibcxx_PCHFLAGS
2604 dnl
2605 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2606   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2607   if test $enable_libstdcxx_pch = yes; then
2608     AC_CACHE_CHECK([for compiler with PCH support],
2609       [glibcxx_cv_prog_CXX_pch],
2610       [ac_save_CXXFLAGS="$CXXFLAGS"
2611        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2612        AC_LANG_SAVE
2613        AC_LANG_CPLUSPLUS
2614        echo '#include <math.h>' > conftest.h
2615        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2616                           -o conftest.h.gch 1>&5 2>&1 &&
2617                 echo '#error "pch failed"' > conftest.h &&
2618           echo '#include "conftest.h"' > conftest.cc &&
2619                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2620        then
2621          glibcxx_cv_prog_CXX_pch=yes
2622        else
2623          glibcxx_cv_prog_CXX_pch=no
2624        fi
2625        rm -f conftest*
2626        CXXFLAGS=$ac_save_CXXFLAGS
2627        AC_LANG_RESTORE
2628       ])
2629     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2630   fi
2631
2632   AC_MSG_CHECKING([for enabled PCH])
2633   AC_MSG_RESULT([$enable_libstdcxx_pch])
2634
2635   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2636   if test $enable_libstdcxx_pch = yes; then
2637     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2638   else
2639     glibcxx_PCHFLAGS=""
2640   fi
2641   AC_SUBST(glibcxx_PCHFLAGS)
2642 ])
2643
2644
2645 dnl
2646 dnl Check for atomic builtins.
2647 dnl See:
2648 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
2649 dnl
2650 dnl This checks to see if the host supports the compiler-generated
2651 dnl builtins for atomic operations for various integral sizes. Note, this
2652 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2653 dnl that are used should be checked.
2654 dnl
2655 dnl Note:
2656 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2657 dnl
2658 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2659   AC_LANG_SAVE
2660   AC_LANG_CPLUSPLUS
2661   old_CXXFLAGS="$CXXFLAGS"
2662
2663   # Do link tests if possible, instead asm tests, limited to some platforms
2664   # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2665   # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2666   atomic_builtins_link_tests=no
2667   if test x$gcc_no_link != xyes; then
2668     # Can do link tests. Limit to some tested platforms
2669     case "$host" in
2670       *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2671         atomic_builtins_link_tests=yes
2672         ;;
2673     esac
2674   fi
2675
2676   if test x$atomic_builtins_link_tests = xyes; then
2677
2678   # Do link tests.
2679
2680   CXXFLAGS="$CXXFLAGS -fno-exceptions"
2681
2682   AC_MSG_CHECKING([for atomic builtins for bool])
2683   AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2684     AC_TRY_LINK(
2685       [ ],
2686       [typedef bool atomic_type;
2687        atomic_type c1;
2688        atomic_type c2;
2689        atomic_type c3(0);
2690        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2691        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2692                                    __ATOMIC_RELAXED);
2693        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2694        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2695       ],
2696       [glibcxx_cv_atomic_bool=yes],
2697       [glibcxx_cv_atomic_bool=no])
2698   ])
2699   AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2700
2701   AC_MSG_CHECKING([for atomic builtins for short])
2702   AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2703     AC_TRY_LINK(
2704       [ ],
2705       [typedef short atomic_type;
2706        atomic_type c1;
2707        atomic_type c2;
2708        atomic_type c3(0);
2709        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2710        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2711                                    __ATOMIC_RELAXED);
2712        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2713        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2714       ],
2715       [glibcxx_cv_atomic_short=yes],
2716       [glibcxx_cv_atomic_short=no])
2717   ])
2718   AC_MSG_RESULT($glibcxx_cv_atomic_short)
2719
2720   AC_MSG_CHECKING([for atomic builtins for int])
2721   AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2722     AC_TRY_LINK(
2723       [ ],
2724       [typedef int atomic_type;
2725        atomic_type c1;
2726        atomic_type c2;
2727        atomic_type c3(0);
2728        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2729        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2730                                    __ATOMIC_RELAXED);
2731        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2732        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2733       ],
2734       [glibcxx_cv_atomic_int=yes],
2735       [glibcxx_cv_atomic_int=no])
2736   ])
2737   AC_MSG_RESULT($glibcxx_cv_atomic_int)
2738
2739   AC_MSG_CHECKING([for atomic builtins for long long])
2740   AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2741     AC_TRY_LINK(
2742       [ ],
2743       [typedef long long atomic_type;
2744        atomic_type c1;
2745        atomic_type c2;
2746        atomic_type c3(0);
2747        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2748        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2749                                    __ATOMIC_RELAXED);
2750        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2751        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2752       ],
2753       [glibcxx_cv_atomic_long_long=yes],
2754       [glibcxx_cv_atomic_long_long=no])
2755   ])
2756   AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2757
2758   else
2759
2760   # Do asm tests.
2761
2762   # Compile unoptimized.
2763   CXXFLAGS='-O0 -S'
2764
2765   # Fake what AC_TRY_COMPILE does.
2766
2767     cat > conftest.$ac_ext << EOF
2768 [#]line __oline__ "configure"
2769 int main()
2770 {
2771   typedef bool atomic_type;
2772   atomic_type c1;
2773   atomic_type c2;
2774   atomic_type c3(0);
2775   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2776   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2777                               __ATOMIC_RELAXED);
2778   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2779   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2780
2781   return 0;
2782 }
2783 EOF
2784
2785     AC_MSG_CHECKING([for atomic builtins for bool])
2786     if AC_TRY_EVAL(ac_compile); then
2787       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2788         glibcxx_cv_atomic_bool=no
2789       else
2790         glibcxx_cv_atomic_bool=yes
2791       fi
2792     fi
2793     AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2794     rm -f conftest*
2795
2796     cat > conftest.$ac_ext << EOF
2797 [#]line __oline__ "configure"
2798 int main()
2799 {
2800   typedef short atomic_type;
2801   atomic_type c1;
2802   atomic_type c2;
2803   atomic_type c3(0);
2804   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2805   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2806                               __ATOMIC_RELAXED);
2807   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2808   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2809
2810   return 0;
2811 }
2812 EOF
2813
2814     AC_MSG_CHECKING([for atomic builtins for short])
2815     if AC_TRY_EVAL(ac_compile); then
2816       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2817         glibcxx_cv_atomic_short=no
2818       else
2819         glibcxx_cv_atomic_short=yes
2820       fi
2821     fi
2822     AC_MSG_RESULT($glibcxx_cv_atomic_short)
2823     rm -f conftest*
2824
2825     cat > conftest.$ac_ext << EOF
2826 [#]line __oline__ "configure"
2827 int main()
2828 {
2829   // NB: _Atomic_word not necessarily int.
2830   typedef int atomic_type;
2831   atomic_type c1;
2832   atomic_type c2;
2833   atomic_type c3(0);
2834   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2835   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2836                               __ATOMIC_RELAXED);
2837   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2838   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2839
2840   return 0;
2841 }
2842 EOF
2843
2844     AC_MSG_CHECKING([for atomic builtins for int])
2845     if AC_TRY_EVAL(ac_compile); then
2846       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2847         glibcxx_cv_atomic_int=no
2848       else
2849         glibcxx_cv_atomic_int=yes
2850       fi
2851     fi
2852     AC_MSG_RESULT($glibcxx_cv_atomic_int)
2853     rm -f conftest*
2854
2855     cat > conftest.$ac_ext << EOF
2856 [#]line __oline__ "configure"
2857 int main()
2858 {
2859   typedef long long atomic_type;
2860   atomic_type c1;
2861   atomic_type c2;
2862   atomic_type c3(0);
2863   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2864   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2865                               __ATOMIC_RELAXED);
2866   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2867   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2868
2869   return 0;
2870 }
2871 EOF
2872
2873     AC_MSG_CHECKING([for atomic builtins for long long])
2874     if AC_TRY_EVAL(ac_compile); then
2875       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2876         glibcxx_cv_atomic_long_long=no
2877       else
2878         glibcxx_cv_atomic_long_long=yes
2879       fi
2880     fi
2881     AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2882     rm -f conftest*
2883
2884   fi
2885
2886   CXXFLAGS="$old_CXXFLAGS"
2887   AC_LANG_RESTORE
2888
2889   # Set atomicity_dir to builtins if all but the long long test above passes.
2890   if test $glibcxx_cv_atomic_bool = yes \
2891      && test $glibcxx_cv_atomic_short = yes \
2892      && test $glibcxx_cv_atomic_int = yes; then
2893     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2894     [Define if the compiler supports C++11 atomics.])
2895     atomicity_dir=cpu/generic/atomicity_builtins
2896   fi
2897
2898   # If still generic, set to mutex.
2899   if test $atomicity_dir = "cpu/generic" ; then
2900     atomicity_dir=cpu/generic/atomicity_mutex
2901     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2902       if test "x$target_thread_file" = xsingle; then
2903         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2904         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2905       else
2906         AC_MSG_WARN([They will be faked using a mutex.])
2907         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2908       fi
2909   fi
2910
2911 ])
2912
2913
2914 dnl
2915 dnl Check for exception handling support.  If an explicit enable/disable
2916 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2917 dnl target may or may not support call frame exceptions.
2918 dnl
2919 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2920 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2921 dnl Neither one forces an attempt at detection.
2922 dnl
2923 dnl Defines:
2924 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2925 dnl
2926 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2927   AC_MSG_CHECKING([for exception model to use])
2928   AC_LANG_SAVE
2929   AC_LANG_CPLUSPLUS
2930   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2931     [force use of builtin_setjmp for exceptions],
2932     [permit yes|no|auto])
2933
2934   if test $enable_sjlj_exceptions = auto; then
2935     # Botheration.  Now we've got to detect the exception model.  Link tests
2936     # against libgcc.a are problematic since we've not been given proper -L
2937     # bits for single-tree newlib and libgloss.
2938     #
2939     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2940     cat > conftest.$ac_ext << EOF
2941 [#]line __oline__ "configure"
2942 struct S { ~S(); };
2943 void bar();
2944 void foo()
2945 {
2946   S s;
2947   bar();
2948 }
2949 EOF
2950     old_CXXFLAGS="$CXXFLAGS"
2951     CXXFLAGS=-S
2952     if AC_TRY_EVAL(ac_compile); then
2953       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2954         enable_sjlj_exceptions=yes
2955       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2956         enable_sjlj_exceptions=no
2957       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2958         enable_sjlj_exceptions=no
2959       fi
2960     fi
2961     CXXFLAGS="$old_CXXFLAGS"
2962     rm -f conftest*
2963   fi
2964
2965   # This is a tad weird, for hysterical raisins.  We have to map
2966   # enable/disable to two different models.
2967   case $enable_sjlj_exceptions in
2968     yes)
2969       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2970         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2971       ac_exception_model_name=sjlj
2972       ;;
2973     no)
2974       ac_exception_model_name="call frame"
2975       ;;
2976     *)
2977       AC_MSG_ERROR([unable to detect exception model])
2978       ;;
2979   esac
2980  AC_LANG_RESTORE
2981  AC_MSG_RESULT($ac_exception_model_name)
2982 ])
2983
2984
2985 dnl
2986 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2987 dnl
2988 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
2989 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
2990 dnl  +  Usage:  GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
2991 dnl       Where DEFAULT is 'yes'.
2992 dnl
2993 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
2994 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
2995
2996 if test x$enable_libstdcxx_visibility = xyes ; then
2997   dnl all hail libgfortran
2998   dnl Check whether the target supports hidden visibility.
2999   AC_CACHE_CHECK([whether the target supports hidden visibility],
3000                  glibcxx_cv_have_attribute_visibility, [
3001   save_CFLAGS="$CFLAGS"
3002   CFLAGS="$CFLAGS -Werror"
3003   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3004                  [], glibcxx_cv_have_attribute_visibility=yes,
3005                  glibcxx_cv_have_attribute_visibility=no)
3006   CFLAGS="$save_CFLAGS"])
3007   if test $glibcxx_cv_have_attribute_visibility = no; then
3008     enable_libstdcxx_visibility=no
3009   fi
3010 fi
3011
3012 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3013 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3014 ])
3015
3016
3017 dnl
3018 dnl Add version tags to symbols in shared library (or not), additionally
3019 dnl marking other symbols as private/local (or not).
3020 dnl
3021 dnl Sets libtool_VERSION, and determines shared library SONAME.
3022 dnl
3023 dnl  This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3024 dnl
3025 dnl --enable-symvers=style adds a version script to the linker call when
3026 dnl       creating the shared library.  The choice of version script is
3027 dnl       controlled by 'style'.
3028 dnl --disable-symvers does not.
3029 dnl
3030 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3031 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
3032 dnl       choose a default style based on linker characteristics.  Passing
3033 dnl       'no' disables versioning.
3034 dnl
3035 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3036
3037 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3038   [enables symbol versioning of the shared library],
3039   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3040
3041 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3042 # don't know enough about $LD to do tricks...
3043 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3044 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3045 # with extern "C++" in version scripts.
3046 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3047
3048 # Turn a 'yes' into a suitable default.
3049 if test x$enable_symvers = xyes ; then
3050   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3051     enable_symvers=no
3052   else
3053     if test $with_gnu_ld = yes ; then
3054       case ${target_os} in
3055         hpux*)
3056           enable_symvers=no ;;
3057         *)
3058           enable_symvers=gnu ;;
3059       esac
3060     else
3061       case ${target_os} in
3062         darwin*)
3063           enable_symvers=darwin ;;
3064         # Sun symbol versioning exists since Solaris 2.5.
3065         solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3066           # make_sunver.pl needs GNU c++filt to support extern "C++" in
3067           # version scripts, so disable symbol versioning if none can be
3068           # found.
3069           if test -z "$ac_cv_path_CXXFILT"; then
3070             AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3071             AC_MSG_WARN([=== no GNU c++filt could  be found.])
3072             AC_MSG_WARN([=== Symbol versioning will be disabled.])
3073             enable_symvers=no
3074           else
3075             enable_symvers=sun
3076           fi
3077           ;;
3078         *)
3079           enable_symvers=no ;;
3080       esac
3081     fi
3082   fi
3083 fi
3084
3085 # Check to see if 'darwin' or 'darwin-export' can win.
3086 if test x$enable_symvers = xdarwin-export ; then
3087     enable_symvers=darwin
3088 fi
3089
3090 # Check if 'sun' was requested on non-Solaris 2 platforms.
3091 if test x$enable_symvers = xsun ; then
3092   case ${target_os} in
3093     solaris2*)
3094       # All fine.
3095       ;;
3096     *)
3097       # Unlikely to work.
3098       AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3099       AC_MSG_WARN([=== you are not targetting Solaris 2.])
3100       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3101       enable_symvers=no
3102       ;;
3103   esac
3104 fi
3105
3106 # Check to see if 'gnu' can win.
3107 if test $enable_symvers = gnu ||
3108   test $enable_symvers = gnu-versioned-namespace ||
3109   test $enable_symvers = sun; then
3110   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3111   AC_MSG_CHECKING([for shared libgcc])
3112   ac_save_CFLAGS="$CFLAGS"
3113   CFLAGS=' -lgcc_s'
3114   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3115   CFLAGS="$ac_save_CFLAGS"
3116   if test $glibcxx_shared_libgcc = no; then
3117     cat > conftest.c <<EOF
3118 int main (void) { return 0; }
3119 EOF
3120 changequote(,)dnl
3121     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3122                              -shared -shared-libgcc -o conftest.so \
3123                              conftest.c -v 2>&1 >/dev/null \
3124                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3125 changequote([,])dnl
3126     rm -f conftest.c conftest.so
3127     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3128       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3129       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3130       CFLAGS="$ac_save_CFLAGS"
3131     fi
3132   fi
3133   AC_MSG_RESULT($glibcxx_shared_libgcc)
3134
3135   # For GNU ld, we need at least this version.  The format is described in
3136   # GLIBCXX_CHECK_LINKER_FEATURES above.
3137   glibcxx_min_gnu_ld_version=21400
3138
3139   # If no shared libgcc, can't win.
3140   if test $glibcxx_shared_libgcc != yes; then
3141       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3142       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3143       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3144       enable_symvers=no
3145   elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3146     : All interesting versions of Sun ld support sun style symbol versioning.
3147   elif test $with_gnu_ld != yes ; then
3148     # just fail for now
3149     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3150     AC_MSG_WARN([=== you are not using the GNU linker.])
3151     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3152     enable_symvers=no
3153   elif test $glibcxx_ld_is_gold = yes ; then
3154     : All versions of gold support symbol versioning.
3155   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3156     # The right tools, the right setup, but too old.  Fallbacks?
3157     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3158     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3159     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3160     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3161     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3162     enable_symvers=no
3163   fi
3164 fi
3165
3166 # For libtool versioning info, format is CURRENT:REVISION:AGE
3167 libtool_VERSION=6:17:0
3168
3169 # Everything parsed; figure out what files and settings to use.
3170 case $enable_symvers in
3171   no)
3172     SYMVER_FILE=config/abi/pre/none.ver
3173     ;;
3174   gnu)
3175     SYMVER_FILE=config/abi/pre/gnu.ver
3176     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3177               [Define to use GNU versioning in the shared library.])
3178     ;;
3179   gnu-versioned-namespace)
3180     libtool_VERSION=7:0:0
3181     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3182     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3183               [Define to use GNU namespace versioning in the shared library.])
3184     ;;
3185   darwin)
3186     SYMVER_FILE=config/abi/pre/gnu.ver
3187     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3188               [Define to use darwin versioning in the shared library.])
3189     ;;
3190   sun)
3191     SYMVER_FILE=config/abi/pre/gnu.ver
3192     AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3193               [Define to use Sun versioning in the shared library.])
3194     ;;
3195 esac
3196
3197 if test x$enable_symvers != xno ; then
3198   AC_DEFINE(_GLIBCXX_SYMVER, 1,
3199          [Define to use symbol versioning in the shared library.])
3200 fi
3201
3202 AC_CACHE_CHECK([whether the target supports .symver directive],
3203                glibcxx_cv_have_as_symver_directive, [
3204   AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3205                  [], glibcxx_cv_have_as_symver_directive=yes,
3206                  glibcxx_cv_have_as_symver_directive=no)])
3207 if test $glibcxx_cv_have_as_symver_directive = yes; then
3208   AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3209     [Define to 1 if the target assembler supports .symver directive.])
3210 fi
3211
3212 AC_SUBST(SYMVER_FILE)
3213 AC_SUBST(port_specific_symbol_files)
3214 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3215 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3216 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3217 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3218 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3219 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3220
3221 if test $enable_symvers != no ; then
3222    case ${target_os} in
3223      # The Solaris 2 runtime linker doesn't support the GNU extension of
3224      # binding the same symbol to different versions
3225      solaris2*)
3226        ;;
3227      # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3228      *)
3229        AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3230          [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3231        ;;
3232     esac
3233 fi
3234
3235 # Now, set up compatibility support, if any.
3236 # In addition, need this to deal with std::size_t mangling in
3237 # src/compatibility.cc.  In a perfect world, could use
3238 # typeid(std::size_t).name()[0] to do direct substitution.
3239 AC_MSG_CHECKING([for size_t as unsigned int])
3240 ac_save_CFLAGS="$CFLAGS"
3241 CFLAGS="-Werror"
3242 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3243                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3244 CFLAGS=$ac_save_CFLAGS
3245 if test "$glibcxx_size_t_is_i" = yes; then
3246   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3247 fi
3248 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3249
3250 AC_MSG_CHECKING([for ptrdiff_t as int])
3251 ac_save_CFLAGS="$CFLAGS"
3252 CFLAGS="-Werror"
3253 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3254                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3255 CFLAGS=$ac_save_CFLAGS
3256 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3257   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3258 fi
3259 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3260 ])
3261
3262
3263 dnl
3264 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3265 dnl We must stage the required headers so that they will be installed
3266 dnl with the library (unlike libgcc, the STL implementation is provided
3267 dnl solely within headers).  Since we must not inject random user-space
3268 dnl macro names into user-provided C++ code, we first stage into <file>-in
3269 dnl and process to <file> with an output command.  The reason for a two-
3270 dnl stage process here is to correctly handle $srcdir!=$objdir without
3271 dnl having to write complex code (the sed commands to clean the macro
3272 dnl namespace are complex and fragile enough as it is).  We must also
3273 dnl add a relative path so that -I- is supported properly.
3274 dnl
3275 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3276   AC_MSG_CHECKING([for thread model used by GCC])
3277   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3278   AC_MSG_RESULT([$target_thread_file])
3279 ])
3280
3281
3282 dnl
3283 dnl Check if gthread implementation defines the types and functions
3284 dnl required by the c++0x thread library.  Conforming gthread
3285 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3286 dnl
3287 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3288 dnl
3289 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3290   GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3291
3292   if test x$enable_libstdcxx_threads = xauto ||
3293      test x$enable_libstdcxx_threads = xyes; then
3294
3295   AC_LANG_SAVE
3296   AC_LANG_CPLUSPLUS
3297
3298   ac_save_CXXFLAGS="$CXXFLAGS"
3299   CXXFLAGS="$CXXFLAGS -fno-exceptions \
3300         -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3301
3302   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3303   case $target_thread_file in
3304     posix)
3305       CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3306   esac
3307
3308   AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3309
3310   AC_TRY_COMPILE([#include <unistd.h>],
3311     [
3312       // In case of POSIX threads check _POSIX_TIMEOUTS.
3313       #if (defined(_PTHREADS) \
3314           && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3315       #error
3316       #endif
3317     ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3318
3319   AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3320                      [Define to 1 if mutex_timedlock is available.])
3321
3322   if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3323   else res_mutex_timedlock=no ; fi
3324   AC_MSG_RESULT([$res_mutex_timedlock])
3325
3326   AC_MSG_CHECKING([for gthreads library])
3327
3328   AC_TRY_COMPILE([#include "gthr.h"],
3329     [
3330       #ifndef __GTHREADS_CXX0X
3331       #error
3332       #endif
3333     ], [case $target_os in
3334           # gthreads support breaks symbol versioning on Solaris 9 (PR
3335           # libstdc++/52189).
3336           solaris2.9*)
3337             if test x$enable_symvers = xno; then
3338               ac_has_gthreads=yes
3339             elif test x$enable_libstdcxx_threads = xyes; then
3340               AC_MSG_WARN([You have requested C++11 threads support, but])
3341               AC_MSG_WARN([this breaks symbol versioning.])
3342               ac_has_gthreads=yes
3343             else
3344               ac_has_gthreads=no
3345             fi
3346             ;;
3347           *)
3348             ac_has_gthreads=yes
3349             ;;
3350         esac],
3351        [ac_has_gthreads=no])
3352   else
3353     ac_has_gthreads=no
3354   fi
3355
3356   AC_MSG_RESULT([$ac_has_gthreads])
3357
3358   if test x"$ac_has_gthreads" = x"yes"; then
3359     AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3360               [Define if gthreads library is available.])
3361   fi
3362
3363   CXXFLAGS="$ac_save_CXXFLAGS"
3364   AC_LANG_RESTORE
3365 ])
3366
3367
3368 # Check whether LC_MESSAGES is available in <locale.h>.
3369 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3370 #
3371 # This file file be copied and used freely without restrictions.  It can
3372 # be used in projects which are not available under the GNU Public License
3373 # but which still want to provide support for the GNU gettext functionality.
3374 # Please note that the actual code is *not* freely available.
3375 AC_DEFUN([AC_LC_MESSAGES], [
3376   AC_CHECK_HEADER(locale.h, [
3377     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3378       [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3379        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3380     if test $ac_cv_val_LC_MESSAGES = yes; then
3381       AC_DEFINE(HAVE_LC_MESSAGES, 1,
3382                 [Define if LC_MESSAGES is available in <locale.h>.])
3383     fi
3384   ])
3385 ])
3386
3387 dnl
3388 dnl Check whether rdrand is supported in the assembler.
3389 AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [
3390   AC_MSG_CHECKING([for rdrand support in assembler])
3391   AC_CACHE_VAL(ac_cv_x86_rdrand, [
3392   ac_cv_x86_rdrand=no
3393   case "$target" in
3394     i?86-*-* | \
3395     x86_64-*-*)
3396     AC_TRY_COMPILE(, [asm("rdrand %eax");],
3397                 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no])
3398   esac
3399   ])
3400   if test $ac_cv_x86_rdrand = yes; then
3401     AC_DEFINE(_GLIBCXX_X86_RDRAND, 1,
3402                 [ Defined if as can handle rdrand. ])
3403   fi
3404   AC_MSG_RESULT($ac_cv_x86_rdrand)
3405 ])
3406
3407 dnl
3408 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
3409 dnl
3410 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
3411
3412   AC_LANG_SAVE
3413   AC_LANG_CPLUSPLUS
3414   ac_save_CXXFLAGS="$CXXFLAGS"
3415   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3416
3417   AC_MSG_CHECKING([for get_nprocs])
3418   AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
3419     GCC_TRY_COMPILE_OR_LINK(
3420       [#include <sys/sysinfo.h>],
3421       [int n = get_nprocs();],
3422       [glibcxx_cv_GET_NPROCS=yes],
3423       [glibcxx_cv_GET_NPROCS=no])
3424   ])
3425   if test $glibcxx_cv_GET_NPROCS = yes; then
3426     AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
3427   fi
3428   AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
3429
3430   CXXFLAGS="$ac_save_CXXFLAGS"
3431   AC_LANG_RESTORE
3432 ])
3433
3434 dnl
3435 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
3436 dnl
3437 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
3438
3439   AC_LANG_SAVE
3440   AC_LANG_CPLUSPLUS
3441   ac_save_CXXFLAGS="$CXXFLAGS"
3442   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3443
3444   AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
3445   AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
3446     GCC_TRY_COMPILE_OR_LINK(
3447       [#include <unistd.h>],
3448       [int n = sysconf(_SC_NPROCESSORS_ONLN);],
3449       [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
3450       [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
3451   ])
3452   if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
3453     AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN  is available in <unistd.h>.])
3454   fi
3455   AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
3456
3457   CXXFLAGS="$ac_save_CXXFLAGS"
3458   AC_LANG_RESTORE
3459 ])
3460
3461 dnl
3462 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
3463 dnl
3464 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
3465
3466   AC_LANG_SAVE
3467   AC_LANG_CPLUSPLUS
3468   ac_save_CXXFLAGS="$CXXFLAGS"
3469   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3470
3471   AC_MSG_CHECKING([for _SC_NPROC_ONLN])
3472   AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [
3473     GCC_TRY_COMPILE_OR_LINK(
3474       [#include <unistd.h>],
3475       [int n = sysconf(_SC_NPROC_ONLN);],
3476       [glibcxx_cv_SC_NPROC_ONLN=yes],
3477       [glibcxx_cv_SC_NPROC_ONLN=no])
3478   ])
3479   if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
3480     AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN  is available in <unistd.h>.])
3481   fi
3482   AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN)
3483
3484   CXXFLAGS="$ac_save_CXXFLAGS"
3485   AC_LANG_RESTORE
3486 ])
3487
3488 dnl
3489 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
3490 dnl
3491 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
3492
3493   AC_LANG_SAVE
3494   AC_LANG_CPLUSPLUS
3495   ac_save_CXXFLAGS="$CXXFLAGS"
3496   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3497
3498   AC_MSG_CHECKING([for pthreads_num_processors_np])
3499   AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
3500     GCC_TRY_COMPILE_OR_LINK(
3501       [#include <pthread.h>],
3502       [int n = pthread_num_processors_np();],
3503       [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
3504       [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
3505   ])
3506   if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
3507     AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
3508   fi
3509   AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP)
3510
3511   CXXFLAGS="$ac_save_CXXFLAGS"
3512   AC_LANG_RESTORE
3513 ])
3514
3515 dnl
3516 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
3517 dnl
3518 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
3519
3520   AC_LANG_SAVE
3521   AC_LANG_CPLUSPLUS
3522   ac_save_CXXFLAGS="$CXXFLAGS"
3523   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3524
3525   AC_MSG_CHECKING([for hw.ncpu sysctl])
3526   AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [
3527     GCC_TRY_COMPILE_OR_LINK(
3528       [
3529        #include <stddef.h>
3530        #include <sys/sysctl.h>
3531        ],
3532       [
3533        int count;
3534        size_t size = sizeof(count);
3535        int mib[] = { CTL_HW, HW_NCPU };
3536        sysctl(mib, 2, &count, &size, NULL, 0);
3537       ],
3538       [glibcxx_cv_SYSCTL_HW_NCPU=yes],
3539       [glibcxx_cv_SYSCTL_HW_NCPU=no])
3540   ])
3541   if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
3542     AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
3543   fi
3544   AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU)
3545
3546   CXXFLAGS="$ac_save_CXXFLAGS"
3547   AC_LANG_RESTORE
3548 ])
3549
3550 dnl
3551 dnl Check to see if python pretty printing can be activated.
3552 dnl
3553 dnl --with-python-dir=dir
3554 dnl installs directory into $prefix/dir
3555 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
3556
3557 AC_MSG_CHECKING([for custom python install directory])
3558 AC_ARG_WITH([python-dir],
3559             AS_HELP_STRING([--with-python-dir],
3560                            [the location to install Python modules. This path is relative starting from the prefix.]),
3561             [with_python_dir=$withval], [with_python_dir="no"])
3562 AC_MSG_RESULT(${with_python_dir})
3563
3564 # Needed for installing Python modules during make install.
3565 python_mod_dir="${with_python_dir}"
3566 AC_SUBST(python_mod_dir)
3567 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
3568 ])
3569
3570 dnl
3571 dnl Check to see if -Werror is disabled.
3572 dnl
3573 dnl --enable-werror/--disable-werror
3574 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
3575   AC_MSG_CHECKING([for -Werror])
3576   GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
3577   AC_MSG_RESULT($enable_werror)
3578   GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
3579 ])
3580
3581
3582 # Macros from the top-level gcc directory.
3583 m4_include([../config/gc++filt.m4])
3584 m4_include([../config/tls.m4])