libstdc++-v3/acinclude.m4

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