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