libstdc++-v3/acinclude.m4

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