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