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