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