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 whether C++200x's standard layout types are supported.
1481 dnl
1482 AC_DEFUN([GLIBCXX_CHECK_STANDARD_LAYOUT], [
1483
1484   AC_MSG_CHECKING([for ISO C++200x standard layout type support])
1485   AC_CACHE_VAL(ac_standard_layout, [
1486   AC_LANG_SAVE
1487   AC_LANG_CPLUSPLUS
1488   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1489   ac_save_CXXFLAGS="$CXXFLAGS"
1490   CXXFLAGS='-std=gnu++0x'
1491
1492   AC_TRY_COMPILE([struct b
1493                   {
1494                     bool t;
1495
1496                     // Need standard layout relaxation from POD
1497                     private:
1498                     b& operator=(const b&);
1499                     b(const b&);
1500                     };
1501
1502                     int main()
1503                     {
1504                       b tst1 = { false };
1505                        return 0;
1506                     }],,
1507              [ac_standard_layout=yes], [ac_standard_layout=no])
1508
1509   CXXFLAGS="$ac_save_CXXFLAGS"
1510   AC_LANG_RESTORE
1511   ])
1512   AC_MSG_RESULT($ac_standard_layout)
1513   if test x"$ac_standard_layout" = x"yes"; then
1514     AC_DEFINE(_GLIBCXX_USE_STANDARD_LAYOUT, 1,
1515               [Define if standard layout types are supported in C++200x.])
1516   fi
1517 ])
1518
1519 dnl
1520 dnl Check for what type of C headers to use.
1521 dnl
1522 dnl --enable-cheaders= [does stuff].
1523 dnl --disable-cheaders [does not do anything, really].
1524 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1525 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1526 dnl
1527 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1528   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1529     [construct "C" headers for g++], [permit c|c_std|c_global])
1530   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1531
1532   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1533
1534   # Allow overrides to configure.host here.
1535   if test $enable_cheaders = c_global; then
1536      c_compatibility=yes
1537   fi
1538
1539   if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1540      c_extra=yes
1541   fi
1542
1543   AC_SUBST(C_INCLUDE_DIR)
1544   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1545   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1546   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1547   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1548   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1549 ])
1550
1551
1552 dnl
1553 dnl Check for which locale library to use.  The choice is mapped to
1554 dnl a subdirectory of config/locale.
1555 dnl
1556 dnl Default is generic.
1557 dnl
1558 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1559   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1560     [use MODEL for target locale package],
1561     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1562
1563   # Deal with gettext issues.  Default to not using it (=no) until we detect
1564   # support for it later.  Let the user turn it off via --e/d, but let that
1565   # default to on for easier handling.
1566   USE_NLS=no
1567   AC_ARG_ENABLE(nls,
1568     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1569     [],
1570     [enable_nls=yes])
1571
1572   # Either a known packaage, or "auto"
1573   if test $enable_clocale = no || test $enable_clocale = yes; then
1574      enable_clocale=auto
1575   fi
1576   enable_clocale_flag=$enable_clocale
1577
1578   # Probe for locale model to use if none specified.
1579   # Default to "generic".
1580   if test $enable_clocale_flag = auto; then
1581     case ${target_os} in
1582       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1583         enable_clocale_flag=gnu
1584         ;;
1585       darwin* | freebsd*)
1586         enable_clocale_flag=darwin
1587         ;;
1588       *)
1589         enable_clocale_flag=generic
1590         ;;
1591     esac
1592   fi
1593
1594   # Sanity check model, and test for special functionality.
1595   if test $enable_clocale_flag = gnu; then
1596     AC_EGREP_CPP([_GLIBCXX_ok], [
1597     #include <features.h>
1598     #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1599       _GLIBCXX_ok
1600     #endif
1601     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1602
1603     if test $enable_clocale = auto; then
1604       # Test for bugs early in glibc-2.2.x series
1605       AC_TRY_RUN([
1606       #define _GNU_SOURCE 1
1607       #include <locale.h>
1608       #include <string.h>
1609       #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1610       extern __typeof(newlocale) __newlocale;
1611       extern __typeof(duplocale) __duplocale;
1612       extern __typeof(strcoll_l) __strcoll_l;
1613       #endif
1614       int main()
1615       {
1616         const char __one[] = "Äuglein Augmen";
1617         const char __two[] = "Äuglein";
1618         int i;
1619         int j;
1620         __locale_t        loc;
1621         __locale_t        loc_dup;
1622         loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1623         loc_dup = __duplocale(loc);
1624         i = __strcoll_l(__one, __two, loc);
1625         j = __strcoll_l(__one, __two, loc_dup);
1626         return 0;
1627       }
1628       ],
1629       [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1630       [enable_clocale_flag=generic])
1631     fi
1632
1633     # Set it to scream when it hurts.
1634     ac_save_CFLAGS="$CFLAGS"
1635     CFLAGS="-Wimplicit-function-declaration -Werror"
1636
1637     # Use strxfrm_l if available.
1638     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1639                     #include <string.h>
1640                     #include <locale.h>],
1641                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1642                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1643                     [Define if strxfrm_l is available in <string.h>.]),)
1644
1645     # Use strerror_l if available.
1646     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1647                     #include <string.h>
1648                     #include <locale.h>],
1649                     [__locale_t loc; strerror_l(5, loc);],
1650                     AC_DEFINE(HAVE_STRERROR_L, 1,
1651                     [Define if strerror_l is available in <string.h>.]),)
1652
1653     CFLAGS="$ac_save_CFLAGS"
1654   fi
1655
1656   # Perhaps use strerror_r if available, and strerror_l isn't.
1657   ac_save_CFLAGS="$CFLAGS"
1658   CFLAGS="-Wimplicit-function-declaration -Werror"
1659   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1660                   #include <string.h>
1661                   #include <locale.h>],
1662                   [char s[128]; strerror_r(5, s, 128);],
1663                   AC_DEFINE(HAVE_STRERROR_R, 1,
1664                   [Define if strerror_r is available in <string.h>.]),)
1665   CFLAGS="$ac_save_CFLAGS"
1666
1667   # Set configure bits for specified locale package
1668   AC_MSG_CHECKING([for C locale to use])
1669   case ${enable_clocale_flag} in
1670     generic)
1671       AC_MSG_RESULT(generic)
1672
1673       CLOCALE_H=config/locale/generic/c_locale.h
1674       CLOCALE_CC=config/locale/generic/c_locale.cc
1675       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1676       CCOLLATE_CC=config/locale/generic/collate_members.cc
1677       CCTYPE_CC=config/locale/generic/ctype_members.cc
1678       CMESSAGES_H=config/locale/generic/messages_members.h
1679       CMESSAGES_CC=config/locale/generic/messages_members.cc
1680       CMONEY_CC=config/locale/generic/monetary_members.cc
1681       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1682       CTIME_H=config/locale/generic/time_members.h
1683       CTIME_CC=config/locale/generic/time_members.cc
1684       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1685       ;;
1686     darwin)
1687       AC_MSG_RESULT(darwin or freebsd)
1688
1689       CLOCALE_H=config/locale/generic/c_locale.h
1690       CLOCALE_CC=config/locale/generic/c_locale.cc
1691       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1692       CCOLLATE_CC=config/locale/generic/collate_members.cc
1693       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1694       CMESSAGES_H=config/locale/generic/messages_members.h
1695       CMESSAGES_CC=config/locale/generic/messages_members.cc
1696       CMONEY_CC=config/locale/generic/monetary_members.cc
1697       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1698       CTIME_H=config/locale/generic/time_members.h
1699       CTIME_CC=config/locale/generic/time_members.cc
1700       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1701       ;;
1702
1703     gnu)
1704       AC_MSG_RESULT(gnu)
1705
1706       # Declare intention to use gettext, and add support for specific
1707       # languages.
1708       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1709       ALL_LINGUAS="de fr"
1710
1711       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1712       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1713       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1714         USE_NLS=yes
1715       fi
1716       # Export the build objects.
1717       for ling in $ALL_LINGUAS; do \
1718         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1719         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1720       done
1721       AC_SUBST(glibcxx_MOFILES)
1722       AC_SUBST(glibcxx_POFILES)
1723
1724       CLOCALE_H=config/locale/gnu/c_locale.h
1725       CLOCALE_CC=config/locale/gnu/c_locale.cc
1726       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1727       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1728       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1729       CMESSAGES_H=config/locale/gnu/messages_members.h
1730       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1731       CMONEY_CC=config/locale/gnu/monetary_members.cc
1732       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1733       CTIME_H=config/locale/gnu/time_members.h
1734       CTIME_CC=config/locale/gnu/time_members.cc
1735       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1736       ;;
1737     ieee_1003.1-2001)
1738       AC_MSG_RESULT(IEEE 1003.1)
1739
1740       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1741       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1742       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1743       CCOLLATE_CC=config/locale/generic/collate_members.cc
1744       CCTYPE_CC=config/locale/generic/ctype_members.cc
1745       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1746       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1747       CMONEY_CC=config/locale/generic/monetary_members.cc
1748       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1749       CTIME_H=config/locale/generic/time_members.h
1750       CTIME_CC=config/locale/generic/time_members.cc
1751       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1752       ;;
1753   esac
1754
1755   # This is where the testsuite looks for locale catalogs, using the
1756   # -DLOCALEDIR define during testsuite compilation.
1757   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1758   AC_SUBST(glibcxx_localedir)
1759
1760   # A standalone libintl (e.g., GNU libintl) may be in use.
1761   if test $USE_NLS = yes; then
1762     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1763     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1764   fi
1765   if test $USE_NLS = yes; then
1766     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1767               [Define if NLS translations are to be used.])
1768   fi
1769
1770   AC_SUBST(USE_NLS)
1771   AC_SUBST(CLOCALE_H)
1772   AC_SUBST(CMESSAGES_H)
1773   AC_SUBST(CCODECVT_CC)
1774   AC_SUBST(CCOLLATE_CC)
1775   AC_SUBST(CCTYPE_CC)
1776   AC_SUBST(CMESSAGES_CC)
1777   AC_SUBST(CMONEY_CC)
1778   AC_SUBST(CNUMERIC_CC)
1779   AC_SUBST(CTIME_H)
1780   AC_SUBST(CTIME_CC)
1781   AC_SUBST(CLOCALE_CC)
1782   AC_SUBST(CLOCALE_INTERNAL_H)
1783 ])
1784
1785
1786 dnl
1787 dnl Check for which std::allocator base class to use.  The choice is
1788 dnl mapped from a subdirectory of include/ext.
1789 dnl
1790 dnl Default is new.
1791 dnl
1792 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1793   AC_MSG_CHECKING([for std::allocator base class])
1794   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1795     [use KIND for target std::allocator base],
1796     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1797
1798   # If they didn't use this option switch, or if they specified --enable
1799   # with no specific model, we'll have to look for one.  If they
1800   # specified --disable (???), do likewise.
1801   if test $enable_libstdcxx_allocator = no ||
1802      test $enable_libstdcxx_allocator = yes;
1803   then
1804      enable_libstdcxx_allocator=auto
1805   fi
1806
1807   # Either a known package, or "auto". Auto implies the default choice
1808   # for a particular platform.
1809   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1810
1811   # Probe for host-specific support if no specific model is specified.
1812   # Default to "new".
1813   if test $enable_libstdcxx_allocator_flag = auto; then
1814     case ${target_os} in
1815       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1816         enable_libstdcxx_allocator_flag=new
1817         ;;
1818       *)
1819         enable_libstdcxx_allocator_flag=new
1820         ;;
1821     esac
1822   fi
1823   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1824
1825
1826   # Set configure bits for specified locale package
1827   case ${enable_libstdcxx_allocator_flag} in
1828     bitmap)
1829       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1830       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1831       ;;
1832     malloc)
1833       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1834       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1835       ;;
1836     mt)
1837       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1838       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1839       ;;
1840     new)
1841       ALLOCATOR_H=config/allocator/new_allocator_base.h
1842       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1843       ;;
1844     pool)
1845       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1846       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1847       ;;
1848   esac
1849
1850   AC_SUBST(ALLOCATOR_H)
1851   AC_SUBST(ALLOCATOR_NAME)
1852 ])
1853
1854
1855 dnl
1856 dnl Check for whether the Boost-derived checks should be turned on.
1857 dnl
1858 dnl --enable-concept-checks turns them on.
1859 dnl --disable-concept-checks leaves them off.
1860 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1861 dnl       Where DEFAULT is either `yes' or `no'.
1862 dnl
1863 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1864   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1865   if test $enable_concept_checks = yes; then
1866     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1867               [Define to use concept checking code from the boost libraries.])
1868   fi
1869 ])
1870
1871 dnl
1872 dnl Check for parallel mode pre-requisites, including OpenMP support.
1873 dnl
1874 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
1875 dnl
1876 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
1877
1878   # NB: libstdc++ may be configured before libgomp: can't check for the actual
1879   # dependencies (omp.h and libgomp).
1880   enable_parallel=no;
1881   if test -f $glibcxx_builddir/../libgomp/omp.h; then
1882     enable_parallel=yes;
1883   else
1884     AC_MSG_NOTICE([$glibcxx_builddir/../libgomp/omp.h not found])
1885   fi
1886
1887   # Check to see if it's explicitly disabled.
1888 #  GLIBCXX_ENABLE(libgomp,$1,,[enable code depending on libgomp],
1889 #       [permit yes|no])
1890
1891 #  if test x$enable_libgomp = xno; then
1892 #    enable_parallel=no
1893 #  fi
1894
1895   AC_MSG_CHECKING([for parallel mode support])
1896   AC_MSG_RESULT([$enable_parallel])
1897   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
1898 ])
1899
1900
1901 dnl
1902 dnl Check for which I/O library to use:  stdio, or something specific.
1903 dnl
1904 dnl Default is stdio.
1905 dnl
1906 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1907   AC_MSG_CHECKING([for underlying I/O to use])
1908   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1909     [use target-specific I/O package], [permit stdio])
1910
1911   # Now that libio has been removed, you can have any color you want as long
1912   # as it's black.  This is one big no-op until other packages are added, but
1913   # showing the framework never hurts.
1914   case ${enable_cstdio} in
1915     stdio)
1916       CSTDIO_H=config/io/c_io_stdio.h
1917       BASIC_FILE_H=config/io/basic_file_stdio.h
1918       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1919       AC_MSG_RESULT(stdio)
1920       ;;
1921   esac
1922
1923   AC_SUBST(CSTDIO_H)
1924   AC_SUBST(BASIC_FILE_H)
1925   AC_SUBST(BASIC_FILE_CC)
1926 ])
1927
1928
1929 dnl
1930 dnl Check for "unusual" flags to pass to the compiler while building.
1931 dnl
1932 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1933 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1934 dnl --disable-cxx-flags passes nothing.
1935 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1936 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1937 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1938 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1939 dnl       If "default flags" is an empty string, the effect is the same
1940 dnl       as --disable or --enable=no.
1941 dnl
1942 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1943   AC_MSG_CHECKING([for extra compiler flags for building])
1944   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1945     [pass compiler FLAGS when building library],
1946     [case "x$enable_cxx_flags" in
1947       xno | x)   enable_cxx_flags= ;;
1948       x-*)       ;;
1949       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1950      esac])
1951
1952   # Run through flags (either default or command-line) and set anything
1953   # extra (e.g., #defines) that must accompany particular g++ options.
1954   if test -n "$enable_cxx_flags"; then
1955     for f in $enable_cxx_flags; do
1956       case "$f" in
1957         -fhonor-std)  ;;
1958         -*)  ;;
1959         *)   # and we're trying to pass /what/ exactly?
1960              AC_MSG_ERROR([compiler flags start with a -]) ;;
1961       esac
1962     done
1963   fi
1964
1965   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1966   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1967   AC_SUBST(EXTRA_CXX_FLAGS)
1968 ])
1969
1970
1971 dnl
1972 dnl Check to see if debugging libraries are to be built.
1973 dnl
1974 dnl --enable-libstdcxx-debug
1975 dnl builds a separate set of debugging libraries in addition to the
1976 dnl normal (shared, static) libstdc++ binaries.
1977 dnl
1978 dnl --disable-libstdcxx-debug
1979 dnl builds only one (non-debug) version of libstdc++.
1980 dnl
1981 dnl --enable-libstdcxx-debug-flags=FLAGS
1982 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1983 dnl
1984 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1985 dnl       Where DEFAULT is either `yes' or `no'.
1986 dnl
1987 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1988   AC_MSG_CHECKING([for additional debug build])
1989   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1990   AC_MSG_RESULT($enable_libstdcxx_debug)
1991   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1992 ])
1993
1994
1995 dnl
1996 dnl Check for explicit debug flags.
1997 dnl
1998 dnl --enable-libstdcxx-debug-flags='-O1'
1999 dnl is a general method for passing flags to be used when
2000 dnl building debug libraries with --enable-debug.
2001 dnl
2002 dnl --disable-libstdcxx-debug-flags does nothing.
2003 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2004 dnl       If "default flags" is an empty string, the effect is the same
2005 dnl       as --disable or --enable=no.
2006 dnl
2007 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2008   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2009     [pass compiler FLAGS when building debug library],
2010     [case "x$enable_libstdcxx_debug_flags" in
2011       xno | x)    enable_libstdcxx_debug_flags= ;;
2012       x-*)        ;;
2013       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2014      esac])
2015
2016   # Option parsed, now set things appropriately
2017   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2018   AC_SUBST(DEBUG_FLAGS)
2019
2020   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2021 ])
2022
2023
2024 dnl
2025 dnl Check if the user only wants a freestanding library implementation.
2026 dnl
2027 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2028 dnl installing only the headers required by [17.4.1.3] and the language
2029 dnl support library.  More than that will be built (to keep the Makefiles
2030 dnl conveniently clean), but not installed.
2031 dnl
2032 dnl Sets:
2033 dnl  is_hosted  (yes/no)
2034 dnl
2035 dnl Defines:
2036 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2037 dnl
2038 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2039   AC_ARG_ENABLE([hosted-libstdcxx],
2040     AC_HELP_STRING([--disable-hosted-libstdcxx],
2041                    [only build freestanding C++ runtime support]),,
2042     [case "$host" in
2043         arm*-*-symbianelf*)
2044             enable_hosted_libstdcxx=no
2045             ;;
2046         *)
2047             enable_hosted_libstdcxx=yes
2048             ;;
2049      esac])
2050   if test "$enable_hosted_libstdcxx" = no; then
2051     AC_MSG_NOTICE([Only freestanding libraries will be built])
2052     is_hosted=no
2053     hosted_define=0
2054     enable_abi_check=no
2055     enable_libstdcxx_pch=no
2056   else
2057     is_hosted=yes
2058     hosted_define=1
2059   fi
2060   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2061   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2062     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2063 ])
2064
2065
2066 dnl
2067 dnl Check for template specializations for the 'long long' type.
2068 dnl The result determines only whether 'long long' I/O is enabled; things
2069 dnl like numeric_limits<> specializations are always available.
2070 dnl
2071 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2072 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2073 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2074 dnl       Where DEFAULT is either `yes' or `no'.
2075 dnl
2076 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2077   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2078   if test $enable_long_long = yes; then
2079     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2080               [Define if code specialized for long long should be used.])
2081   fi
2082   AC_MSG_CHECKING([for enabled long long specializations])
2083   AC_MSG_RESULT([$enable_long_long])
2084 ])
2085
2086
2087 dnl
2088 dnl Check for template specializations for the 'wchar_t' type.
2089 dnl
2090 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2091 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2092 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2093 dnl       Where DEFAULT is either `yes' or `no'.
2094 dnl
2095 dnl Necessary support must also be present.
2096 dnl
2097 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2098   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2099
2100   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2101   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2102   AC_MSG_CHECKING([for mbstate_t])
2103   AC_TRY_COMPILE([#include <wchar.h>],
2104   [mbstate_t teststate;],
2105   have_mbstate_t=yes, have_mbstate_t=no)
2106   AC_MSG_RESULT($have_mbstate_t)
2107   if test x"$have_mbstate_t" = xyes; then
2108     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2109   fi
2110
2111   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2112   # ac_has_wchar_h.
2113   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2114
2115   if test x"$enable_wchar_t" = x"yes"; then
2116
2117     AC_LANG_SAVE
2118     AC_LANG_CPLUSPLUS
2119
2120     if test x"$ac_has_wchar_h" = xyes &&
2121        test x"$ac_has_wctype_h" = xyes; then
2122       AC_TRY_COMPILE([#include <wchar.h>
2123                       #include <stddef.h>
2124                       wint_t i;
2125                       long l = WEOF;
2126                       long j = WCHAR_MIN;
2127                       long k = WCHAR_MAX;
2128                       namespace test
2129                       {
2130                         using ::btowc;
2131                         using ::fgetwc;
2132                         using ::fgetws;
2133                         using ::fputwc;
2134                         using ::fputws;
2135                         using ::fwide;
2136                         using ::fwprintf;
2137                         using ::fwscanf;
2138                         using ::getwc;
2139                         using ::getwchar;
2140                         using ::mbrlen;
2141                         using ::mbrtowc;
2142                         using ::mbsinit;
2143                         using ::mbsrtowcs;
2144                         using ::putwc;
2145                         using ::putwchar;
2146                         using ::swprintf;
2147                         using ::swscanf;
2148                         using ::ungetwc;
2149                         using ::vfwprintf;
2150                         using ::vswprintf;
2151                         using ::vwprintf;
2152                         using ::wcrtomb;
2153                         using ::wcscat;
2154                         using ::wcschr;
2155                         using ::wcscmp;
2156                         using ::wcscoll;
2157                         using ::wcscpy;
2158                         using ::wcscspn;
2159                         using ::wcsftime;
2160                         using ::wcslen;
2161                         using ::wcsncat;
2162                         using ::wcsncmp;
2163                         using ::wcsncpy;
2164                         using ::wcspbrk;
2165                         using ::wcsrchr;
2166                         using ::wcsrtombs;
2167                         using ::wcsspn;
2168                         using ::wcsstr;
2169                         using ::wcstod;
2170                         using ::wcstok;
2171                         using ::wcstol;
2172                         using ::wcstoul;
2173                         using ::wcsxfrm;
2174                         using ::wctob;
2175                         using ::wmemchr;
2176                         using ::wmemcmp;
2177                         using ::wmemcpy;
2178                         using ::wmemmove;
2179                         using ::wmemset;
2180                         using ::wprintf;
2181                         using ::wscanf;
2182                       }
2183                      ],[],[], [enable_wchar_t=no])
2184     else
2185       enable_wchar_t=no
2186     fi
2187
2188     AC_LANG_RESTORE
2189   fi
2190
2191   if test x"$enable_wchar_t" = x"yes"; then
2192     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2193               [Define if code specialized for wchar_t should be used.])
2194   fi
2195
2196   AC_MSG_CHECKING([for enabled wchar_t specializations])
2197   AC_MSG_RESULT([$enable_wchar_t])
2198 ])
2199
2200
2201 dnl
2202 dnl Check to see if building and using a C++ precompiled header can be done.
2203 dnl
2204 dnl --enable-libstdcxx-pch=yes
2205 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2206 dnl may work, after some light-hearted attempts to puzzle out compiler
2207 dnl support, flip bits on in include/Makefile.am
2208 dnl
2209 dnl --disable-libstdcxx-pch
2210 dnl turns off attempts to use or build stdc++.h.gch.
2211 dnl
2212 dnl Substs:
2213 dnl  glibcxx_PCHFLAGS
2214 dnl
2215 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2216   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2217   if test $enable_libstdcxx_pch = yes; then
2218     AC_CACHE_CHECK([for compiler with PCH support],
2219       [glibcxx_cv_prog_CXX_pch],
2220       [ac_save_CXXFLAGS="$CXXFLAGS"
2221        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2222        AC_LANG_SAVE
2223        AC_LANG_CPLUSPLUS
2224        echo '#include <math.h>' > conftest.h
2225        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2226                           -o conftest.h.gch 1>&5 2>&1 &&
2227                 echo '#error "pch failed"' > conftest.h &&
2228           echo '#include "conftest.h"' > conftest.cc &&
2229                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2230        then
2231          glibcxx_cv_prog_CXX_pch=yes
2232        else
2233          glibcxx_cv_prog_CXX_pch=no
2234        fi
2235        rm -f conftest*
2236        CXXFLAGS=$ac_save_CXXFLAGS
2237        AC_LANG_RESTORE
2238       ])
2239     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2240   fi
2241
2242   AC_MSG_CHECKING([for enabled PCH])
2243   AC_MSG_RESULT([$enable_libstdcxx_pch])
2244
2245   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2246   if test $enable_libstdcxx_pch = yes; then
2247     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2248   else
2249     glibcxx_PCHFLAGS=""
2250   fi
2251   AC_SUBST(glibcxx_PCHFLAGS)
2252 ])
2253
2254
2255 dnl
2256 dnl Check for atomic builtins.
2257 dnl See:
2258 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2259 dnl
2260 dnl This checks to see if the host supports the compiler-generated
2261 dnl builtins for atomic operations. Note, this is intended to be an
2262 dnl all-or-nothing switch, so all the atomic operations that are used
2263 dnl should be checked.
2264 dnl
2265 dnl Note:
2266 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
2267 dnl see: CHECK_SYNC_FETCH_AND_ADD
2268 dnl
2269 dnl Defines:
2270 dnl  _GLIBCXX_ATOMIC_BUILTINS if the compiler on this target supports atomics.
2271 dnl
2272 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2273   AC_MSG_CHECKING([for atomic builtins])
2274   AC_LANG_SAVE
2275   AC_LANG_CPLUSPLUS
2276
2277   # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2278     cat > conftest.$ac_ext << EOF
2279 [#]line __oline__ "configure"
2280 int main()
2281 {
2282   // NB: _Atomic_word not necessarily int.
2283   typedef int atomic_type;
2284   atomic_type c1;
2285   atomic_type c2;
2286   const atomic_type c3(0);
2287   if (__sync_fetch_and_add(&c1, c2) == c3)
2288     {
2289       // Do something.
2290     }
2291    return 0;
2292 }
2293 EOF
2294     old_CXXFLAGS="$CXXFLAGS"
2295     CXXFLAGS=-S
2296     if AC_TRY_EVAL(ac_compile); then
2297       if grep __sync_fetch_and_add conftest.s >/dev/null 2>&1 ; then
2298         enable_atomic_builtins=no
2299       else
2300       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2301         [Define if builtin atomic operations are supported on this host.])
2302         enable_atomic_builtins=yes
2303         atomicity_dir=cpu/generic/atomicity_builtins
2304       fi
2305     fi
2306     CXXFLAGS="$old_CXXFLAGS"
2307     rm -f conftest*
2308
2309    # Now, if still generic, set to mutex.
2310   if test $atomicity_dir = "cpu/generic" ; then
2311         atomicity_dir=cpu/generic/atomicity_mutex
2312   fi
2313  AC_LANG_RESTORE
2314  AC_MSG_RESULT($enable_atomic_builtins)
2315 ])
2316
2317
2318 dnl
2319 dnl Check for exception handling support.  If an explicit enable/disable
2320 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2321 dnl target may or may not support call frame exceptions.
2322 dnl
2323 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2324 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2325 dnl Neither one forces an attempt at detection.
2326 dnl
2327 dnl Defines:
2328 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2329 dnl
2330 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2331   AC_MSG_CHECKING([for exception model to use])
2332   AC_LANG_SAVE
2333   AC_LANG_CPLUSPLUS
2334   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2335     [force use of builtin_setjmp for exceptions],
2336     [permit yes|no|auto])
2337
2338   if test $enable_sjlj_exceptions = auto; then
2339     # Botheration.  Now we've got to detect the exception model.  Link tests
2340     # against libgcc.a are problematic since we've not been given proper -L
2341     # bits for single-tree newlib and libgloss.
2342     #
2343     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2344     cat > conftest.$ac_ext << EOF
2345 [#]line __oline__ "configure"
2346 struct S { ~S(); };
2347 void bar();
2348 void foo()
2349 {
2350   S s;
2351   bar();
2352 }
2353 EOF
2354     old_CXXFLAGS="$CXXFLAGS"
2355     CXXFLAGS=-S
2356     if AC_TRY_EVAL(ac_compile); then
2357       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2358         enable_sjlj_exceptions=yes
2359       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2360         enable_sjlj_exceptions=no
2361       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2362         enable_sjlj_exceptions=no
2363       fi
2364     fi
2365     CXXFLAGS="$old_CXXFLAGS"
2366     rm -f conftest*
2367   fi
2368
2369   # This is a tad weird, for hysterical raisins.  We have to map
2370   # enable/disable to two different models.
2371   case $enable_sjlj_exceptions in
2372     yes)
2373       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2374         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2375       ac_exception_model_name=sjlj
2376       ;;
2377     no)
2378       ac_exception_model_name="call frame"
2379       ;;
2380     *)
2381       AC_MSG_ERROR([unable to detect exception model])
2382       ;;
2383   esac
2384  AC_LANG_RESTORE
2385  AC_MSG_RESULT($ac_exception_model_name)
2386 ])
2387
2388
2389 dnl
2390 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2391 dnl
2392 dnl --enable-visibility enables attempt to use visibility attributes.
2393 dnl --disable-visibility turns off all use of visibility attributes.
2394 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2395 dnl       Where DEFAULT is 'yes'.
2396 dnl
2397 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2398 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2399
2400 if test x$enable_visibility = xyes ; then
2401   dnl all hail libgfortran
2402   dnl Check whether the target supports hidden visibility.
2403   AC_CACHE_CHECK([whether the target supports hidden visibility],
2404                  have_attribute_visibility, [
2405   save_CFLAGS="$CFLAGS"
2406   CFLAGS="$CFLAGS -Werror"
2407   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2408                  [], have_attribute_visibility=yes,
2409                  have_attribute_visibility=no)
2410   CFLAGS="$save_CFLAGS"])
2411   if test $have_attribute_visibility = no; then
2412     enable_visibility=no
2413   fi
2414 fi
2415
2416 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2417 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2418 ])
2419
2420
2421 dnl
2422 dnl Add version tags to symbols in shared library (or not), additionally
2423 dnl marking other symbols as private/local (or not).
2424 dnl
2425 dnl --enable-symvers=style adds a version script to the linker call when
2426 dnl       creating the shared library.  The choice of version script is
2427 dnl       controlled by 'style'.
2428 dnl --disable-symvers does not.
2429 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2430 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2431 dnl       choose a default style based on linker characteristics.  Passing
2432 dnl       'no' disables versioning.
2433 dnl
2434 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2435
2436 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2437   [enables symbol versioning of the shared library],
2438   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2439
2440 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2441 # don't know enough about $LD to do tricks...
2442 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2443
2444 # Turn a 'yes' into a suitable default.
2445 if test x$enable_symvers = xyes ; then
2446   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2447     enable_symvers=no
2448   else
2449     if test $with_gnu_ld = yes ; then
2450       enable_symvers=gnu
2451     else
2452       case ${target_os} in
2453         darwin*)
2454           enable_symvers=darwin ;;
2455         *)
2456           enable_symvers=no ;;
2457       esac
2458     fi
2459   fi
2460 fi
2461
2462 # Check to see if 'darwin' or 'darwin-export' can win.
2463 if test x$enable_symvers = xdarwin-export ; then
2464     enable_symvers=darwin
2465 fi
2466
2467 # Check to see if 'gnu' can win.
2468 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2469   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2470   AC_MSG_CHECKING([for shared libgcc])
2471   ac_save_CFLAGS="$CFLAGS"
2472   CFLAGS=' -lgcc_s'
2473   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2474   CFLAGS="$ac_save_CFLAGS"
2475   if test $glibcxx_shared_libgcc = no; then
2476     cat > conftest.c <<EOF
2477 int main (void) { return 0; }
2478 EOF
2479 changequote(,)dnl
2480     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2481                              -shared -shared-libgcc -o conftest.so \
2482                              conftest.c -v 2>&1 >/dev/null \
2483                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2484 changequote([,])dnl
2485     rm -f conftest.c conftest.so
2486     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2487       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2488       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2489       CFLAGS="$ac_save_CFLAGS"
2490     fi
2491   fi
2492   AC_MSG_RESULT($glibcxx_shared_libgcc)
2493
2494   # For GNU ld, we need at least this version.  The format is described in
2495   # GLIBCXX_CHECK_LINKER_FEATURES above.
2496   glibcxx_min_gnu_ld_version=21400
2497
2498   # If no shared libgcc, can't win.
2499   if test $glibcxx_shared_libgcc != yes; then
2500       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2501       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2502       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2503       enable_symvers=no
2504   elif test $with_gnu_ld != yes ; then
2505     # just fail for now
2506     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2507     AC_MSG_WARN([=== you are not using the GNU linker.])
2508     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2509     enable_symvers=no
2510   elif test $glibcxx_ld_is_gold = yes ; then
2511     : All versions of gold support symbol versioning.
2512   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2513     # The right tools, the right setup, but too old.  Fallbacks?
2514     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2515     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2516     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2517     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2518     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2519     enable_symvers=no
2520   fi
2521 fi
2522
2523 # Everything parsed; figure out what file to use.
2524 case $enable_symvers in
2525   no)
2526     SYMVER_FILE=config/abi/pre/none.ver
2527     ;;
2528   gnu)
2529     SYMVER_FILE=config/abi/pre/gnu.ver
2530     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2531               [Define to use GNU versioning in the shared library.])
2532     ;;
2533   gnu-versioned-namespace)
2534     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2535     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2536               [Define to use GNU namespace versioning in the shared library.])
2537     ;;
2538   darwin)
2539     SYMVER_FILE=config/abi/pre/gnu.ver
2540     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2541               [Define to use darwin versioning in the shared library.])
2542     ;;
2543 esac
2544
2545 if test x$enable_symvers != xno ; then
2546   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2547          [Define to use symbol versioning in the shared library.])
2548 fi
2549
2550 AC_SUBST(SYMVER_FILE)
2551 AC_SUBST(port_specific_symbol_files)
2552 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2553 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2554 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2555 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2556 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2557
2558 # Now, set up compatibility support, if any.
2559 # In addition, need this to deal with std::size_t mangling in
2560 # src/compatibility.cc.  In a perfect world, could use
2561 # typeid(std::size_t).name()[0] to do direct substitution.
2562 AC_MSG_CHECKING([for size_t as unsigned int])
2563 ac_save_CFLAGS="$CFLAGS"
2564 CFLAGS="-Werror"
2565 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2566                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2567 CFLAGS=$ac_save_CFLAGS
2568 if test "$glibcxx_size_t_is_i" = yes; then
2569   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2570 fi
2571 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2572
2573 AC_MSG_CHECKING([for ptrdiff_t as int])
2574 ac_save_CFLAGS="$CFLAGS"
2575 CFLAGS="-Werror"
2576 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2577                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2578 CFLAGS=$ac_save_CFLAGS
2579 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2580   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2581 fi
2582 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2583 ])
2584
2585
2586 dnl
2587 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2588 dnl We must stage the required headers so that they will be installed
2589 dnl with the library (unlike libgcc, the STL implementation is provided
2590 dnl solely within headers).  Since we must not inject random user-space
2591 dnl macro names into user-provided C++ code, we first stage into <file>-in
2592 dnl and process to <file> with an output command.  The reason for a two-
2593 dnl stage process here is to correctly handle $srcdir!=$objdir without
2594 dnl having to write complex code (the sed commands to clean the macro
2595 dnl namespace are complex and fragile enough as it is).  We must also
2596 dnl add a relative path so that -I- is supported properly.
2597 dnl
2598 dnl Substs:
2599 dnl  glibcxx_thread_h
2600 dnl
2601 dnl Defines:
2602 dnl  HAVE_GTHR_DEFAULT
2603 dnl
2604 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2605   AC_MSG_CHECKING([for thread model used by GCC])
2606   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2607   AC_MSG_RESULT([$target_thread_file])
2608
2609   if test $target_thread_file != single; then
2610     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2611               [Define if gthr-default.h exists
2612               (meaning that threading support is enabled).])
2613   fi
2614
2615   glibcxx_thread_h=gthr-$target_thread_file.h
2616
2617   dnl Check for __GTHREADS define.
2618   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2619   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2620     enable_thread=yes
2621   else
2622    enable_thread=no
2623   fi
2624
2625   AC_SUBST(glibcxx_thread_h)
2626 ])
2627
2628
2629 # Check whether LC_MESSAGES is available in <locale.h>.
2630 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2631 #
2632 # This file file be copied and used freely without restrictions.  It can
2633 # be used in projects which are not available under the GNU Public License
2634 # but which still want to provide support for the GNU gettext functionality.
2635 # Please note that the actual code is *not* freely available.
2636 AC_DEFUN([AC_LC_MESSAGES], [
2637   AC_CHECK_HEADER(locale.h, [
2638     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2639       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2640        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2641     if test $ac_cv_val_LC_MESSAGES = yes; then
2642       AC_DEFINE(HAVE_LC_MESSAGES, 1,
2643                 [Define if LC_MESSAGES is available in <locale.h>.])
2644     fi
2645   ])
2646 ])
2647
2648 # Macros from the top-level gcc directory.
2649 m4_include([../config/tls.m4])
2650