libstdc++-v3/acinclude.m4

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