libstdc++-v3/acinclude.m4

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