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