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