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