libstdc++-v3/acinclude.m4

   1 dnl
   2 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
   3 dnl
   4 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
   5 dnl end of configure.  This lets tested variables be reassigned, and the
   6 dnl conditional will depend on the final state of the variable.  For a simple
   7 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
   8 dnl
   9 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
  10 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
  11   m4_divert_text([glibcxx_diversion],dnl
  12    AM_CONDITIONAL([$1],[$2])
  13   )dnl
  14 ])dnl
  15 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
  16
  17
  18 dnl
  19 dnl Check to see what architecture and operating system we are compiling
  20 dnl for.  Also, if architecture- or OS-specific flags are required for
  21 dnl compilation, pick them up here.
  22 dnl
  23 AC_DEFUN([GLIBCXX_CHECK_HOST], [
  24   . $glibcxx_srcdir/configure.host
  25   AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
  26   AC_MSG_NOTICE([OS config directory is $os_include_dir])
  27 ])
  28
  29 dnl
  30 dnl Initialize the rest of the library configury.  At this point we have
  31 dnl variables like $host.
  32 dnl
  33 dnl Sets:
  34 dnl  SUBDIRS
  35 dnl Substs:
  36 dnl  glibcxx_builddir     (absolute path)
  37 dnl  glibcxx_srcdir       (absolute path)
  38 dnl  toplevel_srcdir      (absolute path)
  39 dnl  with_cross_host
  40 dnl  with_newlib
  41 dnl  with_target_subdir
  42 dnl plus
  43 dnl  - the variables in GLIBCXX_CHECK_HOST / configure.host
  44 dnl  - default settings for all AM_CONFITIONAL test variables
  45 dnl  - lots of tools, like CC and CXX
  46 dnl
  47 AC_DEFUN([GLIBCXX_CONFIGURE], [
  48   # Keep these sync'd with the list in Makefile.am.  The first provides an
  49   # expandable list at autoconf time; the second provides an expandable list
  50   # (i.e., shell variable) at configure time.
  51   m4_define([glibcxx_SUBDIRS],[include libsupc++ python src doc po testsuite])
  52   SUBDIRS='glibcxx_SUBDIRS'
  53
  54   # These need to be absolute paths, yet at the same time need to
  55   # canonicalize only relative paths, because then amd will not unmount
  56   # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
  57   glibcxx_builddir=`${PWDCMD-pwd}`
  58   case $srcdir in
  59     [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
  60     *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
  61   esac
  62   toplevel_srcdir=${glibcxx_srcdir}/..
  63   AC_SUBST(glibcxx_builddir)
  64   AC_SUBST(glibcxx_srcdir)
  65   AC_SUBST(toplevel_srcdir)
  66
  67   # We use these options to decide which functions to include.  They are
  68   # set from the top level.
  69   AC_ARG_WITH([target-subdir],
  70     AC_HELP_STRING([--with-target-subdir=SUBDIR],
  71                    [configuring in a subdirectory]))
  72
  73   AC_ARG_WITH([cross-host],
  74     AC_HELP_STRING([--with-cross-host=HOST],
  75                    [configuring with a cross compiler]))
  76
  77   AC_ARG_WITH([newlib],
  78     AC_HELP_STRING([--with-newlib],
  79                    [assume newlib as a system C library]))
  80
  81   # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
  82   # available).  Uncomment the next line to force a particular method.
  83   AC_PROG_LN_S
  84   #LN_S='cp -p'
  85
  86   AC_CHECK_TOOL(AS, as)
  87   AC_CHECK_TOOL(AR, ar)
  88   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
  89
  90   AM_MAINTAINER_MODE
  91
  92   # Set up safe default values for all subsequent AM_CONDITIONAL tests
  93   # which are themselves conditionally expanded.
  94   ## (Right now, this only matters for enable_wchar_t, but nothing prevents
  95   ## other macros from doing the same.  This should be automated.)  -pme
  96
  97   # Check for C library flavor since Linux platforms use different configuration
  98   # directories depending on the C library in use.
  99   AC_EGREP_CPP([_using_uclibc], [
 100   #include <stdio.h>
 101   #if __UCLIBC__
 102     _using_uclibc
 103   #endif
 104   ], uclibc=yes, uclibc=no)
 105
 106   AC_EGREP_CPP([_using_bionic], [
 107   #include <stdio.h>
 108   #if __BIONIC__
 109     _using_bionic
 110   #endif
 111   ], bionic=yes, bionic=no)
 112
 113   # Find platform-specific directories containing configuration info.
 114   # Also possibly modify flags used elsewhere, as needed by the platform.
 115   GLIBCXX_CHECK_HOST
 116 ])
 117
 118
 119 dnl
 120 dnl Tests for newer compiler features, or features that are present in newer
 121 dnl compiler versions but not older compiler versions still in use, should
 122 dnl be placed here.
 123 dnl
 124 dnl Defines:
 125 dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
 126 dnl   new inlining code or the new system_header pragma will die on -Werror.
 127 dnl   Leave it out by default and use maint-mode to use it.
 128 dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 129 dnl   compiler supports it and the user has not requested debug mode.
 130 dnl
 131 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
 132   # All these tests are for C++; save the language and the compiler flags.
 133   # The CXXFLAGS thing is suspicious, but based on similar bits previously
 134   # found in GLIBCXX_CONFIGURE.
 135   AC_LANG_SAVE
 136   AC_LANG_CPLUSPLUS
 137   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 138   ac_save_CXXFLAGS="$CXXFLAGS"
 139
 140   # Check for maintainer-mode bits.
 141   if test x"$USE_MAINTAINER_MODE" = xno; then
 142     WERROR=''
 143   else
 144     WERROR='-Werror'
 145   fi
 146
 147   # Check for -ffunction-sections -fdata-sections
 148   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
 149   CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
 150   AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
 151   if test "$ac_test_CXXFLAGS" = set; then
 152     CXXFLAGS="$ac_save_CXXFLAGS"
 153   else
 154     # this is the suspicious part
 155     CXXFLAGS=''
 156   fi
 157   if test x"$ac_fdsections" = x"yes"; then
 158     SECTION_FLAGS='-ffunction-sections -fdata-sections'
 159   fi
 160   AC_MSG_RESULT($ac_fdsections)
 161
 162   AC_LANG_RESTORE
 163   AC_SUBST(WERROR)
 164   AC_SUBST(SECTION_FLAGS)
 165 ])
 166
 167
 168 dnl
 169 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
 170 dnl the native linker is in use, all variables will be defined to something
 171 dnl safe (like an empty string).
 172 dnl
 173 dnl Defines:
 174 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
 175 dnl  OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
 176 dnl  LD (as a side effect of testing)
 177 dnl Sets:
 178 dnl  with_gnu_ld
 179 dnl  glibcxx_ld_is_gold (set to "no" or "yes")
 180 dnl  glibcxx_gnu_ld_version (possibly)
 181 dnl
 182 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
 183 dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
 184 dnl
 185 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
 186   # If we're not using GNU ld, then there's no point in even trying these
 187   # tests.  Check for that first.  We should have already tested for gld
 188   # by now (in libtool), but require it now just to be safe...
 189   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
 190   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
 191   AC_REQUIRE([AC_PROG_LD])
 192   AC_REQUIRE([AC_PROG_AWK])
 193
 194   # The name set by libtool depends on the version of libtool.  Shame on us
 195   # for depending on an impl detail, but c'est la vie.  Older versions used
 196   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
 197   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
 198   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
 199   # set (hence we're using an older libtool), then set it.
 200   if test x${with_gnu_ld+set} != xset; then
 201     if test x${ac_cv_prog_gnu_ld+set} != xset; then
 202       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
 203       with_gnu_ld=no
 204     else
 205       with_gnu_ld=$ac_cv_prog_gnu_ld
 206     fi
 207   fi
 208
 209   # Start by getting the version number.  I think the libtool test already
 210   # does some of this, but throws away the result.
 211   glibcxx_ld_is_gold=no
 212   if test x"$with_gnu_ld" = x"yes"; then
 213     AC_MSG_CHECKING([for ld version])
 214     changequote(,)
 215     if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
 216       glibcxx_ld_is_gold=yes
 217     fi
 218     ldver=`$LD --version 2>/dev/null |
 219            sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'`
 220     changequote([,])
 221     glibcxx_gnu_ld_version=`echo $ldver | \
 222            $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
 223     AC_MSG_RESULT($glibcxx_gnu_ld_version)
 224   fi
 225
 226   # Set --gc-sections.
 227   glibcxx_have_gc_sections=no
 228   if test "$glibcxx_ld_is_gold" = "yes"; then
 229     if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
 230       glibcxx_have_gc_sections=yes
 231     fi
 232   else
 233     glibcxx_gcsections_min_ld=21602
 234     if test x"$with_gnu_ld" = x"yes" &&
 235         test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
 236       glibcxx_have_gc_sections=yes
 237     fi
 238   fi
 239   if test "$glibcxx_have_gc_sections" = "yes"; then
 240     # Sufficiently young GNU ld it is!  Joy and bunny rabbits!
 241     # NB: This flag only works reliably after 2.16.1. Configure tests
 242     # for this are difficult, so hard wire a value that should work.
 243
 244     ac_test_CFLAGS="${CFLAGS+set}"
 245     ac_save_CFLAGS="$CFLAGS"
 246     CFLAGS='-Wl,--gc-sections'
 247
 248     # Check for -Wl,--gc-sections
 249     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
 250     AC_TRY_LINK([ int one(void) { return 1; }
 251      int two(void) { return 2; }
 252         ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
 253     if test "$ac_gcsections" = "yes"; then
 254       rm -f conftest.c
 255       touch conftest.c
 256       if $CC -c conftest.c; then
 257         if $LD --gc-sections -o conftest conftest.o 2>&1 | \
 258            grep "Warning: gc-sections option ignored" > /dev/null; then
 259           ac_gcsections=no
 260         fi
 261       fi
 262       rm -f conftest.c conftest.o conftest
 263     fi
 264     if test "$ac_gcsections" = "yes"; then
 265       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
 266     fi
 267     AC_MSG_RESULT($ac_gcsections)
 268
 269     if test "$ac_test_CFLAGS" = set; then
 270       CFLAGS="$ac_save_CFLAGS"
 271     else
 272       # this is the suspicious part
 273       CFLAGS=''
 274     fi
 275   fi
 276
 277   # Set -z,relro.
 278   # Note this is only for shared objects.
 279   ac_ld_relro=no
 280   if test x"$with_gnu_ld" = x"yes"; then
 281     AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
 282     cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
 283     if test -n "$cxx_z_relo"; then
 284       OPT_LDFLAGS="-Wl,-z,relro"
 285       ac_ld_relro=yes
 286     fi
 287     AC_MSG_RESULT($ac_ld_relro)
 288   fi
 289
 290   # Set linker optimization flags.
 291   if test x"$with_gnu_ld" = x"yes"; then
 292     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
 293   fi
 294
 295   AC_SUBST(SECTION_LDFLAGS)
 296   AC_SUBST(OPT_LDFLAGS)
 297 ])
 298
 299
 300 dnl
 301 dnl Check for headers for, and arguments to, the setrlimit() function.
 302 dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
 303 dnl
 304 dnl Defines:
 305 dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits
 306 dnl  various HAVE_LIMIT_* for individual limit names
 307 dnl
 308 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
 309   AC_MSG_CHECKING([for RLIMIT_$1])
 310   AC_TRY_COMPILE(
 311     [#include <unistd.h>
 312      #include <sys/time.h>
 313      #include <sys/resource.h>
 314     ],
 315     [ int f = RLIMIT_$1 ; ],
 316     [glibcxx_mresult=1], [glibcxx_mresult=0])
 317   AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
 318                      [Only used in build directory testsuite_hooks.h.])
 319   if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
 320   AC_MSG_RESULT($res)
 321 ])
 322
 323 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
 324   setrlimit_have_headers=yes
 325   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
 326                    [],
 327                    [setrlimit_have_headers=no])
 328   # If don't have the headers, then we can't run the tests now, and we
 329   # won't be seeing any of these during testsuite compilation.
 330   if test $setrlimit_have_headers = yes; then
 331     # Can't do these in a loop, else the resulting syntax is wrong.
 332     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
 333     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
 334     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
 335     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
 336     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
 337
 338     # Check for rlimit, setrlimit.
 339     AC_CACHE_VAL(glibcxx_cv_setrlimit, [
 340       AC_TRY_COMPILE(
 341         [#include <unistd.h>
 342          #include <sys/time.h>
 343          #include <sys/resource.h>
 344         ],
 345         [struct rlimit r;
 346          setrlimit(0, &r);],
 347         [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
 348     ])
 349   fi
 350
 351   AC_MSG_CHECKING([for testsuite resource limits support])
 352   if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
 353     ac_res_limits=yes
 354     AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
 355               [Define if using setrlimit to set resource limits during
 356               "make check"])
 357   else
 358     ac_res_limits=no
 359   fi
 360   AC_MSG_RESULT($ac_res_limits)
 361 ])
 362
 363
 364 dnl
 365 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
 366 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
 367 dnl
 368 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
 369
 370   AC_LANG_SAVE
 371   AC_LANG_CPLUSPLUS
 372   ac_save_CXXFLAGS="$CXXFLAGS"
 373   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 374
 375   AC_MSG_CHECKING([for S_ISREG or S_IFREG])
 376   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
 377     GCC_TRY_COMPILE_OR_LINK(
 378       [#include <sys/stat.h>],
 379       [struct stat buffer;
 380        fstat(0, &buffer);
 381        S_ISREG(buffer.st_mode);],
 382       [glibcxx_cv_S_ISREG=yes],
 383       [glibcxx_cv_S_ISREG=no])
 384   ])
 385   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
 386     GCC_TRY_COMPILE_OR_LINK(
 387       [#include <sys/stat.h>],
 388       [struct stat buffer;
 389        fstat(0, &buffer);
 390        S_IFREG & buffer.st_mode;],
 391       [glibcxx_cv_S_IFREG=yes],
 392       [glibcxx_cv_S_IFREG=no])
 393   ])
 394   res=no
 395   if test $glibcxx_cv_S_ISREG = yes; then
 396     AC_DEFINE(HAVE_S_ISREG, 1,
 397               [Define if S_IFREG is available in <sys/stat.h>.])
 398     res=S_ISREG
 399   elif test $glibcxx_cv_S_IFREG = yes; then
 400     AC_DEFINE(HAVE_S_IFREG, 1,
 401               [Define if S_IFREG is available in <sys/stat.h>.])
 402     res=S_IFREG
 403   fi
 404   AC_MSG_RESULT($res)
 405
 406   CXXFLAGS="$ac_save_CXXFLAGS"
 407   AC_LANG_RESTORE
 408 ])
 409
 410
 411 dnl
 412 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
 413 dnl
 414 AC_DEFUN([GLIBCXX_CHECK_POLL], [
 415
 416   AC_LANG_SAVE
 417   AC_LANG_CPLUSPLUS
 418   ac_save_CXXFLAGS="$CXXFLAGS"
 419   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 420
 421   AC_MSG_CHECKING([for poll])
 422   AC_CACHE_VAL(glibcxx_cv_POLL, [
 423     GCC_TRY_COMPILE_OR_LINK(
 424       [#include <poll.h>],
 425       [struct pollfd pfd[1];
 426        pfd[0].events = POLLIN;
 427        poll(pfd, 1, 0);],
 428       [glibcxx_cv_POLL=yes],
 429       [glibcxx_cv_POLL=no])
 430   ])
 431   if test $glibcxx_cv_POLL = yes; then
 432     AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
 433   fi
 434   AC_MSG_RESULT($glibcxx_cv_POLL)
 435
 436   CXXFLAGS="$ac_save_CXXFLAGS"
 437   AC_LANG_RESTORE
 438 ])
 439
 440
 441 dnl
 442 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
 443 dnl
 444 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
 445
 446   AC_LANG_SAVE
 447   AC_LANG_CPLUSPLUS
 448   ac_save_CXXFLAGS="$CXXFLAGS"
 449   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 450
 451   AC_MSG_CHECKING([for writev])
 452   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
 453     GCC_TRY_COMPILE_OR_LINK(
 454       [#include <sys/uio.h>],
 455       [struct iovec iov[2];
 456        writev(0, iov, 0);],
 457       [glibcxx_cv_WRITEV=yes],
 458       [glibcxx_cv_WRITEV=no])
 459   ])
 460   if test $glibcxx_cv_WRITEV = yes; then
 461     AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
 462   fi
 463   AC_MSG_RESULT($glibcxx_cv_WRITEV)
 464
 465   CXXFLAGS="$ac_save_CXXFLAGS"
 466   AC_LANG_RESTORE
 467 ])
 468
 469
 470 dnl
 471 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
 472 dnl Also check whether int64_t is actually a typedef to long or long long.
 473 dnl
 474 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
 475
 476   AC_LANG_SAVE
 477   AC_LANG_CPLUSPLUS
 478
 479   AC_MSG_CHECKING([for int64_t])
 480   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
 481     AC_TRY_COMPILE(
 482       [#include <stdint.h>],
 483       [int64_t var;],
 484       [glibcxx_cv_INT64_T=yes],
 485       [glibcxx_cv_INT64_T=no])
 486   ])
 487
 488   if test $glibcxx_cv_INT64_T = yes; then
 489     AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
 490     AC_MSG_RESULT($glibcxx_cv_INT64_T)
 491
 492     AC_MSG_CHECKING([for int64_t as long])
 493     AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
 494       AC_TRY_COMPILE(
 495         [#include <stdint.h>
 496         template<typename, typename> struct same { enum { value = -1 }; };
 497         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
 498         int array[same<int64_t, long>::value];], [],
 499         [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
 500     ])
 501
 502     if test $glibcxx_cv_int64_t_long = yes; then
 503       AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
 504       AC_MSG_RESULT($glibcxx_cv_int64_t_long)
 505     fi
 506
 507     AC_MSG_CHECKING([for int64_t as long long])
 508     AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
 509       AC_TRY_COMPILE(
 510         [#include <stdint.h>
 511         template<typename, typename> struct same { enum { value = -1 }; };
 512         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
 513         int array[same<int64_t, long long>::value];], [],
 514         [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
 515     ])
 516
 517     if test $glibcxx_cv_int64_t_long_long = yes; then
 518       AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
 519       AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
 520     fi
 521   fi
 522
 523   AC_LANG_RESTORE
 524 ])
 525
 526
 527 dnl
 528 dnl Check whether LFS support is available.
 529 dnl
 530 AC_DEFUN([GLIBCXX_CHECK_LFS], [
 531   AC_LANG_SAVE
 532   AC_LANG_CPLUSPLUS
 533   ac_save_CXXFLAGS="$CXXFLAGS"
 534   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 535   AC_MSG_CHECKING([for LFS support])
 536   AC_CACHE_VAL(glibcxx_cv_LFS, [
 537     GCC_TRY_COMPILE_OR_LINK(
 538       [#include <unistd.h>
 539        #include <stdio.h>
 540        #include <sys/stat.h>
 541       ],
 542       [FILE* fp;
 543        fopen64("t", "w");
 544        fseeko64(fp, 0, SEEK_CUR);
 545        ftello64(fp);
 546        lseek64(1, 0, SEEK_CUR);
 547        struct stat64 buf;
 548        fstat64(1, &buf);],
 549       [glibcxx_cv_LFS=yes],
 550       [glibcxx_cv_LFS=no])
 551   ])
 552   if test $glibcxx_cv_LFS = yes; then
 553     AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
 554   fi
 555   AC_MSG_RESULT($glibcxx_cv_LFS)
 556   CXXFLAGS="$ac_save_CXXFLAGS"
 557   AC_LANG_RESTORE
 558 ])
 559
 560
 561 dnl
 562 dnl Check for whether a fully dynamic basic_string implementation should
 563 dnl be turned on, that does not put empty objects in per-process static
 564 dnl memory (mostly useful together with shared memory allocators, see PR
 565 dnl libstdc++/16612 for details).
 566 dnl
 567 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
 568 dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
 569 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
 570 dnl       Where DEFAULT is either `yes' or `no'.
 571 dnl
 572 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
 573   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
 574   if test $enable_fully_dynamic_string = yes; then
 575     AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
 576               [Define if a fully dynamic basic_string is wanted.])
 577   fi
 578 ])
 579
 580
 581 dnl
 582 dnl Does any necessary configuration of the testsuite directory.  Generates
 583 dnl the testsuite_hooks.h header.
 584 dnl
 585 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
 586 dnl
 587 dnl Sets:
 588 dnl  enable_abi_check
 589 dnl  GLIBCXX_TEST_WCHAR_T
 590 dnl  GLIBCXX_TEST_THREAD
 591 dnl Substs:
 592 dnl  baseline_dir
 593 dnl  baseline_subdir_switch
 594 dnl
 595 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
 596   if $GLIBCXX_IS_NATIVE ; then
 597     # Do checks for resource limit functions.
 598     GLIBCXX_CHECK_SETRLIMIT
 599
 600     # Look for setenv, so that extended locale tests can be performed.
 601     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
 602   fi
 603
 604   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
 605      test $enable_symvers != no; then
 606     case "$host" in
 607       *-*-cygwin*)
 608         enable_abi_check=no ;;
 609       *)
 610         enable_abi_check=yes ;;
 611     esac
 612   else
 613     # Only build this as native, since automake does not understand
 614     # CXX_FOR_BUILD.
 615     enable_abi_check=no
 616   fi
 617
 618   # Export file names for ABI checking.
 619   baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
 620   AC_SUBST(baseline_dir)
 621   baseline_subdir_switch="$abi_baseline_subdir_switch"
 622   AC_SUBST(baseline_subdir_switch)
 623 ])
 624
 625
 626 dnl
 627 dnl Does any necessary configuration of the documentation directory.
 628 dnl
 629 dnl XSLTPROC must be set before this
 630 dnl
 631 dnl Sets:
 632 dnl  glibcxx_stylesheets
 633 dnl Substs:
 634 dnl  XSL_STYLE_DIR
 635 dnl
 636 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
 637
 638 AC_MSG_CHECKING([for stylesheets used in generation of documentation])
 639 glibcxx_stylesheets=no
 640 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then
 641   glibcxx_stylesheets=yes
 642 fi
 643 AC_MSG_RESULT($glibcxx_stylesheets)
 644
 645 AC_MSG_CHECKING([for local stylesheet directory])
 646 glibcxx_local_stylesheets=no
 647 if test x"$glibcxx_stylesheets" = x"yes"; then
 648   if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then
 649     glibcxx_local_stylesheets=yes
 650     XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets
 651   fi
 652   if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then
 653     glibcxx_local_stylesheets=yes
 654     XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
 655   fi
 656 fi
 657 AC_MSG_RESULT($glibcxx_local_stylesheets)
 658
 659 if test x"$glibcxx_local_stylesheets" = x"yes"; then
 660   AC_SUBST(XSL_STYLE_DIR)
 661   AC_MSG_NOTICE($XSL_STYLE_DIR)
 662 else
 663   glibcxx_stylesheets=no
 664 fi
 665 ])
 666
 667
 668 dnl
 669 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
 670 dnl
 671 dnl Substs:
 672 dnl  GLIBCXX_INCLUDES
 673 dnl  TOPLEVEL_INCLUDES
 674 dnl
 675 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
 676   # Used for every C++ compile we perform.
 677   GLIBCXX_INCLUDES="\
 678 -I$glibcxx_builddir/include/$host_alias \
 679 -I$glibcxx_builddir/include \
 680 -I$glibcxx_srcdir/libsupc++"
 681
 682   # For Canadian crosses, pick this up too.
 683   if test $CANADIAN = yes; then
 684     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
 685   fi
 686
 687   # Stuff in the actual top level.  Currently only used by libsupc++ to
 688   # get unwind* headers from the libgcc dir.
 689   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
 690   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
 691
 692   # Now, export this to all the little Makefiles....
 693   AC_SUBST(GLIBCXX_INCLUDES)
 694   AC_SUBST(TOPLEVEL_INCLUDES)
 695 ])
 696
 697
 698 dnl
 699 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
 700 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
 701 dnl
 702 dnl Substs:
 703 dnl  OPTIMIZE_CXXFLAGS
 704 dnl  WARN_FLAGS
 705 dnl
 706 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
 707   # Optimization flags that are probably a good idea for thrill-seekers. Just
 708   # uncomment the lines below and make, everything else is ready to go...
 709   # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
 710   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
 711   AC_SUBST(OPTIMIZE_CXXFLAGS)
 712
 713   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
 714   AC_SUBST(WARN_FLAGS)
 715 ])
 716
 717
 718 dnl
 719 dnl All installation directory information is determined here.
 720 dnl
 721 dnl Substs:
 722 dnl  gxx_install_dir
 723 dnl  glibcxx_prefixdir
 724 dnl  glibcxx_toolexecdir
 725 dnl  glibcxx_toolexeclibdir
 726 dnl
 727 dnl Assumes cross_compiling bits already done, and with_cross_host in
 728 dnl particular.
 729 dnl
 730 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
 731 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
 732 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
 733   glibcxx_toolexecdir=no
 734   glibcxx_toolexeclibdir=no
 735   glibcxx_prefixdir=$prefix
 736
 737   AC_MSG_CHECKING([for gxx-include-dir])
 738   AC_ARG_WITH([gxx-include-dir],
 739     AC_HELP_STRING([--with-gxx-include-dir=DIR],
 740                    [installation directory for include files]),
 741     [case "$withval" in
 742       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
 743       no)  gxx_include_dir=no ;;
 744       *)   gxx_include_dir=$withval ;;
 745      esac],
 746     [gxx_include_dir=no])
 747   AC_MSG_RESULT($gxx_include_dir)
 748
 749   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
 750   AC_ARG_ENABLE([version-specific-runtime-libs],
 751     AC_HELP_STRING([--enable-version-specific-runtime-libs],
 752                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
 753     [case "$enableval" in
 754       yes) version_specific_libs=yes ;;
 755       no)  version_specific_libs=no ;;
 756       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
 757      esac],
 758     [version_specific_libs=no])
 759   AC_MSG_RESULT($version_specific_libs)
 760
 761   # Default case for install directory for include files.
 762   if test $version_specific_libs = no && test $gxx_include_dir = no; then
 763     gxx_include_dir='include/c++/${gcc_version}'
 764     if test -n "$with_cross_host" &&
 765        test x"$with_cross_host" != x"no"; then
 766       gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
 767     else
 768       gxx_include_dir='${prefix}/'"$gxx_include_dir"
 769     fi
 770   fi
 771
 772   # Version-specific runtime libs processing.
 773   if test $version_specific_libs = yes; then
 774     # Need the gcc compiler version to know where to install libraries
 775     # and header files if --enable-version-specific-runtime-libs option
 776     # is selected.  FIXME: these variables are misnamed, there are
 777     # no executables installed in _toolexecdir or _toolexeclibdir.
 778     if test x"$gxx_include_dir" = x"no"; then
 779       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
 780     fi
 781     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 782     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
 783   fi
 784
 785   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
 786   # Install a library built with a cross compiler in tooldir, not libdir.
 787   if test x"$glibcxx_toolexecdir" = x"no"; then
 788     if test -n "$with_cross_host" &&
 789        test x"$with_cross_host" != x"no"; then
 790       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
 791       glibcxx_toolexeclibdir='${toolexecdir}/lib'
 792     else
 793       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 794       glibcxx_toolexeclibdir='${libdir}'
 795     fi
 796     multi_os_directory=`$CXX -print-multi-os-directory`
 797     case $multi_os_directory in
 798       .) ;; # Avoid trailing /.
 799       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
 800     esac
 801   fi
 802
 803   AC_MSG_CHECKING([for install location])
 804   AC_MSG_RESULT($gxx_include_dir)
 805
 806   AC_SUBST(glibcxx_prefixdir)
 807   AC_SUBST(gxx_include_dir)
 808   AC_SUBST(glibcxx_toolexecdir)
 809   AC_SUBST(glibcxx_toolexeclibdir)
 810 ])
 811
 812
 813 dnl
 814 dnl GLIBCXX_ENABLE
 815 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
 816 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
 817 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
 818 dnl
 819 dnl See docs/html/17_intro/configury.html#enable for documentation.
 820 dnl
 821 m4_define([GLIBCXX_ENABLE],[dnl
 822 m4_define([_g_switch],[--enable-$1])dnl
 823 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
 824  AC_ARG_ENABLE([$1],m4_dquote(_g_help),
 825   m4_bmatch([$5],
 826    [^permit ],
 827      [[
 828       case "$enableval" in
 829        m4_bpatsubst([$5],[permit ])) ;;
 830        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
 831           dnl Idea for future:  generate a URL pointing to
 832           dnl "onlinedocs/configopts.html#whatever"
 833       esac
 834      ]],
 835    [^$],
 836      [[
 837       case "$enableval" in
 838        yes|no) ;;
 839        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
 840       esac
 841      ]],
 842    [[$5]]),
 843   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
 844 m4_undefine([_g_switch])dnl
 845 m4_undefine([_g_help])dnl
 846 ])
 847
 848
 849 dnl
 850 dnl Check for ISO/IEC 9899:1999 "C99" support.
 851 dnl
 852 dnl --enable-c99 defines _GLIBCXX_USE_C99
 853 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
 854 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
 855 dnl       Where DEFAULT is either `yes' or `no'.
 856 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
 857 dnl
 858 AC_DEFUN([GLIBCXX_ENABLE_C99], [
 859   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
 860
 861   if test x"$enable_c99" = x"yes"; then
 862
 863   AC_LANG_SAVE
 864   AC_LANG_CPLUSPLUS
 865
 866   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
 867   # undefined and fake C99 facilities - like pre-standard snprintf - may be
 868   # spuriously enabled.
 869   # Long term, -std=c++0x could be even better, could manage to explicitely
 870   # request C99 facilities to the underlying C headers.
 871   ac_save_CXXFLAGS="$CXXFLAGS"
 872   CXXFLAGS="$CXXFLAGS -std=c++98"
 873   ac_save_LIBS="$LIBS"
 874   ac_save_gcc_no_link="$gcc_no_link"
 875
 876   if test x$gcc_no_link != xyes; then
 877     # Use -fno-exceptions to that the C driver can link these tests without
 878     # hitting undefined references to personality routines.
 879     CXXFLAGS="$CXXFLAGS -fno-exceptions"
 880     AC_CHECK_LIB(m, sin, [
 881       LIBS="$LIBS -lm"
 882     ], [
 883       # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
 884       gcc_no_link=yes
 885     ])
 886   fi
 887
 888   # Check for the existence of <math.h> functions used if C99 is enabled.
 889   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
 890   AC_CACHE_VAL(glibcxx_cv_c99_math, [
 891   GCC_TRY_COMPILE_OR_LINK(
 892      [#include <math.h>
 893       volatile double d1, d2;
 894       volatile int i;],
 895      [i = fpclassify(d1);
 896       i = isfinite(d1);
 897       i = isinf(d1);
 898       i = isnan(d1);
 899       i = isnormal(d1);
 900       i = signbit(d1);
 901       i = isgreater(d1, d2);
 902       i = isgreaterequal(d1, d2);
 903       i = isless(d1, d2);
 904       i = islessequal(d1, d2);
 905       i = islessgreater(d1, d2);
 906       i = islessgreater(d1, d2);
 907       i = isunordered(d1, d2);
 908      ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
 909   ])
 910   AC_MSG_RESULT($glibcxx_cv_c99_math)
 911   if test x"$glibcxx_cv_c99_math" = x"yes"; then
 912     AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
 913               [Define if C99 functions or macros in <math.h> should be imported
 914               in <cmath> in namespace std.])
 915   fi
 916
 917   # Check for the existence of <complex.h> complex math functions.
 918   # This is necessary even though libstdc++ uses the builtin versions
 919   # of these functions, because if the builtin cannot be used, a reference
 920   # to the library function is emitted.
 921   AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
 922   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 923   glibcxx_cv_c99_complex=no;
 924   if test x"$ac_has_complex_h" = x"yes"; then
 925     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
 926     GCC_TRY_COMPILE_OR_LINK(
 927        [#include <complex.h>
 928         typedef __complex__ float float_type;
 929         typedef __complex__ double double_type;
 930         typedef __complex__ long double ld_type;
 931         volatile float_type tmpf;
 932         volatile double_type tmpd;
 933         volatile ld_type tmpld;
 934         volatile float f;
 935         volatile double d;
 936         volatile long double ld;],
 937        [f = cabsf(tmpf);
 938         f = cargf(tmpf);
 939         tmpf = ccosf(tmpf);
 940         tmpf = ccoshf(tmpf);
 941         tmpf = cexpf(tmpf);
 942         tmpf = clogf(tmpf);
 943         tmpf = csinf(tmpf);
 944         tmpf = csinhf(tmpf);
 945         tmpf = csqrtf(tmpf);
 946         tmpf = ctanf(tmpf);
 947         tmpf = ctanhf(tmpf);
 948         tmpf = cpowf(tmpf, tmpf);
 949         tmpf = cprojf(tmpf);
 950         d = cabs(tmpd);
 951         d = carg(tmpd);
 952         tmpd = ccos(tmpd);
 953         tmpd = ccosh(tmpd);
 954         tmpd = cexp(tmpd);
 955         tmpd = clog(tmpd);
 956         tmpd = csin(tmpd);
 957         tmpd = csinh(tmpd);
 958         tmpd = csqrt(tmpd);
 959         tmpd = ctan(tmpd);
 960         tmpd = ctanh(tmpd);
 961         tmpd = cpow(tmpd, tmpd);
 962         tmpd = cproj(tmpd);
 963         ld = cabsl(tmpld);
 964         ld = cargl(tmpld);
 965         tmpld = ccosl(tmpld);
 966         tmpld = ccoshl(tmpld);
 967         tmpld = cexpl(tmpld);
 968         tmpld = clogl(tmpld);
 969         tmpld = csinl(tmpld);
 970         tmpld = csinhl(tmpld);
 971         tmpld = csqrtl(tmpld);
 972         tmpld = ctanl(tmpld);
 973         tmpld = ctanhl(tmpld);
 974         tmpld = cpowl(tmpld, tmpld);
 975         tmpld = cprojl(tmpld);
 976        ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
 977   fi
 978   AC_MSG_RESULT($glibcxx_cv_c99_complex)
 979   if test x"$glibcxx_cv_c99_complex" = x"yes"; then
 980     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 981               [Define if C99 functions in <complex.h> should be used in
 982               <complex>. Using compiler builtins for these functions requires
 983               corresponding C99 library functions to be present.])
 984   fi
 985
 986   # Check for the existence in <stdio.h> of vscanf, et. al.
 987   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 988   AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
 989   GCC_TRY_COMPILE_OR_LINK(
 990      [#include <stdio.h>
 991       #include <stdarg.h>
 992       void foo(char* fmt, ...)
 993       {
 994         va_list args; va_start(args, fmt);
 995         vfscanf(stderr, "%i", args);
 996         vscanf("%i", args);
 997         vsnprintf(fmt, 0, "%i", args);
 998         vsscanf(fmt, "%i", args);
 999       }],
1000      [snprintf("12", 0, "%i");],
1001      [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
1002   ])
1003   AC_MSG_RESULT($glibcxx_cv_c99_stdio)
1004
1005   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1006   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1007   AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
1008   GCC_TRY_COMPILE_OR_LINK(
1009      [#include <stdlib.h>
1010       volatile float f;
1011       volatile long double ld;
1012       volatile unsigned long long ll;
1013       lldiv_t mydivt;],
1014      [char* tmp;
1015       f = strtof("gnu", &tmp);
1016       ld = strtold("gnu", &tmp);
1017       ll = strtoll("gnu", &tmp, 10);
1018       ll = strtoull("gnu", &tmp, 10);
1019       ll = llabs(10);
1020       mydivt = lldiv(10,1);
1021       ll = mydivt.quot;
1022       ll = mydivt.rem;
1023       ll = atoll("10");
1024       _Exit(0);
1025       ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
1026   ])
1027   AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
1028
1029   # Check for the existence in <wchar.h> of wcstold, etc.
1030   glibcxx_cv_c99_wchar=no;
1031   if test x"$ac_has_wchar_h" = xyes &&
1032      test x"$ac_has_wctype_h" = xyes; then
1033     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1034     AC_TRY_COMPILE([#include <wchar.h>
1035                     namespace test
1036                     {
1037                       using ::wcstold;
1038                       using ::wcstoll;
1039                       using ::wcstoull;
1040                     }
1041                    ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
1042
1043     # Checks for wide character functions that may not be present.
1044     # Injection of these is wrapped with guard macros.
1045     # NB: only put functions here, instead of immediately above, if
1046     # absolutely necessary.
1047     AC_TRY_COMPILE([#include <wchar.h>
1048                     namespace test { using ::vfwscanf; } ], [],
1049                    [AC_DEFINE(HAVE_VFWSCANF,1,
1050                         [Defined if vfwscanf exists.])],[])
1051
1052     AC_TRY_COMPILE([#include <wchar.h>
1053                     namespace test { using ::vswscanf; } ], [],
1054                    [AC_DEFINE(HAVE_VSWSCANF,1,
1055                         [Defined if vswscanf exists.])],[])
1056
1057     AC_TRY_COMPILE([#include <wchar.h>
1058                     namespace test { using ::vwscanf; } ], [],
1059                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1060
1061     AC_TRY_COMPILE([#include <wchar.h>
1062                     namespace test { using ::wcstof; } ], [],
1063                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1064
1065     AC_TRY_COMPILE([#include <wctype.h>],
1066                    [ wint_t t; int i = iswblank(t);],
1067                    [AC_DEFINE(HAVE_ISWBLANK,1,
1068                         [Defined if iswblank exists.])],[])
1069
1070     AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1071   fi
1072
1073   # Option parsed, now set things appropriately.
1074   if test x"$glibcxx_cv_c99_math" = x"no" ||
1075      test x"$glibcxx_cv_c99_complex" = x"no" ||
1076      test x"$glibcxx_cv_c99_stdio" = x"no" ||
1077      test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1078      test x"$glibcxx_cv_c99_wchar" = x"no"; then
1079     enable_c99=no;
1080   else
1081     AC_DEFINE(_GLIBCXX_USE_C99, 1,
1082     [Define if C99 functions or macros from <wchar.h>, <math.h>,
1083     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1084   fi
1085
1086   gcc_no_link="$ac_save_gcc_no_link"
1087   LIBS="$ac_save_LIBS"
1088   CXXFLAGS="$ac_save_CXXFLAGS"
1089   AC_LANG_RESTORE
1090   fi
1091
1092   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1093   AC_MSG_RESULT($enable_c99)
1094 ])
1095
1096
1097 dnl
1098 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1099 dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this]
1100 dnl in the current C++0x working draft.
1101 dnl
1102 dnl --enable-libstdcxx-time
1103 dnl --enable-libstdcxx-time=yes
1104 dnl        checks for the availability of monotonic and realtime clocks,
1105 dnl        nanosleep and sched_yield in libc and libposix4 and, in case, links
1106 dnl       the latter
1107 dnl --enable-libstdcxx-time=rt
1108 dnl        also searches (and, in case, links) librt.  Note that this is
1109 dnl        not always desirable because, in glibc, for example, in turn it
1110 dnl        triggers the linking of libpthread too, which activates locking,
1111 dnl        a large overhead for single-thread programs.
1112 dnl --enable-libstdcxx-time=no
1113 dnl --disable-libstdcxx-time
1114 dnl        disables the checks completely
1115 dnl
1116 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1117
1118   AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1119   GLIBCXX_ENABLE(libstdcxx-time,$1,[[[=KIND]]],
1120     [use KIND for check type],
1121     [permit yes|no|rt])
1122
1123   AC_LANG_SAVE
1124   AC_LANG_CPLUSPLUS
1125   ac_save_CXXFLAGS="$CXXFLAGS"
1126   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1127   ac_save_LIBS="$LIBS"
1128
1129   ac_has_clock_monotonic=no
1130   ac_has_clock_realtime=no
1131   AC_MSG_RESULT($enable_libstdcxx_time)
1132
1133   if test x"$enable_libstdcxx_time" != x"no"; then
1134
1135     if test x"$enable_libstdcxx_time" = x"rt"; then
1136       AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1137       AC_SEARCH_LIBS(nanosleep, [rt posix4])
1138     else
1139       AC_SEARCH_LIBS(clock_gettime, [posix4])
1140       AC_SEARCH_LIBS(nanosleep, [posix4])
1141     fi
1142
1143     case "$ac_cv_search_clock_gettime" in
1144       -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1145       ;;
1146     esac
1147     case "$ac_cv_search_nanosleep" in
1148       -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1149       ;;
1150     esac
1151
1152     AC_SEARCH_LIBS(sched_yield, [rt posix4])
1153
1154     case "$ac_cv_search_sched_yield" in
1155       -lposix4*)
1156       GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1157       AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1158                 [ Defined if sched_yield is available. ])
1159       ;;
1160       -lrt*)
1161       if test x"$enable_libstdcxx_time" = x"rt"; then
1162         GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1163         AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1164                   [ Defined if sched_yield is available. ])
1165       fi
1166       ;;
1167       *)
1168       AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1169                 [ Defined if sched_yield is available. ])
1170       ;;
1171     esac
1172
1173     AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1174
1175     if test x"$ac_has_unistd_h" = x"yes"; then
1176       AC_MSG_CHECKING([for monotonic clock])
1177       AC_TRY_LINK(
1178         [#include <unistd.h>
1179          #include <time.h>
1180         ],
1181         [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1182           timespec tp;
1183          #endif
1184           clock_gettime(CLOCK_MONOTONIC, &tp);
1185         ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1186
1187       AC_MSG_RESULT($ac_has_clock_monotonic)
1188
1189       AC_MSG_CHECKING([for realtime clock])
1190       AC_TRY_LINK(
1191         [#include <unistd.h>
1192          #include <time.h>
1193         ],
1194         [#if _POSIX_TIMERS > 0
1195           timespec tp;
1196          #endif
1197           clock_gettime(CLOCK_REALTIME, &tp);
1198         ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1199
1200       AC_MSG_RESULT($ac_has_clock_realtime)
1201
1202       AC_MSG_CHECKING([for nanosleep])
1203       AC_TRY_LINK(
1204         [#include <unistd.h>
1205          #include <time.h>
1206         ],
1207         [#if _POSIX_TIMERS > 0
1208           timespec tp;
1209          #endif
1210           nanosleep(&tp, 0);
1211         ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1212
1213       AC_MSG_RESULT($ac_has_nanosleep)
1214     fi
1215   fi
1216
1217   if test x"$ac_has_clock_monotonic" = x"yes"; then
1218     AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1219       [ Defined if clock_gettime has monotonic clock support. ])
1220   fi
1221
1222   if test x"$ac_has_clock_realtime" = x"yes"; then
1223     AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1224       [ Defined if clock_gettime has realtime clock support. ])
1225   fi
1226
1227   if test x"$ac_has_nanosleep" = x"yes"; then
1228     AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1229       [ Defined if nanosleep is available. ])
1230   fi
1231
1232   AC_SUBST(GLIBCXX_LIBS)
1233
1234   CXXFLAGS="$ac_save_CXXFLAGS"
1235   LIBS="$ac_save_LIBS"
1236   AC_LANG_RESTORE
1237 ])
1238
1239 dnl
1240 dnl Check for gettimeofday, used in the implementation of 20.8.5
1241 dnl [time.clock] in the current C++0x working draft.
1242 dnl
1243 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1244
1245   AC_MSG_CHECKING([for gettimeofday])
1246
1247   AC_LANG_SAVE
1248   AC_LANG_CPLUSPLUS
1249   ac_save_CXXFLAGS="$CXXFLAGS"
1250   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1251
1252   ac_has_gettimeofday=no;
1253   AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1254   if test x"$ac_has_sys_time_h" = x"yes"; then
1255     AC_MSG_CHECKING([for gettimeofday])
1256     GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1257       [timeval tv; gettimeofday(&tv, 0);],
1258       [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1259
1260     AC_MSG_RESULT($ac_has_gettimeofday)
1261   fi
1262
1263   if test x"$ac_has_gettimeofday" = x"yes"; then
1264     AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1265       [ Defined if gettimeofday is available. ])
1266   fi
1267
1268   CXXFLAGS="$ac_save_CXXFLAGS"
1269   AC_LANG_RESTORE
1270 ])
1271
1272 dnl
1273 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1274 dnl facilities in Chapter 8, "C compatibility".
1275 dnl
1276 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1277
1278   AC_LANG_SAVE
1279   AC_LANG_CPLUSPLUS
1280
1281   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1282   # undefined and fake C99 facilities may be spuriously enabled.
1283   ac_save_CXXFLAGS="$CXXFLAGS"
1284   CXXFLAGS="$CXXFLAGS -std=c++98"
1285
1286   # Check for the existence of <complex.h> complex math functions used
1287   # by tr1/complex.
1288   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1289   ac_c99_complex_tr1=no;
1290   if test x"$ac_has_complex_h" = x"yes"; then
1291     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1292     AC_TRY_COMPILE([#include <complex.h>],
1293                    [typedef __complex__ float float_type; float_type tmpf;
1294                     cacosf(tmpf);
1295                     casinf(tmpf);
1296                     catanf(tmpf);
1297                     cacoshf(tmpf);
1298                     casinhf(tmpf);
1299                     catanhf(tmpf);
1300                     typedef __complex__ double double_type; double_type tmpd;
1301                     cacos(tmpd);
1302                     casin(tmpd);
1303                     catan(tmpd);
1304                     cacosh(tmpd);
1305                     casinh(tmpd);
1306                     catanh(tmpd);
1307                     typedef __complex__ long double ld_type; ld_type tmpld;
1308                     cacosl(tmpld);
1309                     casinl(tmpld);
1310                     catanl(tmpld);
1311                     cacoshl(tmpld);
1312                     casinhl(tmpld);
1313                     catanhl(tmpld);
1314                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1315   fi
1316   AC_MSG_RESULT($ac_c99_complex_tr1)
1317   if test x"$ac_c99_complex_tr1" = x"yes"; then
1318     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1319               [Define if C99 functions in <complex.h> should be used in
1320               <tr1/complex>. Using compiler builtins for these functions
1321               requires corresponding C99 library functions to be present.])
1322   fi
1323
1324   # Check for the existence of <ctype.h> functions.
1325   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1326   AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1327   AC_TRY_COMPILE([#include <ctype.h>],
1328                  [int ch;
1329                   int ret;
1330                   ret = isblank(ch);
1331                  ],[glibcxx_cv_c99_ctype_tr1=yes],
1332                    [glibcxx_cv_c99_ctype_tr1=no])
1333   ])
1334   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1335   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1336     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1337               [Define if C99 functions in <ctype.h> should be imported in
1338               <tr1/cctype> in namespace std::tr1.])
1339   fi
1340
1341   # Check for the existence of <fenv.h> functions.
1342   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1343   ac_c99_fenv_tr1=no;
1344   if test x"$ac_has_fenv_h" = x"yes"; then
1345     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1346     AC_TRY_COMPILE([#include <fenv.h>],
1347                    [int except, mode;
1348                     fexcept_t* pflag;
1349                     fenv_t* penv;
1350                     int ret;
1351                     ret = feclearexcept(except);
1352                     ret = fegetexceptflag(pflag, except);
1353                     ret = feraiseexcept(except);
1354                     ret = fesetexceptflag(pflag, except);
1355                     ret = fetestexcept(except);
1356                     ret = fegetround();
1357                     ret = fesetround(mode);
1358                     ret = fegetenv(penv);
1359                     ret = feholdexcept(penv);
1360                     ret = fesetenv(penv);
1361                     ret = feupdateenv(penv);
1362                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1363   fi
1364   AC_MSG_RESULT($ac_c99_fenv_tr1)
1365   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1366     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1367               [Define if C99 functions in <fenv.h> should be imported in
1368               <tr1/cfenv> in namespace std::tr1.])
1369   fi
1370
1371   # Check for the existence of <stdint.h> types.
1372   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1373   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1374   AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1375                   #define __STDC_CONSTANT_MACROS
1376                   #include <stdint.h>],
1377                  [typedef int8_t          my_int8_t;
1378                   my_int8_t               i8 = INT8_MIN;
1379                   i8 = INT8_MAX;
1380                   typedef int16_t         my_int16_t;
1381                   my_int16_t              i16 = INT16_MIN;
1382                   i16 = INT16_MAX;
1383                   typedef int32_t         my_int32_t;
1384                   my_int32_t              i32 = INT32_MIN;
1385                   i32 = INT32_MAX;
1386                   typedef int64_t         my_int64_t;
1387                   my_int64_t              i64 = INT64_MIN;
1388                   i64 = INT64_MAX;
1389                   typedef int_fast8_t     my_int_fast8_t;
1390                   my_int_fast8_t          if8 = INT_FAST8_MIN;
1391                   if8 = INT_FAST8_MAX;
1392                   typedef int_fast16_t    my_int_fast16_t;
1393                   my_int_fast16_t         if16 = INT_FAST16_MIN;
1394                   if16 = INT_FAST16_MAX;
1395                   typedef int_fast32_t    my_int_fast32_t;
1396                   my_int_fast32_t         if32 = INT_FAST32_MIN;
1397                   if32 = INT_FAST32_MAX;
1398                   typedef int_fast64_t    my_int_fast64_t;
1399                   my_int_fast64_t         if64 = INT_FAST64_MIN;
1400                   if64 = INT_FAST64_MAX;
1401                   typedef int_least8_t    my_int_least8_t;
1402                   my_int_least8_t         il8 = INT_LEAST8_MIN;
1403                   il8 = INT_LEAST8_MAX;
1404                   typedef int_least16_t   my_int_least16_t;
1405                   my_int_least16_t        il16 = INT_LEAST16_MIN;
1406                   il16 = INT_LEAST16_MAX;
1407                   typedef int_least32_t   my_int_least32_t;
1408                   my_int_least32_t        il32 = INT_LEAST32_MIN;
1409                   il32 = INT_LEAST32_MAX;
1410                   typedef int_least64_t   my_int_least64_t;
1411                   my_int_least64_t        il64 = INT_LEAST64_MIN;
1412                   il64 = INT_LEAST64_MAX;
1413                   typedef intmax_t        my_intmax_t;
1414                   my_intmax_t             im = INTMAX_MAX;
1415                   im = INTMAX_MIN;
1416                   typedef intptr_t        my_intptr_t;
1417                   my_intptr_t             ip = INTPTR_MAX;
1418                   ip = INTPTR_MIN;
1419                   typedef uint8_t         my_uint8_t;
1420                   my_uint8_t              ui8 = UINT8_MAX;
1421                   ui8 = UINT8_MAX;
1422                   typedef uint16_t        my_uint16_t;
1423                   my_uint16_t             ui16 = UINT16_MAX;
1424                   ui16 = UINT16_MAX;
1425                   typedef uint32_t        my_uint32_t;
1426                   my_uint32_t             ui32 = UINT32_MAX;
1427                   ui32 = UINT32_MAX;
1428                   typedef uint64_t        my_uint64_t;
1429                   my_uint64_t             ui64 = UINT64_MAX;
1430                   ui64 = UINT64_MAX;
1431                   typedef uint_fast8_t    my_uint_fast8_t;
1432                   my_uint_fast8_t         uif8 = UINT_FAST8_MAX;
1433                   uif8 = UINT_FAST8_MAX;
1434                   typedef uint_fast16_t   my_uint_fast16_t;
1435                   my_uint_fast16_t        uif16 = UINT_FAST16_MAX;
1436                   uif16 = UINT_FAST16_MAX;
1437                   typedef uint_fast32_t   my_uint_fast32_t;
1438                   my_uint_fast32_t        uif32 = UINT_FAST32_MAX;
1439                   uif32 = UINT_FAST32_MAX;
1440                   typedef uint_fast64_t   my_uint_fast64_t;
1441                   my_uint_fast64_t        uif64 = UINT_FAST64_MAX;
1442                   uif64 = UINT_FAST64_MAX;
1443                   typedef uint_least8_t   my_uint_least8_t;
1444                   my_uint_least8_t        uil8 = UINT_LEAST8_MAX;
1445                   uil8 = UINT_LEAST8_MAX;
1446                   typedef uint_least16_t  my_uint_least16_t;
1447                   my_uint_least16_t       uil16 = UINT_LEAST16_MAX;
1448                   uil16 = UINT_LEAST16_MAX;
1449                   typedef uint_least32_t  my_uint_least32_t;
1450                   my_uint_least32_t       uil32 = UINT_LEAST32_MAX;
1451                   uil32 = UINT_LEAST32_MAX;
1452                   typedef uint_least64_t  my_uint_least64_t;
1453                   my_uint_least64_t       uil64 = UINT_LEAST64_MAX;
1454                   uil64 = UINT_LEAST64_MAX;
1455                   typedef uintmax_t       my_uintmax_t;
1456                   my_uintmax_t            uim = UINTMAX_MAX;
1457                   uim = UINTMAX_MAX;
1458                   typedef uintptr_t       my_uintptr_t;
1459                   my_uintptr_t            uip = UINTPTR_MAX;
1460                   uip = UINTPTR_MAX;
1461                  ],[glibcxx_cv_c99_stdint_tr1=yes],
1462                    [glibcxx_cv_c99_stdint_tr1=no])
1463   ])
1464   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1465   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1466     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1467               [Define if C99 types in <stdint.h> should be imported in
1468               <tr1/cstdint> in namespace std::tr1.])
1469   fi
1470
1471   # Check for the existence of <math.h> functions.
1472   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1473   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1474   AC_TRY_COMPILE([#include <math.h>],
1475                  [typedef double_t  my_double_t;
1476                   typedef float_t   my_float_t;
1477                   acosh(0.0);
1478                   acoshf(0.0f);
1479                   acoshl(0.0l);
1480                   asinh(0.0);
1481                   asinhf(0.0f);
1482                   asinhl(0.0l);
1483                   atanh(0.0);
1484                   atanhf(0.0f);
1485                   atanhl(0.0l);
1486                   cbrt(0.0);
1487                   cbrtf(0.0f);
1488                   cbrtl(0.0l);
1489                   copysign(0.0, 0.0);
1490                   copysignf(0.0f, 0.0f);
1491                   copysignl(0.0l, 0.0l);
1492                   erf(0.0);
1493                   erff(0.0f);
1494                   erfl(0.0l);
1495                   erfc(0.0);
1496                   erfcf(0.0f);
1497                   erfcl(0.0l);
1498                   exp2(0.0);
1499                   exp2f(0.0f);
1500                   exp2l(0.0l);
1501                   expm1(0.0);
1502                   expm1f(0.0f);
1503                   expm1l(0.0l);
1504                   fdim(0.0, 0.0);
1505                   fdimf(0.0f, 0.0f);
1506                   fdiml(0.0l, 0.0l);
1507                   fma(0.0, 0.0, 0.0);
1508                   fmaf(0.0f, 0.0f, 0.0f);
1509                   fmal(0.0l, 0.0l, 0.0l);
1510                   fmax(0.0, 0.0);
1511                   fmaxf(0.0f, 0.0f);
1512                   fmaxl(0.0l, 0.0l);
1513                   fmin(0.0, 0.0);
1514                   fminf(0.0f, 0.0f);
1515                   fminl(0.0l, 0.0l);
1516                   hypot(0.0, 0.0);
1517                   hypotf(0.0f, 0.0f);
1518                   hypotl(0.0l, 0.0l);
1519                   ilogb(0.0);
1520                   ilogbf(0.0f);
1521                   ilogbl(0.0l);
1522                   lgamma(0.0);
1523                   lgammaf(0.0f);
1524                   lgammal(0.0l);
1525                   llrint(0.0);
1526                   llrintf(0.0f);
1527                   llrintl(0.0l);
1528                   llround(0.0);
1529                   llroundf(0.0f);
1530                   llroundl(0.0l);
1531                   log1p(0.0);
1532                   log1pf(0.0f);
1533                   log1pl(0.0l);
1534                   log2(0.0);
1535                   log2f(0.0f);
1536                   log2l(0.0l);
1537                   logb(0.0);
1538                   logbf(0.0f);
1539                   logbl(0.0l);
1540                   lrint(0.0);
1541                   lrintf(0.0f);
1542                   lrintl(0.0l);
1543                   lround(0.0);
1544                   lroundf(0.0f);
1545                   lroundl(0.0l);
1546                   nan(0);
1547                   nanf(0);
1548                   nanl(0);
1549                   nearbyint(0.0);
1550                   nearbyintf(0.0f);
1551                   nearbyintl(0.0l);
1552                   nextafter(0.0, 0.0);
1553                   nextafterf(0.0f, 0.0f);
1554                   nextafterl(0.0l, 0.0l);
1555                   nexttoward(0.0, 0.0);
1556                   nexttowardf(0.0f, 0.0f);
1557                   nexttowardl(0.0l, 0.0l);
1558                   remainder(0.0, 0.0);
1559                   remainderf(0.0f, 0.0f);
1560                   remainderl(0.0l, 0.0l);
1561                   remquo(0.0, 0.0, 0);
1562                   remquof(0.0f, 0.0f, 0);
1563                   remquol(0.0l, 0.0l, 0);
1564                   rint(0.0);
1565                   rintf(0.0f);
1566                   rintl(0.0l);
1567                   round(0.0);
1568                   roundf(0.0f);
1569                   roundl(0.0l);
1570                   scalbln(0.0, 0l);
1571                   scalblnf(0.0f, 0l);
1572                   scalblnl(0.0l, 0l);
1573                   scalbn(0.0, 0);
1574                   scalbnf(0.0f, 0);
1575                   scalbnl(0.0l, 0);
1576                   tgamma(0.0);
1577                   tgammaf(0.0f);
1578                   tgammal(0.0l);
1579                   trunc(0.0);
1580                   truncf(0.0f);
1581                   truncl(0.0l);
1582                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1583   ])
1584   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1585   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1586     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1587               [Define if C99 functions or macros in <math.h> should be imported
1588               in <tr1/cmath> in namespace std::tr1.])
1589   fi
1590
1591   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1592   # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1593   ac_c99_inttypes_tr1=no;
1594   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1595     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1596     AC_TRY_COMPILE([#include <inttypes.h>],
1597                    [intmax_t i, numer, denom, base;
1598                     const char* s;
1599                     char** endptr;
1600                     intmax_t ret = imaxabs(i);
1601                     imaxdiv_t dret = imaxdiv(numer, denom);
1602                     ret = strtoimax(s, endptr, base);
1603                     uintmax_t uret = strtoumax(s, endptr, base);
1604                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1605   fi
1606   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1607   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1608     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1609               [Define if C99 functions in <inttypes.h> should be imported in
1610               <tr1/cinttypes> in namespace std::tr1.])
1611   fi
1612
1613   # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1614   # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1615   ac_c99_inttypes_wchar_t_tr1=no;
1616   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1617     AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1618     AC_TRY_COMPILE([#include <inttypes.h>],
1619                    [intmax_t base;
1620                     const wchar_t* s;
1621                     wchar_t** endptr;
1622                     intmax_t ret = wcstoimax(s, endptr, base);
1623                     uintmax_t uret = wcstoumax(s, endptr, base);
1624                    ],[ac_c99_inttypes_wchar_t_tr1=yes],
1625                      [ac_c99_inttypes_wchar_t_tr1=no])
1626   fi
1627   AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1628   if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1629     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1630               [Define if wchar_t C99 functions in <inttypes.h> should be
1631               imported in <tr1/cinttypes> in namespace std::tr1.])
1632   fi
1633
1634   # Check for the existence of the <stdbool.h> header.
1635   AC_CHECK_HEADERS(stdbool.h)
1636
1637   CXXFLAGS="$ac_save_CXXFLAGS"
1638   AC_LANG_RESTORE
1639 ])
1640
1641 dnl
1642 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1643 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1644 dnl
1645 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1646
1647   AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1648   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1649     if test -r /dev/random && test -r /dev/urandom; then
1650       glibcxx_cv_random_tr1=yes;
1651     else
1652       glibcxx_cv_random_tr1=no;
1653     fi
1654   ])
1655   AC_MSG_RESULT($glibcxx_cv_random_tr1)
1656
1657   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1658     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1659               [Define if /dev/random and /dev/urandom are available for
1660                the random_device of TR1 (Chapter 5.1).])
1661   fi
1662
1663 ])
1664
1665 dnl
1666 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
1667 dnl
1668 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
1669
1670   AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
1671   AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
1672                  [#include <stdio.h>],
1673                  [AC_MSG_ERROR([computing EOF failed])])
1674   ])
1675   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
1676                      [Define to the value of the EOF integer constant.])
1677
1678   AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
1679   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
1680                  [#include <stdio.h>],
1681                  [AC_MSG_ERROR([computing SEEK_CUR failed])])
1682   ])
1683   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
1684                      [Define to the value of the SEEK_CUR integer constant.])
1685
1686   AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
1687   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
1688                  [#include <stdio.h>],
1689                  [AC_MSG_ERROR([computing SEEK_END failed])])
1690   ])
1691   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
1692                      [Define to the value of the SEEK_END integer constant.])
1693 ])
1694
1695 dnl
1696 dnl Check whether required C++ overloads are present in <math.h>.
1697 dnl
1698
1699 AC_DEFUN([GLIBCXX_CHECK_MATH_PROTO], [
1700
1701   AC_LANG_SAVE
1702   AC_LANG_CPLUSPLUS
1703
1704   case "$host" in
1705     *-*-solaris2.*)
1706       # Solaris 8 FCS only had an overload for double std::abs(double) in
1707       # <iso/math_iso.h>.  Patches 111721-04 (SPARC) and 112757-01 (x86)
1708       # introduced the full set also found from Solaris 9 onwards.
1709       AC_MSG_CHECKING([for float std::abs(float) overload])
1710       AC_CACHE_VAL(glibcxx_cv_abs_float, [
1711         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1712           [#include <math.h>
1713            namespace std {
1714              inline float abs(float __x)
1715              {  return __builtin_fabsf(__x); }
1716            }
1717         ])],
1718         [glibcxx_cv_abs_float=no],
1719         [glibcxx_cv_abs_float=yes]
1720       )])
1721
1722       # autoheader cannot handle indented templates.
1723       AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO1],
1724         [/* Define if all C++ overloads are available in <math.h>.  */
1725 #if __cplusplus >= 199711L
1726 #undef __CORRECT_ISO_CPP_MATH_H_PROTO1
1727 #endif])
1728       AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO2],
1729         [/* Define if only double std::abs(double) is available in <math.h>.  */
1730 #if __cplusplus >= 199711L
1731 #undef __CORRECT_ISO_CPP_MATH_H_PROTO2
1732 #endif])
1733
1734       if test $glibcxx_cv_abs_float = yes; then
1735         AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO1)
1736       else
1737         AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO2)
1738       fi
1739       AC_MSG_RESULT($glibcxx_cv_abs_float)
1740       ;;
1741   esac
1742
1743   AC_LANG_RESTORE
1744 ])
1745
1746 dnl
1747 dnl Check whether required C++ overloads are present in <stdlib.h>.
1748 dnl
1749
1750 AC_DEFUN([GLIBCXX_CHECK_STDLIB_PROTO], [
1751
1752   AC_LANG_SAVE
1753   AC_LANG_CPLUSPLUS
1754
1755   case "$host" in
1756     *-*-solaris2.*)
1757       # Solaris 8 FCS lacked the overloads for long std::abs(long) and
1758       # ldiv_t std::div(long, long) in <iso/stdlib_iso.h>.  Patches 109607-02
1759       # (SPARC) and 109608-02 (x86) introduced them.
1760       AC_MSG_CHECKING([for long std::abs(long) overload])
1761       AC_CACHE_VAL(glibcxx_cv_abs_long, [
1762         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1763           [#include <stdlib.h>
1764            namespace std {
1765              inline long
1766              abs(long __i) { return labs(__i); }
1767            }
1768         ])],
1769         [glibcxx_cv_abs_long=no],
1770         [glibcxx_cv_abs_long=yes]
1771       )])
1772
1773       # autoheader cannot handle indented templates.
1774       AH_VERBATIM([__CORRECT_ISO_CPP_STDLIB_H_PROTO],
1775         [/* Define if all C++ overloads are available in <stdlib.h>.  */
1776 #if __cplusplus >= 199711L
1777 #undef __CORRECT_ISO_CPP_STDLIB_H_PROTO
1778 #endif])
1779       if test $glibcxx_cv_abs_long = yes; then
1780         AC_DEFINE(__CORRECT_ISO_CPP_STDLIB_H_PROTO, 1)
1781       fi
1782       AC_MSG_RESULT($glibcxx_cv_abs_long)
1783       ;;
1784   esac
1785
1786   AC_LANG_RESTORE
1787 ])
1788
1789 dnl
1790 dnl Check whether macros, etc are present for <system_error>
1791 dnl
1792 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1793
1794 m4_pushdef([n_syserr], [1])dnl
1795 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1796                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1797                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
1798                       ECHILD, ENOSPC, EPERM,
1799                       ETIMEDOUT, EWOULDBLOCK],
1800 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1801 AC_MSG_CHECKING([for syserr])
1802 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1803 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1804                                    [int i = syserr;])],
1805                   [glibcxx_cv_system_error[]n_syserr=yes],
1806                   [glibcxx_cv_system_error[]n_syserr=no])
1807 ])
1808 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1809 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1810   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1811 fi
1812 m4_define([n_syserr], m4_incr(n_syserr))dnl
1813 m4_popdef([SYSERR])dnl
1814 ])
1815 m4_popdef([n_syserr])dnl
1816 ])
1817
1818 dnl
1819 dnl Check for what type of C headers to use.
1820 dnl
1821 dnl --enable-cheaders= [does stuff].
1822 dnl --disable-cheaders [does not do anything, really].
1823 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1824 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1825 dnl
1826 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1827   GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
1828     [construct "C" headers for g++], [permit c|c_std|c_global])
1829   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1830
1831   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1832
1833   # Allow overrides to configure.host here.
1834   if test $enable_cheaders = c_global; then
1835      c_compatibility=yes
1836   fi
1837
1838   AC_SUBST(C_INCLUDE_DIR)
1839   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1840   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1841   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1842   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1843 ])
1844
1845
1846 dnl
1847 dnl Check for which locale library to use.  The choice is mapped to
1848 dnl a subdirectory of config/locale.
1849 dnl
1850 dnl Default is generic.
1851 dnl
1852 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1853   GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
1854     [use MODEL for target locale package],
1855     [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
1856
1857   # Deal with gettext issues.  Default to not using it (=no) until we detect
1858   # support for it later.  Let the user turn it off via --e/d, but let that
1859   # default to on for easier handling.
1860   USE_NLS=no
1861   AC_ARG_ENABLE(nls,
1862     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1863     [],
1864     [enable_nls=yes])
1865
1866   # Either a known package, or "auto"
1867   if test $enable_clocale = no || test $enable_clocale = yes; then
1868      enable_clocale=auto
1869   fi
1870   enable_clocale_flag=$enable_clocale
1871
1872   # Probe for locale model to use if none specified.
1873   # Default to "generic".
1874   if test $enable_clocale_flag = auto; then
1875     case ${target_os} in
1876       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1877         enable_clocale_flag=gnu
1878         ;;
1879       darwin* | freebsd*)
1880         enable_clocale_flag=darwin
1881         ;;
1882       *)
1883         if test x"$with_newlib" = x"yes"; then
1884           enable_clocale_flag=newlib
1885         else
1886           enable_clocale_flag=generic
1887         fi
1888         ;;
1889     esac
1890   fi
1891
1892   # Sanity check model, and test for special functionality.
1893   if test $enable_clocale_flag = gnu; then
1894     AC_EGREP_CPP([_GLIBCXX_ok], [
1895     #include <features.h>
1896     #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1897       _GLIBCXX_ok
1898     #endif
1899     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1900
1901     # Set it to scream when it hurts.
1902     ac_save_CFLAGS="$CFLAGS"
1903     CFLAGS="-Wimplicit-function-declaration -Werror"
1904
1905     # Use strxfrm_l if available.
1906     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1907                     #include <string.h>
1908                     #include <locale.h>],
1909                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1910                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1911                     [Define if strxfrm_l is available in <string.h>.]),)
1912
1913     # Use strerror_l if available.
1914     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1915                     #include <string.h>
1916                     #include <locale.h>],
1917                     [__locale_t loc; strerror_l(5, loc);],
1918                     AC_DEFINE(HAVE_STRERROR_L, 1,
1919                     [Define if strerror_l is available in <string.h>.]),)
1920
1921     CFLAGS="$ac_save_CFLAGS"
1922   fi
1923
1924   # Perhaps use strerror_r if available, and strerror_l isn't.
1925   ac_save_CFLAGS="$CFLAGS"
1926   CFLAGS="-Wimplicit-function-declaration -Werror"
1927   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1928                   #include <string.h>
1929                   #include <locale.h>],
1930                   [char s[128]; strerror_r(5, s, 128);],
1931                   AC_DEFINE(HAVE_STRERROR_R, 1,
1932                   [Define if strerror_r is available in <string.h>.]),)
1933   CFLAGS="$ac_save_CFLAGS"
1934
1935   # Set configure bits for specified locale package
1936   AC_MSG_CHECKING([for C locale to use])
1937   case ${enable_clocale_flag} in
1938     generic)
1939       AC_MSG_RESULT(generic)
1940
1941       CLOCALE_H=config/locale/generic/c_locale.h
1942       CLOCALE_CC=config/locale/generic/c_locale.cc
1943       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1944       CCOLLATE_CC=config/locale/generic/collate_members.cc
1945       CCTYPE_CC=config/locale/generic/ctype_members.cc
1946       CMESSAGES_H=config/locale/generic/messages_members.h
1947       CMESSAGES_CC=config/locale/generic/messages_members.cc
1948       CMONEY_CC=config/locale/generic/monetary_members.cc
1949       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1950       CTIME_H=config/locale/generic/time_members.h
1951       CTIME_CC=config/locale/generic/time_members.cc
1952       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1953       ;;
1954     darwin)
1955       AC_MSG_RESULT(darwin or freebsd)
1956
1957       CLOCALE_H=config/locale/generic/c_locale.h
1958       CLOCALE_CC=config/locale/generic/c_locale.cc
1959       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1960       CCOLLATE_CC=config/locale/generic/collate_members.cc
1961       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1962       CMESSAGES_H=config/locale/generic/messages_members.h
1963       CMESSAGES_CC=config/locale/generic/messages_members.cc
1964       CMONEY_CC=config/locale/generic/monetary_members.cc
1965       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1966       CTIME_H=config/locale/generic/time_members.h
1967       CTIME_CC=config/locale/generic/time_members.cc
1968       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1969       ;;
1970
1971     gnu)
1972       AC_MSG_RESULT(gnu)
1973
1974       # Declare intention to use gettext, and add support for specific
1975       # languages.
1976       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1977       ALL_LINGUAS="de fr"
1978
1979       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1980       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1981       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1982         USE_NLS=yes
1983       fi
1984       # Export the build objects.
1985       for ling in $ALL_LINGUAS; do \
1986         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1987         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1988       done
1989       AC_SUBST(glibcxx_MOFILES)
1990       AC_SUBST(glibcxx_POFILES)
1991
1992       CLOCALE_H=config/locale/gnu/c_locale.h
1993       CLOCALE_CC=config/locale/gnu/c_locale.cc
1994       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1995       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1996       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1997       CMESSAGES_H=config/locale/gnu/messages_members.h
1998       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1999       CMONEY_CC=config/locale/gnu/monetary_members.cc
2000       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2001       CTIME_H=config/locale/gnu/time_members.h
2002       CTIME_CC=config/locale/gnu/time_members.cc
2003       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2004       ;;
2005     ieee_1003.1-2001)
2006       AC_MSG_RESULT(IEEE 1003.1)
2007
2008       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2009       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2010       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2011       CCOLLATE_CC=config/locale/generic/collate_members.cc
2012       CCTYPE_CC=config/locale/generic/ctype_members.cc
2013       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2014       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2015       CMONEY_CC=config/locale/generic/monetary_members.cc
2016       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2017       CTIME_H=config/locale/generic/time_members.h
2018       CTIME_CC=config/locale/generic/time_members.cc
2019       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2020       ;;
2021     newlib)
2022       AC_MSG_RESULT(newlib)
2023
2024       CLOCALE_H=config/locale/generic/c_locale.h
2025       CLOCALE_CC=config/locale/generic/c_locale.cc
2026       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2027       CCOLLATE_CC=config/locale/generic/collate_members.cc
2028       CCTYPE_CC=config/locale/newlib/ctype_members.cc
2029       CMESSAGES_H=config/locale/generic/messages_members.h
2030       CMESSAGES_CC=config/locale/generic/messages_members.cc
2031       CMONEY_CC=config/locale/generic/monetary_members.cc
2032       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2033       CTIME_H=config/locale/generic/time_members.h
2034       CTIME_CC=config/locale/generic/time_members.cc
2035       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2036       ;;
2037   esac
2038
2039   # This is where the testsuite looks for locale catalogs, using the
2040   # -DLOCALEDIR define during testsuite compilation.
2041   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2042   AC_SUBST(glibcxx_localedir)
2043
2044   # A standalone libintl (e.g., GNU libintl) may be in use.
2045   if test $USE_NLS = yes; then
2046     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2047     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2048   fi
2049   if test $USE_NLS = yes; then
2050     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2051               [Define if NLS translations are to be used.])
2052   fi
2053
2054   AC_SUBST(USE_NLS)
2055   AC_SUBST(CLOCALE_H)
2056   AC_SUBST(CMESSAGES_H)
2057   AC_SUBST(CCODECVT_CC)
2058   AC_SUBST(CCOLLATE_CC)
2059   AC_SUBST(CCTYPE_CC)
2060   AC_SUBST(CMESSAGES_CC)
2061   AC_SUBST(CMONEY_CC)
2062   AC_SUBST(CNUMERIC_CC)
2063   AC_SUBST(CTIME_H)
2064   AC_SUBST(CTIME_CC)
2065   AC_SUBST(CLOCALE_CC)
2066   AC_SUBST(CLOCALE_INTERNAL_H)
2067 ])
2068
2069
2070 dnl
2071 dnl Check for which std::allocator base class to use.  The choice is
2072 dnl mapped from a subdirectory of include/ext.
2073 dnl
2074 dnl Default is new.
2075 dnl
2076 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2077   AC_MSG_CHECKING([for std::allocator base class])
2078   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2079     [use KIND for target std::allocator base],
2080     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2081
2082   # If they didn't use this option switch, or if they specified --enable
2083   # with no specific model, we'll have to look for one.  If they
2084   # specified --disable (???), do likewise.
2085   if test $enable_libstdcxx_allocator = no ||
2086      test $enable_libstdcxx_allocator = yes;
2087   then
2088      enable_libstdcxx_allocator=auto
2089   fi
2090
2091   # Either a known package, or "auto". Auto implies the default choice
2092   # for a particular platform.
2093   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2094
2095   # Probe for host-specific support if no specific model is specified.
2096   # Default to "new".
2097   if test $enable_libstdcxx_allocator_flag = auto; then
2098     case ${target_os} in
2099       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2100         enable_libstdcxx_allocator_flag=new
2101         ;;
2102       *)
2103         enable_libstdcxx_allocator_flag=new
2104         ;;
2105     esac
2106   fi
2107   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2108
2109
2110   # Set configure bits for specified locale package
2111   case ${enable_libstdcxx_allocator_flag} in
2112     bitmap)
2113       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2114       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2115       ;;
2116     malloc)
2117       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2118       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2119       ;;
2120     mt)
2121       ALLOCATOR_H=config/allocator/mt_allocator_base.h
2122       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2123       ;;
2124     new)
2125       ALLOCATOR_H=config/allocator/new_allocator_base.h
2126       ALLOCATOR_NAME=__gnu_cxx::new_allocator
2127       ;;
2128     pool)
2129       ALLOCATOR_H=config/allocator/pool_allocator_base.h
2130       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2131       ;;
2132   esac
2133
2134   AC_SUBST(ALLOCATOR_H)
2135   AC_SUBST(ALLOCATOR_NAME)
2136 ])
2137
2138
2139 dnl
2140 dnl Check for whether the Boost-derived checks should be turned on.
2141 dnl
2142 dnl --enable-concept-checks turns them on.
2143 dnl --disable-concept-checks leaves them off.
2144 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2145 dnl       Where DEFAULT is either `yes' or `no'.
2146 dnl
2147 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2148   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2149   if test $enable_concept_checks = yes; then
2150     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2151               [Define to use concept checking code from the boost libraries.])
2152   fi
2153 ])
2154
2155 dnl
2156 dnl Use extern templates.
2157 dnl
2158 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2159 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2160
2161 dnl  +  Usage:  GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2162 dnl       Where DEFAULT is `yes' or `no'.
2163 dnl
2164 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2165
2166   GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2167
2168   AC_MSG_CHECKING([for extern template support])
2169   AC_MSG_RESULT([$enable_extern_template])
2170
2171   GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2172 ])
2173
2174 dnl
2175 dnl Check for parallel mode pre-requisites, including OpenMP support.
2176 dnl
2177 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
2178 dnl
2179 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2180
2181   enable_parallel=no;
2182
2183   # See if configured libgomp/omp.h exists. (libgomp may be in
2184   # noconfigdirs but not explicitly disabled.)
2185   if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2186     enable_parallel=yes;
2187   else
2188     AC_MSG_NOTICE([target-libgomp not built])
2189   fi
2190
2191   AC_MSG_CHECKING([for parallel mode support])
2192   AC_MSG_RESULT([$enable_parallel])
2193   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2194 ])
2195
2196
2197 dnl
2198 dnl Check for which I/O library to use:  stdio, or something specific.
2199 dnl
2200 dnl Default is stdio.
2201 dnl
2202 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2203   AC_MSG_CHECKING([for underlying I/O to use])
2204   GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2205     [use target-specific I/O package], [permit stdio])
2206
2207   # Now that libio has been removed, you can have any color you want as long
2208   # as it's black.  This is one big no-op until other packages are added, but
2209   # showing the framework never hurts.
2210   case ${enable_cstdio} in
2211     stdio)
2212       CSTDIO_H=config/io/c_io_stdio.h
2213       BASIC_FILE_H=config/io/basic_file_stdio.h
2214       BASIC_FILE_CC=config/io/basic_file_stdio.cc
2215       AC_MSG_RESULT(stdio)
2216       ;;
2217   esac
2218
2219   AC_SUBST(CSTDIO_H)
2220   AC_SUBST(BASIC_FILE_H)
2221   AC_SUBST(BASIC_FILE_CC)
2222 ])
2223
2224
2225 dnl
2226 dnl Check for "unusual" flags to pass to the compiler while building.
2227 dnl
2228 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2229 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2230 dnl --disable-cxx-flags passes nothing.
2231 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2232 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2233 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2234 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2235 dnl       If "default flags" is an empty string, the effect is the same
2236 dnl       as --disable or --enable=no.
2237 dnl
2238 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2239   AC_MSG_CHECKING([for extra compiler flags for building])
2240   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2241     [pass compiler FLAGS when building library],
2242     [case "x$enable_cxx_flags" in
2243       xno | x)   enable_cxx_flags= ;;
2244       x-*)       ;;
2245       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2246      esac])
2247
2248   # Run through flags (either default or command-line) and set anything
2249   # extra (e.g., #defines) that must accompany particular g++ options.
2250   if test -n "$enable_cxx_flags"; then
2251     for f in $enable_cxx_flags; do
2252       case "$f" in
2253         -fhonor-std)  ;;
2254         -*)  ;;
2255         *)   # and we're trying to pass /what/ exactly?
2256              AC_MSG_ERROR([compiler flags start with a -]) ;;
2257       esac
2258     done
2259   fi
2260
2261   EXTRA_CXX_FLAGS="$enable_cxx_flags"
2262   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2263   AC_SUBST(EXTRA_CXX_FLAGS)
2264 ])
2265
2266
2267 dnl
2268 dnl Check to see if debugging libraries are to be built.
2269 dnl
2270 dnl --enable-libstdcxx-debug
2271 dnl builds a separate set of debugging libraries in addition to the
2272 dnl normal (shared, static) libstdc++ binaries.
2273 dnl
2274 dnl --disable-libstdcxx-debug
2275 dnl builds only one (non-debug) version of libstdc++.
2276 dnl
2277 dnl --enable-libstdcxx-debug-flags=FLAGS
2278 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2279 dnl
2280 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2281 dnl       Where DEFAULT is either `yes' or `no'.
2282 dnl
2283 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2284   AC_MSG_CHECKING([for additional debug build])
2285   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2286   AC_MSG_RESULT($enable_libstdcxx_debug)
2287   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2288 ])
2289
2290
2291 dnl
2292 dnl Check for explicit debug flags.
2293 dnl
2294 dnl --enable-libstdcxx-debug-flags='-O1'
2295 dnl is a general method for passing flags to be used when
2296 dnl building debug libraries with --enable-debug.
2297 dnl
2298 dnl --disable-libstdcxx-debug-flags does nothing.
2299 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2300 dnl       If "default flags" is an empty string, the effect is the same
2301 dnl       as --disable or --enable=no.
2302 dnl
2303 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2304   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2305     [pass compiler FLAGS when building debug library],
2306     [case "x$enable_libstdcxx_debug_flags" in
2307       xno | x)    enable_libstdcxx_debug_flags= ;;
2308       x-*)        ;;
2309       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2310      esac])
2311
2312   # Option parsed, now set things appropriately
2313   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2314   AC_SUBST(DEBUG_FLAGS)
2315
2316   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2317 ])
2318
2319
2320 dnl
2321 dnl Check if the user only wants a freestanding library implementation.
2322 dnl
2323 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2324 dnl installing only the headers required by [17.4.1.3] and the language
2325 dnl support library.  More than that will be built (to keep the Makefiles
2326 dnl conveniently clean), but not installed.
2327 dnl
2328 dnl Sets:
2329 dnl  is_hosted  (yes/no)
2330 dnl
2331 dnl Defines:
2332 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2333 dnl
2334 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2335   AC_ARG_ENABLE([hosted-libstdcxx],
2336     AC_HELP_STRING([--disable-hosted-libstdcxx],
2337                    [only build freestanding C++ runtime support]),,
2338     [case "$host" in
2339         arm*-*-symbianelf*)
2340             enable_hosted_libstdcxx=no
2341             ;;
2342         *)
2343             enable_hosted_libstdcxx=yes
2344             ;;
2345      esac])
2346   if test "$enable_hosted_libstdcxx" = no; then
2347     AC_MSG_NOTICE([Only freestanding libraries will be built])
2348     is_hosted=no
2349     hosted_define=0
2350     enable_abi_check=no
2351     enable_libstdcxx_pch=no
2352   else
2353     is_hosted=yes
2354     hosted_define=1
2355   fi
2356   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2357   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2358     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2359 ])
2360
2361
2362 dnl
2363 dnl Check for template specializations for the 'long long' type.
2364 dnl The result determines only whether 'long long' I/O is enabled; things
2365 dnl like numeric_limits<> specializations are always available.
2366 dnl
2367 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2368 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2369 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2370 dnl       Where DEFAULT is either `yes' or `no'.
2371 dnl
2372 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2373   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2374   if test $enable_long_long = yes; then
2375     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2376               [Define if code specialized for long long should be used.])
2377   fi
2378   AC_MSG_CHECKING([for enabled long long specializations])
2379   AC_MSG_RESULT([$enable_long_long])
2380 ])
2381
2382
2383 dnl
2384 dnl Check for decimal floating point.
2385 dnl See:
2386 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2387 dnl
2388 dnl This checks to see if the host supports decimal floating point types.
2389 dnl
2390 dnl Defines:
2391 dnl  _GLIBCXX_USE_DECIMAL_FLOAT
2392 dnl
2393 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2394
2395   # Fake what AC_TRY_COMPILE does, without linking as this is
2396   # unnecessary for this test.
2397
2398     cat > conftest.$ac_ext << EOF
2399 [#]line __oline__ "configure"
2400 int main()
2401 {
2402   _Decimal32 d1;
2403   _Decimal64 d2;
2404   _Decimal128 d3;
2405   return 0;
2406 }
2407 EOF
2408
2409     AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2410     if AC_TRY_EVAL(ac_compile); then
2411       AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2412       [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2413       enable_dfp=yes
2414     else
2415       enable_dfp=no
2416     fi
2417     AC_MSG_RESULT($enable_dfp)
2418     rm -f conftest*
2419 ])
2420
2421 dnl
2422 dnl Check for GNU 128-bit integer and floating point types.
2423 dnl
2424 dnl Note: also checks that the types aren't standard types.
2425 dnl
2426 dnl Defines:
2427 dnl  _GLIBCXX_USE_INT128
2428 dnl  _GLIBCXX_USE_FLOAT128
2429 dnl
2430 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
2431
2432   AC_LANG_SAVE
2433   AC_LANG_CPLUSPLUS
2434
2435   # Fake what AC_TRY_COMPILE does, without linking as this is
2436   # unnecessary for this test.
2437
2438     cat > conftest.$ac_ext << EOF
2439 [#]line __oline__ "configure"
2440 template<typename T1, typename T2>
2441   struct same
2442   { typedef T2 type; };
2443
2444 template<typename T>
2445   struct same<T, T>;
2446
2447 int main()
2448 {
2449   typename same<long, __int128_t>::type                i1;
2450   typename same<unsigned long, __uint128_t>::type      u1;
2451   typename same<long long, __int128_t>::type           i2;
2452   typename same<unsigned long long, __uint128_t>::type u2;
2453 }
2454 EOF
2455
2456     AC_MSG_CHECKING([for __int128_t and __uint128_t])
2457     if AC_TRY_EVAL(ac_compile); then
2458       AC_DEFINE(_GLIBCXX_USE_INT128, 1,
2459       [Define if __int128_t and __uint128_t types are supported on this host.])
2460       enable_int128=yes
2461     else
2462       enable_int128=no
2463     fi
2464     AC_MSG_RESULT($enable_int128)
2465     rm -f conftest*
2466
2467     cat > conftest.$ac_ext << EOF
2468 [#]line __oline__ "configure"
2469 template<typename T1, typename T2>
2470   struct same
2471   { typedef T2 type; };
2472
2473 template<typename T>
2474   struct same<T, T>;
2475
2476 int main()
2477 {
2478   typename same<double, __float128>::type      f1;
2479   typename same<long double, __float128>::type f2;
2480 }
2481 EOF
2482
2483     AC_MSG_CHECKING([for __float128])
2484     if AC_TRY_EVAL(ac_compile); then
2485       AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
2486       [Define if __float128 is supported on this host.])
2487       enable_float128=yes
2488     else
2489       enable_float128=no
2490     fi
2491     AC_MSG_RESULT($enable_float128)
2492     rm -f conftest*
2493
2494   AC_LANG_RESTORE
2495 ])
2496
2497 dnl
2498 dnl Check for template specializations for the 'wchar_t' type.
2499 dnl
2500 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2501 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2502 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2503 dnl       Where DEFAULT is either `yes' or `no'.
2504 dnl
2505 dnl Necessary support must also be present.
2506 dnl
2507 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2508   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2509
2510   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2511   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2512   AC_MSG_CHECKING([for mbstate_t])
2513   AC_TRY_COMPILE([#include <wchar.h>],
2514   [mbstate_t teststate;],
2515   have_mbstate_t=yes, have_mbstate_t=no)
2516   AC_MSG_RESULT($have_mbstate_t)
2517   if test x"$have_mbstate_t" = xyes; then
2518     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2519   fi
2520
2521   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2522   # ac_has_wchar_h.
2523   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2524
2525   if test x"$enable_wchar_t" = x"yes"; then
2526
2527     AC_LANG_SAVE
2528     AC_LANG_CPLUSPLUS
2529
2530     if test x"$ac_has_wchar_h" = xyes &&
2531        test x"$ac_has_wctype_h" = xyes; then
2532       AC_TRY_COMPILE([#include <wchar.h>
2533                       #include <stddef.h>
2534                       wint_t i;
2535                       long l = WEOF;
2536                       long j = WCHAR_MIN;
2537                       long k = WCHAR_MAX;
2538                       namespace test
2539                       {
2540                         using ::btowc;
2541                         using ::fgetwc;
2542                         using ::fgetws;
2543                         using ::fputwc;
2544                         using ::fputws;
2545                         using ::fwide;
2546                         using ::fwprintf;
2547                         using ::fwscanf;
2548                         using ::getwc;
2549                         using ::getwchar;
2550                         using ::mbrlen;
2551                         using ::mbrtowc;
2552                         using ::mbsinit;
2553                         using ::mbsrtowcs;
2554                         using ::putwc;
2555                         using ::putwchar;
2556                         using ::swprintf;
2557                         using ::swscanf;
2558                         using ::ungetwc;
2559                         using ::vfwprintf;
2560                         using ::vswprintf;
2561                         using ::vwprintf;
2562                         using ::wcrtomb;
2563                         using ::wcscat;
2564                         using ::wcschr;
2565                         using ::wcscmp;
2566                         using ::wcscoll;
2567                         using ::wcscpy;
2568                         using ::wcscspn;
2569                         using ::wcsftime;
2570                         using ::wcslen;
2571                         using ::wcsncat;
2572                         using ::wcsncmp;
2573                         using ::wcsncpy;
2574                         using ::wcspbrk;
2575                         using ::wcsrchr;
2576                         using ::wcsrtombs;
2577                         using ::wcsspn;
2578                         using ::wcsstr;
2579                         using ::wcstod;
2580                         using ::wcstok;
2581                         using ::wcstol;
2582                         using ::wcstoul;
2583                         using ::wcsxfrm;
2584                         using ::wctob;
2585                         using ::wmemchr;
2586                         using ::wmemcmp;
2587                         using ::wmemcpy;
2588                         using ::wmemmove;
2589                         using ::wmemset;
2590                         using ::wprintf;
2591                         using ::wscanf;
2592                       }
2593                      ],[],[], [enable_wchar_t=no])
2594     else
2595       enable_wchar_t=no
2596     fi
2597
2598     AC_LANG_RESTORE
2599   fi
2600
2601   if test x"$enable_wchar_t" = x"yes"; then
2602     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2603               [Define if code specialized for wchar_t should be used.])
2604   fi
2605
2606   AC_MSG_CHECKING([for enabled wchar_t specializations])
2607   AC_MSG_RESULT([$enable_wchar_t])
2608 ])
2609
2610
2611 dnl
2612 dnl Check to see if building and using a C++ precompiled header can be done.
2613 dnl
2614 dnl --enable-libstdcxx-pch=yes
2615 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2616 dnl may work, after some light-hearted attempts to puzzle out compiler
2617 dnl support, flip bits on in include/Makefile.am
2618 dnl
2619 dnl --disable-libstdcxx-pch
2620 dnl turns off attempts to use or build stdc++.h.gch.
2621 dnl
2622 dnl Substs:
2623 dnl  glibcxx_PCHFLAGS
2624 dnl
2625 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2626   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2627   if test $enable_libstdcxx_pch = yes; then
2628     AC_CACHE_CHECK([for compiler with PCH support],
2629       [glibcxx_cv_prog_CXX_pch],
2630       [ac_save_CXXFLAGS="$CXXFLAGS"
2631        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2632        AC_LANG_SAVE
2633        AC_LANG_CPLUSPLUS
2634        echo '#include <math.h>' > conftest.h
2635        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2636                           -o conftest.h.gch 1>&5 2>&1 &&
2637                 echo '#error "pch failed"' > conftest.h &&
2638           echo '#include "conftest.h"' > conftest.cc &&
2639                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2640        then
2641          glibcxx_cv_prog_CXX_pch=yes
2642        else
2643          glibcxx_cv_prog_CXX_pch=no
2644        fi
2645        rm -f conftest*
2646        CXXFLAGS=$ac_save_CXXFLAGS
2647        AC_LANG_RESTORE
2648       ])
2649     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2650   fi
2651
2652   AC_MSG_CHECKING([for enabled PCH])
2653   AC_MSG_RESULT([$enable_libstdcxx_pch])
2654
2655   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2656   if test $enable_libstdcxx_pch = yes; then
2657     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2658   else
2659     glibcxx_PCHFLAGS=""
2660   fi
2661   AC_SUBST(glibcxx_PCHFLAGS)
2662 ])
2663
2664
2665 dnl
2666 dnl Check for atomic builtins.
2667 dnl See:
2668 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2669 dnl
2670 dnl This checks to see if the host supports the compiler-generated
2671 dnl builtins for atomic operations for various integral sizes. Note, this
2672 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2673 dnl that are used should be checked.
2674 dnl
2675 dnl Note:
2676 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2677 dnl
2678 dnl Defines:
2679 dnl  _GLIBCXX_ATOMIC_BUILTINS_1
2680 dnl  _GLIBCXX_ATOMIC_BUILTINS_2
2681 dnl  _GLIBCXX_ATOMIC_BUILTINS_4
2682 dnl  _GLIBCXX_ATOMIC_BUILTINS_8
2683 dnl
2684 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2685   AC_LANG_SAVE
2686   AC_LANG_CPLUSPLUS
2687   old_CXXFLAGS="$CXXFLAGS"
2688
2689   # Do link tests if possible, instead asm tests, limited to some platforms
2690   # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2691   # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2692   atomic_builtins_link_tests=no
2693   if test x$gcc_no_link != xyes; then
2694     # Can do link tests. Limit to some tested platforms
2695     case "$host" in
2696       *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2697         atomic_builtins_link_tests=yes
2698         ;;
2699     esac
2700   fi
2701
2702   if test x$atomic_builtins_link_tests = xyes; then
2703
2704   # Do link tests.
2705
2706   CXXFLAGS="$CXXFLAGS -fno-exceptions"
2707
2708   AC_MSG_CHECKING([for atomic builtins for bool])
2709   AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2710     AC_TRY_LINK(
2711       [ ],
2712       [typedef bool atomic_type;
2713        atomic_type c1;
2714        atomic_type c2;
2715        const atomic_type c3(0);
2716        __sync_fetch_and_add(&c1, c2);
2717        __sync_val_compare_and_swap(&c1, c3, c2);
2718        __sync_lock_test_and_set(&c1, c3);
2719        __sync_lock_release(&c1);
2720        __sync_synchronize();],
2721       [glibcxx_cv_atomic_bool=yes],
2722       [glibcxx_cv_atomic_bool=no])
2723   ])
2724   if test $glibcxx_cv_atomic_bool = yes; then
2725     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2726       [Define if builtin atomic operations for bool are supported on this host.])
2727   fi
2728   AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2729
2730   AC_MSG_CHECKING([for atomic builtins for short])
2731   AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2732     AC_TRY_LINK(
2733       [ ],
2734       [typedef short atomic_type;
2735        atomic_type c1;
2736        atomic_type c2;
2737        const atomic_type c3(0);
2738        __sync_fetch_and_add(&c1, c2);
2739        __sync_val_compare_and_swap(&c1, c3, c2);
2740        __sync_lock_test_and_set(&c1, c3);
2741        __sync_lock_release(&c1);
2742        __sync_synchronize();],
2743       [glibcxx_cv_atomic_short=yes],
2744       [glibcxx_cv_atomic_short=no])
2745   ])
2746   if test $glibcxx_cv_atomic_short = yes; then
2747     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2748       [Define if builtin atomic operations for short are supported on this host.])
2749   fi
2750   AC_MSG_RESULT($glibcxx_cv_atomic_short)
2751
2752   AC_MSG_CHECKING([for atomic builtins for int])
2753   AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2754     AC_TRY_LINK(
2755       [ ],
2756       [typedef int atomic_type;
2757        atomic_type c1;
2758        atomic_type c2;
2759        const atomic_type c3(0);
2760        __sync_fetch_and_add(&c1, c2);
2761        __sync_val_compare_and_swap(&c1, c3, c2);
2762        __sync_lock_test_and_set(&c1, c3);
2763        __sync_lock_release(&c1);
2764        __sync_synchronize();],
2765       [glibcxx_cv_atomic_int=yes],
2766       [glibcxx_cv_atomic_int=no])
2767   ])
2768   if test $glibcxx_cv_atomic_int = yes; then
2769     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2770       [Define if builtin atomic operations for int are supported on this host.])
2771   fi
2772   AC_MSG_RESULT($glibcxx_cv_atomic_int)
2773
2774   AC_MSG_CHECKING([for atomic builtins for long long])
2775   AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2776     AC_TRY_LINK(
2777       [ ],
2778       [typedef long long atomic_type;
2779        atomic_type c1;
2780        atomic_type c2;
2781        const atomic_type c3(0);
2782        __sync_fetch_and_add(&c1, c2);
2783        __sync_val_compare_and_swap(&c1, c3, c2);
2784        __sync_lock_test_and_set(&c1, c3);
2785        __sync_lock_release(&c1);
2786        __sync_synchronize();],
2787       [glibcxx_cv_atomic_long_long=yes],
2788       [glibcxx_cv_atomic_long_long=no])
2789   ])
2790   if test $glibcxx_cv_atomic_long_long = yes; then
2791     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2792       [Define if builtin atomic operations for long long are supported on this host.])
2793   fi
2794   AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2795
2796   else
2797
2798   # Do asm tests.
2799
2800   # Compile unoptimized.
2801   CXXFLAGS='-O0 -S'
2802
2803   # Fake what AC_TRY_COMPILE does.
2804
2805     cat > conftest.$ac_ext << EOF
2806 [#]line __oline__ "configure"
2807 int main()
2808 {
2809   typedef bool atomic_type;
2810   atomic_type c1;
2811   atomic_type c2;
2812   const atomic_type c3(0);
2813   __sync_fetch_and_add(&c1, c2);
2814   __sync_val_compare_and_swap(&c1, c3, c2);
2815   __sync_lock_test_and_set(&c1, c3);
2816   __sync_lock_release(&c1);
2817   __sync_synchronize();
2818   return 0;
2819 }
2820 EOF
2821
2822     AC_MSG_CHECKING([for atomic builtins for bool])
2823     if AC_TRY_EVAL(ac_compile); then
2824       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2825         glibcxx_cv_atomic_bool=no
2826       else
2827       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2828       [Define if builtin atomic operations for bool are supported on this host.])
2829         glibcxx_cv_atomic_bool=yes
2830       fi
2831     fi
2832     AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2833     rm -f conftest*
2834
2835     cat > conftest.$ac_ext << EOF
2836 [#]line __oline__ "configure"
2837 int main()
2838 {
2839   typedef short atomic_type;
2840   atomic_type c1;
2841   atomic_type c2;
2842   const atomic_type c3(0);
2843   __sync_fetch_and_add(&c1, c2);
2844   __sync_val_compare_and_swap(&c1, c3, c2);
2845   __sync_lock_test_and_set(&c1, c3);
2846   __sync_lock_release(&c1);
2847   __sync_synchronize();
2848   return 0;
2849 }
2850 EOF
2851
2852     AC_MSG_CHECKING([for atomic builtins for short])
2853     if AC_TRY_EVAL(ac_compile); then
2854       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2855         glibcxx_cv_atomic_short=no
2856       else
2857       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2858       [Define if builtin atomic operations for short are supported on this host.])
2859         glibcxx_cv_atomic_short=yes
2860       fi
2861     fi
2862     AC_MSG_RESULT($glibcxx_cv_atomic_short)
2863     rm -f conftest*
2864
2865     cat > conftest.$ac_ext << EOF
2866 [#]line __oline__ "configure"
2867 int main()
2868 {
2869   // NB: _Atomic_word not necessarily int.
2870   typedef int atomic_type;
2871   atomic_type c1;
2872   atomic_type c2;
2873   const atomic_type c3(0);
2874   __sync_fetch_and_add(&c1, c2);
2875   __sync_val_compare_and_swap(&c1, c3, c2);
2876   __sync_lock_test_and_set(&c1, c3);
2877   __sync_lock_release(&c1);
2878   __sync_synchronize();
2879   return 0;
2880 }
2881 EOF
2882
2883     AC_MSG_CHECKING([for atomic builtins for int])
2884     if AC_TRY_EVAL(ac_compile); then
2885       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2886         glibcxx_cv_atomic_int=no
2887       else
2888       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2889         [Define if builtin atomic operations for int are supported on this host.])
2890         glibcxx_cv_atomic_int=yes
2891       fi
2892     fi
2893     AC_MSG_RESULT($glibcxx_cv_atomic_int)
2894     rm -f conftest*
2895
2896     cat > conftest.$ac_ext << EOF
2897 [#]line __oline__ "configure"
2898 int main()
2899 {
2900   typedef long long atomic_type;
2901   atomic_type c1;
2902   atomic_type c2;
2903   const atomic_type c3(0);
2904   __sync_fetch_and_add(&c1, c2);
2905   __sync_val_compare_and_swap(&c1, c3, c2);
2906   __sync_lock_test_and_set(&c1, c3);
2907   __sync_lock_release(&c1);
2908   __sync_synchronize();
2909   return 0;
2910 }
2911 EOF
2912
2913     AC_MSG_CHECKING([for atomic builtins for long long])
2914     if AC_TRY_EVAL(ac_compile); then
2915       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2916         glibcxx_cv_atomic_long_long=no
2917       else
2918       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2919       [Define if builtin atomic operations for long long are supported on this host.])
2920         glibcxx_cv_atomic_long_long=yes
2921       fi
2922     fi
2923     AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2924     rm -f conftest*
2925
2926   fi
2927
2928   CXXFLAGS="$old_CXXFLAGS"
2929   AC_LANG_RESTORE
2930
2931   # Set atomicity_dir to builtins if either of above tests pass.
2932   if test $glibcxx_cv_atomic_int = yes || test $glibcxx_cv_atomic_bool = yes ; then
2933     atomicity_dir=cpu/generic/atomicity_builtins
2934   fi
2935
2936   # If still generic, set to mutex.
2937   if test $atomicity_dir = "cpu/generic" ; then
2938     atomicity_dir=cpu/generic/atomicity_mutex
2939     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2940       if test "x$target_thread_file" = xsingle; then
2941         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2942         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2943       else
2944         AC_MSG_WARN([They will be faked using a mutex.])
2945         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2946       fi
2947   fi
2948
2949 ])
2950
2951
2952 dnl
2953 dnl Check for exception handling support.  If an explicit enable/disable
2954 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2955 dnl target may or may not support call frame exceptions.
2956 dnl
2957 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2958 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2959 dnl Neither one forces an attempt at detection.
2960 dnl
2961 dnl Defines:
2962 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2963 dnl
2964 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2965   AC_MSG_CHECKING([for exception model to use])
2966   AC_LANG_SAVE
2967   AC_LANG_CPLUSPLUS
2968   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2969     [force use of builtin_setjmp for exceptions],
2970     [permit yes|no|auto])
2971
2972   if test $enable_sjlj_exceptions = auto; then
2973     # Botheration.  Now we've got to detect the exception model.  Link tests
2974     # against libgcc.a are problematic since we've not been given proper -L
2975     # bits for single-tree newlib and libgloss.
2976     #
2977     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2978     cat > conftest.$ac_ext << EOF
2979 [#]line __oline__ "configure"
2980 struct S { ~S(); };
2981 void bar();
2982 void foo()
2983 {
2984   S s;
2985   bar();
2986 }
2987 EOF
2988     old_CXXFLAGS="$CXXFLAGS"
2989     CXXFLAGS=-S
2990     if AC_TRY_EVAL(ac_compile); then
2991       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2992         enable_sjlj_exceptions=yes
2993       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2994         enable_sjlj_exceptions=no
2995       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2996         enable_sjlj_exceptions=no
2997       fi
2998     fi
2999     CXXFLAGS="$old_CXXFLAGS"
3000     rm -f conftest*
3001   fi
3002
3003   # This is a tad weird, for hysterical raisins.  We have to map
3004   # enable/disable to two different models.
3005   case $enable_sjlj_exceptions in
3006     yes)
3007       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
3008         [Define if the compiler is configured for setjmp/longjmp exceptions.])
3009       ac_exception_model_name=sjlj
3010       ;;
3011     no)
3012       ac_exception_model_name="call frame"
3013       ;;
3014     *)
3015       AC_MSG_ERROR([unable to detect exception model])
3016       ;;
3017   esac
3018  AC_LANG_RESTORE
3019  AC_MSG_RESULT($ac_exception_model_name)
3020 ])
3021
3022
3023 dnl
3024 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3025 dnl
3026 dnl --enable-visibility enables attempt to use visibility attributes.
3027 dnl --disable-visibility turns off all use of visibility attributes.
3028 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
3029 dnl       Where DEFAULT is 'yes'.
3030 dnl
3031 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
3032 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
3033
3034 if test x$enable_visibility = xyes ; then
3035   dnl all hail libgfortran
3036   dnl Check whether the target supports hidden visibility.
3037   AC_CACHE_CHECK([whether the target supports hidden visibility],
3038                  glibcxx_cv_have_attribute_visibility, [
3039   save_CFLAGS="$CFLAGS"
3040   CFLAGS="$CFLAGS -Werror"
3041   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3042                  [], glibcxx_cv_have_attribute_visibility=yes,
3043                  glibcxx_cv_have_attribute_visibility=no)
3044   CFLAGS="$save_CFLAGS"])
3045   if test $glibcxx_cv_have_attribute_visibility = no; then
3046     enable_visibility=no
3047   fi
3048 fi
3049
3050 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
3051 AC_MSG_NOTICE([visibility supported: $enable_visibility])
3052 ])
3053
3054
3055 dnl
3056 dnl Add version tags to symbols in shared library (or not), additionally
3057 dnl marking other symbols as private/local (or not).
3058 dnl
3059 dnl --enable-symvers=style adds a version script to the linker call when
3060 dnl       creating the shared library.  The choice of version script is
3061 dnl       controlled by 'style'.
3062 dnl --disable-symvers does not.
3063 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3064 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
3065 dnl       choose a default style based on linker characteristics.  Passing
3066 dnl       'no' disables versioning.
3067 dnl
3068 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3069
3070 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3071   [enables symbol versioning of the shared library],
3072   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3073
3074 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3075 # don't know enough about $LD to do tricks...
3076 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3077 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3078 # with extern "C++" in version scripts.
3079 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3080
3081 # Turn a 'yes' into a suitable default.
3082 if test x$enable_symvers = xyes ; then
3083   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3084     enable_symvers=no
3085   else
3086     if test $with_gnu_ld = yes ; then
3087       case ${target_os} in
3088         hpux*)
3089           enable_symvers=no ;;
3090         *)
3091           enable_symvers=gnu ;;
3092       esac
3093     else
3094       case ${target_os} in
3095         darwin*)
3096           enable_symvers=darwin ;;
3097         # Sun symbol versioning exists since Solaris 2.5.
3098         solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3099           # make_sunver.pl needs GNU c++filt to support extern "C++" in
3100           # version scripts, so disable symbol versioning if none can be
3101           # found.
3102           if test -z "$ac_cv_path_CXXFILT"; then
3103             AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3104             AC_MSG_WARN([=== no GNU c++filt could  be found.])
3105             AC_MSG_WARN([=== Symbol versioning will be disabled.])
3106             enable_symvers=no
3107           else
3108             enable_symvers=sun
3109           fi
3110           ;;
3111         *)
3112           enable_symvers=no ;;
3113       esac
3114     fi
3115   fi
3116 fi
3117
3118 # Check to see if 'darwin' or 'darwin-export' can win.
3119 if test x$enable_symvers = xdarwin-export ; then
3120     enable_symvers=darwin
3121 fi
3122
3123 # Check if 'sun' was requested on non-Solaris 2 platforms.
3124 if test x$enable_symvers = xsun ; then
3125   case ${target_os} in
3126     solaris2*)
3127       # All fine.
3128       ;;
3129     *)
3130       # Unlikely to work.
3131       AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3132       AC_MSG_WARN([=== you are not targetting Solaris 2.])
3133       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3134       enable_symvers=no
3135       ;;
3136   esac
3137 fi
3138
3139 # Check to see if 'gnu' can win.
3140 if test $enable_symvers = gnu ||
3141   test $enable_symvers = gnu-versioned-namespace ||
3142   test $enable_symvers = sun; then
3143   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3144   AC_MSG_CHECKING([for shared libgcc])
3145   ac_save_CFLAGS="$CFLAGS"
3146   CFLAGS=' -lgcc_s'
3147   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3148   CFLAGS="$ac_save_CFLAGS"
3149   if test $glibcxx_shared_libgcc = no; then
3150     cat > conftest.c <<EOF
3151 int main (void) { return 0; }
3152 EOF
3153 changequote(,)dnl
3154     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3155                              -shared -shared-libgcc -o conftest.so \
3156                              conftest.c -v 2>&1 >/dev/null \
3157                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3158 changequote([,])dnl
3159     rm -f conftest.c conftest.so
3160     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3161       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3162       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3163       CFLAGS="$ac_save_CFLAGS"
3164     fi
3165   fi
3166   AC_MSG_RESULT($glibcxx_shared_libgcc)
3167
3168   # For GNU ld, we need at least this version.  The format is described in
3169   # GLIBCXX_CHECK_LINKER_FEATURES above.
3170   glibcxx_min_gnu_ld_version=21400
3171
3172   # If no shared libgcc, can't win.
3173   if test $glibcxx_shared_libgcc != yes; then
3174       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3175       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3176       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3177       enable_symvers=no
3178   elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3179     : All interesting versions of Sun ld support sun style symbol versioning.
3180   elif test $with_gnu_ld != yes ; then
3181     # just fail for now
3182     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3183     AC_MSG_WARN([=== you are not using the GNU linker.])
3184     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3185     enable_symvers=no
3186   elif test $glibcxx_ld_is_gold = yes ; then
3187     : All versions of gold support symbol versioning.
3188   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3189     # The right tools, the right setup, but too old.  Fallbacks?
3190     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3191     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3192     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3193     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3194     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3195     enable_symvers=no
3196   fi
3197 fi
3198
3199 # Everything parsed; figure out what file to use.
3200 case $enable_symvers in
3201   no)
3202     SYMVER_FILE=config/abi/pre/none.ver
3203     ;;
3204   gnu)
3205     SYMVER_FILE=config/abi/pre/gnu.ver
3206     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3207               [Define to use GNU versioning in the shared library.])
3208     ;;
3209   gnu-versioned-namespace)
3210     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3211     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3212               [Define to use GNU namespace versioning in the shared library.])
3213     ;;
3214   darwin)
3215     SYMVER_FILE=config/abi/pre/gnu.ver
3216     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3217               [Define to use darwin versioning in the shared library.])
3218     ;;
3219   sun)
3220     SYMVER_FILE=config/abi/pre/gnu.ver
3221     AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3222               [Define to use Sun versioning in the shared library.])
3223     ;;
3224 esac
3225
3226 if test x$enable_symvers != xno ; then
3227   AC_DEFINE(_GLIBCXX_SYMVER, 1,
3228          [Define to use symbol versioning in the shared library.])
3229 fi
3230
3231 AC_CACHE_CHECK([whether the target supports .symver directive],
3232                glibcxx_cv_have_as_symver_directive, [
3233   AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3234                  [], glibcxx_cv_have_as_symver_directive=yes,
3235                  glibcxx_cv_have_as_symver_directive=no)])
3236 if test $glibcxx_cv_have_as_symver_directive = yes; then
3237   AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3238     [Define to 1 if the target assembler supports .symver directive.])
3239 fi
3240
3241 AC_SUBST(SYMVER_FILE)
3242 AC_SUBST(port_specific_symbol_files)
3243 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3244 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3245 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3246 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3247 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3248 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3249
3250 if test $enable_symvers != no ; then
3251    case ${target_os} in
3252      # The Solaris 2 runtime linker doesn't support the GNU extension of
3253      # binding the same symbol to different versions
3254      solaris2*)
3255        symvers_renaming=no  ;;
3256      # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3257      *)
3258        AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3259          [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3260        symvers_renaming=yes  ;;
3261     esac
3262 else
3263     symvers_renaming=no
3264 fi
3265 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SOL2, test $symvers_renaming = no)
3266
3267 # Now, set up compatibility support, if any.
3268 # In addition, need this to deal with std::size_t mangling in
3269 # src/compatibility.cc.  In a perfect world, could use
3270 # typeid(std::size_t).name()[0] to do direct substitution.
3271 AC_MSG_CHECKING([for size_t as unsigned int])
3272 ac_save_CFLAGS="$CFLAGS"
3273 CFLAGS="-Werror"
3274 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3275                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3276 CFLAGS=$ac_save_CFLAGS
3277 if test "$glibcxx_size_t_is_i" = yes; then
3278   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3279 fi
3280 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3281
3282 AC_MSG_CHECKING([for ptrdiff_t as int])
3283 ac_save_CFLAGS="$CFLAGS"
3284 CFLAGS="-Werror"
3285 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3286                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3287 CFLAGS=$ac_save_CFLAGS
3288 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3289   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3290 fi
3291 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3292 ])
3293
3294
3295 dnl
3296 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3297 dnl We must stage the required headers so that they will be installed
3298 dnl with the library (unlike libgcc, the STL implementation is provided
3299 dnl solely within headers).  Since we must not inject random user-space
3300 dnl macro names into user-provided C++ code, we first stage into <file>-in
3301 dnl and process to <file> with an output command.  The reason for a two-
3302 dnl stage process here is to correctly handle $srcdir!=$objdir without
3303 dnl having to write complex code (the sed commands to clean the macro
3304 dnl namespace are complex and fragile enough as it is).  We must also
3305 dnl add a relative path so that -I- is supported properly.
3306 dnl
3307 dnl Substs:
3308 dnl  glibcxx_thread_h
3309 dnl
3310 dnl Defines:
3311 dnl  HAVE_GTHR_DEFAULT
3312 dnl
3313 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3314   AC_MSG_CHECKING([for thread model used by GCC])
3315   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3316   AC_MSG_RESULT([$target_thread_file])
3317
3318   if test $target_thread_file != single; then
3319     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
3320               [Define if gthr-default.h exists
3321               (meaning that threading support is enabled).])
3322   fi
3323
3324   glibcxx_thread_h=gthr-$target_thread_file.h
3325
3326   dnl Check for __GTHREADS define.
3327   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
3328   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
3329     enable_thread=yes
3330   else
3331    enable_thread=no
3332   fi
3333
3334   AC_SUBST(glibcxx_thread_h)
3335 ])
3336
3337
3338 dnl
3339 dnl Check if gthread implementation defines the types and functions
3340 dnl required by the c++0x thread library.  Conforming gthread
3341 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3342 dnl
3343 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3344   AC_LANG_SAVE
3345   AC_LANG_CPLUSPLUS
3346
3347   ac_save_CXXFLAGS="$CXXFLAGS"
3348   CXXFLAGS="$CXXFLAGS -fno-exceptions -I${toplevel_srcdir}/gcc"
3349
3350   AC_MSG_CHECKING([check whether it can be safely assumed that mutex_timedlock is available])
3351
3352   AC_TRY_COMPILE([#include <unistd.h>],
3353     [
3354       #if !defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS < 0
3355       #error
3356       #endif
3357     ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3358
3359   AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3360                      [Define to 1 if mutex_timedlock is available.])
3361
3362   if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3363   else res_mutex_timedlock=no ; fi
3364   AC_MSG_RESULT([$res_mutex_timedlock])
3365
3366   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3367   case $target_thread_file in
3368     posix)
3369       CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3370   esac
3371
3372   AC_MSG_CHECKING([for gthreads library])
3373
3374   AC_TRY_COMPILE([
3375                   #include "gthr.h"
3376                   #include <unistd.h>
3377                  ],
3378     [
3379       #ifndef __GTHREADS_CXX0X
3380       #error
3381       #endif
3382
3383       // In case of POSIX threads check _POSIX_TIMEOUTS too.
3384       #if (defined(_PTHREADS) \
3385            && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3386       #error
3387       #endif
3388     ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
3389
3390   AC_MSG_RESULT([$ac_has_gthreads])
3391
3392   if test x"$ac_has_gthreads" = x"yes"; then
3393     AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3394               [Define if gthreads library is available.])
3395   fi
3396
3397   CXXFLAGS="$ac_save_CXXFLAGS"
3398   AC_LANG_RESTORE
3399 ])
3400
3401
3402 # Check whether LC_MESSAGES is available in <locale.h>.
3403 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3404 #
3405 # This file file be copied and used freely without restrictions.  It can
3406 # be used in projects which are not available under the GNU Public License
3407 # but which still want to provide support for the GNU gettext functionality.
3408 # Please note that the actual code is *not* freely available.
3409 AC_DEFUN([AC_LC_MESSAGES], [
3410   AC_CHECK_HEADER(locale.h, [
3411     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3412       [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3413        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3414     if test $ac_cv_val_LC_MESSAGES = yes; then
3415       AC_DEFINE(HAVE_LC_MESSAGES, 1,
3416                 [Define if LC_MESSAGES is available in <locale.h>.])
3417     fi
3418   ])
3419 ])
3420
3421 dnl
3422 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
3423 dnl
3424 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
3425
3426   AC_LANG_SAVE
3427   AC_LANG_CPLUSPLUS
3428   ac_save_CXXFLAGS="$CXXFLAGS"
3429   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3430
3431   AC_MSG_CHECKING([for get_nprocs])
3432   AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
3433     GCC_TRY_COMPILE_OR_LINK(
3434       [#include <sys/sysinfo.h>],
3435       [int n = get_nprocs();],
3436       [glibcxx_cv_GET_NPROCS=yes],
3437       [glibcxx_cv_GET_NPROCS=no])
3438   ])
3439   if test $glibcxx_cv_GET_NPROCS = yes; then
3440     AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
3441   fi
3442   AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
3443
3444   CXXFLAGS="$ac_save_CXXFLAGS"
3445   AC_LANG_RESTORE
3446 ])
3447
3448 dnl
3449 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
3450 dnl
3451 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
3452
3453   AC_LANG_SAVE
3454   AC_LANG_CPLUSPLUS
3455   ac_save_CXXFLAGS="$CXXFLAGS"
3456   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3457
3458   AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
3459   AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
3460     GCC_TRY_COMPILE_OR_LINK(
3461       [#include <unistd.h>],
3462       [int n = sysconf(_SC_NPROCESSORS_ONLN);],
3463       [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
3464       [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
3465   ])
3466   if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
3467     AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN  is available in <unistd.h>.])
3468   fi
3469   AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
3470
3471   CXXFLAGS="$ac_save_CXXFLAGS"
3472   AC_LANG_RESTORE
3473 ])
3474
3475
3476 # Macros from the top-level gcc directory.
3477 m4_include([../config/gc++filt.m4])
3478 m4_include([../config/tls.m4])