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