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 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
 678 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
 679   glibcxx_toolexecdir=no
 680   glibcxx_toolexeclibdir=no
 681   glibcxx_prefixdir=$prefix
 682
 683   AC_MSG_CHECKING([for gxx-include-dir])
 684   AC_ARG_WITH([gxx-include-dir],
 685     AC_HELP_STRING([--with-gxx-include-dir=DIR],
 686                    [installation directory for include files]),
 687     [case "$withval" in
 688       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
 689       no)  gxx_include_dir=no ;;
 690       *)   gxx_include_dir=$withval ;;
 691      esac],
 692     [gxx_include_dir=no])
 693   AC_MSG_RESULT($gxx_include_dir)
 694
 695   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
 696   AC_ARG_ENABLE([version-specific-runtime-libs],
 697     AC_HELP_STRING([--enable-version-specific-runtime-libs],
 698                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
 699     [case "$enableval" in
 700       yes) version_specific_libs=yes ;;
 701       no)  version_specific_libs=no ;;
 702       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
 703      esac],
 704     [version_specific_libs=no])
 705   AC_MSG_RESULT($version_specific_libs)
 706
 707   # Default case for install directory for include files.
 708   if test $version_specific_libs = no && test $gxx_include_dir = no; then
 709     gxx_include_dir='include/c++/${gcc_version}'
 710     if test -n "$with_cross_host" &&
 711        test x"$with_cross_host" != x"no"; then
 712       gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
 713     else
 714       gxx_include_dir='${prefix}/'"$gxx_include_dir"
 715     fi
 716   fi
 717
 718   # Version-specific runtime libs processing.
 719   if test $version_specific_libs = yes; then
 720     # Need the gcc compiler version to know where to install libraries
 721     # and header files if --enable-version-specific-runtime-libs option
 722     # is selected.  FIXME: these variables are misnamed, there are
 723     # no executables installed in _toolexecdir or _toolexeclibdir.
 724     if test x"$gxx_include_dir" = x"no"; then
 725       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
 726     fi
 727     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 728     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
 729   fi
 730
 731   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
 732   # Install a library built with a cross compiler in tooldir, not libdir.
 733   if test x"$glibcxx_toolexecdir" = x"no"; then
 734     if test -n "$with_cross_host" &&
 735        test x"$with_cross_host" != x"no"; then
 736       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
 737       glibcxx_toolexeclibdir='${toolexecdir}/lib'
 738     else
 739       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 740       glibcxx_toolexeclibdir='${libdir}'
 741     fi
 742     multi_os_directory=`$CXX -print-multi-os-directory`
 743     case $multi_os_directory in
 744       .) ;; # Avoid trailing /.
 745       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
 746     esac
 747   fi
 748
 749   AC_MSG_CHECKING([for install location])
 750   AC_MSG_RESULT($gxx_include_dir)
 751
 752   AC_SUBST(glibcxx_prefixdir)
 753   AC_SUBST(gxx_include_dir)
 754   AC_SUBST(glibcxx_toolexecdir)
 755   AC_SUBST(glibcxx_toolexeclibdir)
 756 ])
 757
 758
 759 dnl
 760 dnl GLIBCXX_ENABLE
 761 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
 762 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
 763 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
 764 dnl
 765 dnl See docs/html/17_intro/configury.html#enable for documentation.
 766 dnl
 767 m4_define([GLIBCXX_ENABLE],[dnl
 768 m4_define([_g_switch],[--enable-$1])dnl
 769 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
 770  AC_ARG_ENABLE($1,_g_help,
 771   m4_bmatch([$5],
 772    [^permit ],
 773      [[
 774       case "$enableval" in
 775        m4_bpatsubst([$5],[permit ])) ;;
 776        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
 777           dnl Idea for future:  generate a URL pointing to
 778           dnl "onlinedocs/configopts.html#whatever"
 779       esac
 780      ]],
 781    [^$],
 782      [[
 783       case "$enableval" in
 784        yes|no) ;;
 785        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
 786       esac
 787      ]],
 788    [[$5]]),
 789   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
 790 m4_undefine([_g_switch])dnl
 791 m4_undefine([_g_help])dnl
 792 ])
 793
 794
 795 dnl
 796 dnl Check for ISO/IEC 9899:1999 "C99" support.
 797 dnl
 798 dnl --enable-c99 defines _GLIBCXX_USE_C99
 799 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
 800 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
 801 dnl       Where DEFAULT is either `yes' or `no'.
 802 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
 803 dnl
 804 AC_DEFUN([GLIBCXX_ENABLE_C99], [
 805   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
 806
 807   if test x"$enable_c99" = x"yes"; then
 808
 809   AC_LANG_SAVE
 810   AC_LANG_CPLUSPLUS
 811
 812   # Check for the existence of <math.h> functions used if C99 is enabled.
 813   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
 814   AC_CACHE_VAL(ac_c99_math, [
 815   AC_TRY_COMPILE([#include <math.h>],
 816                  [fpclassify(0.0);
 817                   isfinite(0.0);
 818                   isinf(0.0);
 819                   isnan(0.0);
 820                   isnormal(0.0);
 821                   signbit(0.0);
 822                   isgreater(0.0,0.0);
 823                   isgreaterequal(0.0,0.0);
 824                   isless(0.0,0.0);
 825                   islessequal(0.0,0.0);
 826                   islessgreater(0.0,0.0);
 827                   islessgreater(0.0,0.0);
 828                   isunordered(0.0,0.0);
 829                  ],[ac_c99_math=yes], [ac_c99_math=no])
 830   ])
 831   AC_MSG_RESULT($ac_c99_math)
 832   if test x"$ac_c99_math" = x"yes"; then
 833     AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
 834               [Define if C99 functions or macros in <math.h> should be imported
 835               in <cmath> in namespace std.])
 836   fi
 837
 838   # Check for the existence of <complex.h> complex math functions.
 839   # This is necessary even though libstdc++ uses the builtin versions
 840   # of these functions, because if the builtin cannot be used, a reference
 841   # to the library function is emitted.
 842   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 843   ac_c99_complex=no;
 844   if test x"$ac_has_complex_h" = x"yes"; then
 845     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
 846     AC_TRY_COMPILE([#include <complex.h>],
 847                    [typedef __complex__ float float_type; float_type tmpf;
 848                     cabsf(tmpf);
 849                     cargf(tmpf);
 850                     ccosf(tmpf);
 851                     ccoshf(tmpf);
 852                     cexpf(tmpf);
 853                     clogf(tmpf);
 854                     csinf(tmpf);
 855                     csinhf(tmpf);
 856                     csqrtf(tmpf);
 857                     ctanf(tmpf);
 858                     ctanhf(tmpf);
 859                     cpowf(tmpf, tmpf);
 860                     typedef __complex__ double double_type; double_type tmpd;
 861                     cabs(tmpd);
 862                     carg(tmpd);
 863                     ccos(tmpd);
 864                     ccosh(tmpd);
 865                     cexp(tmpd);
 866                     clog(tmpd);
 867                     csin(tmpd);
 868                     csinh(tmpd);
 869                     csqrt(tmpd);
 870                     ctan(tmpd);
 871                     ctanh(tmpd);
 872                     cpow(tmpd, tmpd);
 873                     typedef __complex__ long double ld_type; ld_type tmpld;
 874                     cabsl(tmpld);
 875                     cargl(tmpld);
 876                     ccosl(tmpld);
 877                     ccoshl(tmpld);
 878                     cexpl(tmpld);
 879                     clogl(tmpld);
 880                     csinl(tmpld);
 881                     csinhl(tmpld);
 882                     csqrtl(tmpld);
 883                     ctanl(tmpld);
 884                     ctanhl(tmpld);
 885                     cpowl(tmpld, tmpld);
 886                    ],[ac_c99_complex=yes], [ac_c99_complex=no])
 887   fi
 888   AC_MSG_RESULT($ac_c99_complex)
 889   if test x"$ac_c99_complex" = x"yes"; then
 890     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 891               [Define if C99 functions in <complex.h> should be used in
 892               <complex>. Using compiler builtins for these functions requires
 893               corresponding C99 library functions to be present.])
 894   fi
 895
 896   # Check for the existence in <stdio.h> of vscanf, et. al.
 897   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 898   AC_CACHE_VAL(ac_c99_stdio, [
 899   AC_TRY_COMPILE([#include <stdio.h>
 900                   #include <stdarg.h>
 901                   void foo(char* fmt, ...)
 902                   {
 903                     va_list args; va_start(args, fmt);
 904                     vfscanf(stderr, "%i", args);
 905                     vscanf("%i", args);
 906                     vsnprintf(fmt, 0, "%i", args);
 907                     vsscanf(fmt, "%i", args);
 908                   }],
 909                  [snprintf("12", 0, "%i");],
 910                  [ac_c99_stdio=yes], [ac_c99_stdio=no])
 911   ])
 912   AC_MSG_RESULT($ac_c99_stdio)
 913
 914   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
 915   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
 916   AC_CACHE_VAL(ac_c99_stdlib, [
 917   AC_TRY_COMPILE([#include <stdlib.h>],
 918                  [char* tmp;
 919                   strtof("gnu", &tmp);
 920                   strtold("gnu", &tmp);
 921                   strtoll("gnu", &tmp, 10);
 922                   strtoull("gnu", &tmp, 10);
 923                   llabs(10);
 924                   lldiv(10,1);
 925                   atoll("10");
 926                   _Exit(0);
 927                   lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
 928   ])
 929   AC_MSG_RESULT($ac_c99_stdlib)
 930
 931   # Check for the existence in <wchar.h> of wcstold, etc.
 932   ac_c99_wchar=no;
 933   if test x"$ac_has_wchar_h" = xyes &&
 934      test x"$ac_has_wctype_h" = xyes; then
 935     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
 936     AC_TRY_COMPILE([#include <wchar.h>
 937                     namespace test
 938                     {
 939                       using ::wcstold;
 940                       using ::wcstoll;
 941                       using ::wcstoull;
 942                     }
 943                    ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
 944
 945     # Checks for wide character functions that may not be present.
 946     # Injection of these is wrapped with guard macros.
 947     # NB: only put functions here, instead of immediately above, if
 948     # absolutely necessary.
 949     AC_TRY_COMPILE([#include <wchar.h>
 950                     namespace test { using ::vfwscanf; } ], [],
 951                    [AC_DEFINE(HAVE_VFWSCANF,1,
 952                         [Defined if vfwscanf exists.])],[])
 953
 954     AC_TRY_COMPILE([#include <wchar.h>
 955                     namespace test { using ::vswscanf; } ], [],
 956                    [AC_DEFINE(HAVE_VSWSCANF,1,
 957                         [Defined if vswscanf exists.])],[])
 958
 959     AC_TRY_COMPILE([#include <wchar.h>
 960                     namespace test { using ::vwscanf; } ], [],
 961                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
 962
 963     AC_TRY_COMPILE([#include <wchar.h>
 964                     namespace test { using ::wcstof; } ], [],
 965                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
 966
 967     AC_TRY_COMPILE([#include <wctype.h>],
 968                    [ wint_t t; int i = iswblank(t);],
 969                    [AC_DEFINE(HAVE_ISWBLANK,1,
 970                         [Defined if iswblank exists.])],[])
 971
 972     AC_MSG_RESULT($ac_c99_wchar)
 973   fi
 974
 975   # Option parsed, now set things appropriately.
 976   if test x"$ac_c99_math" = x"no" ||
 977      test x"$ac_c99_complex" = x"no" ||
 978      test x"$ac_c99_stdio" = x"no" ||
 979      test x"$ac_c99_stdlib" = x"no" ||
 980      test x"$ac_c99_wchar" = x"no"; then
 981     enable_c99=no;
 982   else
 983     AC_DEFINE(_GLIBCXX_USE_C99, 1,
 984     [Define if C99 functions or macros from <wchar.h>, <math.h>,
 985     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
 986   fi
 987
 988   AC_LANG_RESTORE
 989   fi
 990
 991   AC_MSG_CHECKING([for fully enabled ISO C99 support])
 992   AC_MSG_RESULT($enable_c99)
 993 ])
 994
 995
 996 dnl
 997 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
 998 dnl facilities in Chapter 8, "C compatibility".
 999 dnl
1000 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1001
1002   AC_LANG_SAVE
1003   AC_LANG_CPLUSPLUS
1004
1005   # Check for the existence of <complex.h> complex math functions used
1006   # by tr1/complex.
1007   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1008   ac_c99_complex_tr1=no;
1009   if test x"$ac_has_complex_h" = x"yes"; then
1010     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1011     AC_TRY_COMPILE([#include <complex.h>],
1012                    [typedef __complex__ float float_type; float_type tmpf;
1013                     cacosf(tmpf);
1014                     casinf(tmpf);
1015                     catanf(tmpf);
1016                     cacoshf(tmpf);
1017                     casinhf(tmpf);
1018                     catanhf(tmpf);
1019                     typedef __complex__ double double_type; double_type tmpd;
1020                     cacos(tmpd);
1021                     casin(tmpd);
1022                     catan(tmpd);
1023                     cacosh(tmpd);
1024                     casinh(tmpd);
1025                     catanh(tmpd);
1026                     typedef __complex__ long double ld_type; ld_type tmpld;
1027                     cacosl(tmpld);
1028                     casinl(tmpld);
1029                     catanl(tmpld);
1030                     cacoshl(tmpld);
1031                     casinhl(tmpld);
1032                     catanhl(tmpld);
1033                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1034   fi
1035   AC_MSG_RESULT($ac_c99_complex_tr1)
1036   if test x"$ac_c99_complex_tr1" = x"yes"; then
1037     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1038               [Define if C99 functions in <complex.h> should be used in
1039               <tr1/complex>. Using compiler builtins for these functions
1040               requires corresponding C99 library functions to be present.])
1041   fi
1042
1043   # Check for the existence of <ctype.h> functions.
1044   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1045   AC_CACHE_VAL(ac_c99_ctype_tr1, [
1046   AC_TRY_COMPILE([#include <ctype.h>],
1047                  [int ch;
1048                   int ret;
1049                   ret = isblank(ch);
1050                  ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no])
1051   ])
1052   AC_MSG_RESULT($ac_c99_ctype_tr1)
1053   if test x"$ac_c99_ctype_tr1" = x"yes"; then
1054     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1055               [Define if C99 functions in <ctype.h> should be imported in
1056               <tr1/cctype> in namespace std::tr1.])
1057   fi
1058
1059   # Check for the existence of <fenv.h> functions.
1060   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1061   ac_c99_fenv_tr1=no;
1062   if test x"$ac_has_fenv_h" = x"yes"; then
1063     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1064     AC_TRY_COMPILE([#include <fenv.h>],
1065                    [int except, mode;
1066                     fexcept_t* pflag;
1067                     fenv_t* penv;
1068                     int ret;
1069                     ret = feclearexcept(except);
1070                     ret = fegetexceptflag(pflag, except);
1071                     ret = feraiseexcept(except);
1072                     ret = fesetexceptflag(pflag, except);
1073                     ret = fetestexcept(except);
1074                     ret = fegetround();
1075                     ret = fesetround(mode);
1076                     ret = fegetenv(penv);
1077                     ret = feholdexcept(penv);
1078                     ret = fesetenv(penv);
1079                     ret = feupdateenv(penv);
1080                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1081   fi
1082   AC_MSG_RESULT($ac_c99_fenv_tr1)
1083   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1084     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1085               [Define if C99 functions in <fenv.h> should be imported in
1086               <tr1/cfenv> in namespace std::tr1.])
1087   fi
1088
1089   # Check for the existence of <stdint.h> types.
1090   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1091   AC_CACHE_VAL(ac_c99_stdint_tr1, [
1092   AC_TRY_COMPILE([#include <stdint.h>],
1093                  [typedef int8_t          my_int8_t;
1094                   typedef int16_t         my_int16_t;
1095                   typedef int32_t         my_int32_t;
1096                   typedef int64_t         my_int64_t;
1097                   typedef int_fast8_t     my_int_fast8_t;
1098                   typedef int_fast16_t    my_int_fast16_t;
1099                   typedef int_fast32_t    my_int_fast32_t;
1100                   typedef int_fast64_t    my_int_fast64_t;
1101                   typedef int_least8_t    my_int_least8_t;
1102                   typedef int_least16_t   my_int_least16_t;
1103                   typedef int_least32_t   my_int_least32_t;
1104                   typedef int_least64_t   my_int_least64_t;
1105                   typedef intmax_t        my_intmax_t;
1106                   typedef intptr_t        my_intptr_t;
1107                   typedef uint8_t         my_uint8_t;
1108                   typedef uint16_t        my_uint16_t;
1109                   typedef uint32_t        my_uint32_t;
1110                   typedef uint64_t        my_uint64_t;
1111                   typedef uint_fast8_t    my_uint_fast8_t;
1112                   typedef uint_fast16_t   my_uint_fast16_t;
1113                   typedef uint_fast32_t   my_uint_fast32_t;
1114                   typedef uint_fast64_t   my_uint_fast64_t;
1115                   typedef uint_least8_t   my_uint_least8_t;
1116                   typedef uint_least16_t  my_uint_least16_t;
1117                   typedef uint_least32_t  my_uint_least32_t;
1118                   typedef uint_least64_t  my_uint_least64_t;
1119                   typedef uintmax_t       my_uintmax_t;
1120                   typedef uintptr_t       my_uintptr_t;
1121                  ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no])
1122   ])
1123   AC_MSG_RESULT($ac_c99_stdint_tr1)
1124   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1125     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1126               [Define if C99 types in <stdint.h> should be imported in
1127               <tr1/cstdint> in namespace std::tr1.])
1128   fi
1129
1130   # Check for the existence of <math.h> functions.
1131   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1132   AC_CACHE_VAL(ac_c99_math_tr1, [
1133   AC_TRY_COMPILE([#include <math.h>],
1134                  [typedef double_t  my_double_t;
1135                   typedef float_t   my_float_t;
1136                   acosh(0.0);
1137                   acoshf(0.0f);
1138                   acoshl(0.0l);
1139                   asinh(0.0);
1140                   asinhf(0.0f);
1141                   asinhl(0.0l);
1142                   atanh(0.0);
1143                   atanhf(0.0f);
1144                   atanhl(0.0l);
1145                   cbrt(0.0);
1146                   cbrtf(0.0f);
1147                   cbrtl(0.0l);
1148                   copysign(0.0, 0.0);
1149                   copysignf(0.0f, 0.0f);
1150                   copysignl(0.0l, 0.0l);
1151                   erf(0.0);
1152                   erff(0.0f);
1153                   erfl(0.0l);
1154                   erfc(0.0);
1155                   erfcf(0.0f);
1156                   erfcl(0.0l);
1157                   exp2(0.0);
1158                   exp2f(0.0f);
1159                   exp2l(0.0l);
1160                   expm1(0.0);
1161                   expm1f(0.0f);
1162                   expm1l(0.0l);
1163                   fdim(0.0, 0.0);
1164                   fdimf(0.0f, 0.0f);
1165                   fdiml(0.0l, 0.0l);
1166                   fma(0.0, 0.0, 0.0);
1167                   fmaf(0.0f, 0.0f, 0.0f);
1168                   fmal(0.0l, 0.0l, 0.0l);
1169                   fmax(0.0, 0.0);
1170                   fmaxf(0.0f, 0.0f);
1171                   fmaxl(0.0l, 0.0l);
1172                   fmin(0.0, 0.0);
1173                   fminf(0.0f, 0.0f);
1174                   fminl(0.0l, 0.0l);
1175                   hypot(0.0, 0.0);
1176                   hypotf(0.0f, 0.0f);
1177                   hypotl(0.0l, 0.0l);
1178                   ilogb(0.0);
1179                   ilogbf(0.0f);
1180                   ilogbl(0.0l);
1181                   lgamma(0.0);
1182                   lgammaf(0.0f);
1183                   lgammal(0.0l);
1184                   llrint(0.0);
1185                   llrintf(0.0f);
1186                   llrintl(0.0l);
1187                   llround(0.0);
1188                   llroundf(0.0f);
1189                   llroundl(0.0l);
1190                   log1p(0.0);
1191                   log1pf(0.0f);
1192                   log1pl(0.0l);
1193                   log2(0.0);
1194                   log2f(0.0f);
1195                   log2l(0.0l);
1196                   logb(0.0);
1197                   logbf(0.0f);
1198                   logbl(0.0l);
1199                   lrint(0.0);
1200                   lrintf(0.0f);
1201                   lrintl(0.0l);
1202                   lround(0.0);
1203                   lroundf(0.0f);
1204                   lroundl(0.0l);
1205                   nan(0);
1206                   nanf(0);
1207                   nanl(0);
1208                   nearbyint(0.0);
1209                   nearbyintf(0.0f);
1210                   nearbyintl(0.0l);
1211                   nextafter(0.0, 0.0);
1212                   nextafterf(0.0f, 0.0f);
1213                   nextafterl(0.0l, 0.0l);
1214                   nexttoward(0.0, 0.0);
1215                   nexttowardf(0.0f, 0.0f);
1216                   nexttowardl(0.0l, 0.0l);
1217                   remainder(0.0, 0.0);
1218                   remainderf(0.0f, 0.0f);
1219                   remainderl(0.0l, 0.0l);
1220                   remquo(0.0, 0.0, 0);
1221                   remquo(0.0f, 0.0f, 0);
1222                   remquo(0.0l, 0.0l, 0);
1223                   rint(0.0);
1224                   rintf(0.0f);
1225                   rintl(0.0l);
1226                   round(0.0);
1227                   roundf(0.0f);
1228                   roundl(0.0l);
1229                   scalbln(0.0, 0l);
1230                   scalblnf(0.0f, 0l);
1231                   scalblnl(0.0l, 0l);
1232                   scalbn(0.0, 0);
1233                   scalbnf(0.0f, 0);
1234                   scalbnl(0.0l, 0);
1235                   tgamma(0.0);
1236                   tgammaf(0.0f);
1237                   tgammal(0.0l);
1238                   trunc(0.0);
1239                   truncf(0.0f);
1240                   truncl(0.0l);
1241                  ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
1242   ])
1243   AC_MSG_RESULT($ac_c99_math_tr1)
1244   if test x"$ac_c99_math_tr1" = x"yes"; then
1245     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1246               [Define if C99 functions or macros in <math.h> should be imported
1247               in <tr1/cmath> in namespace std::tr1.])
1248   fi
1249
1250   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1251   # sense if the previous check fails, per C99, 7.8/1).
1252   ac_c99_inttypes_tr1=no;
1253   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1254     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1255     AC_TRY_COMPILE([#include <inttypes.h>],
1256                    [intmax_t i, numer, denom, base;
1257                     const char* s;
1258                     char** endptr;
1259                     intmax_t ret = imaxabs(i);
1260                     imaxdiv_t dret = imaxdiv(numer, denom);
1261                     ret = strtoimax(s, endptr, base);
1262                     uintmax_t uret = strtoumax(s, endptr, base);
1263                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1264   fi
1265   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1266   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1267     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1268               [Define if C99 functions in <inttypes.h> should be imported in
1269               <tr1/cinttypes> in namespace std::tr1.])
1270   fi
1271
1272   # Check for the existence of the <stdbool.h> header.
1273   AC_CHECK_HEADERS(stdbool.h)
1274
1275   AC_LANG_RESTORE
1276 ])
1277
1278 dnl
1279 dnl Check whether "dev/random" and "dev/urandom" are available for the
1280 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1281 dnl
1282 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1283
1284   AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1285   AC_CACHE_VAL(ac_random_tr1, [
1286   AC_TRY_RUN([#include <stdio.h>
1287               int main()
1288               {
1289                 return !(fopen("/dev/random", "r")
1290                          && fopen("/dev/urandom", "r"));
1291               }
1292              ],
1293              [ac_random_tr1=yes], [ac_random_tr1=no],
1294              [ac_random_tr1=no])
1295   ])
1296   AC_MSG_RESULT($ac_random_tr1)
1297   if test x"$ac_random_tr1" = x"yes"; then
1298     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1299               [Define if dev/random and dev/urandom are available for
1300                the random_device of TR1 (Chapter 5.1).])
1301   fi
1302
1303 ])
1304
1305 dnl
1306 dnl Check for what type of C headers to use.
1307 dnl
1308 dnl --enable-cheaders= [does stuff].
1309 dnl --disable-cheaders [does not do anything, really].
1310 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1311 dnl       Where DEFAULT is either `c' or `c_std'.
1312 dnl
1313 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1314   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1315     [construct "C" headers for g++], [permit c|c_std])
1316   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1317
1318   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1319
1320   AC_SUBST(C_INCLUDE_DIR)
1321   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1322   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1323   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1324 ])
1325
1326
1327 dnl
1328 dnl Check for which locale library to use.  The choice is mapped to
1329 dnl a subdirectory of config/locale.
1330 dnl
1331 dnl Default is generic.
1332 dnl
1333 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1334   AC_MSG_CHECKING([for C locale to use])
1335   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1336     [use MODEL for target locale package],
1337     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1338
1339   # If they didn't use this option switch, or if they specified --enable
1340   # with no specific model, we'll have to look for one.  If they
1341   # specified --disable (???), do likewise.
1342   if test $enable_clocale = no || test $enable_clocale = yes; then
1343      enable_clocale=auto
1344   fi
1345
1346   # Either a known package, or "auto"
1347   enable_clocale_flag=$enable_clocale
1348
1349   # Probe for locale support if no specific model is specified.
1350   # Default to "generic".
1351   if test $enable_clocale_flag = auto; then
1352     case ${target_os} in
1353       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1354         AC_EGREP_CPP([_GLIBCXX_ok], [
1355         #include <features.h>
1356         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1357           _GLIBCXX_ok
1358         #endif
1359         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1360
1361         # Test for bugs early in glibc-2.2.x series
1362           if test $enable_clocale_flag = gnu; then
1363           AC_TRY_RUN([
1364           #define _GNU_SOURCE 1
1365           #include <locale.h>
1366           #include <string.h>
1367           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1368           extern __typeof(newlocale) __newlocale;
1369           extern __typeof(duplocale) __duplocale;
1370           extern __typeof(strcoll_l) __strcoll_l;
1371           #endif
1372           int main()
1373           {
1374               const char __one[] = "Äuglein Augmen";
1375               const char __two[] = "Äuglein";
1376               int i;
1377               int j;
1378               __locale_t        loc;
1379                __locale_t        loc_dup;
1380               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1381               loc_dup = __duplocale(loc);
1382               i = __strcoll_l(__one, __two, loc);
1383               j = __strcoll_l(__one, __two, loc_dup);
1384               return 0;
1385           }
1386           ],
1387           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1388           [enable_clocale_flag=generic])
1389           fi
1390
1391         # ... at some point put __strxfrm_l tests in as well.
1392         ;;
1393       darwin* | freebsd*)
1394         enable_clocale_flag=darwin
1395         ;;
1396       *)
1397         enable_clocale_flag=generic
1398         ;;
1399     esac
1400   fi
1401
1402   # Deal with gettext issues.  Default to not using it (=no) until we detect
1403   # support for it later.  Let the user turn it off via --e/d, but let that
1404   # default to on for easier handling.
1405   USE_NLS=no
1406   AC_ARG_ENABLE(nls,
1407     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1408     [],
1409     [enable_nls=yes])
1410
1411   # Set configure bits for specified locale package
1412   case ${enable_clocale_flag} in
1413     generic)
1414       AC_MSG_RESULT(generic)
1415
1416       CLOCALE_H=config/locale/generic/c_locale.h
1417       CLOCALE_CC=config/locale/generic/c_locale.cc
1418       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1419       CCOLLATE_CC=config/locale/generic/collate_members.cc
1420       CCTYPE_CC=config/locale/generic/ctype_members.cc
1421       CMESSAGES_H=config/locale/generic/messages_members.h
1422       CMESSAGES_CC=config/locale/generic/messages_members.cc
1423       CMONEY_CC=config/locale/generic/monetary_members.cc
1424       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1425       CTIME_H=config/locale/generic/time_members.h
1426       CTIME_CC=config/locale/generic/time_members.cc
1427       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1428       ;;
1429     darwin)
1430       AC_MSG_RESULT(darwin or freebsd)
1431
1432       CLOCALE_H=config/locale/generic/c_locale.h
1433       CLOCALE_CC=config/locale/generic/c_locale.cc
1434       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1435       CCOLLATE_CC=config/locale/generic/collate_members.cc
1436       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1437       CMESSAGES_H=config/locale/generic/messages_members.h
1438       CMESSAGES_CC=config/locale/generic/messages_members.cc
1439       CMONEY_CC=config/locale/generic/monetary_members.cc
1440       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1441       CTIME_H=config/locale/generic/time_members.h
1442       CTIME_CC=config/locale/generic/time_members.cc
1443       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1444       ;;
1445
1446     gnu)
1447       AC_MSG_RESULT(gnu)
1448
1449       # Declare intention to use gettext, and add support for specific
1450       # languages.
1451       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1452       ALL_LINGUAS="de fr"
1453
1454       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1455       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1456       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1457         USE_NLS=yes
1458       fi
1459       # Export the build objects.
1460       for ling in $ALL_LINGUAS; do \
1461         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1462         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1463       done
1464       AC_SUBST(glibcxx_MOFILES)
1465       AC_SUBST(glibcxx_POFILES)
1466
1467       CLOCALE_H=config/locale/gnu/c_locale.h
1468       CLOCALE_CC=config/locale/gnu/c_locale.cc
1469       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1470       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1471       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1472       CMESSAGES_H=config/locale/gnu/messages_members.h
1473       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1474       CMONEY_CC=config/locale/gnu/monetary_members.cc
1475       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1476       CTIME_H=config/locale/gnu/time_members.h
1477       CTIME_CC=config/locale/gnu/time_members.cc
1478       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1479       ;;
1480     ieee_1003.1-2001)
1481       AC_MSG_RESULT(IEEE 1003.1)
1482
1483       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1484       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1485       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1486       CCOLLATE_CC=config/locale/generic/collate_members.cc
1487       CCTYPE_CC=config/locale/generic/ctype_members.cc
1488       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1489       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1490       CMONEY_CC=config/locale/generic/monetary_members.cc
1491       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1492       CTIME_H=config/locale/generic/time_members.h
1493       CTIME_CC=config/locale/generic/time_members.cc
1494       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1495       ;;
1496   esac
1497
1498   # This is where the testsuite looks for locale catalogs, using the
1499   # -DLOCALEDIR define during testsuite compilation.
1500   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1501   AC_SUBST(glibcxx_localedir)
1502
1503   # A standalone libintl (e.g., GNU libintl) may be in use.
1504   if test $USE_NLS = yes; then
1505     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1506     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1507   fi
1508   if test $USE_NLS = yes; then
1509     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1510               [Define if NLS translations are to be used.])
1511   fi
1512
1513   AC_SUBST(USE_NLS)
1514   AC_SUBST(CLOCALE_H)
1515   AC_SUBST(CMESSAGES_H)
1516   AC_SUBST(CCODECVT_CC)
1517   AC_SUBST(CCOLLATE_CC)
1518   AC_SUBST(CCTYPE_CC)
1519   AC_SUBST(CMESSAGES_CC)
1520   AC_SUBST(CMONEY_CC)
1521   AC_SUBST(CNUMERIC_CC)
1522   AC_SUBST(CTIME_H)
1523   AC_SUBST(CTIME_CC)
1524   AC_SUBST(CLOCALE_CC)
1525   AC_SUBST(CLOCALE_INTERNAL_H)
1526 ])
1527
1528
1529 dnl
1530 dnl Check for which std::allocator base class to use.  The choice is
1531 dnl mapped from a subdirectory of include/ext.
1532 dnl
1533 dnl Default is new.
1534 dnl
1535 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1536   AC_MSG_CHECKING([for std::allocator base class])
1537   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1538     [use KIND for target std::allocator base],
1539     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1540
1541   # If they didn't use this option switch, or if they specified --enable
1542   # with no specific model, we'll have to look for one.  If they
1543   # specified --disable (???), do likewise.
1544   if test $enable_libstdcxx_allocator = no ||
1545      test $enable_libstdcxx_allocator = yes;
1546   then
1547      enable_libstdcxx_allocator=auto
1548   fi
1549
1550   # Either a known package, or "auto". Auto implies the default choice
1551   # for a particular platform.
1552   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1553
1554   # Probe for host-specific support if no specific model is specified.
1555   # Default to "new".
1556   if test $enable_libstdcxx_allocator_flag = auto; then
1557     case ${target_os} in
1558       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1559         enable_libstdcxx_allocator_flag=new
1560         ;;
1561       *)
1562         enable_libstdcxx_allocator_flag=new
1563         ;;
1564     esac
1565   fi
1566   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1567
1568
1569   # Set configure bits for specified locale package
1570   case ${enable_libstdcxx_allocator_flag} in
1571     bitmap)
1572       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1573       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1574       ;;
1575     malloc)
1576       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1577       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1578       ;;
1579     mt)
1580       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1581       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1582       ;;
1583     new)
1584       ALLOCATOR_H=config/allocator/new_allocator_base.h
1585       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1586       ;;
1587     pool)
1588       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1589       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1590       ;;
1591   esac
1592
1593   AC_SUBST(ALLOCATOR_H)
1594   AC_SUBST(ALLOCATOR_NAME)
1595 ])
1596
1597
1598 dnl
1599 dnl Check for whether the Boost-derived checks should be turned on.
1600 dnl
1601 dnl --enable-concept-checks turns them on.
1602 dnl --disable-concept-checks leaves them off.
1603 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1604 dnl       Where DEFAULT is either `yes' or `no'.
1605 dnl
1606 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1607   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1608   if test $enable_concept_checks = yes; then
1609     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1610               [Define to use concept checking code from the boost libraries.])
1611   fi
1612 ])
1613
1614
1615 dnl
1616 dnl Check for which I/O library to use:  stdio, or something specific.
1617 dnl
1618 dnl Default is stdio.
1619 dnl
1620 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1621   AC_MSG_CHECKING([for underlying I/O to use])
1622   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1623     [use target-specific I/O package], [permit stdio])
1624
1625   # Now that libio has been removed, you can have any color you want as long
1626   # as it's black.  This is one big no-op until other packages are added, but
1627   # showing the framework never hurts.
1628   case ${enable_cstdio} in
1629     stdio)
1630       CSTDIO_H=config/io/c_io_stdio.h
1631       BASIC_FILE_H=config/io/basic_file_stdio.h
1632       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1633       AC_MSG_RESULT(stdio)
1634       ;;
1635   esac
1636
1637   AC_SUBST(CSTDIO_H)
1638   AC_SUBST(BASIC_FILE_H)
1639   AC_SUBST(BASIC_FILE_CC)
1640 ])
1641
1642
1643 dnl
1644 dnl Check for "unusual" flags to pass to the compiler while building.
1645 dnl
1646 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1647 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1648 dnl --disable-cxx-flags passes nothing.
1649 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1650 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1651 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1652 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1653 dnl       If "default flags" is an empty string, the effect is the same
1654 dnl       as --disable or --enable=no.
1655 dnl
1656 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1657   AC_MSG_CHECKING([for extra compiler flags for building])
1658   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1659     [pass compiler FLAGS when building library],
1660     [case "x$enable_cxx_flags" in
1661       xno | x)   enable_cxx_flags= ;;
1662       x-*)       ;;
1663       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1664      esac])
1665
1666   # Run through flags (either default or command-line) and set anything
1667   # extra (e.g., #defines) that must accompany particular g++ options.
1668   if test -n "$enable_cxx_flags"; then
1669     for f in $enable_cxx_flags; do
1670       case "$f" in
1671         -fhonor-std)  ;;
1672         -*)  ;;
1673         *)   # and we're trying to pass /what/ exactly?
1674              AC_MSG_ERROR([compiler flags start with a -]) ;;
1675       esac
1676     done
1677   fi
1678
1679   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1680   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1681   AC_SUBST(EXTRA_CXX_FLAGS)
1682 ])
1683
1684
1685 dnl
1686 dnl Check to see if debugging libraries are to be built.
1687 dnl
1688 dnl --enable-libstdcxx-debug
1689 dnl builds a separate set of debugging libraries in addition to the
1690 dnl normal (shared, static) libstdc++ binaries.
1691 dnl
1692 dnl --disable-libstdcxx-debug
1693 dnl builds only one (non-debug) version of libstdc++.
1694 dnl
1695 dnl --enable-libstdcxx-debug-flags=FLAGS
1696 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1697 dnl
1698 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1699 dnl       Where DEFAULT is either `yes' or `no'.
1700 dnl
1701 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1702   AC_MSG_CHECKING([for additional debug build])
1703   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1704   AC_MSG_RESULT($enable_libstdcxx_debug)
1705   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1706 ])
1707
1708
1709 dnl
1710 dnl Check for explicit debug flags.
1711 dnl
1712 dnl --enable-libstdcxx-debug-flags='-O1'
1713 dnl is a general method for passing flags to be used when
1714 dnl building debug libraries with --enable-debug.
1715 dnl
1716 dnl --disable-libstdcxx-debug-flags does nothing.
1717 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1718 dnl       If "default flags" is an empty string, the effect is the same
1719 dnl       as --disable or --enable=no.
1720 dnl
1721 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1722   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1723     [pass compiler FLAGS when building debug library],
1724     [case "x$enable_libstdcxx_debug_flags" in
1725       xno | x)    enable_libstdcxx_debug_flags= ;;
1726       x-*)        ;;
1727       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1728      esac])
1729
1730   # Option parsed, now set things appropriately
1731   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1732   AC_SUBST(DEBUG_FLAGS)
1733
1734   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1735 ])
1736
1737
1738 dnl
1739 dnl Check if the user only wants a freestanding library implementation.
1740 dnl
1741 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1742 dnl installing only the headers required by [17.4.1.3] and the language
1743 dnl support library.  More than that will be built (to keep the Makefiles
1744 dnl conveniently clean), but not installed.
1745 dnl
1746 dnl Sets:
1747 dnl  is_hosted  (yes/no)
1748 dnl
1749 dnl Defines:
1750 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1751 dnl
1752 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1753   AC_ARG_ENABLE([hosted-libstdcxx],
1754     AC_HELP_STRING([--disable-hosted-libstdcxx],
1755                    [only build freestanding C++ runtime support]),,
1756     [case "$host" in
1757         arm*-*-symbianelf*)
1758             enable_hosted_libstdcxx=no
1759             ;;
1760         *)
1761             enable_hosted_libstdcxx=yes
1762             ;;
1763      esac])
1764   if test "$enable_hosted_libstdcxx" = no; then
1765     AC_MSG_NOTICE([Only freestanding libraries will be built])
1766     is_hosted=no
1767     hosted_define=0
1768     enable_abi_check=no
1769     enable_libstdcxx_pch=no
1770   else
1771     is_hosted=yes
1772     hosted_define=1
1773   fi
1774   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1775   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1776     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1777 ])
1778
1779
1780 dnl
1781 dnl Check for template specializations for the 'long long' type.
1782 dnl The result determines only whether 'long long' I/O is enabled; things
1783 dnl like numeric_limits<> specializations are always available.
1784 dnl
1785 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1786 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1787 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1788 dnl       Where DEFAULT is either `yes' or `no'.
1789 dnl
1790 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1791   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1792   if test $enable_long_long = yes; then
1793     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1794               [Define if code specialized for long long should be used.])
1795   fi
1796   AC_MSG_CHECKING([for enabled long long specializations])
1797   AC_MSG_RESULT([$enable_long_long])
1798 ])
1799
1800
1801 dnl
1802 dnl Check for template specializations for the 'wchar_t' type.
1803 dnl
1804 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1805 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1806 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1807 dnl       Where DEFAULT is either `yes' or `no'.
1808 dnl
1809 dnl Necessary support must also be present.
1810 dnl
1811 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1812   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1813
1814   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
1815   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
1816   AC_MSG_CHECKING([for mbstate_t])
1817   AC_TRY_COMPILE([#include <wchar.h>],
1818   [mbstate_t teststate;],
1819   have_mbstate_t=yes, have_mbstate_t=no)
1820   AC_MSG_RESULT($have_mbstate_t)
1821   if test x"$have_mbstate_t" = xyes; then
1822     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
1823   fi
1824
1825   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
1826   # ac_has_wchar_h.
1827   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
1828
1829   if test x"$enable_wchar_t" = x"yes"; then
1830
1831     AC_LANG_SAVE
1832     AC_LANG_CPLUSPLUS
1833
1834     if test x"$ac_has_wchar_h" = xyes &&
1835        test x"$ac_has_wctype_h" = xyes; then
1836       AC_TRY_COMPILE([#include <wchar.h>
1837                       #include <stddef.h>
1838                       wint_t i;
1839                       long l = WEOF;
1840                       long j = WCHAR_MIN;
1841                       long k = WCHAR_MAX;
1842                       namespace test
1843                       {
1844                         using ::btowc;
1845                         using ::fgetwc;
1846                         using ::fgetws;
1847                         using ::fputwc;
1848                         using ::fputws;
1849                         using ::fwide;
1850                         using ::fwprintf;
1851                         using ::fwscanf;
1852                         using ::getwc;
1853                         using ::getwchar;
1854                         using ::mbrlen;
1855                         using ::mbrtowc;
1856                         using ::mbsinit;
1857                         using ::mbsrtowcs;
1858                         using ::putwc;
1859                         using ::putwchar;
1860                         using ::swprintf;
1861                         using ::swscanf;
1862                         using ::ungetwc;
1863                         using ::vfwprintf;
1864                         using ::vswprintf;
1865                         using ::vwprintf;
1866                         using ::wcrtomb;
1867                         using ::wcscat;
1868                         using ::wcschr;
1869                         using ::wcscmp;
1870                         using ::wcscoll;
1871                         using ::wcscpy;
1872                         using ::wcscspn;
1873                         using ::wcsftime;
1874                         using ::wcslen;
1875                         using ::wcsncat;
1876                         using ::wcsncmp;
1877                         using ::wcsncpy;
1878                         using ::wcspbrk;
1879                         using ::wcsrchr;
1880                         using ::wcsrtombs;
1881                         using ::wcsspn;
1882                         using ::wcsstr;
1883                         using ::wcstod;
1884                         using ::wcstok;
1885                         using ::wcstol;
1886                         using ::wcstoul;
1887                         using ::wcsxfrm;
1888                         using ::wctob;
1889                         using ::wmemchr;
1890                         using ::wmemcmp;
1891                         using ::wmemcpy;
1892                         using ::wmemmove;
1893                         using ::wmemset;
1894                         using ::wprintf;
1895                         using ::wscanf;
1896                       }
1897                      ],[],[], [enable_wchar_t=no])
1898     else
1899       enable_wchar_t=no
1900     fi
1901
1902     AC_LANG_RESTORE
1903   fi
1904
1905   if test x"$enable_wchar_t" = x"yes"; then
1906     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
1907               [Define if code specialized for wchar_t should be used.])
1908   fi
1909
1910   AC_MSG_CHECKING([for enabled wchar_t specializations])
1911   AC_MSG_RESULT([$enable_wchar_t])
1912 ])
1913
1914
1915 dnl
1916 dnl Check to see if building and using a C++ precompiled header can be done.
1917 dnl
1918 dnl --enable-libstdcxx-pch=yes
1919 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1920 dnl may work, after some light-hearted attempts to puzzle out compiler
1921 dnl support, flip bits on in include/Makefile.am
1922 dnl
1923 dnl --disable-libstdcxx-pch
1924 dnl turns off attempts to use or build stdc++.h.gch.
1925 dnl
1926 dnl Substs:
1927 dnl  glibcxx_PCHFLAGS
1928 dnl
1929 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1930   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1931   if test $enable_libstdcxx_pch = yes; then
1932     AC_CACHE_CHECK([for compiler with PCH support],
1933       [glibcxx_cv_prog_CXX_pch],
1934       [ac_save_CXXFLAGS="$CXXFLAGS"
1935        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1936        AC_LANG_SAVE
1937        AC_LANG_CPLUSPLUS
1938        echo '#include <math.h>' > conftest.h
1939        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1940                           -o conftest.h.gch 1>&5 2>&1 &&
1941                 echo '#error "pch failed"' > conftest.h &&
1942           echo '#include "conftest.h"' > conftest.cc &&
1943                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1944        then
1945          glibcxx_cv_prog_CXX_pch=yes
1946        else
1947          glibcxx_cv_prog_CXX_pch=no
1948        fi
1949        rm -f conftest*
1950        CXXFLAGS=$ac_save_CXXFLAGS
1951        AC_LANG_RESTORE
1952       ])
1953     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1954   fi
1955
1956   AC_MSG_CHECKING([for enabled PCH])
1957   AC_MSG_RESULT([$enable_libstdcxx_pch])
1958
1959   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1960   if test $enable_libstdcxx_pch = yes; then
1961     glibcxx_PCHFLAGS="-include bits/stdc++.h"
1962   else
1963     glibcxx_PCHFLAGS=""
1964   fi
1965   AC_SUBST(glibcxx_PCHFLAGS)
1966 ])
1967
1968
1969 dnl
1970 dnl Check for atomic builtins.
1971 dnl See:
1972 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
1973 dnl
1974 dnl This checks to see if the host supports the compiler-generated
1975 dnl builtins for atomic operations. Note, this is intended to be an
1976 dnl all-or-nothing switch, so all the atomic operations that are used
1977 dnl should be checked.
1978 dnl
1979 dnl Note:
1980 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
1981 dnl see: CHECK_SYNC_FETCH_AND_ADD
1982 dnl
1983 dnl Defines:
1984 dnl  _GLIBCXX_ATOMIC_BUILTINS if the compiler on this target supports atomics.
1985 dnl
1986 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
1987   AC_MSG_CHECKING([for atomic builtins])
1988   AC_LANG_SAVE
1989   AC_LANG_CPLUSPLUS
1990
1991   # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
1992     cat > conftest.$ac_ext << EOF
1993 [#]line __oline__ "configure"
1994 int main()
1995 {
1996   // NB: _Atomic_word not necessarily int.
1997   typedef int atomic_type;
1998   atomic_type c1;
1999   atomic_type c2;
2000   const atomic_type c3(0);
2001   if (__sync_fetch_and_add(&c1, c2) == c3)
2002     {
2003       // Do something.
2004     }
2005    return 0;
2006 }
2007 EOF
2008     old_CXXFLAGS="$CXXFLAGS"
2009     CXXFLAGS="$CXXFLAGS -S"
2010     if AC_TRY_EVAL(ac_compile); then
2011       if grep __sync_fetch_and_add conftest.s >/dev/null 2>&1 ; then
2012         enable_atomic_builtins=no
2013       else
2014       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2015         [Define if builtin atomic operations are supported on this host.])
2016         enable_atomic_builtins=yes
2017         atomicity_dir=cpu/generic/atomicity_builtins
2018       fi
2019     fi
2020     CXXFLAGS="$old_CXXFLAGS"
2021     rm -f conftest*
2022
2023    # Now, if still generic, set to mutex.
2024   if test $atomicity_dir = "cpu/generic" ; then
2025         atomicity_dir=cpu/generic/atomicity_mutex
2026   fi
2027  AC_LANG_RESTORE
2028  AC_MSG_RESULT($enable_atomic_builtins)
2029 ])
2030
2031
2032 dnl
2033 dnl Check for exception handling support.  If an explicit enable/disable
2034 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2035 dnl target may or may not support call frame exceptions.
2036 dnl
2037 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2038 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2039 dnl Neither one forces an attempt at detection.
2040 dnl
2041 dnl Defines:
2042 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2043 dnl
2044 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2045   AC_MSG_CHECKING([for exception model to use])
2046   AC_LANG_SAVE
2047   AC_LANG_CPLUSPLUS
2048   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2049     [force use of builtin_setjmp for exceptions],
2050     [permit yes|no|auto])
2051
2052   if test $enable_sjlj_exceptions = auto; then
2053     # Botheration.  Now we've got to detect the exception model.  Link tests
2054     # against libgcc.a are problematic since we've not been given proper -L
2055     # bits for single-tree newlib and libgloss.
2056     #
2057     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2058     cat > conftest.$ac_ext << EOF
2059 [#]line __oline__ "configure"
2060 struct S { ~S(); };
2061 void bar();
2062 void foo()
2063 {
2064   S s;
2065   bar();
2066 }
2067 EOF
2068     old_CXXFLAGS="$CXXFLAGS"
2069     CXXFLAGS=-S
2070     if AC_TRY_EVAL(ac_compile); then
2071       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2072         enable_sjlj_exceptions=yes
2073       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2074         enable_sjlj_exceptions=no
2075       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2076         enable_sjlj_exceptions=no
2077       fi
2078     fi
2079     CXXFLAGS="$old_CXXFLAGS"
2080     rm -f conftest*
2081   fi
2082
2083   # This is a tad weird, for hysterical raisins.  We have to map
2084   # enable/disable to two different models.
2085   case $enable_sjlj_exceptions in
2086     yes)
2087       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2088         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2089       ac_exception_model_name=sjlj
2090       ;;
2091     no)
2092       ac_exception_model_name="call frame"
2093       ;;
2094     *)
2095       AC_MSG_ERROR([unable to detect exception model])
2096       ;;
2097   esac
2098  AC_LANG_RESTORE
2099  AC_MSG_RESULT($ac_exception_model_name)
2100 ])
2101
2102
2103 dnl
2104 dnl Add version tags to symbols in shared library (or not), additionally
2105 dnl marking other symbols as private/local (or not).
2106 dnl
2107 dnl --enable-symvers=style adds a version script to the linker call when
2108 dnl       creating the shared library.  The choice of version script is
2109 dnl       controlled by 'style'.
2110 dnl --disable-symvers does not.
2111 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2112 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2113 dnl       choose a default style based on linker characteristics.  Passing
2114 dnl       'no' disables versioning.
2115 dnl
2116 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2117
2118 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2119   [enables symbol versioning of the shared library],
2120   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2121
2122 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2123 # don't know enough about $LD to do tricks...
2124 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2125
2126 # Turn a 'yes' into a suitable default.
2127 if test x$enable_symvers = xyes ; then
2128   if test $enable_shared = no || test "x$LD" = x ; then
2129     enable_symvers=no
2130   else
2131     if test $with_gnu_ld = yes ; then
2132       enable_symvers=gnu
2133     else
2134       case ${target_os} in
2135         darwin*)
2136           enable_symvers=darwin ;;
2137         *)
2138           enable_symvers=no ;;
2139       esac
2140     fi
2141   fi
2142 fi
2143
2144 # Check to see if 'darwin' or 'darwin-export' can win.
2145 if test x$enable_symvers = xdarwin-export ; then
2146     enable_symvers=darwin
2147 fi
2148
2149 # Check to see if 'gnu' can win.
2150 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2151   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2152   AC_MSG_CHECKING([for shared libgcc])
2153   ac_save_CFLAGS="$CFLAGS"
2154   CFLAGS=' -lgcc_s'
2155   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2156   CFLAGS="$ac_save_CFLAGS"
2157   if test $glibcxx_shared_libgcc = no; then
2158     cat > conftest.c <<EOF
2159 int main (void) { return 0; }
2160 EOF
2161 changequote(,)dnl
2162     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2163                              -shared -shared-libgcc -o conftest.so \
2164                              conftest.c -v 2>&1 >/dev/null \
2165                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2166 changequote([,])dnl
2167     rm -f conftest.c conftest.so
2168     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2169       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2170       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2171       CFLAGS="$ac_save_CFLAGS"
2172     fi
2173   fi
2174   AC_MSG_RESULT($glibcxx_shared_libgcc)
2175
2176   # For GNU ld, we need at least this version.  The format is described in
2177   # GLIBCXX_CHECK_LINKER_FEATURES above.
2178   glibcxx_min_gnu_ld_version=21400
2179
2180   # If no shared libgcc, can't win.
2181   if test $glibcxx_shared_libgcc != yes; then
2182       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2183       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2184       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2185       enable_symvers=no
2186   elif test $with_gnu_ld != yes ; then
2187     # just fail for now
2188     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2189     AC_MSG_WARN([=== you are not using the GNU linker.])
2190     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2191     enable_symvers=no
2192   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2193     # The right tools, the right setup, but too old.  Fallbacks?
2194     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2195     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2196     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2197     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2198     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2199     enable_symvers=no
2200   fi
2201 fi
2202
2203 # Everything parsed; figure out what file to use.
2204 case $enable_symvers in
2205   no)
2206     SYMVER_FILE=config/abi/pre/none.ver
2207     ;;
2208   gnu)
2209     SYMVER_FILE=config/abi/pre/gnu.ver
2210     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2211               [Define to use GNU versioning in the shared library.])
2212     ;;
2213   gnu-versioned-namespace)
2214     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2215     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2216               [Define to use GNU namespace versioning in the shared library.])
2217     ;;
2218   darwin)
2219     SYMVER_FILE=config/abi/pre/gnu.ver
2220     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2221               [Define to use darwin versioning in the shared library.])
2222     ;;
2223 esac
2224
2225 if test x$enable_symvers != xno ; then
2226   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2227          [Define to use symbol versioning in the shared library.])
2228 fi
2229
2230 AC_SUBST(SYMVER_FILE)
2231 AC_SUBST(port_specific_symbol_files)
2232 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2233 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2234 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2235 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2236 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2237
2238 # Now, set up compatibility support, if any.
2239 # In addition, need this to deal with std::size_t mangling in
2240 # src/compatibility.cc.  In a perfect world, could use
2241 # typeid(std::size_t).name()[0] to do direct substitution.
2242 AC_MSG_CHECKING([for size_t as unsigned int])
2243 ac_save_CFLAGS="$CFLAGS"
2244 CFLAGS="-Werror"
2245 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2246                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2247 CFLAGS=$ac_save_CFLAGS
2248 if test "$glibcxx_size_t_is_i" = yes; then
2249   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2250 fi
2251 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2252
2253 AC_MSG_CHECKING([for ptrdiff_t as int])
2254 ac_save_CFLAGS="$CFLAGS"
2255 CFLAGS="-Werror"
2256 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2257                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2258 CFLAGS=$ac_save_CFLAGS
2259 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2260   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2261 fi
2262 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2263 ])
2264
2265
2266 dnl
2267 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2268 dnl We must stage the required headers so that they will be installed
2269 dnl with the library (unlike libgcc, the STL implementation is provided
2270 dnl solely within headers).  Since we must not inject random user-space
2271 dnl macro names into user-provided C++ code, we first stage into <file>-in
2272 dnl and process to <file> with an output command.  The reason for a two-
2273 dnl stage process here is to correctly handle $srcdir!=$objdir without
2274 dnl having to write complex code (the sed commands to clean the macro
2275 dnl namespace are complex and fragile enough as it is).  We must also
2276 dnl add a relative path so that -I- is supported properly.
2277 dnl
2278 dnl Substs:
2279 dnl  glibcxx_thread_h
2280 dnl
2281 dnl Defines:
2282 dnl  HAVE_GTHR_DEFAULT
2283 dnl
2284 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2285   AC_MSG_CHECKING([for thread model used by GCC])
2286   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2287   AC_MSG_RESULT([$target_thread_file])
2288
2289   if test $target_thread_file != single; then
2290     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2291               [Define if gthr-default.h exists
2292               (meaning that threading support is enabled).])
2293   fi
2294
2295   glibcxx_thread_h=gthr-$target_thread_file.h
2296
2297   dnl Check for __GTHREADS define.
2298   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2299   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2300     enable_thread=yes
2301   else
2302    enable_thread=no
2303   fi
2304
2305   AC_SUBST(glibcxx_thread_h)
2306 ])
2307
2308
2309 # Check whether LC_MESSAGES is available in <locale.h>.
2310 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2311 #
2312 # This file file be copied and used freely without restrictions.  It can
2313 # be used in projects which are not available under the GNU Public License
2314 # but which still want to provide support for the GNU gettext functionality.
2315 # Please note that the actual code is *not* freely available.
2316
2317 # serial 1
2318 AC_DEFUN([AC_LC_MESSAGES], [
2319   AC_CHECK_HEADER(locale.h, [
2320     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2321       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2322        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2323     if test $ac_cv_val_LC_MESSAGES = yes; then
2324       AC_DEFINE(HAVE_LC_MESSAGES, 1,
2325                 [Define if LC_MESSAGES is available in <locale.h>.])
2326     fi
2327   ])
2328 ])
2329
2330 # Macros from the top-level gcc directory.
2331 m4_include([../config/tls.m4])
2332