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 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   # Find platform-specific directories containing configuration info.
 129   # Also possibly modify flags used elsewhere, as needed by the platform.
 130   GLIBCXX_CHECK_HOST
 131 ])
 132
 133
 134 dnl
 135 dnl Tests for newer compiler features, or features that are present in newer
 136 dnl compiler versions but not older compiler versions still in use, should
 137 dnl be placed here.
 138 dnl
 139 dnl Defines:
 140 dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
 141 dnl   new inlining code or the new system_header pragma will die on -Werror.
 142 dnl   Leave it out by default and use maint-mode to use it.
 143 dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 144 dnl   compiler supports it and the user has not requested debug mode.
 145 dnl
 146 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
 147   # All these tests are for C++; save the language and the compiler flags.
 148   # The CXXFLAGS thing is suspicious, but based on similar bits previously
 149   # found in GLIBCXX_CONFIGURE.
 150   AC_LANG_SAVE
 151   AC_LANG_CPLUSPLUS
 152   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 153   ac_save_CXXFLAGS="$CXXFLAGS"
 154
 155   # Check for maintainer-mode bits.
 156   if test x"$USE_MAINTAINER_MODE" = xno; then
 157     WERROR=''
 158   else
 159     WERROR='-Werror'
 160   fi
 161
 162   # Check for -ffunction-sections -fdata-sections
 163   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
 164   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
 165   AC_TRY_COMPILE(, [int foo;], [ac_fdsections=yes], [ac_fdsections=no])
 166   if test "$ac_test_CXXFLAGS" = set; then
 167     CXXFLAGS="$ac_save_CXXFLAGS"
 168   else
 169     # this is the suspicious part
 170     CXXFLAGS=''
 171   fi
 172   if test x"$ac_fdsections" = x"yes"; then
 173     SECTION_FLAGS='-ffunction-sections -fdata-sections'
 174   fi
 175   AC_MSG_RESULT($ac_fdsections)
 176
 177   AC_LANG_RESTORE
 178   AC_SUBST(WERROR)
 179   AC_SUBST(SECTION_FLAGS)
 180 ])
 181
 182
 183 dnl
 184 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
 185 dnl the native linker is in use, all variables will be defined to something
 186 dnl safe (like an empty string).
 187 dnl
 188 dnl Defines:
 189 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
 190 dnl  OPT_LDFLAGS='-Wl,-O1' if possible
 191 dnl  LD (as a side effect of testing)
 192 dnl Sets:
 193 dnl  with_gnu_ld
 194 dnl  glibcxx_gnu_ld_version (possibly)
 195 dnl
 196 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
 197 dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
 198 dnl
 199 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
 200   # If we're not using GNU ld, then there's no point in even trying these
 201   # tests.  Check for that first.  We should have already tested for gld
 202   # by now (in libtool), but require it now just to be safe...
 203   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
 204   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
 205   AC_REQUIRE([AC_PROG_LD])
 206   AC_REQUIRE([AC_PROG_AWK])
 207
 208   # The name set by libtool depends on the version of libtool.  Shame on us
 209   # for depending on an impl detail, but c'est la vie.  Older versions used
 210   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
 211   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
 212   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
 213   # set (hence we're using an older libtool), then set it.
 214   if test x${with_gnu_ld+set} != xset; then
 215     if test x${ac_cv_prog_gnu_ld+set} != xset; then
 216       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
 217       with_gnu_ld=no
 218     else
 219       with_gnu_ld=$ac_cv_prog_gnu_ld
 220     fi
 221   fi
 222
 223   # Start by getting the version number.  I think the libtool test already
 224   # does some of this, but throws away the result.
 225   changequote(,)
 226   ldver=`$LD --version 2>/dev/null | head -1 | \
 227          sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
 228   changequote([,])
 229   glibcxx_gnu_ld_version=`echo $ldver | \
 230          $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
 231
 232   # Set --gc-sections.
 233   if test "$with_gnu_ld" = "notbroken"; then
 234     # GNU ld it is!  Joy and bunny rabbits!
 235
 236     # All these tests are for C++; save the language and the compiler flags.
 237     # Need to do this so that g++ won't try to link in libstdc++
 238     ac_test_CFLAGS="${CFLAGS+set}"
 239     ac_save_CFLAGS="$CFLAGS"
 240     CFLAGS='-x c++  -Wl,--gc-sections'
 241
 242     # Check for -Wl,--gc-sections
 243     # XXX This test is broken at the moment, as symbols required for linking
 244     # are now in libsupc++ (not built yet).  In addition, this test has
 245     # cored on solaris in the past.  In addition, --gc-sections doesn't
 246     # really work at the moment (keeps on discarding used sections, first
 247     # .eh_frame and now some of the glibc sections for iconv).
 248     # Bzzzzt.  Thanks for playing, maybe next time.
 249     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
 250     AC_TRY_RUN([
 251      int main(void)
 252      {
 253        try { throw 1; }
 254        catch (...) { };
 255        return 0;
 256      }
 257     ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
 258     if test "$ac_test_CFLAGS" = set; then
 259       CFLAGS="$ac_save_CFLAGS"
 260     else
 261       # this is the suspicious part
 262       CFLAGS=''
 263     fi
 264     if test "$ac_sectionLDflags" = "yes"; then
 265       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
 266     fi
 267     AC_MSG_RESULT($ac_sectionLDflags)
 268   fi
 269
 270   # Set linker optimization flags.
 271   if test x"$with_gnu_ld" = x"yes"; then
 272     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
 273   fi
 274
 275   AC_SUBST(SECTION_LDFLAGS)
 276   AC_SUBST(OPT_LDFLAGS)
 277 ])
 278
 279
 280 dnl
 281 dnl Check to see if this target can enable the iconv specializations.
 282 dnl If --disable-c-mbchar was given, no wchar_t specialization is enabled.
 283 dnl (This must have been previously checked, along with the rest of C99
 284 dnl support.) By default, iconv support is disabled.
 285 dnl
 286 dnl Defines:
 287 dnl  _GLIBCXX_USE_ICONV if all the bits are found.
 288 dnl Substs:
 289 dnl  LIBICONV to a -l string containing the iconv library, if needed.
 290 dnl
 291 AC_DEFUN([GLIBCXX_CHECK_ICONV_SUPPORT], [
 292
 293   enable_iconv=no
 294   # Only continue checking if the ISO C99 headers exist and support is on.
 295   if test x"$enable_wchar_t" = xyes; then
 296
 297     # Use iconv for wchar_t to char conversions. As such, check for
 298     # X/Open Portability Guide, version 2 features (XPG2).
 299     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
 300     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
 301
 302     # Check for existence of libiconv.a providing XPG2 wchar_t support.
 303     AC_CHECK_LIB(iconv, iconv, LIBICONV="-liconv")
 304     ac_save_LIBS="$LIBS"
 305     LIBS="$LIBS $LIBICONV"
 306     AC_SUBST(LIBICONV)
 307
 308     AC_CHECK_FUNCS([iconv_open iconv_close iconv nl_langinfo],
 309     [ac_XPG2funcs=yes], [ac_XPG2funcs=no])
 310
 311     LIBS="$ac_save_LIBS"
 312
 313     if test x"$ac_has_iconv_h" = xyes &&
 314        test x"$ac_has_langinfo_h" = xyes &&
 315        test x"$ac_XPG2funcs" = xyes;
 316     then
 317       AC_DEFINE([_GLIBCXX_USE_ICONV],1,
 318                 [Define if iconv and related functions exist and are usable.])
 319       enable_iconv=yes
 320     fi
 321   fi
 322   AC_MSG_CHECKING([for enabled iconv specializations])
 323   AC_MSG_RESULT($enable_iconv)
 324 ])
 325
 326
 327 dnl
 328 dnl Check for headers for, and arguments to, the setrlimit() function.
 329 dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
 330 dnl
 331 dnl Defines:
 332 dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits
 333 dnl  various HAVE_LIMIT_* for individual limit names
 334 dnl
 335 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
 336   AC_MSG_CHECKING([for RLIMIT_$1])
 337   AC_TRY_COMPILE(
 338     [#include <unistd.h>
 339      #include <sys/time.h>
 340      #include <sys/resource.h>
 341     ],
 342     [ int f = RLIMIT_$1 ; ],
 343     [glibcxx_mresult=1], [glibcxx_mresult=0])
 344   AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
 345                      [Only used in build directory testsuite_hooks.h.])
 346   if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
 347   AC_MSG_RESULT($res)
 348 ])
 349
 350 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
 351   setrlimit_have_headers=yes
 352   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
 353                    [],
 354                    [setrlimit_have_headers=no])
 355   # If don't have the headers, then we can't run the tests now, and we
 356   # won't be seeing any of these during testsuite compilation.
 357   if test $setrlimit_have_headers = yes; then
 358     # Can't do these in a loop, else the resulting syntax is wrong.
 359     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
 360     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
 361     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
 362     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
 363     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
 364
 365     # Check for rlimit, setrlimit.
 366     AC_CACHE_VAL(ac_setrlimit, [
 367       AC_TRY_COMPILE(
 368         [#include <unistd.h>
 369          #include <sys/time.h>
 370          #include <sys/resource.h>
 371         ],
 372         [struct rlimit r;
 373          setrlimit(0, &r);],
 374         [ac_setrlimit=yes], [ac_setrlimit=no])
 375     ])
 376   fi
 377
 378   AC_MSG_CHECKING([for testsuite resource limits support])
 379   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
 380     ac_res_limits=yes
 381     AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
 382               [Define if using setrlimit to set resource limits during
 383               "make check"])
 384   else
 385     ac_res_limits=no
 386   fi
 387   AC_MSG_RESULT($ac_res_limits)
 388 ])
 389
 390
 391 dnl
 392 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
 393 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
 394 dnl
 395 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
 396   AC_MSG_CHECKING([for S_ISREG or S_IFREG])
 397   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
 398     AC_TRY_LINK(
 399       [#include <sys/stat.h>],
 400       [struct stat buffer;
 401        fstat(0, &buffer);
 402        S_ISREG(buffer.st_mode);],
 403       [glibcxx_cv_S_ISREG=yes],
 404       [glibcxx_cv_S_ISREG=no])
 405   ])
 406   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
 407     AC_TRY_LINK(
 408       [#include <sys/stat.h>],
 409       [struct stat buffer;
 410        fstat(0, &buffer);
 411        S_IFREG & buffer.st_mode;],
 412       [glibcxx_cv_S_IFREG=yes],
 413       [glibcxx_cv_S_IFREG=no])
 414   ])
 415   res=no
 416   if test $glibcxx_cv_S_ISREG = yes; then
 417     AC_DEFINE(HAVE_S_ISREG, 1,
 418               [Define if S_IFREG is available in <sys/stat.h>.])
 419     res=S_ISREG
 420   elif test $glibcxx_cv_S_IFREG = yes; then
 421     AC_DEFINE(HAVE_S_IFREG, 1,
 422               [Define if S_IFREG is available in <sys/stat.h>.])
 423     res=S_IFREG
 424   fi
 425   AC_MSG_RESULT($res)
 426 ])
 427
 428
 429 dnl
 430 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
 431 dnl
 432 AC_DEFUN([GLIBCXX_CHECK_POLL], [
 433   AC_MSG_CHECKING([for poll])
 434   AC_CACHE_VAL(glibcxx_cv_POLL, [
 435     AC_TRY_LINK(
 436       [#include <poll.h>],
 437       [struct pollfd pfd[1];
 438        pfd[0].events = POLLIN;
 439        poll(pfd, 1, 0);],
 440       [glibcxx_cv_POLL=yes],
 441       [glibcxx_cv_POLL=no])
 442   ])
 443   if test $glibcxx_cv_POLL = yes; then
 444     AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
 445   fi
 446   AC_MSG_RESULT($glibcxx_cv_POLL)
 447 ])
 448
 449
 450 dnl
 451 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
 452 dnl
 453 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
 454   AC_MSG_CHECKING([for writev])
 455   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
 456     AC_TRY_LINK(
 457       [#include <sys/uio.h>],
 458       [struct iovec iov[2];
 459        writev(0, iov, 0);],
 460       [glibcxx_cv_WRITEV=yes],
 461       [glibcxx_cv_WRITEV=no])
 462   ])
 463   if test $glibcxx_cv_WRITEV = yes; then
 464     AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
 465   fi
 466   AC_MSG_RESULT($glibcxx_cv_WRITEV)
 467 ])
 468
 469
 470 dnl
 471 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
 472 dnl
 473 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
 474   AC_MSG_CHECKING([for int64_t])
 475   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
 476     AC_TRY_COMPILE(
 477       [#include <stdint.h>],
 478       [int64_t var;],
 479       [glibcxx_cv_INT64_T=yes],
 480       [glibcxx_cv_INT64_T=no])
 481   ])
 482   if test $glibcxx_cv_INT64_T = yes; then
 483     AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
 484   fi
 485   AC_MSG_RESULT($glibcxx_cv_INT64_T)
 486 ])
 487
 488
 489 dnl
 490 dnl Check whether LFS support is available.
 491 dnl
 492 AC_DEFUN([GLIBCXX_CHECK_LFS], [
 493   AC_LANG_SAVE
 494   AC_LANG_CPLUSPLUS
 495   ac_save_CXXFLAGS="$CXXFLAGS"
 496   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 497   AC_MSG_CHECKING([for LFS support])
 498   AC_CACHE_VAL(glibcxx_cv_LFS, [
 499     AC_TRY_LINK(
 500       [#include <unistd.h>
 501        #include <stdio.h>
 502        #include <sys/stat.h>
 503       ],
 504       [FILE* fp;
 505        fopen64("t", "w");
 506        fseeko64(fp, 0, SEEK_CUR);
 507        ftello64(fp);
 508        lseek64(1, 0, SEEK_CUR);
 509        struct stat64 buf;
 510        fstat64(1, &buf);],
 511       [glibcxx_cv_LFS=yes],
 512       [glibcxx_cv_LFS=no])
 513   ])
 514   if test $glibcxx_cv_LFS = yes; then
 515     AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
 516   fi
 517   AC_MSG_RESULT($glibcxx_cv_LFS)
 518   CXXFLAGS="$ac_save_CXXFLAGS"
 519   AC_LANG_RESTORE
 520 ])
 521
 522
 523 dnl
 524 dnl Check for whether a fully dynamic basic_string implementation should
 525 dnl be turned on, that does not put empty objects in per-process static
 526 dnl memory (mostly useful together with shared memory allocators, see PR
 527 dnl libstdc++/16612 for details).
 528 dnl
 529 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
 530 dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
 531 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
 532 dnl       Where DEFAULT is either `yes' or `no'.
 533 dnl
 534 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
 535   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
 536   if test $enable_fully_dynamic_string = yes; then
 537     AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
 538               [Define if a fully dynamic basic_string is wanted.])
 539   fi
 540 ])
 541
 542
 543 dnl
 544 dnl Does any necessary configuration of the testsuite directory.  Generates
 545 dnl the testsuite_hooks.h header.
 546 dnl
 547 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
 548 dnl
 549 dnl Sets:
 550 dnl  enable_abi_check
 551 dnl  GLIBCXX_TEST_WCHAR_T
 552 dnl  GLIBCXX_TEST_THREAD
 553 dnl Substs:
 554 dnl  baseline_dir
 555 dnl
 556 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
 557   if $GLIBCXX_IS_NATIVE ; then
 558     # Do checks for resource limit functions.
 559     GLIBCXX_CHECK_SETRLIMIT
 560
 561     # Look for setenv, so that extended locale tests can be performed.
 562     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
 563   fi
 564
 565   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
 566      test $enable_symvers != no; then
 567     case "$host" in
 568       *-*-cygwin*)
 569         enable_abi_check=no ;;
 570       *)
 571         enable_abi_check=yes ;;
 572     esac
 573   else
 574     # Only build this as native, since automake does not understand
 575     # CXX_FOR_BUILD.
 576     enable_abi_check=no
 577   fi
 578
 579   # Export file names for ABI checking.
 580   baseline_dir="$glibcxx_srcdir/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
 581   AC_SUBST(baseline_dir)
 582 ])
 583
 584
 585 dnl
 586 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
 587 dnl
 588 dnl Substs:
 589 dnl  GLIBCXX_INCLUDES
 590 dnl  TOPLEVEL_INCLUDES
 591 dnl
 592 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
 593   # Used for every C++ compile we perform.
 594   GLIBCXX_INCLUDES="\
 595 -I$glibcxx_builddir/include/$host_alias \
 596 -I$glibcxx_builddir/include \
 597 -I$glibcxx_srcdir/libsupc++"
 598
 599   # For Canadian crosses, pick this up too.
 600   if test $CANADIAN = yes; then
 601     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
 602   fi
 603
 604   # Stuff in the actual top level.  Currently only used by libsupc++ to
 605   # get unwind* headers from the gcc dir.
 606   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
 607   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
 608
 609   # Now, export this to all the little Makefiles....
 610   AC_SUBST(GLIBCXX_INCLUDES)
 611   AC_SUBST(TOPLEVEL_INCLUDES)
 612 ])
 613
 614
 615 dnl
 616 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
 617 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
 618 dnl
 619 dnl Substs:
 620 dnl  OPTIMIZE_CXXFLAGS
 621 dnl  WARN_FLAGS
 622 dnl
 623 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
 624   # Optimization flags that are probably a good idea for thrill-seekers. Just
 625   # uncomment the lines below and make, everything else is ready to go...
 626   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
 627   OPTIMIZE_CXXFLAGS=
 628   AC_SUBST(OPTIMIZE_CXXFLAGS)
 629
 630   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
 631   AC_SUBST(WARN_FLAGS)
 632 ])
 633
 634
 635 dnl
 636 dnl All installation directory information is determined here.
 637 dnl
 638 dnl Substs:
 639 dnl  gxx_install_dir
 640 dnl  glibcxx_prefixdir
 641 dnl  glibcxx_toolexecdir
 642 dnl  glibcxx_toolexeclibdir
 643 dnl
 644 dnl Assumes cross_compiling bits already done, and with_cross_host in
 645 dnl particular.
 646 dnl
 647 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
 648   glibcxx_toolexecdir=no
 649   glibcxx_toolexeclibdir=no
 650   glibcxx_prefixdir=$prefix
 651
 652   AC_MSG_CHECKING([for gxx-include-dir])
 653   AC_ARG_WITH([gxx-include-dir],
 654     AC_HELP_STRING([--with-gxx-include-dir=DIR],
 655                    [installation directory for include files]),
 656     [case "$withval" in
 657       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
 658       no)  gxx_include_dir=no ;;
 659       *)   gxx_include_dir=$withval ;;
 660      esac],
 661     [gxx_include_dir=no])
 662   AC_MSG_RESULT($gxx_include_dir)
 663
 664   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
 665   AC_ARG_ENABLE([version-specific-runtime-libs],
 666     AC_HELP_STRING([--enable-version-specific-runtime-libs],
 667                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
 668     [case "$enableval" in
 669       yes) version_specific_libs=yes ;;
 670       no)  version_specific_libs=no ;;
 671       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
 672      esac],
 673     [version_specific_libs=no])
 674   AC_MSG_RESULT($version_specific_libs)
 675
 676   # Default case for install directory for include files.
 677   if test $version_specific_libs = no && test $gxx_include_dir = no; then
 678     gxx_include_dir='${prefix}/include/c++/${gcc_version}'
 679   fi
 680
 681   # Version-specific runtime libs processing.
 682   if test $version_specific_libs = yes; then
 683     # Need the gcc compiler version to know where to install libraries
 684     # and header files if --enable-version-specific-runtime-libs option
 685     # is selected.  FIXME: these variables are misnamed, there are
 686     # no executables installed in _toolexecdir or _toolexeclibdir.
 687     if test x"$gxx_include_dir" = x"no"; then
 688       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
 689     fi
 690     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 691     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
 692   fi
 693
 694   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
 695   # Install a library built with a cross compiler in tooldir, not libdir.
 696   if test x"$glibcxx_toolexecdir" = x"no"; then
 697     if test -n "$with_cross_host" &&
 698        test x"$with_cross_host" != x"no"; then
 699       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
 700       glibcxx_toolexeclibdir='${toolexecdir}/lib'
 701     else
 702       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 703       glibcxx_toolexeclibdir='${libdir}'
 704     fi
 705     multi_os_directory=`$CXX -print-multi-os-directory`
 706     case $multi_os_directory in
 707       .) ;; # Avoid trailing /.
 708       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
 709     esac
 710   fi
 711
 712   AC_MSG_CHECKING([for install location])
 713   AC_MSG_RESULT($gxx_include_dir)
 714
 715   AC_SUBST(glibcxx_prefixdir)
 716   AC_SUBST(gxx_include_dir)
 717   AC_SUBST(glibcxx_toolexecdir)
 718   AC_SUBST(glibcxx_toolexeclibdir)
 719 ])
 720
 721
 722 dnl
 723 dnl GLIBCXX_ENABLE
 724 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
 725 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
 726 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
 727 dnl
 728 dnl See docs/html/17_intro/configury.html#enable for documentation.
 729 dnl
 730 m4_define([GLIBCXX_ENABLE],[dnl
 731 m4_define([_g_switch],[--enable-$1])dnl
 732 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
 733  AC_ARG_ENABLE($1,_g_help,
 734   m4_bmatch([$5],
 735    [^permit ],
 736      [[
 737       case "$enableval" in
 738        m4_bpatsubst([$5],[permit ])) ;;
 739        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
 740           dnl Idea for future:  generate a URL pointing to
 741           dnl "onlinedocs/configopts.html#whatever"
 742       esac
 743      ]],
 744    [^$],
 745      [[
 746       case "$enableval" in
 747        yes|no) ;;
 748        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
 749       esac
 750      ]],
 751    [[$5]]),
 752   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
 753 m4_undefine([_g_switch])dnl
 754 m4_undefine([_g_help])dnl
 755 ])
 756
 757
 758 dnl
 759 dnl Check for ISO/IEC 9899:1999 "C99" support.
 760 dnl
 761 dnl --enable-c99 defines _GLIBCXX_USE_C99
 762 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
 763 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
 764 dnl       Where DEFAULT is either `yes' or `no'.
 765 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
 766 dnl
 767 AC_DEFUN([GLIBCXX_ENABLE_C99], [
 768   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
 769
 770   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos
 771   # even if C99 support is turned off.
 772   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
 773   AC_MSG_CHECKING([for mbstate_t])
 774   AC_TRY_COMPILE([#include <wchar.h>],
 775   [mbstate_t teststate;],
 776   have_mbstate_t=yes, have_mbstate_t=no)
 777   AC_MSG_RESULT($have_mbstate_t)
 778   if test x"$have_mbstate_t" = xyes; then
 779     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
 780   fi
 781
 782   if test x"$enable_c99" = x"yes"; then
 783
 784   AC_LANG_SAVE
 785   AC_LANG_CPLUSPLUS
 786
 787   # Check for the existence of <math.h> functions used if C99 is enabled.
 788   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
 789   AC_CACHE_VAL(ac_c99_math, [
 790   AC_TRY_COMPILE([#include <math.h>],
 791                  [fpclassify(0.0);
 792                   isfinite(0.0);
 793                   isinf(0.0);
 794                   isnan(0.0);
 795                   isnormal(0.0);
 796                   signbit(0.0);
 797                   isgreater(0.0,0.0);
 798                   isgreaterequal(0.0,0.0);
 799                   isless(0.0,0.0);
 800                   islessequal(0.0,0.0);
 801                   islessgreater(0.0,0.0);
 802                   islessgreater(0.0,0.0);
 803                   isunordered(0.0,0.0);
 804                  ],[ac_c99_math=yes], [ac_c99_math=no])
 805   ])
 806   AC_MSG_RESULT($ac_c99_math)
 807   if test x"$ac_c99_math" = x"yes"; then
 808     AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
 809               [Define if C99 functions or macros in <math.h> should be imported
 810               in <cmath> in namespace std.])
 811   fi
 812
 813   # Check for the existence of <complex.h> complex math functions.
 814   # This is necessary even though libstdc++ uses the builtin versions
 815   # of these functions, because if the builtin cannot be used, a reference
 816   # to the library function is emitted.
 817   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 818   ac_c99_complex=no;
 819   if test x"$ac_has_complex_h" = x"yes"; then
 820     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
 821     AC_TRY_COMPILE([#include <complex.h>],
 822                    [typedef __complex__ float float_type; float_type tmpf;
 823                     cabsf(tmpf);
 824                     cargf(tmpf);
 825                     ccosf(tmpf);
 826                     ccoshf(tmpf);
 827                     cexpf(tmpf);
 828                     clogf(tmpf);
 829                     csinf(tmpf);
 830                     csinhf(tmpf);
 831                     csqrtf(tmpf);
 832                     ctanf(tmpf);
 833                     ctanhf(tmpf);
 834                     cpowf(tmpf, tmpf);
 835                     typedef __complex__ double double_type; double_type tmpd;
 836                     cabs(tmpd);
 837                     carg(tmpd);
 838                     ccos(tmpd);
 839                     ccosh(tmpd);
 840                     cexp(tmpd);
 841                     clog(tmpd);
 842                     csin(tmpd);
 843                     csinh(tmpd);
 844                     csqrt(tmpd);
 845                     ctan(tmpd);
 846                     ctanh(tmpd);
 847                     cpow(tmpd, tmpd);
 848                     typedef __complex__ long double ld_type; ld_type tmpld;
 849                     cabsl(tmpld);
 850                     cargl(tmpld);
 851                     ccosl(tmpld);
 852                     ccoshl(tmpld);
 853                     cexpl(tmpld);
 854                     clogl(tmpld);
 855                     csinl(tmpld);
 856                     csinhl(tmpld);
 857                     csqrtl(tmpld);
 858                     ctanl(tmpld);
 859                     ctanhl(tmpld);
 860                     cpowl(tmpld, tmpld);
 861                    ],[ac_c99_complex=yes], [ac_c99_complex=no])
 862   fi
 863   AC_MSG_RESULT($ac_c99_complex)
 864   if test x"$ac_c99_complex" = x"yes"; then
 865     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 866               [Define if C99 functions in <complex.h> should be used in
 867               <complex>. Using compiler builtins for these functions requires
 868               corresponding C99 library functions to be present.])
 869   fi
 870
 871   # Check for the existence in <stdio.h> of vscanf, et. al.
 872   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 873   AC_CACHE_VAL(ac_c99_stdio, [
 874   AC_TRY_COMPILE([#include <stdio.h>
 875                   #include <stdarg.h>
 876                   void foo(char* fmt, ...)
 877                   {
 878                     va_list args; va_start(args, fmt);
 879                     vfscanf(stderr, "%i", args);
 880                     vscanf("%i", args);
 881                     vsnprintf(fmt, 0, "%i", args);
 882                     vsscanf(fmt, "%i", args);
 883                   }],
 884                  [snprintf("12", 0, "%i");],
 885                  [ac_c99_stdio=yes], [ac_c99_stdio=no])
 886   ])
 887   AC_MSG_RESULT($ac_c99_stdio)
 888
 889   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
 890   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
 891   AC_CACHE_VAL(ac_c99_stdlib, [
 892   AC_TRY_COMPILE([#include <stdlib.h>],
 893                  [char* tmp;
 894                   strtof("gnu", &tmp);
 895                   strtold("gnu", &tmp);
 896                   strtoll("gnu", &tmp, 10);
 897                   strtoull("gnu", &tmp, 10);
 898                   llabs(10);
 899                   lldiv(10,1);
 900                   atoll("10");
 901                   _Exit(0);
 902                   lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
 903   ])
 904   AC_MSG_RESULT($ac_c99_stdlib)
 905
 906   # Check for the existence in <wchar.h> of wcstoull, WEOF, etc.
 907   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
 908   ac_c99_wchar=no;
 909   if test x"$ac_has_wchar_h" = xyes &&
 910      test x"$ac_has_wctype_h" = xyes; then
 911     AC_TRY_COMPILE([#include <wchar.h>
 912                     #include <stddef.h>
 913                     wint_t i;
 914                     long l = WEOF;
 915                     long j = WCHAR_MIN;
 916                     long k = WCHAR_MAX;
 917                     namespace test
 918                     {
 919                       using ::btowc;
 920                       using ::fgetwc;
 921                       using ::fgetws;
 922                       using ::fputwc;
 923                       using ::fputws;
 924                       using ::fwide;
 925                       using ::fwprintf;
 926                       using ::fwscanf;
 927                       using ::getwc;
 928                       using ::getwchar;
 929                       using ::mbrlen;
 930                       using ::mbrtowc;
 931                       using ::mbsinit;
 932                       using ::mbsrtowcs;
 933                       using ::putwc;
 934                       using ::putwchar;
 935                       using ::swprintf;
 936                       using ::swscanf;
 937                       using ::ungetwc;
 938                       using ::vfwprintf;
 939                       using ::vswprintf;
 940                       using ::vwprintf;
 941                       using ::wcrtomb;
 942                       using ::wcscat;
 943                       using ::wcschr;
 944                       using ::wcscmp;
 945                       using ::wcscoll;
 946                       using ::wcscpy;
 947                       using ::wcscspn;
 948                       using ::wcsftime;
 949                       using ::wcslen;
 950                       using ::wcsncat;
 951                       using ::wcsncmp;
 952                       using ::wcsncpy;
 953                       using ::wcspbrk;
 954                       using ::wcsrchr;
 955                       using ::wcsrtombs;
 956                       using ::wcsspn;
 957                       using ::wcsstr;
 958                       using ::wcstod;
 959                       using ::wcstok;
 960                       using ::wcstol;
 961                       using ::wcstold;
 962                       using ::wcstoll;
 963                       using ::wcstoul;
 964                       using ::wcstoull;
 965                       using ::wcsxfrm;
 966                       using ::wctob;
 967                       using ::wmemchr;
 968                       using ::wmemcmp;
 969                       using ::wmemcpy;
 970                       using ::wmemmove;
 971                       using ::wmemset;
 972                       using ::wprintf;
 973                       using ::wscanf;
 974                     }
 975                    ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
 976
 977     # Checks for wide character functions that may not be present.
 978     # Injection of these is wrapped with guard macros.
 979     # NB: only put functions here, instead of immediately above, if
 980     # absolutely necessary.
 981     AC_TRY_COMPILE([#include <wchar.h>
 982                     namespace test { using ::vfwscanf; } ], [],
 983                    [AC_DEFINE(HAVE_VFWSCANF,1,
 984                         [Defined if vfwscanf exists.])],[])
 985
 986     AC_TRY_COMPILE([#include <wchar.h>
 987                     namespace test { using ::vswscanf; } ], [],
 988                    [AC_DEFINE(HAVE_VSWSCANF,1,
 989                         [Defined if vswscanf exists.])],[])
 990
 991     AC_TRY_COMPILE([#include <wchar.h>
 992                     namespace test { using ::vwscanf; } ], [],
 993                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
 994
 995     AC_TRY_COMPILE([#include <wchar.h>
 996                     namespace test { using ::wcstof; } ], [],
 997                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
 998
 999     AC_TRY_COMPILE([#include <wctype.h>],
1000                    [ wint_t t; int i = iswblank(t);],
1001                    [AC_DEFINE(HAVE_ISWBLANK,1,
1002                         [Defined if iswblank exists.])],[])
1003
1004     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1005     AC_MSG_RESULT($ac_c99_wchar)
1006   fi
1007
1008   # Option parsed, now set things appropriately.
1009   if test x"$ac_c99_math" = x"no" ||
1010      test x"$ac_c99_complex" = x"no" ||
1011      test x"$ac_c99_stdio" = x"no" ||
1012      test x"$ac_c99_stdlib" = x"no" ||
1013      test x"$ac_c99_wchar" = x"no"; then
1014     enable_c99=no;
1015   else
1016     AC_DEFINE(_GLIBCXX_USE_C99, 1,
1017     [Define if C99 functions or macros from <wchar.h>, <math.h>,
1018     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1019   fi
1020
1021   AC_LANG_RESTORE
1022   fi
1023
1024   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1025   AC_MSG_RESULT($enable_c99)
1026 ])
1027
1028
1029 dnl
1030 dnl Check for what type of C headers to use.
1031 dnl
1032 dnl --enable-cheaders= [does stuff].
1033 dnl --disable-cheaders [does not do anything, really].
1034 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1035 dnl       Where DEFAULT is either `c' or `c_std'.
1036 dnl
1037 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1038   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1039     [construct "C" headers for g++], [permit c|c_std])
1040   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1041
1042   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1043
1044   AC_SUBST(C_INCLUDE_DIR)
1045   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1046   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1047   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1048 ])
1049
1050
1051 dnl
1052 dnl Check for which locale library to use.  The choice is mapped to
1053 dnl a subdirectory of config/locale.
1054 dnl
1055 dnl Default is generic.
1056 dnl
1057 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1058   AC_MSG_CHECKING([for C locale to use])
1059   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1060     [use MODEL for target locale package],
1061     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1062
1063   # If they didn't use this option switch, or if they specified --enable
1064   # with no specific model, we'll have to look for one.  If they
1065   # specified --disable (???), do likewise.
1066   if test $enable_clocale = no || test $enable_clocale = yes; then
1067      enable_clocale=auto
1068   fi
1069
1070   # Either a known package, or "auto"
1071   enable_clocale_flag=$enable_clocale
1072
1073   # Probe for locale support if no specific model is specified.
1074   # Default to "generic".
1075   if test $enable_clocale_flag = auto; then
1076     case ${target_os} in
1077       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1078         AC_EGREP_CPP([_GLIBCXX_ok], [
1079         #include <features.h>
1080         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1081           _GLIBCXX_ok
1082         #endif
1083         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1084
1085         # Test for bugs early in glibc-2.2.x series
1086           if test $enable_clocale_flag = gnu; then
1087           AC_TRY_RUN([
1088           #define _GNU_SOURCE 1
1089           #include <locale.h>
1090           #include <string.h>
1091           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1092           extern __typeof(newlocale) __newlocale;
1093           extern __typeof(duplocale) __duplocale;
1094           extern __typeof(strcoll_l) __strcoll_l;
1095           #endif
1096           int main()
1097           {
1098               const char __one[] = "Äuglein Augmen";
1099               const char __two[] = "Äuglein";
1100               int i;
1101               int j;
1102               __locale_t        loc;
1103                __locale_t        loc_dup;
1104               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1105               loc_dup = __duplocale(loc);
1106               i = __strcoll_l(__one, __two, loc);
1107               j = __strcoll_l(__one, __two, loc_dup);
1108               return 0;
1109           }
1110           ],
1111           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1112           [enable_clocale_flag=generic])
1113           fi
1114
1115         # ... at some point put __strxfrm_l tests in as well.
1116         ;;
1117       darwin* | freebsd*)
1118         enable_clocale_flag=darwin
1119         ;;
1120       *)
1121         enable_clocale_flag=generic
1122         ;;
1123     esac
1124   fi
1125
1126   # Deal with gettext issues.  Default to not using it (=no) until we detect
1127   # support for it later.  Let the user turn it off via --e/d, but let that
1128   # default to on for easier handling.
1129   USE_NLS=no
1130   AC_ARG_ENABLE(nls,
1131     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1132     [],
1133     [enable_nls=yes])
1134
1135   # Set configure bits for specified locale package
1136   case ${enable_clocale_flag} in
1137     generic)
1138       AC_MSG_RESULT(generic)
1139
1140       CLOCALE_H=config/locale/generic/c_locale.h
1141       CLOCALE_CC=config/locale/generic/c_locale.cc
1142       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1143       CCOLLATE_CC=config/locale/generic/collate_members.cc
1144       CCTYPE_CC=config/locale/generic/ctype_members.cc
1145       CMESSAGES_H=config/locale/generic/messages_members.h
1146       CMESSAGES_CC=config/locale/generic/messages_members.cc
1147       CMONEY_CC=config/locale/generic/monetary_members.cc
1148       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1149       CTIME_H=config/locale/generic/time_members.h
1150       CTIME_CC=config/locale/generic/time_members.cc
1151       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1152       ;;
1153     darwin)
1154       AC_MSG_RESULT(darwin or freebsd)
1155
1156       CLOCALE_H=config/locale/generic/c_locale.h
1157       CLOCALE_CC=config/locale/generic/c_locale.cc
1158       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1159       CCOLLATE_CC=config/locale/generic/collate_members.cc
1160       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1161       CMESSAGES_H=config/locale/generic/messages_members.h
1162       CMESSAGES_CC=config/locale/generic/messages_members.cc
1163       CMONEY_CC=config/locale/generic/monetary_members.cc
1164       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1165       CTIME_H=config/locale/generic/time_members.h
1166       CTIME_CC=config/locale/generic/time_members.cc
1167       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1168       ;;
1169
1170     gnu)
1171       AC_MSG_RESULT(gnu)
1172
1173       # Declare intention to use gettext, and add support for specific
1174       # languages.
1175       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1176       ALL_LINGUAS="de fr"
1177
1178       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1179       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1180       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1181         USE_NLS=yes
1182       fi
1183       # Export the build objects.
1184       for ling in $ALL_LINGUAS; do \
1185         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1186         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1187       done
1188       AC_SUBST(glibcxx_MOFILES)
1189       AC_SUBST(glibcxx_POFILES)
1190
1191       CLOCALE_H=config/locale/gnu/c_locale.h
1192       CLOCALE_CC=config/locale/gnu/c_locale.cc
1193       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1194       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1195       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1196       CMESSAGES_H=config/locale/gnu/messages_members.h
1197       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1198       CMONEY_CC=config/locale/gnu/monetary_members.cc
1199       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1200       CTIME_H=config/locale/gnu/time_members.h
1201       CTIME_CC=config/locale/gnu/time_members.cc
1202       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1203       ;;
1204     ieee_1003.1-2001)
1205       AC_MSG_RESULT(IEEE 1003.1)
1206
1207       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1208       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1209       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1210       CCOLLATE_CC=config/locale/generic/collate_members.cc
1211       CCTYPE_CC=config/locale/generic/ctype_members.cc
1212       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1213       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1214       CMONEY_CC=config/locale/generic/monetary_members.cc
1215       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1216       CTIME_H=config/locale/generic/time_members.h
1217       CTIME_CC=config/locale/generic/time_members.cc
1218       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1219       ;;
1220   esac
1221
1222   # This is where the testsuite looks for locale catalogs, using the
1223   # -DLOCALEDIR define during testsuite compilation.
1224   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1225   AC_SUBST(glibcxx_localedir)
1226
1227   # A standalone libintl (e.g., GNU libintl) may be in use.
1228   if test $USE_NLS = yes; then
1229     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1230     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1231   fi
1232   if test $USE_NLS = yes; then
1233     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1234               [Define if NLS translations are to be used.])
1235   fi
1236
1237   AC_SUBST(USE_NLS)
1238   AC_SUBST(CLOCALE_H)
1239   AC_SUBST(CMESSAGES_H)
1240   AC_SUBST(CCODECVT_CC)
1241   AC_SUBST(CCOLLATE_CC)
1242   AC_SUBST(CCTYPE_CC)
1243   AC_SUBST(CMESSAGES_CC)
1244   AC_SUBST(CMONEY_CC)
1245   AC_SUBST(CNUMERIC_CC)
1246   AC_SUBST(CTIME_H)
1247   AC_SUBST(CTIME_CC)
1248   AC_SUBST(CLOCALE_CC)
1249   AC_SUBST(CLOCALE_INTERNAL_H)
1250 ])
1251
1252
1253 dnl
1254 dnl Check for which std::allocator base class to use.  The choice is
1255 dnl mapped from a subdirectory of include/ext.
1256 dnl
1257 dnl Default is new.
1258 dnl
1259 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1260   AC_MSG_CHECKING([for std::allocator base class])
1261   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1262     [use KIND for target std::allocator base],
1263     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1264
1265   # If they didn't use this option switch, or if they specified --enable
1266   # with no specific model, we'll have to look for one.  If they
1267   # specified --disable (???), do likewise.
1268   if test $enable_libstdcxx_allocator = no ||
1269      test $enable_libstdcxx_allocator = yes;
1270   then
1271      enable_libstdcxx_allocator=auto
1272   fi
1273
1274   # Either a known package, or "auto". Auto implies the default choice
1275   # for a particular platform.
1276   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1277
1278   # Probe for host-specific support if no specific model is specified.
1279   # Default to "new".
1280   if test $enable_libstdcxx_allocator_flag = auto; then
1281     case ${target_os} in
1282       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1283         enable_libstdcxx_allocator_flag=mt
1284         ;;
1285       *)
1286         enable_libstdcxx_allocator_flag=new
1287         ;;
1288     esac
1289   fi
1290   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1291
1292
1293   # Set configure bits for specified locale package
1294   case ${enable_libstdcxx_allocator_flag} in
1295     bitmap)
1296       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1297       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1298       ;;
1299     malloc)
1300       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1301       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1302       ;;
1303     mt)
1304       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1305       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1306       ;;
1307     new)
1308       ALLOCATOR_H=config/allocator/new_allocator_base.h
1309       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1310       ;;
1311     pool)
1312       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1313       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1314       ;;
1315   esac
1316
1317   AC_SUBST(ALLOCATOR_H)
1318   AC_SUBST(ALLOCATOR_NAME)
1319 ])
1320
1321
1322 dnl
1323 dnl Check for whether the Boost-derived checks should be turned on.
1324 dnl
1325 dnl --enable-concept-checks turns them on.
1326 dnl --disable-concept-checks leaves them off.
1327 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1328 dnl       Where DEFAULT is either `yes' or `no'.
1329 dnl
1330 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1331   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1332   if test $enable_concept_checks = yes; then
1333     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1334               [Define to use concept checking code from the boost libraries.])
1335   fi
1336 ])
1337
1338
1339 dnl
1340 dnl Check for which I/O library to use:  stdio, or something specific.
1341 dnl
1342 dnl Default is stdio.
1343 dnl
1344 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1345   AC_MSG_CHECKING([for underlying I/O to use])
1346   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1347     [use target-specific I/O package], [permit stdio])
1348
1349   # Now that libio has been removed, you can have any color you want as long
1350   # as it's black.  This is one big no-op until other packages are added, but
1351   # showing the framework never hurts.
1352   case ${enable_cstdio} in
1353     stdio)
1354       CSTDIO_H=config/io/c_io_stdio.h
1355       BASIC_FILE_H=config/io/basic_file_stdio.h
1356       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1357       AC_MSG_RESULT(stdio)
1358       ;;
1359   esac
1360
1361   AC_SUBST(CSTDIO_H)
1362   AC_SUBST(BASIC_FILE_H)
1363   AC_SUBST(BASIC_FILE_CC)
1364 ])
1365
1366
1367 dnl
1368 dnl Check for "unusual" flags to pass to the compiler while building.
1369 dnl
1370 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1371 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1372 dnl --disable-cxx-flags passes nothing.
1373 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1374 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1375 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1376 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1377 dnl       If "default flags" is an empty string, the effect is the same
1378 dnl       as --disable or --enable=no.
1379 dnl
1380 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1381   AC_MSG_CHECKING([for extra compiler flags for building])
1382   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1383     [pass compiler FLAGS when building library],
1384     [case "x$enable_cxx_flags" in
1385       xno | x)   enable_cxx_flags= ;;
1386       x-*)       ;;
1387       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1388      esac])
1389
1390   # Run through flags (either default or command-line) and set anything
1391   # extra (e.g., #defines) that must accompany particular g++ options.
1392   if test -n "$enable_cxx_flags"; then
1393     for f in $enable_cxx_flags; do
1394       case "$f" in
1395         -fhonor-std)  ;;
1396         -*)  ;;
1397         *)   # and we're trying to pass /what/ exactly?
1398              AC_MSG_ERROR([compiler flags start with a -]) ;;
1399       esac
1400     done
1401   fi
1402
1403   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1404   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1405   AC_SUBST(EXTRA_CXX_FLAGS)
1406 ])
1407
1408
1409 dnl
1410 dnl Check to see if debugging libraries are to be built.
1411 dnl
1412 dnl --enable-libstdcxx-debug
1413 dnl builds a separate set of debugging libraries in addition to the
1414 dnl normal (shared, static) libstdc++ binaries.
1415 dnl
1416 dnl --disable-libstdcxx-debug
1417 dnl builds only one (non-debug) version of libstdc++.
1418 dnl
1419 dnl --enable-libstdcxx-debug-flags=FLAGS
1420 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1421 dnl
1422 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1423 dnl       Where DEFAULT is either `yes' or `no'.
1424 dnl
1425 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1426   AC_MSG_CHECKING([for additional debug build])
1427   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1428   AC_MSG_RESULT($enable_libstdcxx_debug)
1429   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1430 ])
1431
1432
1433 dnl
1434 dnl Check for explicit debug flags.
1435 dnl
1436 dnl --enable-libstdcxx-debug-flags='-O1'
1437 dnl is a general method for passing flags to be used when
1438 dnl building debug libraries with --enable-debug.
1439 dnl
1440 dnl --disable-libstdcxx-debug-flags does nothing.
1441 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1442 dnl       If "default flags" is an empty string, the effect is the same
1443 dnl       as --disable or --enable=no.
1444 dnl
1445 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1446   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1447     [pass compiler FLAGS when building debug library],
1448     [case "x$enable_libstdcxx_debug_flags" in
1449       xno | x)    enable_libstdcxx_debug_flags= ;;
1450       x-*)        ;;
1451       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1452      esac])
1453
1454   # Option parsed, now set things appropriately
1455   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1456   AC_SUBST(DEBUG_FLAGS)
1457
1458   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1459 ])
1460
1461
1462 dnl
1463 dnl Check if the user only wants a freestanding library implementation.
1464 dnl
1465 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1466 dnl installing only the headers required by [17.4.1.3] and the language
1467 dnl support library.  More than that will be built (to keep the Makefiles
1468 dnl conveniently clean), but not installed.
1469 dnl
1470 dnl Sets:
1471 dnl  is_hosted  (yes/no)
1472 dnl
1473 dnl Defines:
1474 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1475 dnl
1476 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1477   AC_ARG_ENABLE([hosted-libstdcxx],
1478     AC_HELP_STRING([--disable-hosted-libstdcxx],
1479                    [only build freestanding C++ runtime support]),,
1480     [case "$host" in
1481         arm*-*-symbianelf*)
1482             enable_hosted_libstdcxx=no
1483             ;;
1484         *)
1485             enable_hosted_libstdcxx=yes
1486             ;;
1487      esac])
1488   if test "$enable_hosted_libstdcxx" = no; then
1489     AC_MSG_NOTICE([Only freestanding libraries will be built])
1490     is_hosted=no
1491     hosted_define=0
1492     enable_abi_check=no
1493     enable_libstdcxx_pch=no
1494   else
1495     is_hosted=yes
1496     hosted_define=1
1497   fi
1498   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1499   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1500     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1501 ])
1502
1503
1504 dnl
1505 dnl Check for template specializations for the 'long long' type.
1506 dnl The result determines only whether 'long long' I/O is enabled; things
1507 dnl like numeric_limits<> specializations are always available.
1508 dnl
1509 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1510 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1511 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1512 dnl       Where DEFAULT is either `yes' or `no'.
1513 dnl
1514 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1515   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1516   if test $enable_long_long = yes; then
1517     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1518               [Define if code specialized for long long should be used.])
1519   fi
1520   AC_MSG_CHECKING([for enabled long long specializations])
1521   AC_MSG_RESULT([$enable_long_long])
1522 ])
1523
1524
1525 dnl
1526 dnl Check for template specializations for the 'wchar_t' type.
1527 dnl
1528 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1529 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1530 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1531 dnl       Where DEFAULT is either `yes' or `no'.
1532 dnl
1533 dnl Necessary support (probed along with C99 support) must also be present.
1534 dnl
1535 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1536   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1537   if test x"$ac_c99_wchar" = x"yes" && test x"$enable_wchar_t" = x"yes"; then
1538     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
1539               [Define if code specialized for wchar_t should be used.])
1540   fi
1541   AC_MSG_CHECKING([for enabled wchar_t specializations])
1542   AC_MSG_RESULT([$enable_wchar_t])
1543 ])
1544
1545
1546 dnl
1547 dnl Check to see if building and using a C++ precompiled header can be done.
1548 dnl
1549 dnl --enable-libstdcxx-pch=yes
1550 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1551 dnl may work, after some light-hearted attempts to puzzle out compiler
1552 dnl support, flip bits on in include/Makefile.am
1553 dnl
1554 dnl --disable-libstdcxx-pch
1555 dnl turns off attempts to use or build stdc++.h.gch.
1556 dnl
1557 dnl Substs:
1558 dnl  glibcxx_PCHFLAGS
1559 dnl
1560 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1561   AC_MSG_CHECKING([for enabled PCH])
1562   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1563   AC_MSG_RESULT([$enable_libstdcxx_pch])
1564
1565   if test $enable_libstdcxx_pch = yes; then
1566     AC_CACHE_CHECK([for compiler with PCH support],
1567       [glibcxx_cv_prog_CXX_pch],
1568       [ac_save_CXXFLAGS="$CXXFLAGS"
1569        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1570        AC_LANG_SAVE
1571        AC_LANG_CPLUSPLUS
1572        echo '#include <math.h>' > conftest.h
1573        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1574                           -o conftest.h.gch 1>&5 2>&1 &&
1575                 echo '#error "pch failed"' > conftest.h &&
1576           echo '#include "conftest.h"' > conftest.cc &&
1577                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1578        then
1579          glibcxx_cv_prog_CXX_pch=yes
1580        else
1581          glibcxx_cv_prog_CXX_pch=no
1582        fi
1583        rm -f conftest*
1584        CXXFLAGS=$ac_save_CXXFLAGS
1585        AC_LANG_RESTORE
1586       ])
1587     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1588   fi
1589
1590   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1591   if test $enable_libstdcxx_pch = yes; then
1592     glibcxx_PCHFLAGS="-include bits/stdc++.h"
1593   else
1594     glibcxx_PCHFLAGS=""
1595   fi
1596   AC_SUBST(glibcxx_PCHFLAGS)
1597 ])
1598
1599
1600 dnl
1601 dnl Check for exception handling support.  If an explicit enable/disable
1602 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1603 dnl target may or may not support call frame exceptions.
1604 dnl
1605 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1606 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1607 dnl Neither one forces an attempt at detection.
1608 dnl
1609 dnl Defines:
1610 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
1611 dnl
1612 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
1613   AC_MSG_CHECKING([for exception model to use])
1614   AC_LANG_SAVE
1615   AC_LANG_CPLUSPLUS
1616   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
1617     [force use of builtin_setjmp for exceptions],
1618     [permit yes|no|auto])
1619
1620   if test $enable_sjlj_exceptions = auto; then
1621     # Botheration.  Now we've got to detect the exception model.  Link tests
1622     # against libgcc.a are problematic since we've not been given proper -L
1623     # bits for single-tree newlib and libgloss.
1624     #
1625     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
1626     cat > conftest.$ac_ext << EOF
1627 [#]line __oline__ "configure"
1628 struct S { ~S(); };
1629 void bar();
1630 void foo()
1631 {
1632   S s;
1633   bar();
1634 }
1635 EOF
1636     old_CXXFLAGS="$CXXFLAGS"
1637     CXXFLAGS=-S
1638     if AC_TRY_EVAL(ac_compile); then
1639       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1640         enable_sjlj_exceptions=yes
1641       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1642         enable_sjlj_exceptions=no
1643       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
1644         enable_sjlj_exceptions=no
1645       fi
1646     fi
1647     CXXFLAGS="$old_CXXFLAGS"
1648     rm -f conftest*
1649   fi
1650
1651   # This is a tad weird, for hysterical raisins.  We have to map enable/disable
1652   # to two different models.
1653   case $enable_sjlj_exceptions in
1654     yes)
1655       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
1656         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1657       ac_exception_model_name=sjlj
1658       ;;
1659     no)
1660       ac_exception_model_name="call frame"
1661       ;;
1662     *)
1663       AC_MSG_ERROR([unable to detect exception model])
1664       ;;
1665   esac
1666  AC_LANG_RESTORE
1667  AC_MSG_RESULT($ac_exception_model_name)
1668 ])
1669
1670
1671 dnl
1672 dnl Add version tags to symbols in shared library (or not), additionally
1673 dnl marking other symbols as private/local (or not).
1674 dnl
1675 dnl --enable-symvers=style adds a version script to the linker call when
1676 dnl       creating the shared library.  The choice of version script is
1677 dnl       controlled by 'style'.
1678 dnl --disable-symvers does not.
1679 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
1680 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
1681 dnl       choose a default style based on linker characteristics.  Passing
1682 dnl       'no' disables versioning.
1683 dnl
1684 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
1685
1686 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
1687   [enables symbol versioning of the shared library],
1688   [permit yes|no|gnu|darwin-export])
1689
1690 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
1691 # don't know enough about $LD to do tricks...
1692 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
1693
1694 # Turn a 'yes' into a suitable default.
1695 if test x$enable_symvers = xyes ; then
1696   if test $enable_shared = no ||
1697      test "x$LD" = x ; then
1698     enable_symvers=no
1699   elif test $with_gnu_ld == yes ; then
1700     enable_symvers=gnu
1701   else
1702     case ${target_os} in
1703       darwin*)
1704         enable_symvers=darwin-export ;;
1705       *)
1706       AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
1707       AC_MSG_WARN([=== you are not using a supported linker.])
1708       AC_MSG_WARN([=== Symbol versioning will be disabled.])
1709         enable_symvers=no ;;
1710     esac
1711   fi
1712 fi
1713
1714 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
1715 if test $enable_symvers != no; then
1716   AC_MSG_CHECKING([for shared libgcc])
1717   ac_save_CFLAGS="$CFLAGS"
1718   CFLAGS=' -lgcc_s'
1719   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
1720   CFLAGS="$ac_save_CFLAGS"
1721   if test $glibcxx_shared_libgcc = no; then
1722     cat > conftest.c <<EOF
1723 int main (void) { return 0; }
1724 EOF
1725 changequote(,)dnl
1726     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
1727                              -shared -shared-libgcc -o conftest.so \
1728                              conftest.c -v 2>&1 >/dev/null \
1729                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
1730 changequote([,])dnl
1731     rm -f conftest.c conftest.so
1732     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
1733       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
1734       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
1735       CFLAGS="$ac_save_CFLAGS"
1736     fi
1737   fi
1738   AC_MSG_RESULT($glibcxx_shared_libgcc)
1739 fi
1740
1741 # If no shared libgcc, can't win.
1742 if test $glibcxx_shared_libgcc != yes &&
1743    test $enable_symvers != no ; then
1744     AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
1745     AC_MSG_WARN([=== you are not building a shared libgcc_s.])
1746     AC_MSG_WARN([=== Symbol versioning will be disabled.])
1747     enable_symvers=no
1748   enable_symvers=no
1749 fi
1750
1751 # Check to see if 'gnu' can win.
1752 if test $enable_symvers = gnu; then
1753   # For GNU ld, we need at least this version.  The format is described in
1754   # GLIBCXX_CHECK_LINKER_FEATURES above.
1755   glibcxx_min_gnu_ld_version=21400
1756
1757   if test $with_gnu_ld != yes ; then
1758     # just fail for now
1759     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
1760     AC_MSG_WARN([=== you are not using the GNU linker.])
1761     AC_MSG_WARN([=== Symbol versioning will be disabled.])
1762     enable_symvers=no
1763   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
1764     # The right tools, the right setup, but too old.  Fallbacks?
1765     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
1766     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
1767     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
1768     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
1769     AC_MSG_WARN([=== Symbol versioning will be disabled.])
1770     enable_symvers=no
1771   fi
1772 fi
1773
1774 # Everything parsed; figure out what file to use.
1775 case $enable_symvers in
1776   no)
1777     SYMVER_MAP=config/linker-map.dummy
1778     ;;
1779   gnu)
1780     SYMVER_MAP=config/linker-map.gnu
1781     AC_DEFINE(_GLIBCXX_SYMVER, 1,
1782               [Define to use GNU symbol versioning in the shared library.])
1783     ;;
1784   darwin-export)
1785     SYMVER_MAP=config/linker-map.gnu
1786     ;;
1787 esac
1788
1789 # In addition, need this to deal with std::size_t mangling in
1790 # src/compatibility.cc.  In a perfect world, could use
1791 # typeid(std::size_t).name()[0] to do direct substitution.
1792 AC_MSG_CHECKING([for size_t as unsigned int])
1793 ac_save_CFLAGS="$CFLAGS"
1794 CFLAGS="-Werror"
1795 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
1796                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
1797 CFLAGS=$ac_save_CFLAGS
1798 if test "$glibcxx_size_t_is_i" = yes; then
1799   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
1800 fi
1801 AC_MSG_RESULT([$glibcxx_size_t_is_i])
1802
1803 AC_MSG_CHECKING([for ptrdiff_t as int])
1804 ac_save_CFLAGS="$CFLAGS"
1805 CFLAGS="-Werror"
1806 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
1807                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
1808 CFLAGS=$ac_save_CFLAGS
1809 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
1810   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
1811 fi
1812 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
1813
1814 AC_SUBST(SYMVER_MAP)
1815 AC_SUBST(port_specific_symbol_files)
1816 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers == gnu)
1817 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN_EXPORT, dnl
1818   test $enable_symvers == darwin-export)
1819 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
1820 ])
1821
1822
1823 dnl
1824 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1825 dnl We must stage the required headers so that they will be installed
1826 dnl with the library (unlike libgcc, the STL implementation is provided
1827 dnl solely within headers).  Since we must not inject random user-space
1828 dnl macro names into user-provided C++ code, we first stage into <file>-in
1829 dnl and process to <file> with an output command.  The reason for a two-
1830 dnl stage process here is to correctly handle $srcdir!=$objdir without
1831 dnl having to write complex code (the sed commands to clean the macro
1832 dnl namespace are complex and fragile enough as it is).  We must also
1833 dnl add a relative path so that -I- is supported properly.
1834 dnl
1835 dnl Substs:
1836 dnl  glibcxx_thread_h
1837 dnl
1838 dnl Defines:
1839 dnl  HAVE_GTHR_DEFAULT
1840 dnl
1841 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
1842   AC_MSG_CHECKING([for thread model used by GCC])
1843   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
1844   AC_MSG_RESULT([$target_thread_file])
1845
1846   if test $target_thread_file != single; then
1847     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
1848               [Define if gthr-default.h exists
1849               (meaning that threading support is enabled).])
1850   fi
1851
1852   glibcxx_thread_h=gthr-$target_thread_file.h
1853
1854   dnl Check for __GTHREADS define.
1855   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
1856   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
1857     enable_thread=yes
1858   else
1859    enable_thread=no
1860   fi
1861
1862   AC_SUBST(glibcxx_thread_h)
1863 ])
1864
1865
1866 # Check whether LC_MESSAGES is available in <locale.h>.
1867 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1868 #
1869 # This file file be copied and used freely without restrictions.  It can
1870 # be used in projects which are not available under the GNU Public License
1871 # but which still want to provide support for the GNU gettext functionality.
1872 # Please note that the actual code is *not* freely available.
1873
1874 # serial 1
1875 AC_DEFUN([AC_LC_MESSAGES], [
1876   AC_CHECK_HEADER(locale.h, [
1877     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1878       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1879        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1880     if test $ac_cv_val_LC_MESSAGES = yes; then
1881       AC_DEFINE(HAVE_LC_MESSAGES, 1,
1882                 [Define if LC_MESSAGES is available in <locale.h>.])
1883     fi
1884   ])
1885 ])
1886
1887
1888 dnl vim:et:ts=2:sw=2