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 dnl
1272 dnl Check whether "dev/random" and "dev/urandom" are available for the
1273 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1274 dnl
1275 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1276
1277   AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1278   AC_CACHE_VAL(ac_random_tr1, [
1279   AC_TRY_RUN([#include <stdio.h>
1280               int main()
1281               {
1282                 return !(fopen("/dev/random", "r")
1283                          && fopen("/dev/urandom", "r"));
1284               }
1285              ],
1286              [ac_random_tr1=yes], [ac_random_tr1=no],
1287              [ac_random_tr1=no])
1288   ])
1289   AC_MSG_RESULT($ac_random_tr1)
1290   if test x"$ac_random_tr1" = x"yes"; then
1291     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1292               [Define if dev/random and dev/urandom are available for
1293                the random_device of TR1 (Chapter 5.1).])
1294   fi
1295
1296 ])
1297
1298 dnl
1299 dnl Check for what type of C headers to use.
1300 dnl
1301 dnl --enable-cheaders= [does stuff].
1302 dnl --disable-cheaders [does not do anything, really].
1303 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1304 dnl       Where DEFAULT is either `c' or `c_std'.
1305 dnl
1306 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1307   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1308     [construct "C" headers for g++], [permit c|c_std])
1309   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1310
1311   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1312
1313   AC_SUBST(C_INCLUDE_DIR)
1314   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1315   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1316   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1317 ])
1318
1319
1320 dnl
1321 dnl Check for which locale library to use.  The choice is mapped to
1322 dnl a subdirectory of config/locale.
1323 dnl
1324 dnl Default is generic.
1325 dnl
1326 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1327   AC_MSG_CHECKING([for C locale to use])
1328   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1329     [use MODEL for target locale package],
1330     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1331
1332   # If they didn't use this option switch, or if they specified --enable
1333   # with no specific model, we'll have to look for one.  If they
1334   # specified --disable (???), do likewise.
1335   if test $enable_clocale = no || test $enable_clocale = yes; then
1336      enable_clocale=auto
1337   fi
1338
1339   # Either a known package, or "auto"
1340   enable_clocale_flag=$enable_clocale
1341
1342   # Probe for locale support if no specific model is specified.
1343   # Default to "generic".
1344   if test $enable_clocale_flag = auto; then
1345     case ${target_os} in
1346       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1347         AC_EGREP_CPP([_GLIBCXX_ok], [
1348         #include <features.h>
1349         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1350           _GLIBCXX_ok
1351         #endif
1352         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1353
1354         # Test for bugs early in glibc-2.2.x series
1355           if test $enable_clocale_flag = gnu; then
1356           AC_TRY_RUN([
1357           #define _GNU_SOURCE 1
1358           #include <locale.h>
1359           #include <string.h>
1360           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1361           extern __typeof(newlocale) __newlocale;
1362           extern __typeof(duplocale) __duplocale;
1363           extern __typeof(strcoll_l) __strcoll_l;
1364           #endif
1365           int main()
1366           {
1367               const char __one[] = "Äuglein Augmen";
1368               const char __two[] = "Äuglein";
1369               int i;
1370               int j;
1371               __locale_t        loc;
1372                __locale_t        loc_dup;
1373               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1374               loc_dup = __duplocale(loc);
1375               i = __strcoll_l(__one, __two, loc);
1376               j = __strcoll_l(__one, __two, loc_dup);
1377               return 0;
1378           }
1379           ],
1380           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1381           [enable_clocale_flag=generic])
1382           fi
1383
1384         # ... at some point put __strxfrm_l tests in as well.
1385         ;;
1386       darwin* | freebsd*)
1387         enable_clocale_flag=darwin
1388         ;;
1389       *)
1390         enable_clocale_flag=generic
1391         ;;
1392     esac
1393   fi
1394
1395   # Deal with gettext issues.  Default to not using it (=no) until we detect
1396   # support for it later.  Let the user turn it off via --e/d, but let that
1397   # default to on for easier handling.
1398   USE_NLS=no
1399   AC_ARG_ENABLE(nls,
1400     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1401     [],
1402     [enable_nls=yes])
1403
1404   # Set configure bits for specified locale package
1405   case ${enable_clocale_flag} in
1406     generic)
1407       AC_MSG_RESULT(generic)
1408
1409       CLOCALE_H=config/locale/generic/c_locale.h
1410       CLOCALE_CC=config/locale/generic/c_locale.cc
1411       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1412       CCOLLATE_CC=config/locale/generic/collate_members.cc
1413       CCTYPE_CC=config/locale/generic/ctype_members.cc
1414       CMESSAGES_H=config/locale/generic/messages_members.h
1415       CMESSAGES_CC=config/locale/generic/messages_members.cc
1416       CMONEY_CC=config/locale/generic/monetary_members.cc
1417       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1418       CTIME_H=config/locale/generic/time_members.h
1419       CTIME_CC=config/locale/generic/time_members.cc
1420       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1421       ;;
1422     darwin)
1423       AC_MSG_RESULT(darwin or freebsd)
1424
1425       CLOCALE_H=config/locale/generic/c_locale.h
1426       CLOCALE_CC=config/locale/generic/c_locale.cc
1427       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1428       CCOLLATE_CC=config/locale/generic/collate_members.cc
1429       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1430       CMESSAGES_H=config/locale/generic/messages_members.h
1431       CMESSAGES_CC=config/locale/generic/messages_members.cc
1432       CMONEY_CC=config/locale/generic/monetary_members.cc
1433       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1434       CTIME_H=config/locale/generic/time_members.h
1435       CTIME_CC=config/locale/generic/time_members.cc
1436       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1437       ;;
1438
1439     gnu)
1440       AC_MSG_RESULT(gnu)
1441
1442       # Declare intention to use gettext, and add support for specific
1443       # languages.
1444       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1445       ALL_LINGUAS="de fr"
1446
1447       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1448       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1449       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1450         USE_NLS=yes
1451       fi
1452       # Export the build objects.
1453       for ling in $ALL_LINGUAS; do \
1454         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1455         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1456       done
1457       AC_SUBST(glibcxx_MOFILES)
1458       AC_SUBST(glibcxx_POFILES)
1459
1460       CLOCALE_H=config/locale/gnu/c_locale.h
1461       CLOCALE_CC=config/locale/gnu/c_locale.cc
1462       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1463       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1464       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1465       CMESSAGES_H=config/locale/gnu/messages_members.h
1466       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1467       CMONEY_CC=config/locale/gnu/monetary_members.cc
1468       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1469       CTIME_H=config/locale/gnu/time_members.h
1470       CTIME_CC=config/locale/gnu/time_members.cc
1471       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1472       ;;
1473     ieee_1003.1-2001)
1474       AC_MSG_RESULT(IEEE 1003.1)
1475
1476       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1477       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1478       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1479       CCOLLATE_CC=config/locale/generic/collate_members.cc
1480       CCTYPE_CC=config/locale/generic/ctype_members.cc
1481       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1482       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1483       CMONEY_CC=config/locale/generic/monetary_members.cc
1484       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1485       CTIME_H=config/locale/generic/time_members.h
1486       CTIME_CC=config/locale/generic/time_members.cc
1487       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1488       ;;
1489   esac
1490
1491   # This is where the testsuite looks for locale catalogs, using the
1492   # -DLOCALEDIR define during testsuite compilation.
1493   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1494   AC_SUBST(glibcxx_localedir)
1495
1496   # A standalone libintl (e.g., GNU libintl) may be in use.
1497   if test $USE_NLS = yes; then
1498     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1499     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1500   fi
1501   if test $USE_NLS = yes; then
1502     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1503               [Define if NLS translations are to be used.])
1504   fi
1505
1506   AC_SUBST(USE_NLS)
1507   AC_SUBST(CLOCALE_H)
1508   AC_SUBST(CMESSAGES_H)
1509   AC_SUBST(CCODECVT_CC)
1510   AC_SUBST(CCOLLATE_CC)
1511   AC_SUBST(CCTYPE_CC)
1512   AC_SUBST(CMESSAGES_CC)
1513   AC_SUBST(CMONEY_CC)
1514   AC_SUBST(CNUMERIC_CC)
1515   AC_SUBST(CTIME_H)
1516   AC_SUBST(CTIME_CC)
1517   AC_SUBST(CLOCALE_CC)
1518   AC_SUBST(CLOCALE_INTERNAL_H)
1519 ])
1520
1521
1522 dnl
1523 dnl Check for which std::allocator base class to use.  The choice is
1524 dnl mapped from a subdirectory of include/ext.
1525 dnl
1526 dnl Default is new.
1527 dnl
1528 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1529   AC_MSG_CHECKING([for std::allocator base class])
1530   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1531     [use KIND for target std::allocator base],
1532     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1533
1534   # If they didn't use this option switch, or if they specified --enable
1535   # with no specific model, we'll have to look for one.  If they
1536   # specified --disable (???), do likewise.
1537   if test $enable_libstdcxx_allocator = no ||
1538      test $enable_libstdcxx_allocator = yes;
1539   then
1540      enable_libstdcxx_allocator=auto
1541   fi
1542
1543   # Either a known package, or "auto". Auto implies the default choice
1544   # for a particular platform.
1545   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1546
1547   # Probe for host-specific support if no specific model is specified.
1548   # Default to "new".
1549   if test $enable_libstdcxx_allocator_flag = auto; then
1550     case ${target_os} in
1551       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1552         enable_libstdcxx_allocator_flag=new
1553         ;;
1554       *)
1555         enable_libstdcxx_allocator_flag=new
1556         ;;
1557     esac
1558   fi
1559   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1560
1561
1562   # Set configure bits for specified locale package
1563   case ${enable_libstdcxx_allocator_flag} in
1564     bitmap)
1565       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1566       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1567       ;;
1568     malloc)
1569       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1570       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1571       ;;
1572     mt)
1573       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1574       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1575       ;;
1576     new)
1577       ALLOCATOR_H=config/allocator/new_allocator_base.h
1578       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1579       ;;
1580     pool)
1581       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1582       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1583       ;;
1584   esac
1585
1586   AC_SUBST(ALLOCATOR_H)
1587   AC_SUBST(ALLOCATOR_NAME)
1588 ])
1589
1590
1591 dnl
1592 dnl Check for whether the Boost-derived checks should be turned on.
1593 dnl
1594 dnl --enable-concept-checks turns them on.
1595 dnl --disable-concept-checks leaves them off.
1596 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1597 dnl       Where DEFAULT is either `yes' or `no'.
1598 dnl
1599 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1600   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1601   if test $enable_concept_checks = yes; then
1602     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1603               [Define to use concept checking code from the boost libraries.])
1604   fi
1605 ])
1606
1607
1608 dnl
1609 dnl Check for which I/O library to use:  stdio, or something specific.
1610 dnl
1611 dnl Default is stdio.
1612 dnl
1613 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1614   AC_MSG_CHECKING([for underlying I/O to use])
1615   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1616     [use target-specific I/O package], [permit stdio])
1617
1618   # Now that libio has been removed, you can have any color you want as long
1619   # as it's black.  This is one big no-op until other packages are added, but
1620   # showing the framework never hurts.
1621   case ${enable_cstdio} in
1622     stdio)
1623       CSTDIO_H=config/io/c_io_stdio.h
1624       BASIC_FILE_H=config/io/basic_file_stdio.h
1625       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1626       AC_MSG_RESULT(stdio)
1627       ;;
1628   esac
1629
1630   AC_SUBST(CSTDIO_H)
1631   AC_SUBST(BASIC_FILE_H)
1632   AC_SUBST(BASIC_FILE_CC)
1633 ])
1634
1635
1636 dnl
1637 dnl Check for "unusual" flags to pass to the compiler while building.
1638 dnl
1639 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1640 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1641 dnl --disable-cxx-flags passes nothing.
1642 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1643 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1644 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1645 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1646 dnl       If "default flags" is an empty string, the effect is the same
1647 dnl       as --disable or --enable=no.
1648 dnl
1649 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1650   AC_MSG_CHECKING([for extra compiler flags for building])
1651   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1652     [pass compiler FLAGS when building library],
1653     [case "x$enable_cxx_flags" in
1654       xno | x)   enable_cxx_flags= ;;
1655       x-*)       ;;
1656       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1657      esac])
1658
1659   # Run through flags (either default or command-line) and set anything
1660   # extra (e.g., #defines) that must accompany particular g++ options.
1661   if test -n "$enable_cxx_flags"; then
1662     for f in $enable_cxx_flags; do
1663       case "$f" in
1664         -fhonor-std)  ;;
1665         -*)  ;;
1666         *)   # and we're trying to pass /what/ exactly?
1667              AC_MSG_ERROR([compiler flags start with a -]) ;;
1668       esac
1669     done
1670   fi
1671
1672   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1673   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1674   AC_SUBST(EXTRA_CXX_FLAGS)
1675 ])
1676
1677
1678 dnl
1679 dnl Check to see if debugging libraries are to be built.
1680 dnl
1681 dnl --enable-libstdcxx-debug
1682 dnl builds a separate set of debugging libraries in addition to the
1683 dnl normal (shared, static) libstdc++ binaries.
1684 dnl
1685 dnl --disable-libstdcxx-debug
1686 dnl builds only one (non-debug) version of libstdc++.
1687 dnl
1688 dnl --enable-libstdcxx-debug-flags=FLAGS
1689 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1690 dnl
1691 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1692 dnl       Where DEFAULT is either `yes' or `no'.
1693 dnl
1694 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1695   AC_MSG_CHECKING([for additional debug build])
1696   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1697   AC_MSG_RESULT($enable_libstdcxx_debug)
1698   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1699 ])
1700
1701
1702 dnl
1703 dnl Check for explicit debug flags.
1704 dnl
1705 dnl --enable-libstdcxx-debug-flags='-O1'
1706 dnl is a general method for passing flags to be used when
1707 dnl building debug libraries with --enable-debug.
1708 dnl
1709 dnl --disable-libstdcxx-debug-flags does nothing.
1710 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1711 dnl       If "default flags" is an empty string, the effect is the same
1712 dnl       as --disable or --enable=no.
1713 dnl
1714 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1715   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1716     [pass compiler FLAGS when building debug library],
1717     [case "x$enable_libstdcxx_debug_flags" in
1718       xno | x)    enable_libstdcxx_debug_flags= ;;
1719       x-*)        ;;
1720       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1721      esac])
1722
1723   # Option parsed, now set things appropriately
1724   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1725   AC_SUBST(DEBUG_FLAGS)
1726
1727   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1728 ])
1729
1730
1731 dnl
1732 dnl Check if the user only wants a freestanding library implementation.
1733 dnl
1734 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1735 dnl installing only the headers required by [17.4.1.3] and the language
1736 dnl support library.  More than that will be built (to keep the Makefiles
1737 dnl conveniently clean), but not installed.
1738 dnl
1739 dnl Sets:
1740 dnl  is_hosted  (yes/no)
1741 dnl
1742 dnl Defines:
1743 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1744 dnl
1745 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1746   AC_ARG_ENABLE([hosted-libstdcxx],
1747     AC_HELP_STRING([--disable-hosted-libstdcxx],
1748                    [only build freestanding C++ runtime support]),,
1749     [case "$host" in
1750         arm*-*-symbianelf*)
1751             enable_hosted_libstdcxx=no
1752             ;;
1753         *)
1754             enable_hosted_libstdcxx=yes
1755             ;;
1756      esac])
1757   if test "$enable_hosted_libstdcxx" = no; then
1758     AC_MSG_NOTICE([Only freestanding libraries will be built])
1759     is_hosted=no
1760     hosted_define=0
1761     enable_abi_check=no
1762     enable_libstdcxx_pch=no
1763   else
1764     is_hosted=yes
1765     hosted_define=1
1766   fi
1767   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1768   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1769     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1770 ])
1771
1772
1773 dnl
1774 dnl Check for template specializations for the 'long long' type.
1775 dnl The result determines only whether 'long long' I/O is enabled; things
1776 dnl like numeric_limits<> specializations are always available.
1777 dnl
1778 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1779 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1780 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1781 dnl       Where DEFAULT is either `yes' or `no'.
1782 dnl
1783 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1784   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1785   if test $enable_long_long = yes; then
1786     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1787               [Define if code specialized for long long should be used.])
1788   fi
1789   AC_MSG_CHECKING([for enabled long long specializations])
1790   AC_MSG_RESULT([$enable_long_long])
1791 ])
1792
1793
1794 dnl
1795 dnl Check for template specializations for the 'wchar_t' type.
1796 dnl
1797 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1798 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1799 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1800 dnl       Where DEFAULT is either `yes' or `no'.
1801 dnl
1802 dnl Necessary support must also be present.
1803 dnl
1804 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1805   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1806
1807   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
1808   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
1809   AC_MSG_CHECKING([for mbstate_t])
1810   AC_TRY_COMPILE([#include <wchar.h>],
1811   [mbstate_t teststate;],
1812   have_mbstate_t=yes, have_mbstate_t=no)
1813   AC_MSG_RESULT($have_mbstate_t)
1814   if test x"$have_mbstate_t" = xyes; then
1815     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
1816   fi
1817
1818   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
1819   # ac_has_wchar_h.
1820   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
1821
1822   if test x"$enable_wchar_t" = x"yes"; then
1823
1824     AC_LANG_SAVE
1825     AC_LANG_CPLUSPLUS
1826
1827     if test x"$ac_has_wchar_h" = xyes &&
1828        test x"$ac_has_wctype_h" = xyes; then
1829       AC_TRY_COMPILE([#include <wchar.h>
1830                       #include <stddef.h>
1831                       wint_t i;
1832                       long l = WEOF;
1833                       long j = WCHAR_MIN;
1834                       long k = WCHAR_MAX;
1835                       namespace test
1836                       {
1837                         using ::btowc;
1838                         using ::fgetwc;
1839                         using ::fgetws;
1840                         using ::fputwc;
1841                         using ::fputws;
1842                         using ::fwide;
1843                         using ::fwprintf;
1844                         using ::fwscanf;
1845                         using ::getwc;
1846                         using ::getwchar;
1847                         using ::mbrlen;
1848                         using ::mbrtowc;
1849                         using ::mbsinit;
1850                         using ::mbsrtowcs;
1851                         using ::putwc;
1852                         using ::putwchar;
1853                         using ::swprintf;
1854                         using ::swscanf;
1855                         using ::ungetwc;
1856                         using ::vfwprintf;
1857                         using ::vswprintf;
1858                         using ::vwprintf;
1859                         using ::wcrtomb;
1860                         using ::wcscat;
1861                         using ::wcschr;
1862                         using ::wcscmp;
1863                         using ::wcscoll;
1864                         using ::wcscpy;
1865                         using ::wcscspn;
1866                         using ::wcsftime;
1867                         using ::wcslen;
1868                         using ::wcsncat;
1869                         using ::wcsncmp;
1870                         using ::wcsncpy;
1871                         using ::wcspbrk;
1872                         using ::wcsrchr;
1873                         using ::wcsrtombs;
1874                         using ::wcsspn;
1875                         using ::wcsstr;
1876                         using ::wcstod;
1877                         using ::wcstok;
1878                         using ::wcstol;
1879                         using ::wcstoul;
1880                         using ::wcsxfrm;
1881                         using ::wctob;
1882                         using ::wmemchr;
1883                         using ::wmemcmp;
1884                         using ::wmemcpy;
1885                         using ::wmemmove;
1886                         using ::wmemset;
1887                         using ::wprintf;
1888                         using ::wscanf;
1889                       }
1890                      ],[],[], [enable_wchar_t=no])
1891     else
1892       enable_wchar_t=no
1893     fi
1894
1895     AC_LANG_RESTORE
1896   fi
1897
1898   if test x"$enable_wchar_t" = x"yes"; then
1899     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
1900               [Define if code specialized for wchar_t should be used.])
1901   fi
1902
1903   AC_MSG_CHECKING([for enabled wchar_t specializations])
1904   AC_MSG_RESULT([$enable_wchar_t])
1905 ])
1906
1907
1908 dnl
1909 dnl Check to see if building and using a C++ precompiled header can be done.
1910 dnl
1911 dnl --enable-libstdcxx-pch=yes
1912 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1913 dnl may work, after some light-hearted attempts to puzzle out compiler
1914 dnl support, flip bits on in include/Makefile.am
1915 dnl
1916 dnl --disable-libstdcxx-pch
1917 dnl turns off attempts to use or build stdc++.h.gch.
1918 dnl
1919 dnl Substs:
1920 dnl  glibcxx_PCHFLAGS
1921 dnl
1922 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1923   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1924   if test $enable_libstdcxx_pch = yes; then
1925     AC_CACHE_CHECK([for compiler with PCH support],
1926       [glibcxx_cv_prog_CXX_pch],
1927       [ac_save_CXXFLAGS="$CXXFLAGS"
1928        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1929        AC_LANG_SAVE
1930        AC_LANG_CPLUSPLUS
1931        echo '#include <math.h>' > conftest.h
1932        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1933                           -o conftest.h.gch 1>&5 2>&1 &&
1934                 echo '#error "pch failed"' > conftest.h &&
1935           echo '#include "conftest.h"' > conftest.cc &&
1936                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1937        then
1938          glibcxx_cv_prog_CXX_pch=yes
1939        else
1940          glibcxx_cv_prog_CXX_pch=no
1941        fi
1942        rm -f conftest*
1943        CXXFLAGS=$ac_save_CXXFLAGS
1944        AC_LANG_RESTORE
1945       ])
1946     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1947   fi
1948
1949   AC_MSG_CHECKING([for enabled PCH])
1950   AC_MSG_RESULT([$enable_libstdcxx_pch])
1951
1952   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1953   if test $enable_libstdcxx_pch = yes; then
1954     glibcxx_PCHFLAGS="-include bits/stdc++.h"
1955   else
1956     glibcxx_PCHFLAGS=""
1957   fi
1958   AC_SUBST(glibcxx_PCHFLAGS)
1959 ])
1960
1961
1962 dnl
1963 dnl Check for exception handling support.  If an explicit enable/disable
1964 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1965 dnl target may or may not support call frame exceptions.
1966 dnl
1967 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1968 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1969 dnl Neither one forces an attempt at detection.
1970 dnl
1971 dnl Defines:
1972 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
1973 dnl
1974 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
1975   AC_MSG_CHECKING([for exception model to use])
1976   AC_LANG_SAVE
1977   AC_LANG_CPLUSPLUS
1978   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
1979     [force use of builtin_setjmp for exceptions],
1980     [permit yes|no|auto])
1981
1982   if test $enable_sjlj_exceptions = auto; then
1983     # Botheration.  Now we've got to detect the exception model.  Link tests
1984     # against libgcc.a are problematic since we've not been given proper -L
1985     # bits for single-tree newlib and libgloss.
1986     #
1987     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
1988     cat > conftest.$ac_ext << EOF
1989 [#]line __oline__ "configure"
1990 struct S { ~S(); };
1991 void bar();
1992 void foo()
1993 {
1994   S s;
1995   bar();
1996 }
1997 EOF
1998     old_CXXFLAGS="$CXXFLAGS"
1999     CXXFLAGS=-S
2000     if AC_TRY_EVAL(ac_compile); then
2001       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2002         enable_sjlj_exceptions=yes
2003       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2004         enable_sjlj_exceptions=no
2005       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2006         enable_sjlj_exceptions=no
2007       fi
2008     fi
2009     CXXFLAGS="$old_CXXFLAGS"
2010     rm -f conftest*
2011   fi
2012
2013   # This is a tad weird, for hysterical raisins.  We have to map
2014   # enable/disable to two different models.
2015   case $enable_sjlj_exceptions in
2016     yes)
2017       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2018         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2019       ac_exception_model_name=sjlj
2020       ;;
2021     no)
2022       ac_exception_model_name="call frame"
2023       ;;
2024     *)
2025       AC_MSG_ERROR([unable to detect exception model])
2026       ;;
2027   esac
2028  AC_LANG_RESTORE
2029  AC_MSG_RESULT($ac_exception_model_name)
2030 ])
2031
2032
2033 dnl
2034 dnl Add version tags to symbols in shared library (or not), additionally
2035 dnl marking other symbols as private/local (or not).
2036 dnl
2037 dnl --enable-symvers=style adds a version script to the linker call when
2038 dnl       creating the shared library.  The choice of version script is
2039 dnl       controlled by 'style'.
2040 dnl --disable-symvers does not.
2041 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2042 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2043 dnl       choose a default style based on linker characteristics.  Passing
2044 dnl       'no' disables versioning.
2045 dnl
2046 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2047
2048 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2049   [enables symbol versioning of the shared library],
2050   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2051
2052 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2053 # don't know enough about $LD to do tricks...
2054 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2055
2056 # Turn a 'yes' into a suitable default.
2057 if test x$enable_symvers = xyes ; then
2058   if test $enable_shared = no || test "x$LD" = x ; then
2059     enable_symvers=no
2060   else
2061     if test $with_gnu_ld = yes ; then
2062       enable_symvers=gnu
2063     else
2064       case ${target_os} in
2065         darwin*)
2066           enable_symvers=darwin ;;
2067         *)
2068           enable_symvers=no ;;
2069       esac
2070     fi
2071   fi
2072 fi
2073
2074 # Check to see if 'darwin' or 'darwin-export' can win.
2075 if test x$enable_symvers = xdarwin-export ; then
2076     enable_symvers=darwin
2077 fi
2078
2079 # Check to see if 'gnu' can win.
2080 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2081   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2082   AC_MSG_CHECKING([for shared libgcc])
2083   ac_save_CFLAGS="$CFLAGS"
2084   CFLAGS=' -lgcc_s'
2085   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2086   CFLAGS="$ac_save_CFLAGS"
2087   if test $glibcxx_shared_libgcc = no; then
2088     cat > conftest.c <<EOF
2089 int main (void) { return 0; }
2090 EOF
2091 changequote(,)dnl
2092     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2093                              -shared -shared-libgcc -o conftest.so \
2094                              conftest.c -v 2>&1 >/dev/null \
2095                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2096 changequote([,])dnl
2097     rm -f conftest.c conftest.so
2098     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2099       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2100       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2101       CFLAGS="$ac_save_CFLAGS"
2102     fi
2103   fi
2104   AC_MSG_RESULT($glibcxx_shared_libgcc)
2105
2106   # For GNU ld, we need at least this version.  The format is described in
2107   # GLIBCXX_CHECK_LINKER_FEATURES above.
2108   glibcxx_min_gnu_ld_version=21400
2109
2110   # If no shared libgcc, can't win.
2111   if test $glibcxx_shared_libgcc != yes; then
2112       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2113       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2114       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2115       enable_symvers=no
2116   elif test $with_gnu_ld != yes ; then
2117     # just fail for now
2118     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2119     AC_MSG_WARN([=== you are not using the GNU linker.])
2120     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2121     enable_symvers=no
2122   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2123     # The right tools, the right setup, but too old.  Fallbacks?
2124     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2125     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2126     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2127     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2128     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2129     enable_symvers=no
2130   fi
2131 fi
2132
2133 # Everything parsed; figure out what file to use.
2134 case $enable_symvers in
2135   no)
2136     SYMVER_FILE=config/abi/pre/none.ver
2137     ;;
2138   gnu)
2139     SYMVER_FILE=config/abi/pre/gnu.ver
2140     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2141               [Define to use GNU versioning in the shared library.])
2142     ;;
2143   gnu-versioned-namespace)
2144     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2145     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2146               [Define to use GNU namespace versioning in the shared library.])
2147     ;;
2148   darwin)
2149     SYMVER_FILE=config/abi/pre/gnu.ver
2150     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2151               [Define to use darwin versioning in the shared library.])
2152     ;;
2153 esac
2154
2155 if test x$enable_symvers != xno ; then
2156   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2157          [Define to use symbol versioning in the shared library.])
2158 fi
2159
2160 AC_SUBST(SYMVER_FILE)
2161 AC_SUBST(port_specific_symbol_files)
2162 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2163 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2164 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2165 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2166 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2167
2168 # Now, set up compatibility support, if any.
2169 # In addition, need this to deal with std::size_t mangling in
2170 # src/compatibility.cc.  In a perfect world, could use
2171 # typeid(std::size_t).name()[0] to do direct substitution.
2172 AC_MSG_CHECKING([for size_t as unsigned int])
2173 ac_save_CFLAGS="$CFLAGS"
2174 CFLAGS="-Werror"
2175 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2176                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2177 CFLAGS=$ac_save_CFLAGS
2178 if test "$glibcxx_size_t_is_i" = yes; then
2179   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2180 fi
2181 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2182
2183 AC_MSG_CHECKING([for ptrdiff_t as int])
2184 ac_save_CFLAGS="$CFLAGS"
2185 CFLAGS="-Werror"
2186 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2187                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2188 CFLAGS=$ac_save_CFLAGS
2189 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2190   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2191 fi
2192 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2193 ])
2194
2195
2196 dnl
2197 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2198 dnl We must stage the required headers so that they will be installed
2199 dnl with the library (unlike libgcc, the STL implementation is provided
2200 dnl solely within headers).  Since we must not inject random user-space
2201 dnl macro names into user-provided C++ code, we first stage into <file>-in
2202 dnl and process to <file> with an output command.  The reason for a two-
2203 dnl stage process here is to correctly handle $srcdir!=$objdir without
2204 dnl having to write complex code (the sed commands to clean the macro
2205 dnl namespace are complex and fragile enough as it is).  We must also
2206 dnl add a relative path so that -I- is supported properly.
2207 dnl
2208 dnl Substs:
2209 dnl  glibcxx_thread_h
2210 dnl
2211 dnl Defines:
2212 dnl  HAVE_GTHR_DEFAULT
2213 dnl
2214 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2215   AC_MSG_CHECKING([for thread model used by GCC])
2216   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2217   AC_MSG_RESULT([$target_thread_file])
2218
2219   if test $target_thread_file != single; then
2220     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2221               [Define if gthr-default.h exists
2222               (meaning that threading support is enabled).])
2223   fi
2224
2225   glibcxx_thread_h=gthr-$target_thread_file.h
2226
2227   dnl Check for __GTHREADS define.
2228   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2229   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2230     enable_thread=yes
2231   else
2232    enable_thread=no
2233   fi
2234
2235   AC_SUBST(glibcxx_thread_h)
2236 ])
2237
2238
2239 # Check whether LC_MESSAGES is available in <locale.h>.
2240 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2241 #
2242 # This file file be copied and used freely without restrictions.  It can
2243 # be used in projects which are not available under the GNU Public License
2244 # but which still want to provide support for the GNU gettext functionality.
2245 # Please note that the actual code is *not* freely available.
2246
2247 # serial 1
2248 AC_DEFUN([AC_LC_MESSAGES], [
2249   AC_CHECK_HEADER(locale.h, [
2250     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2251       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2252        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2253     if test $ac_cv_val_LC_MESSAGES = yes; then
2254       AC_DEFINE(HAVE_LC_MESSAGES, 1,
2255                 [Define if LC_MESSAGES is available in <locale.h>.])
2256     fi
2257   ])
2258 ])
2259
2260 # Macros from the top-level gcc directory.
2261 m4_include([../config/tls.m4])
2262