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,_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   if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1699      c_extra=yes
1700   fi
1701
1702   AC_SUBST(C_INCLUDE_DIR)
1703   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1704   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1705   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1706   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1707   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1708 ])
1709
1710
1711 dnl
1712 dnl Check for which locale library to use.  The choice is mapped to
1713 dnl a subdirectory of config/locale.
1714 dnl
1715 dnl Default is generic.
1716 dnl
1717 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1718   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1719     [use MODEL for target locale package],
1720     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1721
1722   # Deal with gettext issues.  Default to not using it (=no) until we detect
1723   # support for it later.  Let the user turn it off via --e/d, but let that
1724   # default to on for easier handling.
1725   USE_NLS=no
1726   AC_ARG_ENABLE(nls,
1727     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1728     [],
1729     [enable_nls=yes])
1730
1731   # Either a known packaage, or "auto"
1732   if test $enable_clocale = no || test $enable_clocale = yes; then
1733      enable_clocale=auto
1734   fi
1735   enable_clocale_flag=$enable_clocale
1736
1737   # Probe for locale model to use if none specified.
1738   # Default to "generic".
1739   if test $enable_clocale_flag = auto; then
1740     case ${target_os} in
1741       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1742         enable_clocale_flag=gnu
1743         ;;
1744       darwin* | freebsd*)
1745         enable_clocale_flag=darwin
1746         ;;
1747       *)
1748         enable_clocale_flag=generic
1749         ;;
1750     esac
1751   fi
1752
1753   # Sanity check model, and test for special functionality.
1754   if test $enable_clocale_flag = gnu; then
1755     AC_EGREP_CPP([_GLIBCXX_ok], [
1756     #include <features.h>
1757     #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1758       _GLIBCXX_ok
1759     #endif
1760     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1761
1762     # Set it to scream when it hurts.
1763     ac_save_CFLAGS="$CFLAGS"
1764     CFLAGS="-Wimplicit-function-declaration -Werror"
1765
1766     # Use strxfrm_l if available.
1767     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1768                     #include <string.h>
1769                     #include <locale.h>],
1770                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1771                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1772                     [Define if strxfrm_l is available in <string.h>.]),)
1773
1774     # Use strerror_l if available.
1775     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1776                     #include <string.h>
1777                     #include <locale.h>],
1778                     [__locale_t loc; strerror_l(5, loc);],
1779                     AC_DEFINE(HAVE_STRERROR_L, 1,
1780                     [Define if strerror_l is available in <string.h>.]),)
1781
1782     CFLAGS="$ac_save_CFLAGS"
1783   fi
1784
1785   # Perhaps use strerror_r if available, and strerror_l isn't.
1786   ac_save_CFLAGS="$CFLAGS"
1787   CFLAGS="-Wimplicit-function-declaration -Werror"
1788   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1789                   #include <string.h>
1790                   #include <locale.h>],
1791                   [char s[128]; strerror_r(5, s, 128);],
1792                   AC_DEFINE(HAVE_STRERROR_R, 1,
1793                   [Define if strerror_r is available in <string.h>.]),)
1794   CFLAGS="$ac_save_CFLAGS"
1795
1796   # Set configure bits for specified locale package
1797   AC_MSG_CHECKING([for C locale to use])
1798   case ${enable_clocale_flag} in
1799     generic)
1800       AC_MSG_RESULT(generic)
1801
1802       CLOCALE_H=config/locale/generic/c_locale.h
1803       CLOCALE_CC=config/locale/generic/c_locale.cc
1804       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1805       CCOLLATE_CC=config/locale/generic/collate_members.cc
1806       CCTYPE_CC=config/locale/generic/ctype_members.cc
1807       CMESSAGES_H=config/locale/generic/messages_members.h
1808       CMESSAGES_CC=config/locale/generic/messages_members.cc
1809       CMONEY_CC=config/locale/generic/monetary_members.cc
1810       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1811       CTIME_H=config/locale/generic/time_members.h
1812       CTIME_CC=config/locale/generic/time_members.cc
1813       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1814       ;;
1815     darwin)
1816       AC_MSG_RESULT(darwin or freebsd)
1817
1818       CLOCALE_H=config/locale/generic/c_locale.h
1819       CLOCALE_CC=config/locale/generic/c_locale.cc
1820       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1821       CCOLLATE_CC=config/locale/generic/collate_members.cc
1822       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1823       CMESSAGES_H=config/locale/generic/messages_members.h
1824       CMESSAGES_CC=config/locale/generic/messages_members.cc
1825       CMONEY_CC=config/locale/generic/monetary_members.cc
1826       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1827       CTIME_H=config/locale/generic/time_members.h
1828       CTIME_CC=config/locale/generic/time_members.cc
1829       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1830       ;;
1831
1832     gnu)
1833       AC_MSG_RESULT(gnu)
1834
1835       # Declare intention to use gettext, and add support for specific
1836       # languages.
1837       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1838       ALL_LINGUAS="de fr"
1839
1840       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1841       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1842       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1843         USE_NLS=yes
1844       fi
1845       # Export the build objects.
1846       for ling in $ALL_LINGUAS; do \
1847         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1848         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1849       done
1850       AC_SUBST(glibcxx_MOFILES)
1851       AC_SUBST(glibcxx_POFILES)
1852
1853       CLOCALE_H=config/locale/gnu/c_locale.h
1854       CLOCALE_CC=config/locale/gnu/c_locale.cc
1855       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1856       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1857       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1858       CMESSAGES_H=config/locale/gnu/messages_members.h
1859       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1860       CMONEY_CC=config/locale/gnu/monetary_members.cc
1861       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1862       CTIME_H=config/locale/gnu/time_members.h
1863       CTIME_CC=config/locale/gnu/time_members.cc
1864       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1865       ;;
1866     ieee_1003.1-2001)
1867       AC_MSG_RESULT(IEEE 1003.1)
1868
1869       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1870       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1871       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1872       CCOLLATE_CC=config/locale/generic/collate_members.cc
1873       CCTYPE_CC=config/locale/generic/ctype_members.cc
1874       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1875       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1876       CMONEY_CC=config/locale/generic/monetary_members.cc
1877       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1878       CTIME_H=config/locale/generic/time_members.h
1879       CTIME_CC=config/locale/generic/time_members.cc
1880       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1881       ;;
1882   esac
1883
1884   # This is where the testsuite looks for locale catalogs, using the
1885   # -DLOCALEDIR define during testsuite compilation.
1886   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1887   AC_SUBST(glibcxx_localedir)
1888
1889   # A standalone libintl (e.g., GNU libintl) may be in use.
1890   if test $USE_NLS = yes; then
1891     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1892     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1893   fi
1894   if test $USE_NLS = yes; then
1895     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1896               [Define if NLS translations are to be used.])
1897   fi
1898
1899   AC_SUBST(USE_NLS)
1900   AC_SUBST(CLOCALE_H)
1901   AC_SUBST(CMESSAGES_H)
1902   AC_SUBST(CCODECVT_CC)
1903   AC_SUBST(CCOLLATE_CC)
1904   AC_SUBST(CCTYPE_CC)
1905   AC_SUBST(CMESSAGES_CC)
1906   AC_SUBST(CMONEY_CC)
1907   AC_SUBST(CNUMERIC_CC)
1908   AC_SUBST(CTIME_H)
1909   AC_SUBST(CTIME_CC)
1910   AC_SUBST(CLOCALE_CC)
1911   AC_SUBST(CLOCALE_INTERNAL_H)
1912 ])
1913
1914
1915 dnl
1916 dnl Check for which std::allocator base class to use.  The choice is
1917 dnl mapped from a subdirectory of include/ext.
1918 dnl
1919 dnl Default is new.
1920 dnl
1921 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1922   AC_MSG_CHECKING([for std::allocator base class])
1923   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1924     [use KIND for target std::allocator base],
1925     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1926
1927   # If they didn't use this option switch, or if they specified --enable
1928   # with no specific model, we'll have to look for one.  If they
1929   # specified --disable (???), do likewise.
1930   if test $enable_libstdcxx_allocator = no ||
1931      test $enable_libstdcxx_allocator = yes;
1932   then
1933      enable_libstdcxx_allocator=auto
1934   fi
1935
1936   # Either a known package, or "auto". Auto implies the default choice
1937   # for a particular platform.
1938   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1939
1940   # Probe for host-specific support if no specific model is specified.
1941   # Default to "new".
1942   if test $enable_libstdcxx_allocator_flag = auto; then
1943     case ${target_os} in
1944       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1945         enable_libstdcxx_allocator_flag=new
1946         ;;
1947       *)
1948         enable_libstdcxx_allocator_flag=new
1949         ;;
1950     esac
1951   fi
1952   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1953
1954
1955   # Set configure bits for specified locale package
1956   case ${enable_libstdcxx_allocator_flag} in
1957     bitmap)
1958       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1959       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1960       ;;
1961     malloc)
1962       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1963       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1964       ;;
1965     mt)
1966       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1967       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1968       ;;
1969     new)
1970       ALLOCATOR_H=config/allocator/new_allocator_base.h
1971       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1972       ;;
1973     pool)
1974       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1975       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1976       ;;
1977   esac
1978
1979   AC_SUBST(ALLOCATOR_H)
1980   AC_SUBST(ALLOCATOR_NAME)
1981 ])
1982
1983
1984 dnl
1985 dnl Check for whether the Boost-derived checks should be turned on.
1986 dnl
1987 dnl --enable-concept-checks turns them on.
1988 dnl --disable-concept-checks leaves them off.
1989 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1990 dnl       Where DEFAULT is either `yes' or `no'.
1991 dnl
1992 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1993   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1994   if test $enable_concept_checks = yes; then
1995     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1996               [Define to use concept checking code from the boost libraries.])
1997   fi
1998 ])
1999
2000 dnl
2001 dnl Check for parallel mode pre-requisites, including OpenMP support.
2002 dnl
2003 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
2004 dnl
2005 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2006
2007   enable_parallel=no;
2008
2009   # See if configured libgomp/omp.h exists. (libgomp may be in
2010   # noconfigdirs but not explicitly disabled.)
2011   if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2012     enable_parallel=yes;
2013   else
2014     AC_MSG_NOTICE([target-libgomp not built])
2015   fi
2016
2017   AC_MSG_CHECKING([for parallel mode support])
2018   AC_MSG_RESULT([$enable_parallel])
2019   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2020 ])
2021
2022
2023 dnl
2024 dnl Check for which I/O library to use:  stdio, or something specific.
2025 dnl
2026 dnl Default is stdio.
2027 dnl
2028 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2029   AC_MSG_CHECKING([for underlying I/O to use])
2030   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
2031     [use target-specific I/O package], [permit stdio])
2032
2033   # Now that libio has been removed, you can have any color you want as long
2034   # as it's black.  This is one big no-op until other packages are added, but
2035   # showing the framework never hurts.
2036   case ${enable_cstdio} in
2037     stdio)
2038       CSTDIO_H=config/io/c_io_stdio.h
2039       BASIC_FILE_H=config/io/basic_file_stdio.h
2040       BASIC_FILE_CC=config/io/basic_file_stdio.cc
2041       AC_MSG_RESULT(stdio)
2042       ;;
2043   esac
2044
2045   AC_SUBST(CSTDIO_H)
2046   AC_SUBST(BASIC_FILE_H)
2047   AC_SUBST(BASIC_FILE_CC)
2048 ])
2049
2050
2051 dnl
2052 dnl Check for "unusual" flags to pass to the compiler while building.
2053 dnl
2054 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2055 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2056 dnl --disable-cxx-flags passes nothing.
2057 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2058 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2059 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2060 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2061 dnl       If "default flags" is an empty string, the effect is the same
2062 dnl       as --disable or --enable=no.
2063 dnl
2064 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2065   AC_MSG_CHECKING([for extra compiler flags for building])
2066   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2067     [pass compiler FLAGS when building library],
2068     [case "x$enable_cxx_flags" in
2069       xno | x)   enable_cxx_flags= ;;
2070       x-*)       ;;
2071       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2072      esac])
2073
2074   # Run through flags (either default or command-line) and set anything
2075   # extra (e.g., #defines) that must accompany particular g++ options.
2076   if test -n "$enable_cxx_flags"; then
2077     for f in $enable_cxx_flags; do
2078       case "$f" in
2079         -fhonor-std)  ;;
2080         -*)  ;;
2081         *)   # and we're trying to pass /what/ exactly?
2082              AC_MSG_ERROR([compiler flags start with a -]) ;;
2083       esac
2084     done
2085   fi
2086
2087   EXTRA_CXX_FLAGS="$enable_cxx_flags"
2088   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2089   AC_SUBST(EXTRA_CXX_FLAGS)
2090 ])
2091
2092
2093 dnl
2094 dnl Check to see if debugging libraries are to be built.
2095 dnl
2096 dnl --enable-libstdcxx-debug
2097 dnl builds a separate set of debugging libraries in addition to the
2098 dnl normal (shared, static) libstdc++ binaries.
2099 dnl
2100 dnl --disable-libstdcxx-debug
2101 dnl builds only one (non-debug) version of libstdc++.
2102 dnl
2103 dnl --enable-libstdcxx-debug-flags=FLAGS
2104 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2105 dnl
2106 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2107 dnl       Where DEFAULT is either `yes' or `no'.
2108 dnl
2109 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2110   AC_MSG_CHECKING([for additional debug build])
2111   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2112   AC_MSG_RESULT($enable_libstdcxx_debug)
2113   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2114 ])
2115
2116
2117 dnl
2118 dnl Check for explicit debug flags.
2119 dnl
2120 dnl --enable-libstdcxx-debug-flags='-O1'
2121 dnl is a general method for passing flags to be used when
2122 dnl building debug libraries with --enable-debug.
2123 dnl
2124 dnl --disable-libstdcxx-debug-flags does nothing.
2125 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2126 dnl       If "default flags" is an empty string, the effect is the same
2127 dnl       as --disable or --enable=no.
2128 dnl
2129 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2130   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2131     [pass compiler FLAGS when building debug library],
2132     [case "x$enable_libstdcxx_debug_flags" in
2133       xno | x)    enable_libstdcxx_debug_flags= ;;
2134       x-*)        ;;
2135       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2136      esac])
2137
2138   # Option parsed, now set things appropriately
2139   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2140   AC_SUBST(DEBUG_FLAGS)
2141
2142   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2143 ])
2144
2145
2146 dnl
2147 dnl Check if the user only wants a freestanding library implementation.
2148 dnl
2149 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2150 dnl installing only the headers required by [17.4.1.3] and the language
2151 dnl support library.  More than that will be built (to keep the Makefiles
2152 dnl conveniently clean), but not installed.
2153 dnl
2154 dnl Sets:
2155 dnl  is_hosted  (yes/no)
2156 dnl
2157 dnl Defines:
2158 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2159 dnl
2160 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2161   AC_ARG_ENABLE([hosted-libstdcxx],
2162     AC_HELP_STRING([--disable-hosted-libstdcxx],
2163                    [only build freestanding C++ runtime support]),,
2164     [case "$host" in
2165         arm*-*-symbianelf*)
2166             enable_hosted_libstdcxx=no
2167             ;;
2168         *)
2169             enable_hosted_libstdcxx=yes
2170             ;;
2171      esac])
2172   if test "$enable_hosted_libstdcxx" = no; then
2173     AC_MSG_NOTICE([Only freestanding libraries will be built])
2174     is_hosted=no
2175     hosted_define=0
2176     enable_abi_check=no
2177     enable_libstdcxx_pch=no
2178   else
2179     is_hosted=yes
2180     hosted_define=1
2181   fi
2182   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2183   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2184     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2185 ])
2186
2187
2188 dnl
2189 dnl Check for template specializations for the 'long long' type.
2190 dnl The result determines only whether 'long long' I/O is enabled; things
2191 dnl like numeric_limits<> specializations are always available.
2192 dnl
2193 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2194 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2195 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2196 dnl       Where DEFAULT is either `yes' or `no'.
2197 dnl
2198 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2199   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2200   if test $enable_long_long = yes; then
2201     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2202               [Define if code specialized for long long should be used.])
2203   fi
2204   AC_MSG_CHECKING([for enabled long long specializations])
2205   AC_MSG_RESULT([$enable_long_long])
2206 ])
2207
2208
2209 dnl
2210 dnl Check for decimal floating point.
2211 dnl See:
2212 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2213 dnl
2214 dnl This checks to see if the host supports decimal floating point types.
2215 dnl
2216 dnl Defines:
2217 dnl  _GLIBCXX_USE_DECIMAL_FLOAT
2218 dnl
2219 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2220
2221   # Fake what AC_TRY_COMPILE does, without linking as this is
2222   # unnecessary for this test.
2223
2224     cat > conftest.$ac_ext << EOF
2225 [#]line __oline__ "configure"
2226 int main()
2227 {
2228   _Decimal32 d1;
2229   _Decimal64 d2;
2230   _Decimal128 d3;
2231   return 0;
2232 }
2233 EOF
2234
2235     AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2236     if AC_TRY_EVAL(ac_compile); then
2237       AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2238       [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2239       enable_dfp=yes
2240     else
2241       enable_dfp=no
2242     fi
2243     AC_MSG_RESULT($enable_dfp)
2244     rm -f conftest*
2245 ])
2246
2247 dnl
2248 dnl Check for template specializations for the 'wchar_t' type.
2249 dnl
2250 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2251 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2252 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2253 dnl       Where DEFAULT is either `yes' or `no'.
2254 dnl
2255 dnl Necessary support must also be present.
2256 dnl
2257 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2258   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2259
2260   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2261   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2262   AC_MSG_CHECKING([for mbstate_t])
2263   AC_TRY_COMPILE([#include <wchar.h>],
2264   [mbstate_t teststate;],
2265   have_mbstate_t=yes, have_mbstate_t=no)
2266   AC_MSG_RESULT($have_mbstate_t)
2267   if test x"$have_mbstate_t" = xyes; then
2268     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2269   fi
2270
2271   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2272   # ac_has_wchar_h.
2273   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2274
2275   if test x"$enable_wchar_t" = x"yes"; then
2276
2277     AC_LANG_SAVE
2278     AC_LANG_CPLUSPLUS
2279
2280     if test x"$ac_has_wchar_h" = xyes &&
2281        test x"$ac_has_wctype_h" = xyes; then
2282       AC_TRY_COMPILE([#include <wchar.h>
2283                       #include <stddef.h>
2284                       wint_t i;
2285                       long l = WEOF;
2286                       long j = WCHAR_MIN;
2287                       long k = WCHAR_MAX;
2288                       namespace test
2289                       {
2290                         using ::btowc;
2291                         using ::fgetwc;
2292                         using ::fgetws;
2293                         using ::fputwc;
2294                         using ::fputws;
2295                         using ::fwide;
2296                         using ::fwprintf;
2297                         using ::fwscanf;
2298                         using ::getwc;
2299                         using ::getwchar;
2300                         using ::mbrlen;
2301                         using ::mbrtowc;
2302                         using ::mbsinit;
2303                         using ::mbsrtowcs;
2304                         using ::putwc;
2305                         using ::putwchar;
2306                         using ::swprintf;
2307                         using ::swscanf;
2308                         using ::ungetwc;
2309                         using ::vfwprintf;
2310                         using ::vswprintf;
2311                         using ::vwprintf;
2312                         using ::wcrtomb;
2313                         using ::wcscat;
2314                         using ::wcschr;
2315                         using ::wcscmp;
2316                         using ::wcscoll;
2317                         using ::wcscpy;
2318                         using ::wcscspn;
2319                         using ::wcsftime;
2320                         using ::wcslen;
2321                         using ::wcsncat;
2322                         using ::wcsncmp;
2323                         using ::wcsncpy;
2324                         using ::wcspbrk;
2325                         using ::wcsrchr;
2326                         using ::wcsrtombs;
2327                         using ::wcsspn;
2328                         using ::wcsstr;
2329                         using ::wcstod;
2330                         using ::wcstok;
2331                         using ::wcstol;
2332                         using ::wcstoul;
2333                         using ::wcsxfrm;
2334                         using ::wctob;
2335                         using ::wmemchr;
2336                         using ::wmemcmp;
2337                         using ::wmemcpy;
2338                         using ::wmemmove;
2339                         using ::wmemset;
2340                         using ::wprintf;
2341                         using ::wscanf;
2342                       }
2343                      ],[],[], [enable_wchar_t=no])
2344     else
2345       enable_wchar_t=no
2346     fi
2347
2348     AC_LANG_RESTORE
2349   fi
2350
2351   if test x"$enable_wchar_t" = x"yes"; then
2352     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2353               [Define if code specialized for wchar_t should be used.])
2354   fi
2355
2356   AC_MSG_CHECKING([for enabled wchar_t specializations])
2357   AC_MSG_RESULT([$enable_wchar_t])
2358 ])
2359
2360
2361 dnl
2362 dnl Check to see if building and using a C++ precompiled header can be done.
2363 dnl
2364 dnl --enable-libstdcxx-pch=yes
2365 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2366 dnl may work, after some light-hearted attempts to puzzle out compiler
2367 dnl support, flip bits on in include/Makefile.am
2368 dnl
2369 dnl --disable-libstdcxx-pch
2370 dnl turns off attempts to use or build stdc++.h.gch.
2371 dnl
2372 dnl Substs:
2373 dnl  glibcxx_PCHFLAGS
2374 dnl
2375 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2376   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2377   if test $enable_libstdcxx_pch = yes; then
2378     AC_CACHE_CHECK([for compiler with PCH support],
2379       [glibcxx_cv_prog_CXX_pch],
2380       [ac_save_CXXFLAGS="$CXXFLAGS"
2381        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2382        AC_LANG_SAVE
2383        AC_LANG_CPLUSPLUS
2384        echo '#include <math.h>' > conftest.h
2385        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2386                           -o conftest.h.gch 1>&5 2>&1 &&
2387                 echo '#error "pch failed"' > conftest.h &&
2388           echo '#include "conftest.h"' > conftest.cc &&
2389                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2390        then
2391          glibcxx_cv_prog_CXX_pch=yes
2392        else
2393          glibcxx_cv_prog_CXX_pch=no
2394        fi
2395        rm -f conftest*
2396        CXXFLAGS=$ac_save_CXXFLAGS
2397        AC_LANG_RESTORE
2398       ])
2399     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2400   fi
2401
2402   AC_MSG_CHECKING([for enabled PCH])
2403   AC_MSG_RESULT([$enable_libstdcxx_pch])
2404
2405   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2406   if test $enable_libstdcxx_pch = yes; then
2407     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2408   else
2409     glibcxx_PCHFLAGS=""
2410   fi
2411   AC_SUBST(glibcxx_PCHFLAGS)
2412 ])
2413
2414
2415 dnl
2416 dnl Check for atomic builtins.
2417 dnl See:
2418 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2419 dnl
2420 dnl This checks to see if the host supports the compiler-generated
2421 dnl builtins for atomic operations for various integral sizes. Note, this
2422 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2423 dnl that are used should be checked.
2424 dnl
2425 dnl Note:
2426 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2427 dnl
2428 dnl Defines:
2429 dnl  _GLIBCXX_ATOMIC_BUILTINS_1
2430 dnl  _GLIBCXX_ATOMIC_BUILTINS_2
2431 dnl  _GLIBCXX_ATOMIC_BUILTINS_4
2432 dnl  _GLIBCXX_ATOMIC_BUILTINS_8
2433 dnl
2434 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2435   AC_LANG_SAVE
2436   AC_LANG_CPLUSPLUS
2437   old_CXXFLAGS="$CXXFLAGS"
2438
2439   # Do link tests if possible, instead asm tests, limited to some platforms
2440   # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2441   # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2442   atomic_builtins_link_tests=no
2443   if test x$gcc_no_link != xyes; then
2444     # Can do link tests. Limit to some tested platforms
2445     case "$host" in
2446       *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2447         atomic_builtins_link_tests=yes
2448         ;;
2449     esac
2450   fi
2451
2452   if test x$atomic_builtins_link_tests = xyes; then
2453
2454   # Do link tests.
2455
2456   CXXFLAGS="$CXXFLAGS -fno-exceptions"
2457
2458   AC_MSG_CHECKING([for atomic builtins for bool])
2459   AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2460     AC_TRY_LINK(
2461       [ ],
2462       [typedef bool atomic_type;
2463        atomic_type c1;
2464        atomic_type c2;
2465        const atomic_type c3(0);
2466        __sync_fetch_and_add(&c1, c2);
2467        __sync_val_compare_and_swap(&c1, c3, c2);
2468        __sync_lock_test_and_set(&c1, c3);
2469        __sync_lock_release(&c1);
2470        __sync_synchronize();],
2471       [glibcxx_cv_atomic_bool=yes],
2472       [glibcxx_cv_atomic_bool=no])
2473   ])
2474   if test $glibcxx_cv_atomic_bool = yes; then
2475     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2476       [Define if builtin atomic operations for bool are supported on this host.])
2477   fi
2478   AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2479
2480   AC_MSG_CHECKING([for atomic builtins for short])
2481   AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2482     AC_TRY_LINK(
2483       [ ],
2484       [typedef short atomic_type;
2485        atomic_type c1;
2486        atomic_type c2;
2487        const atomic_type c3(0);
2488        __sync_fetch_and_add(&c1, c2);
2489        __sync_val_compare_and_swap(&c1, c3, c2);
2490        __sync_lock_test_and_set(&c1, c3);
2491        __sync_lock_release(&c1);
2492        __sync_synchronize();],
2493       [glibcxx_cv_atomic_short=yes],
2494       [glibcxx_cv_atomic_short=no])
2495   ])
2496   if test $glibcxx_cv_atomic_short = yes; then
2497     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2498       [Define if builtin atomic operations for short are supported on this host.])
2499   fi
2500   AC_MSG_RESULT($glibcxx_cv_atomic_short)
2501
2502   AC_MSG_CHECKING([for atomic builtins for int])
2503   AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2504     AC_TRY_LINK(
2505       [ ],
2506       [typedef int atomic_type;
2507        atomic_type c1;
2508        atomic_type c2;
2509        const atomic_type c3(0);
2510        __sync_fetch_and_add(&c1, c2);
2511        __sync_val_compare_and_swap(&c1, c3, c2);
2512        __sync_lock_test_and_set(&c1, c3);
2513        __sync_lock_release(&c1);
2514        __sync_synchronize();],
2515       [glibcxx_cv_atomic_int=yes],
2516       [glibcxx_cv_atomic_int=no])
2517   ])
2518   if test $glibcxx_cv_atomic_int = yes; then
2519     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2520       [Define if builtin atomic operations for int are supported on this host.])
2521   fi
2522   AC_MSG_RESULT($glibcxx_cv_atomic_int)
2523
2524   AC_MSG_CHECKING([for atomic builtins for long long])
2525   AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2526     AC_TRY_LINK(
2527       [ ],
2528       [typedef long long atomic_type;
2529        atomic_type c1;
2530        atomic_type c2;
2531        const atomic_type c3(0);
2532        __sync_fetch_and_add(&c1, c2);
2533        __sync_val_compare_and_swap(&c1, c3, c2);
2534        __sync_lock_test_and_set(&c1, c3);
2535        __sync_lock_release(&c1);
2536        __sync_synchronize();],
2537       [glibcxx_cv_atomic_long_long=yes],
2538       [glibcxx_cv_atomic_long_long=no])
2539   ])
2540   if test $glibcxx_cv_atomic_long_long = yes; then
2541     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2542       [Define if builtin atomic operations for long long are supported on this host.])
2543   fi
2544   AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2545
2546   else
2547
2548   # Do asm tests.
2549
2550   # Compile unoptimized.
2551   CXXFLAGS='-O0 -S'
2552
2553   # Fake what AC_TRY_COMPILE does.
2554
2555     cat > conftest.$ac_ext << EOF
2556 [#]line __oline__ "configure"
2557 int main()
2558 {
2559   typedef bool atomic_type;
2560   atomic_type c1;
2561   atomic_type c2;
2562   const atomic_type c3(0);
2563   __sync_fetch_and_add(&c1, c2);
2564   __sync_val_compare_and_swap(&c1, c3, c2);
2565   __sync_lock_test_and_set(&c1, c3);
2566   __sync_lock_release(&c1);
2567   __sync_synchronize();
2568   return 0;
2569 }
2570 EOF
2571
2572     AC_MSG_CHECKING([for atomic builtins for bool])
2573     if AC_TRY_EVAL(ac_compile); then
2574       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2575         glibcxx_cv_atomic_bool=no
2576       else
2577       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2578       [Define if builtin atomic operations for bool are supported on this host.])
2579         glibcxx_cv_atomic_bool=yes
2580       fi
2581     fi
2582     AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2583     rm -f conftest*
2584
2585     cat > conftest.$ac_ext << EOF
2586 [#]line __oline__ "configure"
2587 int main()
2588 {
2589   typedef short atomic_type;
2590   atomic_type c1;
2591   atomic_type c2;
2592   const atomic_type c3(0);
2593   __sync_fetch_and_add(&c1, c2);
2594   __sync_val_compare_and_swap(&c1, c3, c2);
2595   __sync_lock_test_and_set(&c1, c3);
2596   __sync_lock_release(&c1);
2597   __sync_synchronize();
2598   return 0;
2599 }
2600 EOF
2601
2602     AC_MSG_CHECKING([for atomic builtins for short])
2603     if AC_TRY_EVAL(ac_compile); then
2604       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2605         glibcxx_cv_atomic_short=no
2606       else
2607       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2608       [Define if builtin atomic operations for short are supported on this host.])
2609         glibcxx_cv_atomic_short=yes
2610       fi
2611     fi
2612     AC_MSG_RESULT($glibcxx_cv_atomic_short)
2613     rm -f conftest*
2614
2615     cat > conftest.$ac_ext << EOF
2616 [#]line __oline__ "configure"
2617 int main()
2618 {
2619   // NB: _Atomic_word not necessarily int.
2620   typedef int atomic_type;
2621   atomic_type c1;
2622   atomic_type c2;
2623   const atomic_type c3(0);
2624   __sync_fetch_and_add(&c1, c2);
2625   __sync_val_compare_and_swap(&c1, c3, c2);
2626   __sync_lock_test_and_set(&c1, c3);
2627   __sync_lock_release(&c1);
2628   __sync_synchronize();
2629   return 0;
2630 }
2631 EOF
2632
2633     AC_MSG_CHECKING([for atomic builtins for int])
2634     if AC_TRY_EVAL(ac_compile); then
2635       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2636         glibcxx_cv_atomic_int=no
2637       else
2638       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2639         [Define if builtin atomic operations for int are supported on this host.])
2640         glibcxx_cv_atomic_int=yes
2641       fi
2642     fi
2643     AC_MSG_RESULT($glibcxx_cv_atomic_int)
2644     rm -f conftest*
2645
2646     cat > conftest.$ac_ext << EOF
2647 [#]line __oline__ "configure"
2648 int main()
2649 {
2650   typedef long long atomic_type;
2651   atomic_type c1;
2652   atomic_type c2;
2653   const atomic_type c3(0);
2654   __sync_fetch_and_add(&c1, c2);
2655   __sync_val_compare_and_swap(&c1, c3, c2);
2656   __sync_lock_test_and_set(&c1, c3);
2657   __sync_lock_release(&c1);
2658   __sync_synchronize();
2659   return 0;
2660 }
2661 EOF
2662
2663     AC_MSG_CHECKING([for atomic builtins for long long])
2664     if AC_TRY_EVAL(ac_compile); then
2665       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2666         glibcxx_cv_atomic_long_long=no
2667       else
2668       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2669       [Define if builtin atomic operations for long long are supported on this host.])
2670         glibcxx_cv_atomic_long_long=yes
2671       fi
2672     fi
2673     AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2674     rm -f conftest*
2675
2676   fi
2677
2678   CXXFLAGS="$old_CXXFLAGS"
2679   AC_LANG_RESTORE
2680
2681   # Set atomicity_dir to builtins if either of above tests pass.
2682   if test $glibcxx_cv_atomic_int = yes || test $glibcxx_cv_atomic_bool = yes ; then
2683     atomicity_dir=cpu/generic/atomicity_builtins
2684   fi
2685
2686   # If still generic, set to mutex.
2687   if test $atomicity_dir = "cpu/generic" ; then
2688     atomicity_dir=cpu/generic/atomicity_mutex
2689     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2690       if test "x$target_thread_file" = xsingle; then
2691         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2692         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2693       else
2694         AC_MSG_WARN([They will be faked using a mutex.])
2695         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2696       fi
2697   fi
2698
2699 ])
2700
2701
2702 dnl
2703 dnl Check for exception handling support.  If an explicit enable/disable
2704 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2705 dnl target may or may not support call frame exceptions.
2706 dnl
2707 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2708 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2709 dnl Neither one forces an attempt at detection.
2710 dnl
2711 dnl Defines:
2712 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2713 dnl
2714 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2715   AC_MSG_CHECKING([for exception model to use])
2716   AC_LANG_SAVE
2717   AC_LANG_CPLUSPLUS
2718   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2719     [force use of builtin_setjmp for exceptions],
2720     [permit yes|no|auto])
2721
2722   if test $enable_sjlj_exceptions = auto; then
2723     # Botheration.  Now we've got to detect the exception model.  Link tests
2724     # against libgcc.a are problematic since we've not been given proper -L
2725     # bits for single-tree newlib and libgloss.
2726     #
2727     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2728     cat > conftest.$ac_ext << EOF
2729 [#]line __oline__ "configure"
2730 struct S { ~S(); };
2731 void bar();
2732 void foo()
2733 {
2734   S s;
2735   bar();
2736 }
2737 EOF
2738     old_CXXFLAGS="$CXXFLAGS"
2739     CXXFLAGS=-S
2740     if AC_TRY_EVAL(ac_compile); then
2741       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2742         enable_sjlj_exceptions=yes
2743       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2744         enable_sjlj_exceptions=no
2745       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2746         enable_sjlj_exceptions=no
2747       fi
2748     fi
2749     CXXFLAGS="$old_CXXFLAGS"
2750     rm -f conftest*
2751   fi
2752
2753   # This is a tad weird, for hysterical raisins.  We have to map
2754   # enable/disable to two different models.
2755   case $enable_sjlj_exceptions in
2756     yes)
2757       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2758         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2759       ac_exception_model_name=sjlj
2760       ;;
2761     no)
2762       ac_exception_model_name="call frame"
2763       ;;
2764     *)
2765       AC_MSG_ERROR([unable to detect exception model])
2766       ;;
2767   esac
2768  AC_LANG_RESTORE
2769  AC_MSG_RESULT($ac_exception_model_name)
2770 ])
2771
2772
2773 dnl
2774 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2775 dnl
2776 dnl --enable-visibility enables attempt to use visibility attributes.
2777 dnl --disable-visibility turns off all use of visibility attributes.
2778 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2779 dnl       Where DEFAULT is 'yes'.
2780 dnl
2781 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2782 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2783
2784 if test x$enable_visibility = xyes ; then
2785   dnl all hail libgfortran
2786   dnl Check whether the target supports hidden visibility.
2787   AC_CACHE_CHECK([whether the target supports hidden visibility],
2788                  glibcxx_cv_have_attribute_visibility, [
2789   save_CFLAGS="$CFLAGS"
2790   CFLAGS="$CFLAGS -Werror"
2791   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2792                  [], glibcxx_cv_have_attribute_visibility=yes,
2793                  glibcxx_cv_have_attribute_visibility=no)
2794   CFLAGS="$save_CFLAGS"])
2795   if test $glibcxx_cv_have_attribute_visibility = no; then
2796     enable_visibility=no
2797   fi
2798 fi
2799
2800 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2801 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2802 ])
2803
2804
2805 dnl
2806 dnl Add version tags to symbols in shared library (or not), additionally
2807 dnl marking other symbols as private/local (or not).
2808 dnl
2809 dnl --enable-symvers=style adds a version script to the linker call when
2810 dnl       creating the shared library.  The choice of version script is
2811 dnl       controlled by 'style'.
2812 dnl --disable-symvers does not.
2813 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2814 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2815 dnl       choose a default style based on linker characteristics.  Passing
2816 dnl       'no' disables versioning.
2817 dnl
2818 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2819
2820 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2821   [enables symbol versioning of the shared library],
2822   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
2823
2824 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2825 # don't know enough about $LD to do tricks...
2826 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2827 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
2828 # with extern "C++" in version scripts.
2829 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
2830
2831 # Turn a 'yes' into a suitable default.
2832 if test x$enable_symvers = xyes ; then
2833   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2834     enable_symvers=no
2835   else
2836     if test $with_gnu_ld = yes ; then
2837       case ${target_os} in
2838         hpux*)
2839           enable_symvers=no ;;
2840         *)
2841           enable_symvers=gnu ;;
2842       esac
2843     else
2844       case ${target_os} in
2845         darwin*)
2846           enable_symvers=darwin ;;
2847         # Sun symbol versioning exists since Solaris 2.5.
2848         solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
2849           # make_sunver.pl needs GNU c++filt to support extern "C++" in
2850           # version scripts, so disable symbol versioning if none can be
2851           # found.
2852           if test -z "$ac_cv_path_CXXFILT"; then
2853             AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
2854             AC_MSG_WARN([=== no GNU c++filt could  be found.])
2855             AC_MSG_WARN([=== Symbol versioning will be disabled.])
2856             enable_symvers=no
2857           else
2858             enable_symvers=sun
2859           fi
2860           ;;
2861         *)
2862           enable_symvers=no ;;
2863       esac
2864     fi
2865   fi
2866 fi
2867
2868 # Check to see if 'darwin' or 'darwin-export' can win.
2869 if test x$enable_symvers = xdarwin-export ; then
2870     enable_symvers=darwin
2871 fi
2872
2873 # Check if 'sun' was requested on non-Solaris 2 platforms.
2874 if test x$enable_symvers = xsun ; then
2875   case ${target_os} in
2876     solaris2*)
2877       # All fine.
2878       ;;
2879     *)
2880       # Unlikely to work.
2881       AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
2882       AC_MSG_WARN([=== you are not targetting Solaris 2.])
2883       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2884       enable_symvers=no
2885       ;;
2886   esac
2887 fi
2888
2889 # Check to see if 'gnu' can win.
2890 if test $enable_symvers = gnu ||
2891   test $enable_symvers = gnu-versioned-namespace ||
2892   test $enable_symvers = sun; then
2893   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2894   AC_MSG_CHECKING([for shared libgcc])
2895   ac_save_CFLAGS="$CFLAGS"
2896   CFLAGS=' -lgcc_s'
2897   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2898   CFLAGS="$ac_save_CFLAGS"
2899   if test $glibcxx_shared_libgcc = no; then
2900     cat > conftest.c <<EOF
2901 int main (void) { return 0; }
2902 EOF
2903 changequote(,)dnl
2904     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2905                              -shared -shared-libgcc -o conftest.so \
2906                              conftest.c -v 2>&1 >/dev/null \
2907                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2908 changequote([,])dnl
2909     rm -f conftest.c conftest.so
2910     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2911       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2912       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2913       CFLAGS="$ac_save_CFLAGS"
2914     fi
2915   fi
2916   AC_MSG_RESULT($glibcxx_shared_libgcc)
2917
2918   # For GNU ld, we need at least this version.  The format is described in
2919   # GLIBCXX_CHECK_LINKER_FEATURES above.
2920   glibcxx_min_gnu_ld_version=21400
2921
2922   # If no shared libgcc, can't win.
2923   if test $glibcxx_shared_libgcc != yes; then
2924       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2925       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2926       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2927       enable_symvers=no
2928   elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
2929     : All interesting versions of Sun ld support sun style symbol versioning.
2930   elif test $with_gnu_ld != yes ; then
2931     # just fail for now
2932     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2933     AC_MSG_WARN([=== you are not using the GNU linker.])
2934     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2935     enable_symvers=no
2936   elif test $glibcxx_ld_is_gold = yes ; then
2937     : All versions of gold support symbol versioning.
2938   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2939     # The right tools, the right setup, but too old.  Fallbacks?
2940     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2941     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2942     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2943     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2944     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2945     enable_symvers=no
2946   fi
2947 fi
2948
2949 # Everything parsed; figure out what file to use.
2950 case $enable_symvers in
2951   no)
2952     SYMVER_FILE=config/abi/pre/none.ver
2953     ;;
2954   gnu)
2955     SYMVER_FILE=config/abi/pre/gnu.ver
2956     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2957               [Define to use GNU versioning in the shared library.])
2958     ;;
2959   gnu-versioned-namespace)
2960     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2961     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2962               [Define to use GNU namespace versioning in the shared library.])
2963     ;;
2964   darwin)
2965     SYMVER_FILE=config/abi/pre/gnu.ver
2966     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2967               [Define to use darwin versioning in the shared library.])
2968     ;;
2969   sun)
2970     SYMVER_FILE=config/abi/pre/gnu.ver
2971     AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
2972               [Define to use Sun versioning in the shared library.])
2973     ;;
2974 esac
2975
2976 if test x$enable_symvers != xno ; then
2977   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2978          [Define to use symbol versioning in the shared library.])
2979 fi
2980
2981 AC_CACHE_CHECK([whether the target supports .symver directive],
2982                glibcxx_cv_have_as_symver_directive, [
2983   AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
2984                  [], glibcxx_cv_have_as_symver_directive=yes,
2985                  glibcxx_cv_have_as_symver_directive=no)])
2986 if test $glibcxx_cv_have_as_symver_directive = yes; then
2987   AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
2988     [Define to 1 if the target assembler supports .symver directive.])
2989 fi
2990
2991 AC_SUBST(SYMVER_FILE)
2992 AC_SUBST(port_specific_symbol_files)
2993 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2994 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2995 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2996 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2997 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
2998 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2999
3000 if test $enable_symvers != no ; then
3001    case ${target_os} in
3002      # The Solaris 2 runtime linker doesn't support the GNU extension of
3003      # binding the same symbol to different versions
3004      solaris2*)
3005        symvers_renaming=no  ;;
3006      # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3007      *)
3008        AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3009          [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3010        symvers_renaming=yes  ;;
3011     esac
3012 fi
3013 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SOL2, test $symvers_renaming = no)
3014
3015 # Now, set up compatibility support, if any.
3016 # In addition, need this to deal with std::size_t mangling in
3017 # src/compatibility.cc.  In a perfect world, could use
3018 # typeid(std::size_t).name()[0] to do direct substitution.
3019 AC_MSG_CHECKING([for size_t as unsigned int])
3020 ac_save_CFLAGS="$CFLAGS"
3021 CFLAGS="-Werror"
3022 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3023                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3024 CFLAGS=$ac_save_CFLAGS
3025 if test "$glibcxx_size_t_is_i" = yes; then
3026   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3027 fi
3028 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3029
3030 AC_MSG_CHECKING([for ptrdiff_t as int])
3031 ac_save_CFLAGS="$CFLAGS"
3032 CFLAGS="-Werror"
3033 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3034                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3035 CFLAGS=$ac_save_CFLAGS
3036 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3037   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3038 fi
3039 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3040 ])
3041
3042
3043 dnl
3044 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3045 dnl We must stage the required headers so that they will be installed
3046 dnl with the library (unlike libgcc, the STL implementation is provided
3047 dnl solely within headers).  Since we must not inject random user-space
3048 dnl macro names into user-provided C++ code, we first stage into <file>-in
3049 dnl and process to <file> with an output command.  The reason for a two-
3050 dnl stage process here is to correctly handle $srcdir!=$objdir without
3051 dnl having to write complex code (the sed commands to clean the macro
3052 dnl namespace are complex and fragile enough as it is).  We must also
3053 dnl add a relative path so that -I- is supported properly.
3054 dnl
3055 dnl Substs:
3056 dnl  glibcxx_thread_h
3057 dnl
3058 dnl Defines:
3059 dnl  HAVE_GTHR_DEFAULT
3060 dnl
3061 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3062   AC_MSG_CHECKING([for thread model used by GCC])
3063   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3064   AC_MSG_RESULT([$target_thread_file])
3065
3066   if test $target_thread_file != single; then
3067     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
3068               [Define if gthr-default.h exists
3069               (meaning that threading support is enabled).])
3070   fi
3071
3072   glibcxx_thread_h=gthr-$target_thread_file.h
3073
3074   dnl Check for __GTHREADS define.
3075   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
3076   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
3077     enable_thread=yes
3078   else
3079    enable_thread=no
3080   fi
3081
3082   AC_SUBST(glibcxx_thread_h)
3083 ])
3084
3085
3086 dnl
3087 dnl Check if gthread implementation defines the types and functions
3088 dnl required by the c++0x thread library.  Conforming gthread
3089 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3090 dnl
3091 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3092   AC_LANG_SAVE
3093   AC_LANG_CPLUSPLUS
3094
3095   ac_save_CXXFLAGS="$CXXFLAGS"
3096   CXXFLAGS="$CXXFLAGS -fno-exceptions -I${toplevel_srcdir}/gcc"
3097
3098   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3099   case $target_thread_file in
3100     posix)
3101       CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3102   esac
3103
3104   AC_MSG_CHECKING([for gthreads library])
3105
3106   AC_TRY_COMPILE([#include "gthr.h"],
3107     [
3108       #ifndef __GTHREADS_CXX0X
3109       #error
3110       #endif
3111
3112       // In case of POSIX threads check _POSIX_TIMEOUTS too.
3113       #if (defined(_PTHREADS) \
3114            && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3115       #error
3116       #endif
3117     ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
3118
3119   AC_MSG_RESULT([$ac_has_gthreads])
3120
3121   if test x"$ac_has_gthreads" = x"yes"; then
3122     AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3123               [Define if gthreads library is available.])
3124   fi
3125
3126   CXXFLAGS="$ac_save_CXXFLAGS"
3127   AC_LANG_RESTORE
3128 ])
3129
3130
3131 # Check whether LC_MESSAGES is available in <locale.h>.
3132 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3133 #
3134 # This file file be copied and used freely without restrictions.  It can
3135 # be used in projects which are not available under the GNU Public License
3136 # but which still want to provide support for the GNU gettext functionality.
3137 # Please note that the actual code is *not* freely available.
3138 AC_DEFUN([AC_LC_MESSAGES], [
3139   AC_CHECK_HEADER(locale.h, [
3140     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3141       [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3142        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3143     if test $ac_cv_val_LC_MESSAGES = yes; then
3144       AC_DEFINE(HAVE_LC_MESSAGES, 1,
3145                 [Define if LC_MESSAGES is available in <locale.h>.])
3146     fi
3147   ])
3148 ])
3149
3150 # Macros from the top-level gcc directory.
3151 m4_include([../config/gc++filt.m4])
3152 m4_include([../config/tls.m4])
3153