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(ac_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         [ac_setrlimit=yes], [ac_setrlimit=no])
 372     ])
 373   fi
 374
 375   AC_MSG_CHECKING([for testsuite resource limits support])
 376   if test $setrlimit_have_headers = yes && test $ac_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(ac_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      ],[ac_c99_math=yes], [ac_c99_math=no])
 823   ])
 824   AC_MSG_RESULT($ac_c99_math)
 825   if test x"$ac_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   ac_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         d = cabs(tmpd);
 864         d = carg(tmpd);
 865         tmpd = ccos(tmpd);
 866         tmpd = ccosh(tmpd);
 867         tmpd = cexp(tmpd);
 868         tmpd = clog(tmpd);
 869         tmpd = csin(tmpd);
 870         tmpd = csinh(tmpd);
 871         tmpd = csqrt(tmpd);
 872         tmpd = ctan(tmpd);
 873         tmpd = ctanh(tmpd);
 874         tmpd = cpow(tmpd, tmpd);
 875         ld = cabsl(tmpld);
 876         ld = cargl(tmpld);
 877         tmpld = ccosl(tmpld);
 878         tmpld = ccoshl(tmpld);
 879         tmpld = cexpl(tmpld);
 880         tmpld = clogl(tmpld);
 881         tmpld = csinl(tmpld);
 882         tmpld = csinhl(tmpld);
 883         tmpld = csqrtl(tmpld);
 884         tmpld = ctanl(tmpld);
 885         tmpld = ctanhl(tmpld);
 886         tmpld = cpowl(tmpld, tmpld);
 887        ],[ac_c99_complex=yes], [ac_c99_complex=no])
 888   fi
 889   AC_MSG_RESULT($ac_c99_complex)
 890   if test x"$ac_c99_complex" = x"yes"; then
 891     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 892               [Define if C99 functions in <complex.h> should be used in
 893               <complex>. Using compiler builtins for these functions requires
 894               corresponding C99 library functions to be present.])
 895   fi
 896
 897   # Check for the existence in <stdio.h> of vscanf, et. al.
 898   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 899   AC_CACHE_VAL(ac_c99_stdio, [
 900   GCC_TRY_COMPILE_OR_LINK(
 901      [#include <stdio.h>
 902       #include <stdarg.h>
 903       void foo(char* fmt, ...)
 904       {
 905         va_list args; va_start(args, fmt);
 906         vfscanf(stderr, "%i", args);
 907         vscanf("%i", args);
 908         vsnprintf(fmt, 0, "%i", args);
 909         vsscanf(fmt, "%i", args);
 910       }],
 911      [snprintf("12", 0, "%i");],
 912      [ac_c99_stdio=yes], [ac_c99_stdio=no])
 913   ])
 914   AC_MSG_RESULT($ac_c99_stdio)
 915
 916   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
 917   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
 918   AC_CACHE_VAL(ac_c99_stdlib, [
 919   GCC_TRY_COMPILE_OR_LINK(
 920      [#include <stdlib.h>
 921       volatile float f;
 922       volatile long double ld;
 923       volatile unsigned long long ll;
 924       lldiv_t mydivt;],
 925      [char* tmp;
 926       f = strtof("gnu", &tmp);
 927       ld = strtold("gnu", &tmp);
 928       ll = strtoll("gnu", &tmp, 10);
 929       ll = strtoull("gnu", &tmp, 10);
 930       ll = llabs(10);
 931       mydivt = lldiv(10,1);
 932       ll = mydivt.quot;
 933       ll = mydivt.rem;
 934       ll = atoll("10");
 935       _Exit(0);
 936       ],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
 937   ])
 938   AC_MSG_RESULT($ac_c99_stdlib)
 939
 940   # Check for the existence in <wchar.h> of wcstold, etc.
 941   ac_c99_wchar=no;
 942   if test x"$ac_has_wchar_h" = xyes &&
 943      test x"$ac_has_wctype_h" = xyes; then
 944     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
 945     AC_TRY_COMPILE([#include <wchar.h>
 946                     namespace test
 947                     {
 948                       using ::wcstold;
 949                       using ::wcstoll;
 950                       using ::wcstoull;
 951                     }
 952                    ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
 953
 954     # Checks for wide character functions that may not be present.
 955     # Injection of these is wrapped with guard macros.
 956     # NB: only put functions here, instead of immediately above, if
 957     # absolutely necessary.
 958     AC_TRY_COMPILE([#include <wchar.h>
 959                     namespace test { using ::vfwscanf; } ], [],
 960                    [AC_DEFINE(HAVE_VFWSCANF,1,
 961                         [Defined if vfwscanf exists.])],[])
 962
 963     AC_TRY_COMPILE([#include <wchar.h>
 964                     namespace test { using ::vswscanf; } ], [],
 965                    [AC_DEFINE(HAVE_VSWSCANF,1,
 966                         [Defined if vswscanf exists.])],[])
 967
 968     AC_TRY_COMPILE([#include <wchar.h>
 969                     namespace test { using ::vwscanf; } ], [],
 970                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
 971
 972     AC_TRY_COMPILE([#include <wchar.h>
 973                     namespace test { using ::wcstof; } ], [],
 974                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
 975
 976     AC_TRY_COMPILE([#include <wctype.h>],
 977                    [ wint_t t; int i = iswblank(t);],
 978                    [AC_DEFINE(HAVE_ISWBLANK,1,
 979                         [Defined if iswblank exists.])],[])
 980
 981     AC_MSG_RESULT($ac_c99_wchar)
 982   fi
 983
 984   # Option parsed, now set things appropriately.
 985   if test x"$ac_c99_math" = x"no" ||
 986      test x"$ac_c99_complex" = x"no" ||
 987      test x"$ac_c99_stdio" = x"no" ||
 988      test x"$ac_c99_stdlib" = x"no" ||
 989      test x"$ac_c99_wchar" = x"no"; then
 990     enable_c99=no;
 991   else
 992     AC_DEFINE(_GLIBCXX_USE_C99, 1,
 993     [Define if C99 functions or macros from <wchar.h>, <math.h>,
 994     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
 995   fi
 996
 997   gcc_no_link="$ac_save_gcc_no_link"
 998   LIBS="$ac_save_LIBS"
 999   CXXFLAGS="$ac_save_CXXFLAGS"
1000   AC_LANG_RESTORE
1001   fi
1002
1003   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1004   AC_MSG_RESULT($enable_c99)
1005 ])
1006
1007
1008 dnl
1009 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1010 dnl facilities in Chapter 8, "C compatibility".
1011 dnl
1012 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1013
1014   AC_LANG_SAVE
1015   AC_LANG_CPLUSPLUS
1016
1017   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1018   # undefined and fake C99 facilities may be spuriously enabled.
1019   ac_save_CXXFLAGS="$CXXFLAGS"
1020   CXXFLAGS="$CXXFLAGS -std=c++98"
1021
1022   # Check for the existence of <complex.h> complex math functions used
1023   # by tr1/complex.
1024   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1025   ac_c99_complex_tr1=no;
1026   if test x"$ac_has_complex_h" = x"yes"; then
1027     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1028     AC_TRY_COMPILE([#include <complex.h>],
1029                    [typedef __complex__ float float_type; float_type tmpf;
1030                     cacosf(tmpf);
1031                     casinf(tmpf);
1032                     catanf(tmpf);
1033                     cacoshf(tmpf);
1034                     casinhf(tmpf);
1035                     catanhf(tmpf);
1036                     typedef __complex__ double double_type; double_type tmpd;
1037                     cacos(tmpd);
1038                     casin(tmpd);
1039                     catan(tmpd);
1040                     cacosh(tmpd);
1041                     casinh(tmpd);
1042                     catanh(tmpd);
1043                     typedef __complex__ long double ld_type; ld_type tmpld;
1044                     cacosl(tmpld);
1045                     casinl(tmpld);
1046                     catanl(tmpld);
1047                     cacoshl(tmpld);
1048                     casinhl(tmpld);
1049                     catanhl(tmpld);
1050                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1051   fi
1052   AC_MSG_RESULT($ac_c99_complex_tr1)
1053   if test x"$ac_c99_complex_tr1" = x"yes"; then
1054     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1055               [Define if C99 functions in <complex.h> should be used in
1056               <tr1/complex>. Using compiler builtins for these functions
1057               requires corresponding C99 library functions to be present.])
1058   fi
1059
1060   # Check for the existence of <ctype.h> functions.
1061   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1062   AC_CACHE_VAL(ac_c99_ctype_tr1, [
1063   AC_TRY_COMPILE([#include <ctype.h>],
1064                  [int ch;
1065                   int ret;
1066                   ret = isblank(ch);
1067                  ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no])
1068   ])
1069   AC_MSG_RESULT($ac_c99_ctype_tr1)
1070   if test x"$ac_c99_ctype_tr1" = x"yes"; then
1071     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1072               [Define if C99 functions in <ctype.h> should be imported in
1073               <tr1/cctype> in namespace std::tr1.])
1074   fi
1075
1076   # Check for the existence of <fenv.h> functions.
1077   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1078   ac_c99_fenv_tr1=no;
1079   if test x"$ac_has_fenv_h" = x"yes"; then
1080     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1081     AC_TRY_COMPILE([#include <fenv.h>],
1082                    [int except, mode;
1083                     fexcept_t* pflag;
1084                     fenv_t* penv;
1085                     int ret;
1086                     ret = feclearexcept(except);
1087                     ret = fegetexceptflag(pflag, except);
1088                     ret = feraiseexcept(except);
1089                     ret = fesetexceptflag(pflag, except);
1090                     ret = fetestexcept(except);
1091                     ret = fegetround();
1092                     ret = fesetround(mode);
1093                     ret = fegetenv(penv);
1094                     ret = feholdexcept(penv);
1095                     ret = fesetenv(penv);
1096                     ret = feupdateenv(penv);
1097                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1098   fi
1099   AC_MSG_RESULT($ac_c99_fenv_tr1)
1100   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1101     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1102               [Define if C99 functions in <fenv.h> should be imported in
1103               <tr1/cfenv> in namespace std::tr1.])
1104   fi
1105
1106   # Check for the existence of <stdint.h> types.
1107   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1108   AC_CACHE_VAL(ac_c99_stdint_tr1, [
1109   AC_TRY_COMPILE([#include <stdint.h>],
1110                  [typedef int8_t          my_int8_t;
1111                   typedef int16_t         my_int16_t;
1112                   typedef int32_t         my_int32_t;
1113                   typedef int64_t         my_int64_t;
1114                   typedef int_fast8_t     my_int_fast8_t;
1115                   typedef int_fast16_t    my_int_fast16_t;
1116                   typedef int_fast32_t    my_int_fast32_t;
1117                   typedef int_fast64_t    my_int_fast64_t;
1118                   typedef int_least8_t    my_int_least8_t;
1119                   typedef int_least16_t   my_int_least16_t;
1120                   typedef int_least32_t   my_int_least32_t;
1121                   typedef int_least64_t   my_int_least64_t;
1122                   typedef intmax_t        my_intmax_t;
1123                   typedef intptr_t        my_intptr_t;
1124                   typedef uint8_t         my_uint8_t;
1125                   typedef uint16_t        my_uint16_t;
1126                   typedef uint32_t        my_uint32_t;
1127                   typedef uint64_t        my_uint64_t;
1128                   typedef uint_fast8_t    my_uint_fast8_t;
1129                   typedef uint_fast16_t   my_uint_fast16_t;
1130                   typedef uint_fast32_t   my_uint_fast32_t;
1131                   typedef uint_fast64_t   my_uint_fast64_t;
1132                   typedef uint_least8_t   my_uint_least8_t;
1133                   typedef uint_least16_t  my_uint_least16_t;
1134                   typedef uint_least32_t  my_uint_least32_t;
1135                   typedef uint_least64_t  my_uint_least64_t;
1136                   typedef uintmax_t       my_uintmax_t;
1137                   typedef uintptr_t       my_uintptr_t;
1138                  ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no])
1139   ])
1140   AC_MSG_RESULT($ac_c99_stdint_tr1)
1141   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1142     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1143               [Define if C99 types in <stdint.h> should be imported in
1144               <tr1/cstdint> in namespace std::tr1.])
1145   fi
1146
1147   # Check for the existence of <math.h> functions.
1148   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1149   AC_CACHE_VAL(ac_c99_math_tr1, [
1150   AC_TRY_COMPILE([#include <math.h>],
1151                  [typedef double_t  my_double_t;
1152                   typedef float_t   my_float_t;
1153                   acosh(0.0);
1154                   acoshf(0.0f);
1155                   acoshl(0.0l);
1156                   asinh(0.0);
1157                   asinhf(0.0f);
1158                   asinhl(0.0l);
1159                   atanh(0.0);
1160                   atanhf(0.0f);
1161                   atanhl(0.0l);
1162                   cbrt(0.0);
1163                   cbrtf(0.0f);
1164                   cbrtl(0.0l);
1165                   copysign(0.0, 0.0);
1166                   copysignf(0.0f, 0.0f);
1167                   copysignl(0.0l, 0.0l);
1168                   erf(0.0);
1169                   erff(0.0f);
1170                   erfl(0.0l);
1171                   erfc(0.0);
1172                   erfcf(0.0f);
1173                   erfcl(0.0l);
1174                   exp2(0.0);
1175                   exp2f(0.0f);
1176                   exp2l(0.0l);
1177                   expm1(0.0);
1178                   expm1f(0.0f);
1179                   expm1l(0.0l);
1180                   fdim(0.0, 0.0);
1181                   fdimf(0.0f, 0.0f);
1182                   fdiml(0.0l, 0.0l);
1183                   fma(0.0, 0.0, 0.0);
1184                   fmaf(0.0f, 0.0f, 0.0f);
1185                   fmal(0.0l, 0.0l, 0.0l);
1186                   fmax(0.0, 0.0);
1187                   fmaxf(0.0f, 0.0f);
1188                   fmaxl(0.0l, 0.0l);
1189                   fmin(0.0, 0.0);
1190                   fminf(0.0f, 0.0f);
1191                   fminl(0.0l, 0.0l);
1192                   hypot(0.0, 0.0);
1193                   hypotf(0.0f, 0.0f);
1194                   hypotl(0.0l, 0.0l);
1195                   ilogb(0.0);
1196                   ilogbf(0.0f);
1197                   ilogbl(0.0l);
1198                   lgamma(0.0);
1199                   lgammaf(0.0f);
1200                   lgammal(0.0l);
1201                   llrint(0.0);
1202                   llrintf(0.0f);
1203                   llrintl(0.0l);
1204                   llround(0.0);
1205                   llroundf(0.0f);
1206                   llroundl(0.0l);
1207                   log1p(0.0);
1208                   log1pf(0.0f);
1209                   log1pl(0.0l);
1210                   log2(0.0);
1211                   log2f(0.0f);
1212                   log2l(0.0l);
1213                   logb(0.0);
1214                   logbf(0.0f);
1215                   logbl(0.0l);
1216                   lrint(0.0);
1217                   lrintf(0.0f);
1218                   lrintl(0.0l);
1219                   lround(0.0);
1220                   lroundf(0.0f);
1221                   lroundl(0.0l);
1222                   nan(0);
1223                   nanf(0);
1224                   nanl(0);
1225                   nearbyint(0.0);
1226                   nearbyintf(0.0f);
1227                   nearbyintl(0.0l);
1228                   nextafter(0.0, 0.0);
1229                   nextafterf(0.0f, 0.0f);
1230                   nextafterl(0.0l, 0.0l);
1231                   nexttoward(0.0, 0.0);
1232                   nexttowardf(0.0f, 0.0f);
1233                   nexttowardl(0.0l, 0.0l);
1234                   remainder(0.0, 0.0);
1235                   remainderf(0.0f, 0.0f);
1236                   remainderl(0.0l, 0.0l);
1237                   remquo(0.0, 0.0, 0);
1238                   remquo(0.0f, 0.0f, 0);
1239                   remquo(0.0l, 0.0l, 0);
1240                   rint(0.0);
1241                   rintf(0.0f);
1242                   rintl(0.0l);
1243                   round(0.0);
1244                   roundf(0.0f);
1245                   roundl(0.0l);
1246                   scalbln(0.0, 0l);
1247                   scalblnf(0.0f, 0l);
1248                   scalblnl(0.0l, 0l);
1249                   scalbn(0.0, 0);
1250                   scalbnf(0.0f, 0);
1251                   scalbnl(0.0l, 0);
1252                   tgamma(0.0);
1253                   tgammaf(0.0f);
1254                   tgammal(0.0l);
1255                   trunc(0.0);
1256                   truncf(0.0f);
1257                   truncl(0.0l);
1258                  ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
1259   ])
1260   AC_MSG_RESULT($ac_c99_math_tr1)
1261   if test x"$ac_c99_math_tr1" = x"yes"; then
1262     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1263               [Define if C99 functions or macros in <math.h> should be imported
1264               in <tr1/cmath> in namespace std::tr1.])
1265   fi
1266
1267   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1268   # sense if the previous check fails, per C99, 7.8/1).
1269   ac_c99_inttypes_tr1=no;
1270   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1271     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1272     AC_TRY_COMPILE([#include <inttypes.h>],
1273                    [intmax_t i, numer, denom, base;
1274                     const char* s;
1275                     char** endptr;
1276                     intmax_t ret = imaxabs(i);
1277                     imaxdiv_t dret = imaxdiv(numer, denom);
1278                     ret = strtoimax(s, endptr, base);
1279                     uintmax_t uret = strtoumax(s, endptr, base);
1280                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1281   fi
1282   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1283   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1284     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1285               [Define if C99 functions in <inttypes.h> should be imported in
1286               <tr1/cinttypes> in namespace std::tr1.])
1287   fi
1288
1289   # Check for the existence of the <stdbool.h> header.
1290   AC_CHECK_HEADERS(stdbool.h)
1291
1292   CXXFLAGS="$ac_save_CXXFLAGS"
1293   AC_LANG_RESTORE
1294 ])
1295
1296 dnl
1297 dnl Check whether "dev/random" and "dev/urandom" are available for the
1298 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1299 dnl
1300 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1301
1302   AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1303   AC_CACHE_VAL(ac_random_tr1, [
1304   AC_TRY_RUN([#include <stdio.h>
1305               int main()
1306               {
1307                 return !(fopen("/dev/random", "r")
1308                          && fopen("/dev/urandom", "r"));
1309               }
1310              ],
1311              [ac_random_tr1=yes], [ac_random_tr1=no],
1312              [ac_random_tr1=no])
1313   ])
1314   AC_MSG_RESULT($ac_random_tr1)
1315   if test x"$ac_random_tr1" = x"yes"; then
1316     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1317               [Define if dev/random and dev/urandom are available for
1318                the random_device of TR1 (Chapter 5.1).])
1319   fi
1320
1321 ])
1322
1323 dnl
1324 dnl Check whether macros, etc are present for <system_error>
1325 dnl
1326 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1327
1328   AC_MSG_CHECKING([for EOWNERDEAD])
1329   AC_CACHE_VAL(ac_system_error1, [
1330   AC_TRY_COMPILE([#include <errno.h>], [ int i = EOWNERDEAD; ],
1331              [ac_system_error1=yes], [ac_system_error1=no])
1332   ])
1333   AC_MSG_RESULT($ac_system_error1)
1334   if test x"$ac_system_error1" = x"yes"; then
1335     AC_DEFINE(HAVE_EOWNERDEAD, 1, [Define if EOWNERDEAD exists.])
1336   fi
1337
1338   AC_MSG_CHECKING([for ENOTRECOVERABLE])
1339   AC_CACHE_VAL(ac_system_error2, [
1340   AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOTRECOVERABLE; ],
1341              [ac_system_error2=yes], [ac_system_error2=no])
1342   ])
1343   AC_MSG_RESULT($ac_system_error2)
1344   if test x"$ac_system_error2" = x"yes"; then
1345     AC_DEFINE(HAVE_ENOTRECOVERABLE, 1, [Define if ENOTRECOVERABLE exists.])
1346   fi
1347
1348   AC_MSG_CHECKING([for ENOLINK])
1349   AC_CACHE_VAL(ac_system_error3, [
1350   AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOLINK; ],
1351              [ac_system_error3=yes], [ac_system_error3=no])
1352   ])
1353   AC_MSG_RESULT($ac_system_error3)
1354   if test x"$ac_system_error3" = x"yes"; then
1355     AC_DEFINE(HAVE_ENOLINK, 1, [Define if ENOLINK exists.])
1356   fi
1357
1358   AC_MSG_CHECKING([for EPROTO])
1359   AC_CACHE_VAL(ac_system_error_4, [
1360   AC_TRY_COMPILE([#include <errno.h>], [ int i = EPROTO; ],
1361              [ac_system_error_4=yes], [ac_system_error_4=no])
1362   ])
1363   AC_MSG_RESULT($ac_system_error_4)
1364   if test x"$ac_system_error_4" = x"yes"; then
1365     AC_DEFINE(HAVE_EPROTO, 1, [Define if EPROTO exists.])
1366   fi
1367
1368   AC_MSG_CHECKING([for ENODATA])
1369   AC_CACHE_VAL(ac_system_error_5, [
1370   AC_TRY_COMPILE([#include <errno.h>], [ int i = ENODATA; ],
1371              [ac_system_error_5=yes], [ac_system_error_5=no])
1372   ])
1373   AC_MSG_RESULT($ac_system_error_5)
1374   if test x"$ac_system_error_5" = x"yes"; then
1375     AC_DEFINE(HAVE_ENODATA, 1, [Define if ENODATA exists.])
1376   fi
1377
1378   AC_MSG_CHECKING([for ENOSR])
1379   AC_CACHE_VAL(ac_system_error_6, [
1380   AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOSR; ],
1381              [ac_system_error_6=yes], [ac_system_error_6=no])
1382   ])
1383   AC_MSG_RESULT($ac_system_error_6)
1384   if test x"$ac_system_error_6" = x"yes"; then
1385     AC_DEFINE(HAVE_ENOSR, 1, [Define if ENOSR exists.])
1386   fi
1387
1388   AC_MSG_CHECKING([for ENOSTR])
1389   AC_CACHE_VAL(ac_system_error_7, [
1390   AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOSTR; ],
1391              [ac_system_error_7=yes], [ac_system_error_7=no])
1392   ])
1393   AC_MSG_RESULT($ac_system_error_7)
1394   if test x"$ac_system_error_7" = x"yes"; then
1395     AC_DEFINE(HAVE_ENOSTR, 1, [Define if ENOSTR exists.])
1396   fi
1397
1398   AC_MSG_CHECKING([for ETIME])
1399   AC_CACHE_VAL(ac_system_error_8, [
1400   AC_TRY_COMPILE([#include <errno.h>], [ int i = ETIME; ],
1401              [ac_system_error_8=yes], [ac_system_error_8=no])
1402   ])
1403   AC_MSG_RESULT($ac_system_error_8)
1404   if test x"$ac_system_error_8" = x"yes"; then
1405     AC_DEFINE(HAVE_ETIME, 1, [Define if ETIME exists.])
1406   fi
1407
1408   AC_MSG_CHECKING([for sys_nerr])
1409   AC_CACHE_VAL(ac_system_error9, [
1410   AC_TRY_COMPILE([#include <errno.h> ], [ int i = sys_nerr; ],
1411              [ac_system_error9=yes], [ac_system_error9=no])
1412   ])
1413   AC_MSG_RESULT($ac_system_error9)
1414   if test x"$ac_system_error9" = x"yes"; then
1415     AC_DEFINE(HAVE_SYS_NERR, 1, [Define if sys_nerr exists.])
1416   fi
1417
1418   AC_MSG_CHECKING([for EBADMSG])
1419   AC_CACHE_VAL(ac_system_error_10, [
1420   AC_TRY_COMPILE([#include <errno.h>], [ int i = EBADMSG; ],
1421              [ac_system_error_10=yes], [ac_system_error_10=no])
1422   ])
1423   AC_MSG_RESULT($ac_system_error_10)
1424   if test x"$ac_system_error_10" = x"yes"; then
1425     AC_DEFINE(HAVE_EBADMSG, 1, [Define if EBADMSG exists.])
1426   fi
1427
1428   AC_MSG_CHECKING([for ECANCELED])
1429   AC_CACHE_VAL(ac_system_error_11, [
1430   AC_TRY_COMPILE([#include <errno.h>], [ int i = ECANCELED; ],
1431              [ac_system_error_11=yes], [ac_system_error_11=no])
1432   ])
1433   AC_MSG_RESULT($ac_system_error_11)
1434   if test x"$ac_system_error_11" = x"yes"; then
1435     AC_DEFINE(HAVE_ECANCELED, 1, [Define if ECANCELED exists.])
1436   fi
1437
1438   AC_MSG_CHECKING([for EOVERFLOW])
1439   AC_CACHE_VAL(ac_system_error_12, [
1440   AC_TRY_COMPILE([#include <errno.h>], [ int i = EOVERFLOW; ],
1441              [ac_system_error_12=yes], [ac_system_error_12=no])
1442   ])
1443   AC_MSG_RESULT($ac_system_error_12)
1444   if test x"$ac_system_error_12" = x"yes"; then
1445     AC_DEFINE(HAVE_EOVERFLOW, 1, [Define if EOVERFLOW exists.])
1446   fi
1447
1448   AC_MSG_CHECKING([for ENOTSUP])
1449   AC_CACHE_VAL(ac_system_error_13, [
1450   AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOTSUP; ],
1451              [ac_system_error_13=yes], [ac_system_error_13=no])
1452   ])
1453   AC_MSG_RESULT($ac_system_error_13)
1454   if test x"$ac_system_error_13" = x"yes"; then
1455     AC_DEFINE(HAVE_ENOTSUP, 1, [Define if ENOTSUP exists.])
1456   fi
1457
1458   AC_MSG_CHECKING([for EIDRM])
1459   AC_CACHE_VAL(ac_system_error_14, [
1460   AC_TRY_COMPILE([#include <errno.h>], [ int i = EIDRM; ],
1461              [ac_system_error_14=yes], [ac_system_error_14=no])
1462   ])
1463   AC_MSG_RESULT($ac_system_error_14)
1464   if test x"$ac_system_error_14" = x"yes"; then
1465     AC_DEFINE(HAVE_EIDRM, 1, [Define if EIDRM exists.])
1466   fi
1467
1468   AC_MSG_CHECKING([for ETXTBSY])
1469   AC_CACHE_VAL(ac_system_error_15, [
1470   AC_TRY_COMPILE([#include <errno.h>], [ int i = ETXTBSY; ],
1471              [ac_system_error_15=yes], [ac_system_error_15=no])
1472   ])
1473   AC_MSG_RESULT($ac_system_error_15)
1474   if test x"$ac_system_error_15" = x"yes"; then
1475     AC_DEFINE(HAVE_ETXTBSY, 1, [Define if ETXTBSY exists.])
1476   fi
1477 ])
1478
1479 dnl
1480 dnl Check for what type of C headers to use.
1481 dnl
1482 dnl --enable-cheaders= [does stuff].
1483 dnl --disable-cheaders [does not do anything, really].
1484 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1485 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1486 dnl
1487 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1488   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1489     [construct "C" headers for g++], [permit c|c_std|c_global])
1490   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1491
1492   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1493
1494   # Allow overrides to configure.host here.
1495   if test $enable_cheaders = c_global; then
1496      c_compatibility=yes
1497   fi
1498
1499   if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1500      c_extra=yes
1501   fi
1502
1503   AC_SUBST(C_INCLUDE_DIR)
1504   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1505   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1506   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1507   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1508   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1509 ])
1510
1511
1512 dnl
1513 dnl Check for which locale library to use.  The choice is mapped to
1514 dnl a subdirectory of config/locale.
1515 dnl
1516 dnl Default is generic.
1517 dnl
1518 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1519   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1520     [use MODEL for target locale package],
1521     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1522
1523   # Deal with gettext issues.  Default to not using it (=no) until we detect
1524   # support for it later.  Let the user turn it off via --e/d, but let that
1525   # default to on for easier handling.
1526   USE_NLS=no
1527   AC_ARG_ENABLE(nls,
1528     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1529     [],
1530     [enable_nls=yes])
1531
1532   # Either a known packaage, or "auto"
1533   if test $enable_clocale = no || test $enable_clocale = yes; then
1534      enable_clocale=auto
1535   fi
1536   enable_clocale_flag=$enable_clocale
1537
1538   # Probe for locale model to use if none specified.
1539   # Default to "generic".
1540   if test $enable_clocale_flag = auto; then
1541     case ${target_os} in
1542       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1543         enable_clocale_flag=gnu
1544         ;;
1545       darwin* | freebsd*)
1546         enable_clocale_flag=darwin
1547         ;;
1548       *)
1549         enable_clocale_flag=generic
1550         ;;
1551     esac
1552   fi
1553
1554   # Sanity check model, and test for special functionality.
1555   if test $enable_clocale_flag = gnu; then
1556     AC_EGREP_CPP([_GLIBCXX_ok], [
1557     #include <features.h>
1558     #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1559       _GLIBCXX_ok
1560     #endif
1561     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1562
1563     if test $enable_clocale = auto; then
1564       # Test for bugs early in glibc-2.2.x series
1565       AC_TRY_RUN([
1566       #define _GNU_SOURCE 1
1567       #include <locale.h>
1568       #include <string.h>
1569       #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1570       extern __typeof(newlocale) __newlocale;
1571       extern __typeof(duplocale) __duplocale;
1572       extern __typeof(strcoll_l) __strcoll_l;
1573       #endif
1574       int main()
1575       {
1576         const char __one[] = "Äuglein Augmen";
1577         const char __two[] = "Äuglein";
1578         int i;
1579         int j;
1580         __locale_t        loc;
1581         __locale_t        loc_dup;
1582         loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1583         loc_dup = __duplocale(loc);
1584         i = __strcoll_l(__one, __two, loc);
1585         j = __strcoll_l(__one, __two, loc_dup);
1586         return 0;
1587       }
1588       ],
1589       [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1590       [enable_clocale_flag=generic])
1591     fi
1592
1593     # Set it to scream when it hurts.
1594     ac_save_CFLAGS="$CFLAGS"
1595     CFLAGS="-Wimplicit-function-declaration -Werror"
1596
1597     # Use strxfrm_l if available.
1598     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1599                     #include <string.h>
1600                     #include <locale.h>],
1601                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1602                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1603                     [Define if strxfrm_l is available in <string.h>.]),)
1604
1605     # Use strerror_l if available.
1606     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1607                     #include <string.h>
1608                     #include <locale.h>],
1609                     [__locale_t loc; strerror_l(5, loc);],
1610                     AC_DEFINE(HAVE_STRERROR_L, 1,
1611                     [Define if strerror_l is available in <string.h>.]),)
1612
1613     CFLAGS="$ac_save_CFLAGS"
1614   fi
1615
1616   # Perhaps use strerror_r if available, and strerror_l isn't.
1617   ac_save_CFLAGS="$CFLAGS"
1618   CFLAGS="-Wimplicit-function-declaration -Werror"
1619   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1620                   #include <string.h>
1621                   #include <locale.h>],
1622                   [char s[128]; strerror_r(5, s, 128);],
1623                   AC_DEFINE(HAVE_STRERROR_R, 1,
1624                   [Define if strerror_r is available in <string.h>.]),)
1625   CFLAGS="$ac_save_CFLAGS"
1626
1627   # Set configure bits for specified locale package
1628   AC_MSG_CHECKING([for C locale to use])
1629   case ${enable_clocale_flag} in
1630     generic)
1631       AC_MSG_RESULT(generic)
1632
1633       CLOCALE_H=config/locale/generic/c_locale.h
1634       CLOCALE_CC=config/locale/generic/c_locale.cc
1635       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1636       CCOLLATE_CC=config/locale/generic/collate_members.cc
1637       CCTYPE_CC=config/locale/generic/ctype_members.cc
1638       CMESSAGES_H=config/locale/generic/messages_members.h
1639       CMESSAGES_CC=config/locale/generic/messages_members.cc
1640       CMONEY_CC=config/locale/generic/monetary_members.cc
1641       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1642       CTIME_H=config/locale/generic/time_members.h
1643       CTIME_CC=config/locale/generic/time_members.cc
1644       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1645       ;;
1646     darwin)
1647       AC_MSG_RESULT(darwin or freebsd)
1648
1649       CLOCALE_H=config/locale/generic/c_locale.h
1650       CLOCALE_CC=config/locale/generic/c_locale.cc
1651       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1652       CCOLLATE_CC=config/locale/generic/collate_members.cc
1653       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1654       CMESSAGES_H=config/locale/generic/messages_members.h
1655       CMESSAGES_CC=config/locale/generic/messages_members.cc
1656       CMONEY_CC=config/locale/generic/monetary_members.cc
1657       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1658       CTIME_H=config/locale/generic/time_members.h
1659       CTIME_CC=config/locale/generic/time_members.cc
1660       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1661       ;;
1662
1663     gnu)
1664       AC_MSG_RESULT(gnu)
1665
1666       # Declare intention to use gettext, and add support for specific
1667       # languages.
1668       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1669       ALL_LINGUAS="de fr"
1670
1671       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1672       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1673       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1674         USE_NLS=yes
1675       fi
1676       # Export the build objects.
1677       for ling in $ALL_LINGUAS; do \
1678         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1679         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1680       done
1681       AC_SUBST(glibcxx_MOFILES)
1682       AC_SUBST(glibcxx_POFILES)
1683
1684       CLOCALE_H=config/locale/gnu/c_locale.h
1685       CLOCALE_CC=config/locale/gnu/c_locale.cc
1686       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1687       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1688       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1689       CMESSAGES_H=config/locale/gnu/messages_members.h
1690       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1691       CMONEY_CC=config/locale/gnu/monetary_members.cc
1692       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1693       CTIME_H=config/locale/gnu/time_members.h
1694       CTIME_CC=config/locale/gnu/time_members.cc
1695       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1696       ;;
1697     ieee_1003.1-2001)
1698       AC_MSG_RESULT(IEEE 1003.1)
1699
1700       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1701       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1702       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1703       CCOLLATE_CC=config/locale/generic/collate_members.cc
1704       CCTYPE_CC=config/locale/generic/ctype_members.cc
1705       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1706       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1707       CMONEY_CC=config/locale/generic/monetary_members.cc
1708       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1709       CTIME_H=config/locale/generic/time_members.h
1710       CTIME_CC=config/locale/generic/time_members.cc
1711       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1712       ;;
1713   esac
1714
1715   # This is where the testsuite looks for locale catalogs, using the
1716   # -DLOCALEDIR define during testsuite compilation.
1717   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1718   AC_SUBST(glibcxx_localedir)
1719
1720   # A standalone libintl (e.g., GNU libintl) may be in use.
1721   if test $USE_NLS = yes; then
1722     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1723     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1724   fi
1725   if test $USE_NLS = yes; then
1726     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1727               [Define if NLS translations are to be used.])
1728   fi
1729
1730   AC_SUBST(USE_NLS)
1731   AC_SUBST(CLOCALE_H)
1732   AC_SUBST(CMESSAGES_H)
1733   AC_SUBST(CCODECVT_CC)
1734   AC_SUBST(CCOLLATE_CC)
1735   AC_SUBST(CCTYPE_CC)
1736   AC_SUBST(CMESSAGES_CC)
1737   AC_SUBST(CMONEY_CC)
1738   AC_SUBST(CNUMERIC_CC)
1739   AC_SUBST(CTIME_H)
1740   AC_SUBST(CTIME_CC)
1741   AC_SUBST(CLOCALE_CC)
1742   AC_SUBST(CLOCALE_INTERNAL_H)
1743 ])
1744
1745
1746 dnl
1747 dnl Check for which std::allocator base class to use.  The choice is
1748 dnl mapped from a subdirectory of include/ext.
1749 dnl
1750 dnl Default is new.
1751 dnl
1752 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1753   AC_MSG_CHECKING([for std::allocator base class])
1754   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1755     [use KIND for target std::allocator base],
1756     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1757
1758   # If they didn't use this option switch, or if they specified --enable
1759   # with no specific model, we'll have to look for one.  If they
1760   # specified --disable (???), do likewise.
1761   if test $enable_libstdcxx_allocator = no ||
1762      test $enable_libstdcxx_allocator = yes;
1763   then
1764      enable_libstdcxx_allocator=auto
1765   fi
1766
1767   # Either a known package, or "auto". Auto implies the default choice
1768   # for a particular platform.
1769   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1770
1771   # Probe for host-specific support if no specific model is specified.
1772   # Default to "new".
1773   if test $enable_libstdcxx_allocator_flag = auto; then
1774     case ${target_os} in
1775       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1776         enable_libstdcxx_allocator_flag=new
1777         ;;
1778       *)
1779         enable_libstdcxx_allocator_flag=new
1780         ;;
1781     esac
1782   fi
1783   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1784
1785
1786   # Set configure bits for specified locale package
1787   case ${enable_libstdcxx_allocator_flag} in
1788     bitmap)
1789       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1790       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1791       ;;
1792     malloc)
1793       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1794       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1795       ;;
1796     mt)
1797       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1798       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1799       ;;
1800     new)
1801       ALLOCATOR_H=config/allocator/new_allocator_base.h
1802       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1803       ;;
1804     pool)
1805       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1806       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1807       ;;
1808   esac
1809
1810   AC_SUBST(ALLOCATOR_H)
1811   AC_SUBST(ALLOCATOR_NAME)
1812 ])
1813
1814
1815 dnl
1816 dnl Check for whether the Boost-derived checks should be turned on.
1817 dnl
1818 dnl --enable-concept-checks turns them on.
1819 dnl --disable-concept-checks leaves them off.
1820 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1821 dnl       Where DEFAULT is either `yes' or `no'.
1822 dnl
1823 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1824   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1825   if test $enable_concept_checks = yes; then
1826     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1827               [Define to use concept checking code from the boost libraries.])
1828   fi
1829 ])
1830
1831 dnl
1832 dnl Check for parallel mode pre-requisites, including OpenMP support.
1833 dnl
1834 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
1835 dnl
1836 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
1837
1838   # NB: libstdc++ may be configured before libgomp: can't check for the actual
1839   # dependencies (omp.h and libgomp).
1840   enable_parallel=no;
1841   if test -f $glibcxx_builddir/../libgomp/omp.h; then
1842     enable_parallel=yes;
1843   else
1844     AC_MSG_NOTICE([$glibcxx_builddir/../libgomp/omp.h not found])
1845   fi
1846
1847   # Check to see if it's explicitly disabled.
1848 #  GLIBCXX_ENABLE(libgomp,$1,,[enable code depending on libgomp],
1849 #       [permit yes|no])
1850
1851 #  if test x$enable_libgomp = xno; then
1852 #    enable_parallel=no
1853 #  fi
1854
1855   AC_MSG_CHECKING([for parallel mode support])
1856   AC_MSG_RESULT([$enable_parallel])
1857   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
1858 ])
1859
1860
1861 dnl
1862 dnl Check for which I/O library to use:  stdio, or something specific.
1863 dnl
1864 dnl Default is stdio.
1865 dnl
1866 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1867   AC_MSG_CHECKING([for underlying I/O to use])
1868   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1869     [use target-specific I/O package], [permit stdio])
1870
1871   # Now that libio has been removed, you can have any color you want as long
1872   # as it's black.  This is one big no-op until other packages are added, but
1873   # showing the framework never hurts.
1874   case ${enable_cstdio} in
1875     stdio)
1876       CSTDIO_H=config/io/c_io_stdio.h
1877       BASIC_FILE_H=config/io/basic_file_stdio.h
1878       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1879       AC_MSG_RESULT(stdio)
1880       ;;
1881   esac
1882
1883   AC_SUBST(CSTDIO_H)
1884   AC_SUBST(BASIC_FILE_H)
1885   AC_SUBST(BASIC_FILE_CC)
1886 ])
1887
1888
1889 dnl
1890 dnl Check for "unusual" flags to pass to the compiler while building.
1891 dnl
1892 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1893 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1894 dnl --disable-cxx-flags passes nothing.
1895 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1896 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1897 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1898 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1899 dnl       If "default flags" is an empty string, the effect is the same
1900 dnl       as --disable or --enable=no.
1901 dnl
1902 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1903   AC_MSG_CHECKING([for extra compiler flags for building])
1904   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1905     [pass compiler FLAGS when building library],
1906     [case "x$enable_cxx_flags" in
1907       xno | x)   enable_cxx_flags= ;;
1908       x-*)       ;;
1909       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1910      esac])
1911
1912   # Run through flags (either default or command-line) and set anything
1913   # extra (e.g., #defines) that must accompany particular g++ options.
1914   if test -n "$enable_cxx_flags"; then
1915     for f in $enable_cxx_flags; do
1916       case "$f" in
1917         -fhonor-std)  ;;
1918         -*)  ;;
1919         *)   # and we're trying to pass /what/ exactly?
1920              AC_MSG_ERROR([compiler flags start with a -]) ;;
1921       esac
1922     done
1923   fi
1924
1925   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1926   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1927   AC_SUBST(EXTRA_CXX_FLAGS)
1928 ])
1929
1930
1931 dnl
1932 dnl Check to see if debugging libraries are to be built.
1933 dnl
1934 dnl --enable-libstdcxx-debug
1935 dnl builds a separate set of debugging libraries in addition to the
1936 dnl normal (shared, static) libstdc++ binaries.
1937 dnl
1938 dnl --disable-libstdcxx-debug
1939 dnl builds only one (non-debug) version of libstdc++.
1940 dnl
1941 dnl --enable-libstdcxx-debug-flags=FLAGS
1942 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1943 dnl
1944 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1945 dnl       Where DEFAULT is either `yes' or `no'.
1946 dnl
1947 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1948   AC_MSG_CHECKING([for additional debug build])
1949   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1950   AC_MSG_RESULT($enable_libstdcxx_debug)
1951   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1952 ])
1953
1954
1955 dnl
1956 dnl Check for explicit debug flags.
1957 dnl
1958 dnl --enable-libstdcxx-debug-flags='-O1'
1959 dnl is a general method for passing flags to be used when
1960 dnl building debug libraries with --enable-debug.
1961 dnl
1962 dnl --disable-libstdcxx-debug-flags does nothing.
1963 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1964 dnl       If "default flags" is an empty string, the effect is the same
1965 dnl       as --disable or --enable=no.
1966 dnl
1967 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1968   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1969     [pass compiler FLAGS when building debug library],
1970     [case "x$enable_libstdcxx_debug_flags" in
1971       xno | x)    enable_libstdcxx_debug_flags= ;;
1972       x-*)        ;;
1973       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1974      esac])
1975
1976   # Option parsed, now set things appropriately
1977   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1978   AC_SUBST(DEBUG_FLAGS)
1979
1980   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1981 ])
1982
1983
1984 dnl
1985 dnl Check if the user only wants a freestanding library implementation.
1986 dnl
1987 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1988 dnl installing only the headers required by [17.4.1.3] and the language
1989 dnl support library.  More than that will be built (to keep the Makefiles
1990 dnl conveniently clean), but not installed.
1991 dnl
1992 dnl Sets:
1993 dnl  is_hosted  (yes/no)
1994 dnl
1995 dnl Defines:
1996 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1997 dnl
1998 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1999   AC_ARG_ENABLE([hosted-libstdcxx],
2000     AC_HELP_STRING([--disable-hosted-libstdcxx],
2001                    [only build freestanding C++ runtime support]),,
2002     [case "$host" in
2003         arm*-*-symbianelf*)
2004             enable_hosted_libstdcxx=no
2005             ;;
2006         *)
2007             enable_hosted_libstdcxx=yes
2008             ;;
2009      esac])
2010   if test "$enable_hosted_libstdcxx" = no; then
2011     AC_MSG_NOTICE([Only freestanding libraries will be built])
2012     is_hosted=no
2013     hosted_define=0
2014     enable_abi_check=no
2015     enable_libstdcxx_pch=no
2016   else
2017     is_hosted=yes
2018     hosted_define=1
2019   fi
2020   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2021   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2022     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2023 ])
2024
2025
2026 dnl
2027 dnl Check for template specializations for the 'long long' type.
2028 dnl The result determines only whether 'long long' I/O is enabled; things
2029 dnl like numeric_limits<> specializations are always available.
2030 dnl
2031 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2032 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2033 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2034 dnl       Where DEFAULT is either `yes' or `no'.
2035 dnl
2036 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2037   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2038   if test $enable_long_long = yes; then
2039     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2040               [Define if code specialized for long long should be used.])
2041   fi
2042   AC_MSG_CHECKING([for enabled long long specializations])
2043   AC_MSG_RESULT([$enable_long_long])
2044 ])
2045
2046
2047 dnl
2048 dnl Check for template specializations for the 'wchar_t' type.
2049 dnl
2050 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2051 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2052 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2053 dnl       Where DEFAULT is either `yes' or `no'.
2054 dnl
2055 dnl Necessary support must also be present.
2056 dnl
2057 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2058   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2059
2060   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2061   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2062   AC_MSG_CHECKING([for mbstate_t])
2063   AC_TRY_COMPILE([#include <wchar.h>],
2064   [mbstate_t teststate;],
2065   have_mbstate_t=yes, have_mbstate_t=no)
2066   AC_MSG_RESULT($have_mbstate_t)
2067   if test x"$have_mbstate_t" = xyes; then
2068     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2069   fi
2070
2071   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2072   # ac_has_wchar_h.
2073   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2074
2075   if test x"$enable_wchar_t" = x"yes"; then
2076
2077     AC_LANG_SAVE
2078     AC_LANG_CPLUSPLUS
2079
2080     if test x"$ac_has_wchar_h" = xyes &&
2081        test x"$ac_has_wctype_h" = xyes; then
2082       AC_TRY_COMPILE([#include <wchar.h>
2083                       #include <stddef.h>
2084                       wint_t i;
2085                       long l = WEOF;
2086                       long j = WCHAR_MIN;
2087                       long k = WCHAR_MAX;
2088                       namespace test
2089                       {
2090                         using ::btowc;
2091                         using ::fgetwc;
2092                         using ::fgetws;
2093                         using ::fputwc;
2094                         using ::fputws;
2095                         using ::fwide;
2096                         using ::fwprintf;
2097                         using ::fwscanf;
2098                         using ::getwc;
2099                         using ::getwchar;
2100                         using ::mbrlen;
2101                         using ::mbrtowc;
2102                         using ::mbsinit;
2103                         using ::mbsrtowcs;
2104                         using ::putwc;
2105                         using ::putwchar;
2106                         using ::swprintf;
2107                         using ::swscanf;
2108                         using ::ungetwc;
2109                         using ::vfwprintf;
2110                         using ::vswprintf;
2111                         using ::vwprintf;
2112                         using ::wcrtomb;
2113                         using ::wcscat;
2114                         using ::wcschr;
2115                         using ::wcscmp;
2116                         using ::wcscoll;
2117                         using ::wcscpy;
2118                         using ::wcscspn;
2119                         using ::wcsftime;
2120                         using ::wcslen;
2121                         using ::wcsncat;
2122                         using ::wcsncmp;
2123                         using ::wcsncpy;
2124                         using ::wcspbrk;
2125                         using ::wcsrchr;
2126                         using ::wcsrtombs;
2127                         using ::wcsspn;
2128                         using ::wcsstr;
2129                         using ::wcstod;
2130                         using ::wcstok;
2131                         using ::wcstol;
2132                         using ::wcstoul;
2133                         using ::wcsxfrm;
2134                         using ::wctob;
2135                         using ::wmemchr;
2136                         using ::wmemcmp;
2137                         using ::wmemcpy;
2138                         using ::wmemmove;
2139                         using ::wmemset;
2140                         using ::wprintf;
2141                         using ::wscanf;
2142                       }
2143                      ],[],[], [enable_wchar_t=no])
2144     else
2145       enable_wchar_t=no
2146     fi
2147
2148     AC_LANG_RESTORE
2149   fi
2150
2151   if test x"$enable_wchar_t" = x"yes"; then
2152     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2153               [Define if code specialized for wchar_t should be used.])
2154   fi
2155
2156   AC_MSG_CHECKING([for enabled wchar_t specializations])
2157   AC_MSG_RESULT([$enable_wchar_t])
2158 ])
2159
2160
2161 dnl
2162 dnl Check to see if building and using a C++ precompiled header can be done.
2163 dnl
2164 dnl --enable-libstdcxx-pch=yes
2165 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2166 dnl may work, after some light-hearted attempts to puzzle out compiler
2167 dnl support, flip bits on in include/Makefile.am
2168 dnl
2169 dnl --disable-libstdcxx-pch
2170 dnl turns off attempts to use or build stdc++.h.gch.
2171 dnl
2172 dnl Substs:
2173 dnl  glibcxx_PCHFLAGS
2174 dnl
2175 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2176   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2177   if test $enable_libstdcxx_pch = yes; then
2178     AC_CACHE_CHECK([for compiler with PCH support],
2179       [glibcxx_cv_prog_CXX_pch],
2180       [ac_save_CXXFLAGS="$CXXFLAGS"
2181        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2182        AC_LANG_SAVE
2183        AC_LANG_CPLUSPLUS
2184        echo '#include <math.h>' > conftest.h
2185        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2186                           -o conftest.h.gch 1>&5 2>&1 &&
2187                 echo '#error "pch failed"' > conftest.h &&
2188           echo '#include "conftest.h"' > conftest.cc &&
2189                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2190        then
2191          glibcxx_cv_prog_CXX_pch=yes
2192        else
2193          glibcxx_cv_prog_CXX_pch=no
2194        fi
2195        rm -f conftest*
2196        CXXFLAGS=$ac_save_CXXFLAGS
2197        AC_LANG_RESTORE
2198       ])
2199     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2200   fi
2201
2202   AC_MSG_CHECKING([for enabled PCH])
2203   AC_MSG_RESULT([$enable_libstdcxx_pch])
2204
2205   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2206   if test $enable_libstdcxx_pch = yes; then
2207     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2208   else
2209     glibcxx_PCHFLAGS=""
2210   fi
2211   AC_SUBST(glibcxx_PCHFLAGS)
2212 ])
2213
2214
2215 dnl
2216 dnl Check for atomic builtins.
2217 dnl See:
2218 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2219 dnl
2220 dnl This checks to see if the host supports the compiler-generated
2221 dnl builtins for atomic operations. Note, this is intended to be an
2222 dnl all-or-nothing switch, so all the atomic operations that are used
2223 dnl should be checked.
2224 dnl
2225 dnl Note:
2226 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
2227 dnl see: CHECK_SYNC_FETCH_AND_ADD
2228 dnl
2229 dnl Defines:
2230 dnl  _GLIBCXX_ATOMIC_BUILTINS if the compiler on this target supports atomics.
2231 dnl
2232 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2233   AC_MSG_CHECKING([for atomic builtins])
2234   AC_LANG_SAVE
2235   AC_LANG_CPLUSPLUS
2236
2237   # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2238     cat > conftest.$ac_ext << EOF
2239 [#]line __oline__ "configure"
2240 int main()
2241 {
2242   // NB: _Atomic_word not necessarily int.
2243   typedef int atomic_type;
2244   atomic_type c1;
2245   atomic_type c2;
2246   const atomic_type c3(0);
2247   if (__sync_fetch_and_add(&c1, c2) == c3)
2248     {
2249       // Do something.
2250     }
2251    return 0;
2252 }
2253 EOF
2254     old_CXXFLAGS="$CXXFLAGS"
2255     CXXFLAGS=-S
2256     if AC_TRY_EVAL(ac_compile); then
2257       if grep __sync_fetch_and_add conftest.s >/dev/null 2>&1 ; then
2258         enable_atomic_builtins=no
2259       else
2260       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2261         [Define if builtin atomic operations are supported on this host.])
2262         enable_atomic_builtins=yes
2263         atomicity_dir=cpu/generic/atomicity_builtins
2264       fi
2265     fi
2266     CXXFLAGS="$old_CXXFLAGS"
2267     rm -f conftest*
2268
2269    # Now, if still generic, set to mutex.
2270   if test $atomicity_dir = "cpu/generic" ; then
2271         atomicity_dir=cpu/generic/atomicity_mutex
2272   fi
2273  AC_LANG_RESTORE
2274  AC_MSG_RESULT($enable_atomic_builtins)
2275 ])
2276
2277
2278 dnl
2279 dnl Check for exception handling support.  If an explicit enable/disable
2280 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2281 dnl target may or may not support call frame exceptions.
2282 dnl
2283 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2284 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2285 dnl Neither one forces an attempt at detection.
2286 dnl
2287 dnl Defines:
2288 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2289 dnl
2290 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2291   AC_MSG_CHECKING([for exception model to use])
2292   AC_LANG_SAVE
2293   AC_LANG_CPLUSPLUS
2294   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2295     [force use of builtin_setjmp for exceptions],
2296     [permit yes|no|auto])
2297
2298   if test $enable_sjlj_exceptions = auto; then
2299     # Botheration.  Now we've got to detect the exception model.  Link tests
2300     # against libgcc.a are problematic since we've not been given proper -L
2301     # bits for single-tree newlib and libgloss.
2302     #
2303     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2304     cat > conftest.$ac_ext << EOF
2305 [#]line __oline__ "configure"
2306 struct S { ~S(); };
2307 void bar();
2308 void foo()
2309 {
2310   S s;
2311   bar();
2312 }
2313 EOF
2314     old_CXXFLAGS="$CXXFLAGS"
2315     CXXFLAGS=-S
2316     if AC_TRY_EVAL(ac_compile); then
2317       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2318         enable_sjlj_exceptions=yes
2319       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2320         enable_sjlj_exceptions=no
2321       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2322         enable_sjlj_exceptions=no
2323       fi
2324     fi
2325     CXXFLAGS="$old_CXXFLAGS"
2326     rm -f conftest*
2327   fi
2328
2329   # This is a tad weird, for hysterical raisins.  We have to map
2330   # enable/disable to two different models.
2331   case $enable_sjlj_exceptions in
2332     yes)
2333       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2334         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2335       ac_exception_model_name=sjlj
2336       ;;
2337     no)
2338       ac_exception_model_name="call frame"
2339       ;;
2340     *)
2341       AC_MSG_ERROR([unable to detect exception model])
2342       ;;
2343   esac
2344  AC_LANG_RESTORE
2345  AC_MSG_RESULT($ac_exception_model_name)
2346 ])
2347
2348
2349 dnl
2350 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2351 dnl
2352 dnl --enable-visibility enables attempt to use visibility attributes.
2353 dnl --disable-visibility turns off all use of visibility attributes.
2354 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2355 dnl       Where DEFAULT is 'yes'.
2356 dnl
2357 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2358 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2359
2360 if test x$enable_visibility = xyes ; then
2361   dnl all hail libgfortran
2362   dnl Check whether the target supports hidden visibility.
2363   AC_CACHE_CHECK([whether the target supports hidden visibility],
2364                  have_attribute_visibility, [
2365   save_CFLAGS="$CFLAGS"
2366   CFLAGS="$CFLAGS -Werror"
2367   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2368                  [], have_attribute_visibility=yes,
2369                  have_attribute_visibility=no)
2370   CFLAGS="$save_CFLAGS"])
2371   if test $have_attribute_visibility = no; then
2372     enable_visibility=no
2373   fi
2374 fi
2375
2376 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2377 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2378 ])
2379
2380
2381 dnl
2382 dnl Add version tags to symbols in shared library (or not), additionally
2383 dnl marking other symbols as private/local (or not).
2384 dnl
2385 dnl --enable-symvers=style adds a version script to the linker call when
2386 dnl       creating the shared library.  The choice of version script is
2387 dnl       controlled by 'style'.
2388 dnl --disable-symvers does not.
2389 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2390 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2391 dnl       choose a default style based on linker characteristics.  Passing
2392 dnl       'no' disables versioning.
2393 dnl
2394 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2395
2396 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2397   [enables symbol versioning of the shared library],
2398   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2399
2400 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2401 # don't know enough about $LD to do tricks...
2402 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2403
2404 # Turn a 'yes' into a suitable default.
2405 if test x$enable_symvers = xyes ; then
2406   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2407     enable_symvers=no
2408   else
2409     if test $with_gnu_ld = yes ; then
2410       enable_symvers=gnu
2411     else
2412       case ${target_os} in
2413         darwin*)
2414           enable_symvers=darwin ;;
2415         *)
2416           enable_symvers=no ;;
2417       esac
2418     fi
2419   fi
2420 fi
2421
2422 # Check to see if 'darwin' or 'darwin-export' can win.
2423 if test x$enable_symvers = xdarwin-export ; then
2424     enable_symvers=darwin
2425 fi
2426
2427 # Check to see if 'gnu' can win.
2428 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2429   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2430   AC_MSG_CHECKING([for shared libgcc])
2431   ac_save_CFLAGS="$CFLAGS"
2432   CFLAGS=' -lgcc_s'
2433   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2434   CFLAGS="$ac_save_CFLAGS"
2435   if test $glibcxx_shared_libgcc = no; then
2436     cat > conftest.c <<EOF
2437 int main (void) { return 0; }
2438 EOF
2439 changequote(,)dnl
2440     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2441                              -shared -shared-libgcc -o conftest.so \
2442                              conftest.c -v 2>&1 >/dev/null \
2443                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2444 changequote([,])dnl
2445     rm -f conftest.c conftest.so
2446     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2447       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2448       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2449       CFLAGS="$ac_save_CFLAGS"
2450     fi
2451   fi
2452   AC_MSG_RESULT($glibcxx_shared_libgcc)
2453
2454   # For GNU ld, we need at least this version.  The format is described in
2455   # GLIBCXX_CHECK_LINKER_FEATURES above.
2456   glibcxx_min_gnu_ld_version=21400
2457
2458   # If no shared libgcc, can't win.
2459   if test $glibcxx_shared_libgcc != yes; then
2460       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2461       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2462       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2463       enable_symvers=no
2464   elif test $with_gnu_ld != yes ; then
2465     # just fail for now
2466     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2467     AC_MSG_WARN([=== you are not using the GNU linker.])
2468     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2469     enable_symvers=no
2470   elif test $glibcxx_ld_is_gold = yes ; then
2471     : All versions of gold support symbol versioning.
2472   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2473     # The right tools, the right setup, but too old.  Fallbacks?
2474     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2475     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2476     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2477     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2478     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2479     enable_symvers=no
2480   fi
2481 fi
2482
2483 # Everything parsed; figure out what file to use.
2484 case $enable_symvers in
2485   no)
2486     SYMVER_FILE=config/abi/pre/none.ver
2487     ;;
2488   gnu)
2489     SYMVER_FILE=config/abi/pre/gnu.ver
2490     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2491               [Define to use GNU versioning in the shared library.])
2492     ;;
2493   gnu-versioned-namespace)
2494     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2495     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2496               [Define to use GNU namespace versioning in the shared library.])
2497     ;;
2498   darwin)
2499     SYMVER_FILE=config/abi/pre/gnu.ver
2500     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2501               [Define to use darwin versioning in the shared library.])
2502     ;;
2503 esac
2504
2505 if test x$enable_symvers != xno ; then
2506   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2507          [Define to use symbol versioning in the shared library.])
2508 fi
2509
2510 AC_SUBST(SYMVER_FILE)
2511 AC_SUBST(port_specific_symbol_files)
2512 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2513 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2514 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2515 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2516 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2517
2518 # Now, set up compatibility support, if any.
2519 # In addition, need this to deal with std::size_t mangling in
2520 # src/compatibility.cc.  In a perfect world, could use
2521 # typeid(std::size_t).name()[0] to do direct substitution.
2522 AC_MSG_CHECKING([for size_t as unsigned int])
2523 ac_save_CFLAGS="$CFLAGS"
2524 CFLAGS="-Werror"
2525 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2526                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2527 CFLAGS=$ac_save_CFLAGS
2528 if test "$glibcxx_size_t_is_i" = yes; then
2529   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2530 fi
2531 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2532
2533 AC_MSG_CHECKING([for ptrdiff_t as int])
2534 ac_save_CFLAGS="$CFLAGS"
2535 CFLAGS="-Werror"
2536 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2537                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2538 CFLAGS=$ac_save_CFLAGS
2539 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2540   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2541 fi
2542 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2543 ])
2544
2545
2546 dnl
2547 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2548 dnl We must stage the required headers so that they will be installed
2549 dnl with the library (unlike libgcc, the STL implementation is provided
2550 dnl solely within headers).  Since we must not inject random user-space
2551 dnl macro names into user-provided C++ code, we first stage into <file>-in
2552 dnl and process to <file> with an output command.  The reason for a two-
2553 dnl stage process here is to correctly handle $srcdir!=$objdir without
2554 dnl having to write complex code (the sed commands to clean the macro
2555 dnl namespace are complex and fragile enough as it is).  We must also
2556 dnl add a relative path so that -I- is supported properly.
2557 dnl
2558 dnl Substs:
2559 dnl  glibcxx_thread_h
2560 dnl
2561 dnl Defines:
2562 dnl  HAVE_GTHR_DEFAULT
2563 dnl
2564 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2565   AC_MSG_CHECKING([for thread model used by GCC])
2566   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2567   AC_MSG_RESULT([$target_thread_file])
2568
2569   if test $target_thread_file != single; then
2570     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2571               [Define if gthr-default.h exists
2572               (meaning that threading support is enabled).])
2573   fi
2574
2575   glibcxx_thread_h=gthr-$target_thread_file.h
2576
2577   dnl Check for __GTHREADS define.
2578   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2579   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2580     enable_thread=yes
2581   else
2582    enable_thread=no
2583   fi
2584
2585   AC_SUBST(glibcxx_thread_h)
2586 ])
2587
2588
2589 # Check whether LC_MESSAGES is available in <locale.h>.
2590 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2591 #
2592 # This file file be copied and used freely without restrictions.  It can
2593 # be used in projects which are not available under the GNU Public License
2594 # but which still want to provide support for the GNU gettext functionality.
2595 # Please note that the actual code is *not* freely available.
2596 AC_DEFUN([AC_LC_MESSAGES], [
2597   AC_CHECK_HEADER(locale.h, [
2598     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2599       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2600        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2601     if test $ac_cv_val_LC_MESSAGES = yes; then
2602       AC_DEFINE(HAVE_LC_MESSAGES, 1,
2603                 [Define if LC_MESSAGES is available in <locale.h>.])
2604     fi
2605   ])
2606 ])
2607
2608 # Macros from the top-level gcc directory.
2609 m4_include([../config/tls.m4])
2610