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 math 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   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 805   ac_c99_complex=no;
 806   if test x"$ac_has_complex_h" = x"yes"; then
 807     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
 808     AC_TRY_COMPILE([#include <complex.h>],
 809                    [typedef __complex__ float float_type; float_type tmpf;
 810                     cabsf(tmpf);
 811                     cargf(tmpf);
 812                     ccosf(tmpf);
 813                     ccoshf(tmpf);
 814                     cexpf(tmpf);
 815                     clogf(tmpf);
 816                     csinf(tmpf);
 817                     csinhf(tmpf);
 818                     csqrtf(tmpf);
 819                     ctanf(tmpf);
 820                     ctanhf(tmpf);
 821                     cpowf(tmpf, tmpf);
 822                     typedef __complex__ double double_type; double_type tmpd;
 823                     cabs(tmpd);
 824                     carg(tmpd);
 825                     ccos(tmpd);
 826                     ccosh(tmpd);
 827                     cexp(tmpd);
 828                     clog(tmpd);
 829                     csin(tmpd);
 830                     csinh(tmpd);
 831                     csqrt(tmpd);
 832                     ctan(tmpd);
 833                     ctanh(tmpd);
 834                     cpow(tmpd, tmpd);
 835                     typedef __complex__ long double ld_type; ld_type tmpld;
 836                     cabsl(tmpld);
 837                     cargl(tmpld);
 838                     ccosl(tmpld);
 839                     ccoshl(tmpld);
 840                     cexpl(tmpld);
 841                     clogl(tmpld);
 842                     csinl(tmpld);
 843                     csinhl(tmpld);
 844                     csqrtl(tmpld);
 845                     ctanl(tmpld);
 846                     ctanhl(tmpld);
 847                     cpowl(tmpld, tmpld);
 848                    ],[ac_c99_complex=yes], [ac_c99_complex=no])
 849   fi
 850   AC_MSG_RESULT($ac_c99_complex)
 851   if test x"$ac_c99_complex" = x"yes"; then
 852     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 853               [Define if C99 functions in <complex.h> should be used in
 854               <complex>. Using compiler builtins for these functions requires
 855               corresponding C99 library functions to be present.])
 856   fi
 857
 858   # Check for the existence in <stdio.h> of vscanf, et. al.
 859   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 860   AC_CACHE_VAL(ac_c99_stdio, [
 861   AC_TRY_COMPILE([#include <stdio.h>
 862                   #include <stdarg.h>
 863                   void foo(char* fmt, ...)
 864                   {
 865                     va_list args; va_start(args, fmt);
 866                     vfscanf(stderr, "%i", args);
 867                     vscanf("%i", args);
 868                     vsnprintf(fmt, 0, "%i", args);
 869                     vsscanf(fmt, "%i", args);
 870                   }],
 871                  [snprintf("12", 0, "%i");],
 872                  [ac_c99_stdio=yes], [ac_c99_stdio=no])
 873   ])
 874   AC_MSG_RESULT($ac_c99_stdio)
 875
 876   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
 877   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
 878   AC_CACHE_VAL(ac_c99_stdlib, [
 879   AC_TRY_COMPILE([#include <stdlib.h>],
 880                  [char* tmp;
 881                   strtof("gnu", &tmp);
 882                   strtold("gnu", &tmp);
 883                   strtoll("gnu", &tmp, 10);
 884                   strtoull("gnu", &tmp, 10);
 885                   llabs(10);
 886                   lldiv(10,1);
 887                   atoll("10");
 888                   _Exit(0);
 889                   lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
 890   ])
 891   AC_MSG_RESULT($ac_c99_stdlib)
 892
 893   # Check for the existence in <wchar.h> of wcstoull, WEOF, etc.
 894   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
 895   ac_c99_wchar=no;
 896   if test x"$ac_has_wchar_h" = xyes &&
 897      test x"$ac_has_wctype_h" = xyes; then
 898     AC_TRY_COMPILE([#include <wchar.h>
 899                     #include <stddef.h>
 900                     wint_t i;
 901                     long l = WEOF;
 902                     long j = WCHAR_MIN;
 903                     long k = WCHAR_MAX;
 904                     namespace test
 905                     {
 906                       using ::btowc;
 907                       using ::fgetwc;
 908                       using ::fgetws;
 909                       using ::fputwc;
 910                       using ::fputws;
 911                       using ::fwide;
 912                       using ::fwprintf;
 913                       using ::fwscanf;
 914                       using ::getwc;
 915                       using ::getwchar;
 916                       using ::mbrlen;
 917                       using ::mbrtowc;
 918                       using ::mbsinit;
 919                       using ::mbsrtowcs;
 920                       using ::putwc;
 921                       using ::putwchar;
 922                       using ::swprintf;
 923                       using ::swscanf;
 924                       using ::ungetwc;
 925                       using ::vfwprintf;
 926                       using ::vswprintf;
 927                       using ::vwprintf;
 928                       using ::wcrtomb;
 929                       using ::wcscat;
 930                       using ::wcschr;
 931                       using ::wcscmp;
 932                       using ::wcscoll;
 933                       using ::wcscpy;
 934                       using ::wcscspn;
 935                       using ::wcsftime;
 936                       using ::wcslen;
 937                       using ::wcsncat;
 938                       using ::wcsncmp;
 939                       using ::wcsncpy;
 940                       using ::wcspbrk;
 941                       using ::wcsrchr;
 942                       using ::wcsrtombs;
 943                       using ::wcsspn;
 944                       using ::wcsstr;
 945                       using ::wcstod;
 946                       using ::wcstok;
 947                       using ::wcstol;
 948                       using ::wcstold;
 949                       using ::wcstoll;
 950                       using ::wcstoul;
 951                       using ::wcstoull;
 952                       using ::wcsxfrm;
 953                       using ::wctob;
 954                       using ::wmemchr;
 955                       using ::wmemcmp;
 956                       using ::wmemcpy;
 957                       using ::wmemmove;
 958                       using ::wmemset;
 959                       using ::wprintf;
 960                       using ::wscanf;
 961                     }
 962                    ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
 963
 964     # Checks for wide character functions that may not be present.
 965     # Injection of these is wrapped with guard macros.
 966     # NB: only put functions here, instead of immediately above, if
 967     # absolutely necessary.
 968     AC_TRY_COMPILE([#include <wchar.h>
 969                     namespace test { using ::vfwscanf; } ], [],
 970                    [AC_DEFINE(HAVE_VFWSCANF,1,
 971                         [Defined if vfwscanf exists.])],[])
 972
 973     AC_TRY_COMPILE([#include <wchar.h>
 974                     namespace test { using ::vswscanf; } ], [],
 975                    [AC_DEFINE(HAVE_VSWSCANF,1,
 976                         [Defined if vswscanf exists.])],[])
 977
 978     AC_TRY_COMPILE([#include <wchar.h>
 979                     namespace test { using ::vwscanf; } ], [],
 980                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
 981
 982     AC_TRY_COMPILE([#include <wchar.h>
 983                     namespace test { using ::wcstof; } ], [],
 984                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
 985
 986     AC_TRY_COMPILE([#include <wctype.h>],
 987                    [ wint_t t; int i = iswblank(t);],
 988                    [AC_DEFINE(HAVE_ISWBLANK,1,
 989                         [Defined if iswblank exists.])],[])
 990
 991     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
 992     AC_MSG_RESULT($ac_c99_wchar)
 993   fi
 994
 995   # Option parsed, now set things appropriately.
 996   if test x"$ac_c99_math" = x"no" ||
 997      test x"$ac_c99_complex" = x"no" ||
 998      test x"$ac_c99_stdio" = x"no" ||
 999      test x"$ac_c99_stdlib" = x"no" ||
1000      test x"$ac_c99_wchar" = x"no"; then
1001     enable_c99=no;
1002   else
1003     AC_DEFINE(_GLIBCXX_USE_C99, 1,
1004     [Define if C99 functions or macros from <wchar.h>, <math.h>,
1005     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1006   fi
1007
1008   AC_LANG_RESTORE
1009   fi
1010
1011   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1012   AC_MSG_RESULT($enable_c99)
1013 ])
1014
1015
1016 dnl
1017 dnl Check for what type of C headers to use.
1018 dnl
1019 dnl --enable-cheaders= [does stuff].
1020 dnl --disable-cheaders [does not do anything, really].
1021 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1022 dnl       Where DEFAULT is either `c' or `c_std'.
1023 dnl
1024 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1025   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1026     [construct "C" headers for g++], [permit c|c_std])
1027   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1028
1029   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1030
1031   AC_SUBST(C_INCLUDE_DIR)
1032   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1033   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1034   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1035 ])
1036
1037
1038 dnl
1039 dnl Check for which locale library to use.  The choice is mapped to
1040 dnl a subdirectory of config/locale.
1041 dnl
1042 dnl Default is generic.
1043 dnl
1044 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1045   AC_MSG_CHECKING([for C locale to use])
1046   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1047     [use MODEL for target locale package],
1048     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1049
1050   # If they didn't use this option switch, or if they specified --enable
1051   # with no specific model, we'll have to look for one.  If they
1052   # specified --disable (???), do likewise.
1053   if test $enable_clocale = no || test $enable_clocale = yes; then
1054      enable_clocale=auto
1055   fi
1056
1057   # Either a known package, or "auto"
1058   enable_clocale_flag=$enable_clocale
1059
1060   # Probe for locale support if no specific model is specified.
1061   # Default to "generic".
1062   if test $enable_clocale_flag = auto; then
1063     case ${target_os} in
1064       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1065         AC_EGREP_CPP([_GLIBCXX_ok], [
1066         #include <features.h>
1067         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1068           _GLIBCXX_ok
1069         #endif
1070         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1071
1072         # Test for bugs early in glibc-2.2.x series
1073           if test $enable_clocale_flag = gnu; then
1074           AC_TRY_RUN([
1075           #define _GNU_SOURCE 1
1076           #include <locale.h>
1077           #include <string.h>
1078           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1079           extern __typeof(newlocale) __newlocale;
1080           extern __typeof(duplocale) __duplocale;
1081           extern __typeof(strcoll_l) __strcoll_l;
1082           #endif
1083           int main()
1084           {
1085               const char __one[] = "Äuglein Augmen";
1086               const char __two[] = "Äuglein";
1087               int i;
1088               int j;
1089               __locale_t        loc;
1090                __locale_t        loc_dup;
1091               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1092               loc_dup = __duplocale(loc);
1093               i = __strcoll_l(__one, __two, loc);
1094               j = __strcoll_l(__one, __two, loc_dup);
1095               return 0;
1096           }
1097           ],
1098           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1099           [enable_clocale_flag=generic])
1100           fi
1101
1102         # ... at some point put __strxfrm_l tests in as well.
1103         ;;
1104       darwin* | freebsd*)
1105         enable_clocale_flag=darwin
1106         ;;
1107       *)
1108         enable_clocale_flag=generic
1109         ;;
1110     esac
1111   fi
1112
1113   # Deal with gettext issues.  Default to not using it (=no) until we detect
1114   # support for it later.  Let the user turn it off via --e/d, but let that
1115   # default to on for easier handling.
1116   USE_NLS=no
1117   AC_ARG_ENABLE(nls,
1118     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1119     [],
1120     [enable_nls=yes])
1121
1122   # Set configure bits for specified locale package
1123   case ${enable_clocale_flag} in
1124     generic)
1125       AC_MSG_RESULT(generic)
1126
1127       CLOCALE_H=config/locale/generic/c_locale.h
1128       CLOCALE_CC=config/locale/generic/c_locale.cc
1129       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1130       CCOLLATE_CC=config/locale/generic/collate_members.cc
1131       CCTYPE_CC=config/locale/generic/ctype_members.cc
1132       CMESSAGES_H=config/locale/generic/messages_members.h
1133       CMESSAGES_CC=config/locale/generic/messages_members.cc
1134       CMONEY_CC=config/locale/generic/monetary_members.cc
1135       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1136       CTIME_H=config/locale/generic/time_members.h
1137       CTIME_CC=config/locale/generic/time_members.cc
1138       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1139       ;;
1140     darwin)
1141       AC_MSG_RESULT(darwin or freebsd)
1142
1143       CLOCALE_H=config/locale/generic/c_locale.h
1144       CLOCALE_CC=config/locale/generic/c_locale.cc
1145       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1146       CCOLLATE_CC=config/locale/generic/collate_members.cc
1147       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1148       CMESSAGES_H=config/locale/generic/messages_members.h
1149       CMESSAGES_CC=config/locale/generic/messages_members.cc
1150       CMONEY_CC=config/locale/generic/monetary_members.cc
1151       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1152       CTIME_H=config/locale/generic/time_members.h
1153       CTIME_CC=config/locale/generic/time_members.cc
1154       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1155       ;;
1156
1157     gnu)
1158       AC_MSG_RESULT(gnu)
1159
1160       # Declare intention to use gettext, and add support for specific
1161       # languages.
1162       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1163       ALL_LINGUAS="de fr"
1164
1165       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1166       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1167       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1168         USE_NLS=yes
1169       fi
1170       # Export the build objects.
1171       for ling in $ALL_LINGUAS; do \
1172         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1173         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1174       done
1175       AC_SUBST(glibcxx_MOFILES)
1176       AC_SUBST(glibcxx_POFILES)
1177
1178       CLOCALE_H=config/locale/gnu/c_locale.h
1179       CLOCALE_CC=config/locale/gnu/c_locale.cc
1180       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1181       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1182       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1183       CMESSAGES_H=config/locale/gnu/messages_members.h
1184       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1185       CMONEY_CC=config/locale/gnu/monetary_members.cc
1186       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1187       CTIME_H=config/locale/gnu/time_members.h
1188       CTIME_CC=config/locale/gnu/time_members.cc
1189       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1190       ;;
1191     ieee_1003.1-2001)
1192       AC_MSG_RESULT(IEEE 1003.1)
1193
1194       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1195       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1196       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1197       CCOLLATE_CC=config/locale/generic/collate_members.cc
1198       CCTYPE_CC=config/locale/generic/ctype_members.cc
1199       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1200       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1201       CMONEY_CC=config/locale/generic/monetary_members.cc
1202       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1203       CTIME_H=config/locale/generic/time_members.h
1204       CTIME_CC=config/locale/generic/time_members.cc
1205       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1206       ;;
1207   esac
1208
1209   # This is where the testsuite looks for locale catalogs, using the
1210   # -DLOCALEDIR define during testsuite compilation.
1211   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1212   AC_SUBST(glibcxx_localedir)
1213
1214   # A standalone libintl (e.g., GNU libintl) may be in use.
1215   if test $USE_NLS = yes; then
1216     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1217     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1218   fi
1219   if test $USE_NLS = yes; then
1220     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1221               [Define if NLS translations are to be used.])
1222   fi
1223
1224   AC_SUBST(USE_NLS)
1225   AC_SUBST(CLOCALE_H)
1226   AC_SUBST(CMESSAGES_H)
1227   AC_SUBST(CCODECVT_CC)
1228   AC_SUBST(CCOLLATE_CC)
1229   AC_SUBST(CCTYPE_CC)
1230   AC_SUBST(CMESSAGES_CC)
1231   AC_SUBST(CMONEY_CC)
1232   AC_SUBST(CNUMERIC_CC)
1233   AC_SUBST(CTIME_H)
1234   AC_SUBST(CTIME_CC)
1235   AC_SUBST(CLOCALE_CC)
1236   AC_SUBST(CLOCALE_INTERNAL_H)
1237 ])
1238
1239
1240 dnl
1241 dnl Check for which std::allocator base class to use.  The choice is
1242 dnl mapped from a subdirectory of include/ext.
1243 dnl
1244 dnl Default is new.
1245 dnl
1246 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1247   AC_MSG_CHECKING([for std::allocator base class])
1248   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1249     [use KIND for target std::allocator base],
1250     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1251
1252   # If they didn't use this option switch, or if they specified --enable
1253   # with no specific model, we'll have to look for one.  If they
1254   # specified --disable (???), do likewise.
1255   if test $enable_libstdcxx_allocator = no ||
1256      test $enable_libstdcxx_allocator = yes;
1257   then
1258      enable_libstdcxx_allocator=auto
1259   fi
1260
1261   # Either a known package, or "auto". Auto implies the default choice
1262   # for a particular platform.
1263   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1264
1265   # Probe for host-specific support if no specific model is specified.
1266   # Default to "new".
1267   if test $enable_libstdcxx_allocator_flag = auto; then
1268     case ${target_os} in
1269       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1270         enable_libstdcxx_allocator_flag=mt
1271         ;;
1272       *)
1273         enable_libstdcxx_allocator_flag=new
1274         ;;
1275     esac
1276   fi
1277   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1278
1279
1280   # Set configure bits for specified locale package
1281   case ${enable_libstdcxx_allocator_flag} in
1282     bitmap)
1283       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1284       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1285       ;;
1286     malloc)
1287       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1288       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1289       ;;
1290     mt)
1291       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1292       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1293       ;;
1294     new)
1295       ALLOCATOR_H=config/allocator/new_allocator_base.h
1296       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1297       ;;
1298     pool)
1299       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1300       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1301       ;;
1302   esac
1303
1304   AC_SUBST(ALLOCATOR_H)
1305   AC_SUBST(ALLOCATOR_NAME)
1306 ])
1307
1308
1309 dnl
1310 dnl Check for whether the Boost-derived checks should be turned on.
1311 dnl
1312 dnl --enable-concept-checks turns them on.
1313 dnl --disable-concept-checks leaves them off.
1314 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1315 dnl       Where DEFAULT is either `yes' or `no'.
1316 dnl
1317 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1318   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1319   if test $enable_concept_checks = yes; then
1320     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1321               [Define to use concept checking code from the boost libraries.])
1322   fi
1323 ])
1324
1325
1326 dnl
1327 dnl Check for which I/O library to use:  stdio, or something specific.
1328 dnl
1329 dnl Default is stdio.
1330 dnl
1331 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1332   AC_MSG_CHECKING([for underlying I/O to use])
1333   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1334     [use target-specific I/O package], [permit stdio])
1335
1336   # Now that libio has been removed, you can have any color you want as long
1337   # as it's black.  This is one big no-op until other packages are added, but
1338   # showing the framework never hurts.
1339   case ${enable_cstdio} in
1340     stdio)
1341       CSTDIO_H=config/io/c_io_stdio.h
1342       BASIC_FILE_H=config/io/basic_file_stdio.h
1343       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1344       AC_MSG_RESULT(stdio)
1345       ;;
1346   esac
1347
1348   AC_SUBST(CSTDIO_H)
1349   AC_SUBST(BASIC_FILE_H)
1350   AC_SUBST(BASIC_FILE_CC)
1351 ])
1352
1353
1354 dnl
1355 dnl Check for "unusual" flags to pass to the compiler while building.
1356 dnl
1357 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1358 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1359 dnl --disable-cxx-flags passes nothing.
1360 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1361 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1362 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1363 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1364 dnl       If "default flags" is an empty string, the effect is the same
1365 dnl       as --disable or --enable=no.
1366 dnl
1367 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1368   AC_MSG_CHECKING([for extra compiler flags for building])
1369   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1370     [pass compiler FLAGS when building library],
1371     [case "x$enable_cxx_flags" in
1372       xno | x)   enable_cxx_flags= ;;
1373       x-*)       ;;
1374       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1375      esac])
1376
1377   # Run through flags (either default or command-line) and set anything
1378   # extra (e.g., #defines) that must accompany particular g++ options.
1379   if test -n "$enable_cxx_flags"; then
1380     for f in $enable_cxx_flags; do
1381       case "$f" in
1382         -fhonor-std)  ;;
1383         -*)  ;;
1384         *)   # and we're trying to pass /what/ exactly?
1385              AC_MSG_ERROR([compiler flags start with a -]) ;;
1386       esac
1387     done
1388   fi
1389
1390   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1391   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1392   AC_SUBST(EXTRA_CXX_FLAGS)
1393 ])
1394
1395
1396 dnl
1397 dnl Check to see if debugging libraries are to be built.
1398 dnl
1399 dnl --enable-libstdcxx-debug
1400 dnl builds a separate set of debugging libraries in addition to the
1401 dnl normal (shared, static) libstdc++ binaries.
1402 dnl
1403 dnl --disable-libstdcxx-debug
1404 dnl builds only one (non-debug) version of libstdc++.
1405 dnl
1406 dnl --enable-libstdcxx-debug-flags=FLAGS
1407 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1408 dnl
1409 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1410 dnl       Where DEFAULT is either `yes' or `no'.
1411 dnl
1412 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1413   AC_MSG_CHECKING([for additional debug build])
1414   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1415   AC_MSG_RESULT($enable_libstdcxx_debug)
1416   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1417 ])
1418
1419
1420 dnl
1421 dnl Check for explicit debug flags.
1422 dnl
1423 dnl --enable-libstdcxx-debug-flags='-O1'
1424 dnl is a general method for passing flags to be used when
1425 dnl building debug libraries with --enable-debug.
1426 dnl
1427 dnl --disable-libstdcxx-debug-flags does nothing.
1428 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1429 dnl       If "default flags" is an empty string, the effect is the same
1430 dnl       as --disable or --enable=no.
1431 dnl
1432 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1433   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1434     [pass compiler FLAGS when building debug library],
1435     [case "x$enable_libstdcxx_debug_flags" in
1436       xno | x)    enable_libstdcxx_debug_flags= ;;
1437       x-*)        ;;
1438       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1439      esac])
1440
1441   # Option parsed, now set things appropriately
1442   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1443   AC_SUBST(DEBUG_FLAGS)
1444
1445   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1446 ])
1447
1448
1449 dnl
1450 dnl Check if the user only wants a freestanding library implementation.
1451 dnl
1452 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1453 dnl installing only the headers required by [17.4.1.3] and the language
1454 dnl support library.  More than that will be built (to keep the Makefiles
1455 dnl conveniently clean), but not installed.
1456 dnl
1457 dnl Sets:
1458 dnl  is_hosted  (yes/no)
1459 dnl
1460 dnl Defines:
1461 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1462 dnl
1463 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1464   AC_ARG_ENABLE([hosted-libstdcxx],
1465     AC_HELP_STRING([--disable-hosted-libstdcxx],
1466                    [only build freestanding C++ runtime support]),,
1467     [case "$host" in
1468         arm*-*-symbianelf*)
1469             enable_hosted_libstdcxx=no
1470             ;;
1471         *)
1472             enable_hosted_libstdcxx=yes
1473             ;;
1474      esac])
1475   if test "$enable_hosted_libstdcxx" = no; then
1476     AC_MSG_NOTICE([Only freestanding libraries will be built])
1477     is_hosted=no
1478     hosted_define=0
1479     enable_abi_check=no
1480     enable_libstdcxx_pch=no
1481   else
1482     is_hosted=yes
1483     hosted_define=1
1484   fi
1485   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1486   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1487     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1488 ])
1489
1490
1491 dnl
1492 dnl Check for template specializations for the 'long long' type.
1493 dnl The result determines only whether 'long long' I/O is enabled; things
1494 dnl like numeric_limits<> specializations are always available.
1495 dnl
1496 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1497 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1498 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1499 dnl       Where DEFAULT is either `yes' or `no'.
1500 dnl
1501 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1502   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1503   if test $enable_long_long = yes; then
1504     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1505               [Define if code specialized for long long should be used.])
1506   fi
1507   AC_MSG_CHECKING([for enabled long long specializations])
1508   AC_MSG_RESULT([$enable_long_long])
1509 ])
1510
1511
1512 dnl
1513 dnl Check for template specializations for the 'wchar_t' type.
1514 dnl
1515 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1516 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1517 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1518 dnl       Where DEFAULT is either `yes' or `no'.
1519 dnl
1520 dnl Necessary support (probed along with C99 support) must also be present.
1521 dnl
1522 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1523   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1524   if test x"$ac_c99_wchar" = x"yes" && test x"$enable_wchar_t" = x"yes"; then
1525     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
1526               [Define if code specialized for wchar_t should be used.])
1527   fi
1528   AC_MSG_CHECKING([for enabled wchar_t specializations])
1529   AC_MSG_RESULT([$enable_wchar_t])
1530 ])
1531
1532
1533 dnl
1534 dnl Check to see if building and using a C++ precompiled header can be done.
1535 dnl
1536 dnl --enable-libstdcxx-pch=yes
1537 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1538 dnl may work, after some light-hearted attempts to puzzle out compiler
1539 dnl support, flip bits on in include/Makefile.am
1540 dnl
1541 dnl --disable-libstdcxx-pch
1542 dnl turns off attempts to use or build stdc++.h.gch.
1543 dnl
1544 dnl Substs:
1545 dnl  glibcxx_PCHFLAGS
1546 dnl
1547 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1548   AC_MSG_CHECKING([for enabled PCH])
1549   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1550   AC_MSG_RESULT([$enable_libstdcxx_pch])
1551
1552   if test $enable_libstdcxx_pch = yes; then
1553     AC_CACHE_CHECK([for compiler with PCH support],
1554       [glibcxx_cv_prog_CXX_pch],
1555       [ac_save_CXXFLAGS="$CXXFLAGS"
1556        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1557        AC_LANG_SAVE
1558        AC_LANG_CPLUSPLUS
1559        echo '#include <math.h>' > conftest.h
1560        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1561                           -o conftest.h.gch 1>&5 2>&1 &&
1562                 echo '#error "pch failed"' > conftest.h &&
1563           echo '#include "conftest.h"' > conftest.cc &&
1564                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1565        then
1566          glibcxx_cv_prog_CXX_pch=yes
1567        else
1568          glibcxx_cv_prog_CXX_pch=no
1569        fi
1570        rm -f conftest*
1571        CXXFLAGS=$ac_save_CXXFLAGS
1572        AC_LANG_RESTORE
1573       ])
1574     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1575   fi
1576
1577   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1578   if test $enable_libstdcxx_pch = yes; then
1579     glibcxx_PCHFLAGS="-include bits/stdc++.h"
1580   else
1581     glibcxx_PCHFLAGS=""
1582   fi
1583   AC_SUBST(glibcxx_PCHFLAGS)
1584 ])
1585
1586
1587 dnl
1588 dnl Check for exception handling support.  If an explicit enable/disable
1589 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1590 dnl target may or may not support call frame exceptions.
1591 dnl
1592 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1593 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1594 dnl Neither one forces an attempt at detection.
1595 dnl
1596 dnl Defines:
1597 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
1598 dnl
1599 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
1600   AC_MSG_CHECKING([for exception model to use])
1601   AC_LANG_SAVE
1602   AC_LANG_CPLUSPLUS
1603   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
1604     [force use of builtin_setjmp for exceptions],
1605     [permit yes|no|auto])
1606
1607   if test $enable_sjlj_exceptions = auto; then
1608     # Botheration.  Now we've got to detect the exception model.  Link tests
1609     # against libgcc.a are problematic since we've not been given proper -L
1610     # bits for single-tree newlib and libgloss.
1611     #
1612     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
1613     cat > conftest.$ac_ext << EOF
1614 [#]line __oline__ "configure"
1615 struct S { ~S(); };
1616 void bar();
1617 void foo()
1618 {
1619   S s;
1620   bar();
1621 }
1622 EOF
1623     old_CXXFLAGS="$CXXFLAGS"
1624     CXXFLAGS=-S
1625     if AC_TRY_EVAL(ac_compile); then
1626       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1627         enable_sjlj_exceptions=yes
1628       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1629         enable_sjlj_exceptions=no
1630       fi
1631     fi
1632     CXXFLAGS="$old_CXXFLAGS"
1633     rm -f conftest*
1634   fi
1635
1636   # This is a tad weird, for hysterical raisins.  We have to map enable/disable
1637   # to two different models.
1638   case $enable_sjlj_exceptions in
1639     yes)
1640       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
1641         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1642       ac_exception_model_name=sjlj
1643       ;;
1644     no)
1645       ac_exception_model_name="call frame"
1646       ;;
1647     *)
1648       AC_MSG_ERROR([unable to detect exception model])
1649       ;;
1650   esac
1651  AC_LANG_RESTORE
1652  AC_MSG_RESULT($ac_exception_model_name)
1653 ])
1654
1655
1656 dnl
1657 dnl Add version tags to symbols in shared library (or not), additionally
1658 dnl marking other symbols as private/local (or not).
1659 dnl
1660 dnl --enable-symvers=style adds a version script to the linker call when
1661 dnl       creating the shared library.  The choice of version script is
1662 dnl       controlled by 'style'.
1663 dnl --disable-symvers does not.
1664 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
1665 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
1666 dnl       choose a default style based on linker characteristics.  Passing
1667 dnl       'no' disables versioning.
1668 dnl
1669 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
1670
1671 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
1672   [enables symbol versioning of the shared library],
1673   [permit yes|no|gnu])
1674
1675 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
1676 # don't know enough about $LD to do tricks...
1677 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
1678 # FIXME  The following test is too strict, in theory.
1679 if test $enable_shared = no ||
1680         test "x$LD" = x ||
1681         test x$glibcxx_gnu_ld_version = x; then
1682   enable_symvers=no
1683 fi
1684
1685 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
1686 if test $enable_symvers != no; then
1687   AC_MSG_CHECKING([for shared libgcc])
1688   ac_save_CFLAGS="$CFLAGS"
1689   CFLAGS=' -lgcc_s'
1690   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
1691   CFLAGS="$ac_save_CFLAGS"
1692   if test $glibcxx_shared_libgcc = no; then
1693     cat > conftest.c <<EOF
1694 int main (void) { return 0; }
1695 EOF
1696 changequote(,)dnl
1697     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
1698                              -shared -shared-libgcc -o conftest.so \
1699                              conftest.c -v 2>&1 >/dev/null \
1700                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
1701 changequote([,])dnl
1702     rm -f conftest.c conftest.so
1703     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
1704       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
1705       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
1706       CFLAGS="$ac_save_CFLAGS"
1707     fi
1708   fi
1709   AC_MSG_RESULT($glibcxx_shared_libgcc)
1710 fi
1711
1712 # For GNU ld, we need at least this version.  The format is described in
1713 # GLIBCXX_CHECK_LINKER_FEATURES above.
1714 # Need 21590 because of compatibility.cc's asm .symver strings for GLIBCXX_3.4.
1715 glibcxx_min_gnu_ld_version=21590
1716
1717 # Check to see if unspecified "yes" value can win, given results above.
1718 # Change "yes" into either "no" or a style name.
1719 if test $enable_symvers = yes; then
1720   if test $with_gnu_ld = yes &&
1721      test $glibcxx_shared_libgcc = yes;
1722   then
1723     if test $glibcxx_gnu_ld_version -ge $glibcxx_min_gnu_ld_version ; then
1724       enable_symvers=gnu
1725     else
1726       # The right tools, the right setup, but too old.  Fallbacks?
1727       AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
1728       AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
1729       AC_MSG_WARN(=== You would need to upgrade your binutils to version)
1730       AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
1731       if test $glibcxx_gnu_ld_version -ge 21200 ; then
1732         # Globbing fix is present, proper block support is not.
1733         AC_MSG_WARN([=== Symbol versioning will be disabled.])
1734         enable_symvers=no
1735       else
1736         # 2.11 or older.
1737         AC_MSG_WARN([=== Symbol versioning will be disabled.])
1738         enable_symvers=no
1739       fi
1740     fi
1741   else
1742     # just fail for now
1743     AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
1744     AC_MSG_WARN([=== either you are not using a supported linker, or you are])
1745     AC_MSG_WARN([=== not building a shared libgcc_s (which is required).])
1746     AC_MSG_WARN([=== Symbol versioning will be disabled.])
1747     enable_symvers=no
1748   fi
1749 fi
1750
1751 # Everything parsed; figure out what file to use.
1752 case $enable_symvers in
1753   no)
1754     SYMVER_MAP=config/linker-map.dummy
1755     ;;
1756   gnu)
1757     SYMVER_MAP=config/linker-map.gnu
1758     AC_DEFINE(_GLIBCXX_SYMVER, 1,
1759               [Define to use symbol versioning in the shared library.])
1760     ;;
1761 esac
1762
1763 AH_VERBATIM([_GLIBCXX_SYMVERextra],
1764 [/* Define symbol versioning in assember directives. If symbol
1765    versioning is being used, and the assembler supports this kind of
1766    thing, then use it.
1767
1768    NB: _GLIBCXX_AT_AT is a hack to work around quoting issues in m4. */
1769
1770 #if _GLIBCXX_SYMVER
1771   #define _GLIBCXX_ASM_SYMVER(cur, old, version) \
1772    asm (".symver " #cur "," #old _GLIBCXX_AT_AT #version);
1773 #else
1774   #define _GLIBCXX_ASM_SYMVER(cur, old, version)
1775 #endif])
1776
1777 # In addition, need this to deal with std::size_t mangling in
1778 # src/compatibility.cc.  In a perfect world, could use
1779 # typeid(std::size_t).name()[0] to do direct substitution.
1780 AC_MSG_CHECKING([for size_t as unsigned int])
1781 ac_save_CFLAGS="$CFLAGS"
1782 CFLAGS="-Werror"
1783 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
1784                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
1785 CFLAGS=$ac_save_CFLAGS
1786 if test "$glibcxx_size_t_is_i" = yes; then
1787   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
1788 fi
1789 AC_MSG_RESULT([$glibcxx_size_t_is_i])
1790
1791 AC_MSG_CHECKING([for ptrdiff_t as int])
1792 ac_save_CFLAGS="$CFLAGS"
1793 CFLAGS="-Werror"
1794 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
1795                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
1796 CFLAGS=$ac_save_CFLAGS
1797 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
1798   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
1799 fi
1800 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
1801
1802 AC_SUBST(SYMVER_MAP)
1803 AC_SUBST(port_specific_symbol_files)
1804 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
1805 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
1806 ])
1807
1808
1809 dnl
1810 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1811 dnl We must stage the required headers so that they will be installed
1812 dnl with the library (unlike libgcc, the STL implementation is provided
1813 dnl solely within headers).  Since we must not inject random user-space
1814 dnl macro names into user-provided C++ code, we first stage into <file>-in
1815 dnl and process to <file> with an output command.  The reason for a two-
1816 dnl stage process here is to correctly handle $srcdir!=$objdir without
1817 dnl having to write complex code (the sed commands to clean the macro
1818 dnl namespace are complex and fragile enough as it is).  We must also
1819 dnl add a relative path so that -I- is supported properly.
1820 dnl
1821 dnl Substs:
1822 dnl  glibcxx_thread_h
1823 dnl
1824 dnl Defines:
1825 dnl  HAVE_GTHR_DEFAULT
1826 dnl
1827 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
1828   AC_MSG_CHECKING([for thread model used by GCC])
1829   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
1830   AC_MSG_RESULT([$target_thread_file])
1831
1832   if test $target_thread_file != single; then
1833     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
1834               [Define if gthr-default.h exists
1835               (meaning that threading support is enabled).])
1836   fi
1837
1838   glibcxx_thread_h=gthr-$target_thread_file.h
1839
1840   dnl Check for __GTHREADS define.
1841   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
1842   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
1843     enable_thread=yes
1844   else
1845    enable_thread=no
1846   fi
1847
1848   AC_SUBST(glibcxx_thread_h)
1849 ])
1850
1851
1852 # Check whether LC_MESSAGES is available in <locale.h>.
1853 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1854 #
1855 # This file file be copied and used freely without restrictions.  It can
1856 # be used in projects which are not available under the GNU Public License
1857 # but which still want to provide support for the GNU gettext functionality.
1858 # Please note that the actual code is *not* freely available.
1859
1860 # serial 1
1861 AC_DEFUN([AC_LC_MESSAGES], [
1862   AC_CHECK_HEADER(locale.h, [
1863     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1864       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1865        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1866     if test $ac_cv_val_LC_MESSAGES = yes; then
1867       AC_DEFINE(HAVE_LC_MESSAGES, 1,
1868                 [Define if LC_MESSAGES is available in <locale.h>.])
1869     fi
1870   ])
1871 ])
1872
1873
1874 dnl vim:et:ts=2:sw=2