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,_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 Check whether EOF, SEEK_CUR, and SEEK_END have the most common values:
1623 dnl in that case including <cstdio> in some C++ headers can be avoided.
1624 dnl
1625 AC_DEFUN([GLIBCXX_CHECK_STDIO_MACROS], [
1626
1627   AC_MSG_CHECKING([for EOF == -1, SEEK_CUR == 1, SEEK_END == 2])
1628   AC_CACHE_VAL(glibcxx_cv_stdio_macros, [
1629   AC_TRY_COMPILE([#include <stdio.h>],
1630                  [#if ((EOF != -1) || (SEEK_CUR != 1) || (SEEK_END != 2))
1631                     unusual values...
1632                   #endif
1633                  ], [glibcxx_cv_stdio_macros=yes],
1634                     [glibcxx_cv_stdio_macros=no])
1635   ])
1636   AC_MSG_RESULT($glibcxx_cv_stdio_macros)
1637   if test x"$glibcxx_cv_stdio_macros" = x"yes"; then
1638     AC_DEFINE(_GLIBCXX_STDIO_MACROS, 1,
1639               [Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2.])
1640   fi
1641
1642 ])
1643
1644 dnl
1645 dnl Check whether macros, etc are present for <system_error>
1646 dnl
1647 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1648
1649 m4_pushdef([n_syserr], [1])dnl
1650 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1651                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1652                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY],
1653 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1654 AC_MSG_CHECKING([for syserr])
1655 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1656 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1657                                    [int i = syserr;])],
1658                   [glibcxx_cv_system_error[]n_syserr=yes],
1659                   [glibcxx_cv_system_error[]n_syserr=no])
1660 ])
1661 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1662 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1663   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1664 fi
1665 m4_define([n_syserr], m4_incr(n_syserr))dnl
1666 m4_popdef([SYSERR])dnl
1667 ])
1668 m4_popdef([n_syserr])dnl
1669 ])
1670
1671 dnl
1672 dnl Check for what type of C headers to use.
1673 dnl
1674 dnl --enable-cheaders= [does stuff].
1675 dnl --disable-cheaders [does not do anything, really].
1676 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1677 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1678 dnl
1679 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1680   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1681     [construct "C" headers for g++], [permit c|c_std|c_global])
1682   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1683
1684   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1685
1686   # Allow overrides to configure.host here.
1687   if test $enable_cheaders = c_global; then
1688      c_compatibility=yes
1689   fi
1690
1691   if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1692      c_extra=yes
1693   fi
1694
1695   AC_SUBST(C_INCLUDE_DIR)
1696   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1697   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1698   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1699   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1700   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1701 ])
1702
1703
1704 dnl
1705 dnl Check for which locale library to use.  The choice is mapped to
1706 dnl a subdirectory of config/locale.
1707 dnl
1708 dnl Default is generic.
1709 dnl
1710 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1711   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1712     [use MODEL for target locale package],
1713     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1714
1715   # Deal with gettext issues.  Default to not using it (=no) until we detect
1716   # support for it later.  Let the user turn it off via --e/d, but let that
1717   # default to on for easier handling.
1718   USE_NLS=no
1719   AC_ARG_ENABLE(nls,
1720     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1721     [],
1722     [enable_nls=yes])
1723
1724   # Either a known packaage, or "auto"
1725   if test $enable_clocale = no || test $enable_clocale = yes; then
1726      enable_clocale=auto
1727   fi
1728   enable_clocale_flag=$enable_clocale
1729
1730   # Probe for locale model to use if none specified.
1731   # Default to "generic".
1732   if test $enable_clocale_flag = auto; then
1733     case ${target_os} in
1734       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1735         enable_clocale_flag=gnu
1736         ;;
1737       darwin* | freebsd*)
1738         enable_clocale_flag=darwin
1739         ;;
1740       *)
1741         enable_clocale_flag=generic
1742         ;;
1743     esac
1744   fi
1745
1746   # Sanity check model, and test for special functionality.
1747   if test $enable_clocale_flag = gnu; then
1748     AC_EGREP_CPP([_GLIBCXX_ok], [
1749     #include <features.h>
1750     #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1751       _GLIBCXX_ok
1752     #endif
1753     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1754
1755     # Set it to scream when it hurts.
1756     ac_save_CFLAGS="$CFLAGS"
1757     CFLAGS="-Wimplicit-function-declaration -Werror"
1758
1759     # Use strxfrm_l if available.
1760     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1761                     #include <string.h>
1762                     #include <locale.h>],
1763                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1764                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1765                     [Define if strxfrm_l is available in <string.h>.]),)
1766
1767     # Use strerror_l if available.
1768     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1769                     #include <string.h>
1770                     #include <locale.h>],
1771                     [__locale_t loc; strerror_l(5, loc);],
1772                     AC_DEFINE(HAVE_STRERROR_L, 1,
1773                     [Define if strerror_l is available in <string.h>.]),)
1774
1775     CFLAGS="$ac_save_CFLAGS"
1776   fi
1777
1778   # Perhaps use strerror_r if available, and strerror_l isn't.
1779   ac_save_CFLAGS="$CFLAGS"
1780   CFLAGS="-Wimplicit-function-declaration -Werror"
1781   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1782                   #include <string.h>
1783                   #include <locale.h>],
1784                   [char s[128]; strerror_r(5, s, 128);],
1785                   AC_DEFINE(HAVE_STRERROR_R, 1,
1786                   [Define if strerror_r is available in <string.h>.]),)
1787   CFLAGS="$ac_save_CFLAGS"
1788
1789   # Set configure bits for specified locale package
1790   AC_MSG_CHECKING([for C locale to use])
1791   case ${enable_clocale_flag} in
1792     generic)
1793       AC_MSG_RESULT(generic)
1794
1795       CLOCALE_H=config/locale/generic/c_locale.h
1796       CLOCALE_CC=config/locale/generic/c_locale.cc
1797       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1798       CCOLLATE_CC=config/locale/generic/collate_members.cc
1799       CCTYPE_CC=config/locale/generic/ctype_members.cc
1800       CMESSAGES_H=config/locale/generic/messages_members.h
1801       CMESSAGES_CC=config/locale/generic/messages_members.cc
1802       CMONEY_CC=config/locale/generic/monetary_members.cc
1803       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1804       CTIME_H=config/locale/generic/time_members.h
1805       CTIME_CC=config/locale/generic/time_members.cc
1806       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1807       ;;
1808     darwin)
1809       AC_MSG_RESULT(darwin or freebsd)
1810
1811       CLOCALE_H=config/locale/generic/c_locale.h
1812       CLOCALE_CC=config/locale/generic/c_locale.cc
1813       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1814       CCOLLATE_CC=config/locale/generic/collate_members.cc
1815       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1816       CMESSAGES_H=config/locale/generic/messages_members.h
1817       CMESSAGES_CC=config/locale/generic/messages_members.cc
1818       CMONEY_CC=config/locale/generic/monetary_members.cc
1819       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1820       CTIME_H=config/locale/generic/time_members.h
1821       CTIME_CC=config/locale/generic/time_members.cc
1822       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1823       ;;
1824
1825     gnu)
1826       AC_MSG_RESULT(gnu)
1827
1828       # Declare intention to use gettext, and add support for specific
1829       # languages.
1830       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1831       ALL_LINGUAS="de fr"
1832
1833       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1834       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1835       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1836         USE_NLS=yes
1837       fi
1838       # Export the build objects.
1839       for ling in $ALL_LINGUAS; do \
1840         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1841         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1842       done
1843       AC_SUBST(glibcxx_MOFILES)
1844       AC_SUBST(glibcxx_POFILES)
1845
1846       CLOCALE_H=config/locale/gnu/c_locale.h
1847       CLOCALE_CC=config/locale/gnu/c_locale.cc
1848       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1849       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1850       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1851       CMESSAGES_H=config/locale/gnu/messages_members.h
1852       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1853       CMONEY_CC=config/locale/gnu/monetary_members.cc
1854       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1855       CTIME_H=config/locale/gnu/time_members.h
1856       CTIME_CC=config/locale/gnu/time_members.cc
1857       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1858       ;;
1859     ieee_1003.1-2001)
1860       AC_MSG_RESULT(IEEE 1003.1)
1861
1862       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1863       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1864       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1865       CCOLLATE_CC=config/locale/generic/collate_members.cc
1866       CCTYPE_CC=config/locale/generic/ctype_members.cc
1867       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1868       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1869       CMONEY_CC=config/locale/generic/monetary_members.cc
1870       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1871       CTIME_H=config/locale/generic/time_members.h
1872       CTIME_CC=config/locale/generic/time_members.cc
1873       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1874       ;;
1875   esac
1876
1877   # This is where the testsuite looks for locale catalogs, using the
1878   # -DLOCALEDIR define during testsuite compilation.
1879   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1880   AC_SUBST(glibcxx_localedir)
1881
1882   # A standalone libintl (e.g., GNU libintl) may be in use.
1883   if test $USE_NLS = yes; then
1884     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1885     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1886   fi
1887   if test $USE_NLS = yes; then
1888     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1889               [Define if NLS translations are to be used.])
1890   fi
1891
1892   AC_SUBST(USE_NLS)
1893   AC_SUBST(CLOCALE_H)
1894   AC_SUBST(CMESSAGES_H)
1895   AC_SUBST(CCODECVT_CC)
1896   AC_SUBST(CCOLLATE_CC)
1897   AC_SUBST(CCTYPE_CC)
1898   AC_SUBST(CMESSAGES_CC)
1899   AC_SUBST(CMONEY_CC)
1900   AC_SUBST(CNUMERIC_CC)
1901   AC_SUBST(CTIME_H)
1902   AC_SUBST(CTIME_CC)
1903   AC_SUBST(CLOCALE_CC)
1904   AC_SUBST(CLOCALE_INTERNAL_H)
1905 ])
1906
1907
1908 dnl
1909 dnl Check for which std::allocator base class to use.  The choice is
1910 dnl mapped from a subdirectory of include/ext.
1911 dnl
1912 dnl Default is new.
1913 dnl
1914 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1915   AC_MSG_CHECKING([for std::allocator base class])
1916   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1917     [use KIND for target std::allocator base],
1918     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1919
1920   # If they didn't use this option switch, or if they specified --enable
1921   # with no specific model, we'll have to look for one.  If they
1922   # specified --disable (???), do likewise.
1923   if test $enable_libstdcxx_allocator = no ||
1924      test $enable_libstdcxx_allocator = yes;
1925   then
1926      enable_libstdcxx_allocator=auto
1927   fi
1928
1929   # Either a known package, or "auto". Auto implies the default choice
1930   # for a particular platform.
1931   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1932
1933   # Probe for host-specific support if no specific model is specified.
1934   # Default to "new".
1935   if test $enable_libstdcxx_allocator_flag = auto; then
1936     case ${target_os} in
1937       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1938         enable_libstdcxx_allocator_flag=new
1939         ;;
1940       *)
1941         enable_libstdcxx_allocator_flag=new
1942         ;;
1943     esac
1944   fi
1945   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1946
1947
1948   # Set configure bits for specified locale package
1949   case ${enable_libstdcxx_allocator_flag} in
1950     bitmap)
1951       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1952       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1953       ;;
1954     malloc)
1955       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1956       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1957       ;;
1958     mt)
1959       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1960       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1961       ;;
1962     new)
1963       ALLOCATOR_H=config/allocator/new_allocator_base.h
1964       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1965       ;;
1966     pool)
1967       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1968       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1969       ;;
1970   esac
1971
1972   AC_SUBST(ALLOCATOR_H)
1973   AC_SUBST(ALLOCATOR_NAME)
1974 ])
1975
1976
1977 dnl
1978 dnl Check for whether the Boost-derived checks should be turned on.
1979 dnl
1980 dnl --enable-concept-checks turns them on.
1981 dnl --disable-concept-checks leaves them off.
1982 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1983 dnl       Where DEFAULT is either `yes' or `no'.
1984 dnl
1985 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1986   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1987   if test $enable_concept_checks = yes; then
1988     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1989               [Define to use concept checking code from the boost libraries.])
1990   fi
1991 ])
1992
1993 dnl
1994 dnl Check for parallel mode pre-requisites, including OpenMP support.
1995 dnl
1996 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
1997 dnl
1998 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
1999
2000   enable_parallel=no;
2001
2002   # See if configured libgomp/omp.h exists. (libgomp may be in
2003   # noconfigdirs but not explicitly disabled.)
2004   if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2005     enable_parallel=yes;
2006   else
2007     AC_MSG_NOTICE([target-libgomp not built])
2008   fi
2009
2010   AC_MSG_CHECKING([for parallel mode support])
2011   AC_MSG_RESULT([$enable_parallel])
2012   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2013 ])
2014
2015
2016 dnl
2017 dnl Check for which I/O library to use:  stdio, or something specific.
2018 dnl
2019 dnl Default is stdio.
2020 dnl
2021 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2022   AC_MSG_CHECKING([for underlying I/O to use])
2023   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
2024     [use target-specific I/O package], [permit stdio])
2025
2026   # Now that libio has been removed, you can have any color you want as long
2027   # as it's black.  This is one big no-op until other packages are added, but
2028   # showing the framework never hurts.
2029   case ${enable_cstdio} in
2030     stdio)
2031       CSTDIO_H=config/io/c_io_stdio.h
2032       BASIC_FILE_H=config/io/basic_file_stdio.h
2033       BASIC_FILE_CC=config/io/basic_file_stdio.cc
2034       AC_MSG_RESULT(stdio)
2035       ;;
2036   esac
2037
2038   AC_SUBST(CSTDIO_H)
2039   AC_SUBST(BASIC_FILE_H)
2040   AC_SUBST(BASIC_FILE_CC)
2041 ])
2042
2043
2044 dnl
2045 dnl Check for "unusual" flags to pass to the compiler while building.
2046 dnl
2047 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2048 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2049 dnl --disable-cxx-flags passes nothing.
2050 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2051 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2052 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2053 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2054 dnl       If "default flags" is an empty string, the effect is the same
2055 dnl       as --disable or --enable=no.
2056 dnl
2057 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2058   AC_MSG_CHECKING([for extra compiler flags for building])
2059   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2060     [pass compiler FLAGS when building library],
2061     [case "x$enable_cxx_flags" in
2062       xno | x)   enable_cxx_flags= ;;
2063       x-*)       ;;
2064       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2065      esac])
2066
2067   # Run through flags (either default or command-line) and set anything
2068   # extra (e.g., #defines) that must accompany particular g++ options.
2069   if test -n "$enable_cxx_flags"; then
2070     for f in $enable_cxx_flags; do
2071       case "$f" in
2072         -fhonor-std)  ;;
2073         -*)  ;;
2074         *)   # and we're trying to pass /what/ exactly?
2075              AC_MSG_ERROR([compiler flags start with a -]) ;;
2076       esac
2077     done
2078   fi
2079
2080   EXTRA_CXX_FLAGS="$enable_cxx_flags"
2081   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2082   AC_SUBST(EXTRA_CXX_FLAGS)
2083 ])
2084
2085
2086 dnl
2087 dnl Check to see if debugging libraries are to be built.
2088 dnl
2089 dnl --enable-libstdcxx-debug
2090 dnl builds a separate set of debugging libraries in addition to the
2091 dnl normal (shared, static) libstdc++ binaries.
2092 dnl
2093 dnl --disable-libstdcxx-debug
2094 dnl builds only one (non-debug) version of libstdc++.
2095 dnl
2096 dnl --enable-libstdcxx-debug-flags=FLAGS
2097 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2098 dnl
2099 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2100 dnl       Where DEFAULT is either `yes' or `no'.
2101 dnl
2102 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2103   AC_MSG_CHECKING([for additional debug build])
2104   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2105   AC_MSG_RESULT($enable_libstdcxx_debug)
2106   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2107 ])
2108
2109
2110 dnl
2111 dnl Check for explicit debug flags.
2112 dnl
2113 dnl --enable-libstdcxx-debug-flags='-O1'
2114 dnl is a general method for passing flags to be used when
2115 dnl building debug libraries with --enable-debug.
2116 dnl
2117 dnl --disable-libstdcxx-debug-flags does nothing.
2118 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2119 dnl       If "default flags" is an empty string, the effect is the same
2120 dnl       as --disable or --enable=no.
2121 dnl
2122 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2123   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2124     [pass compiler FLAGS when building debug library],
2125     [case "x$enable_libstdcxx_debug_flags" in
2126       xno | x)    enable_libstdcxx_debug_flags= ;;
2127       x-*)        ;;
2128       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2129      esac])
2130
2131   # Option parsed, now set things appropriately
2132   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2133   AC_SUBST(DEBUG_FLAGS)
2134
2135   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2136 ])
2137
2138
2139 dnl
2140 dnl Check if the user only wants a freestanding library implementation.
2141 dnl
2142 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2143 dnl installing only the headers required by [17.4.1.3] and the language
2144 dnl support library.  More than that will be built (to keep the Makefiles
2145 dnl conveniently clean), but not installed.
2146 dnl
2147 dnl Sets:
2148 dnl  is_hosted  (yes/no)
2149 dnl
2150 dnl Defines:
2151 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2152 dnl
2153 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2154   AC_ARG_ENABLE([hosted-libstdcxx],
2155     AC_HELP_STRING([--disable-hosted-libstdcxx],
2156                    [only build freestanding C++ runtime support]),,
2157     [case "$host" in
2158         arm*-*-symbianelf*)
2159             enable_hosted_libstdcxx=no
2160             ;;
2161         *)
2162             enable_hosted_libstdcxx=yes
2163             ;;
2164      esac])
2165   if test "$enable_hosted_libstdcxx" = no; then
2166     AC_MSG_NOTICE([Only freestanding libraries will be built])
2167     is_hosted=no
2168     hosted_define=0
2169     enable_abi_check=no
2170     enable_libstdcxx_pch=no
2171   else
2172     is_hosted=yes
2173     hosted_define=1
2174   fi
2175   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2176   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2177     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2178 ])
2179
2180
2181 dnl
2182 dnl Check for template specializations for the 'long long' type.
2183 dnl The result determines only whether 'long long' I/O is enabled; things
2184 dnl like numeric_limits<> specializations are always available.
2185 dnl
2186 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2187 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2188 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2189 dnl       Where DEFAULT is either `yes' or `no'.
2190 dnl
2191 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2192   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2193   if test $enable_long_long = yes; then
2194     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2195               [Define if code specialized for long long should be used.])
2196   fi
2197   AC_MSG_CHECKING([for enabled long long specializations])
2198   AC_MSG_RESULT([$enable_long_long])
2199 ])
2200
2201
2202 dnl
2203 dnl Check for decimal floating point.
2204 dnl See:
2205 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2206 dnl
2207 dnl This checks to see if the host supports decimal floating point types.
2208 dnl
2209 dnl Defines:
2210 dnl  _GLIBCXX_USE_DECIMAL_FLOAT
2211 dnl
2212 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2213
2214   # Fake what AC_TRY_COMPILE does, without linking as this is
2215   # unnecessary for this test.
2216
2217     cat > conftest.$ac_ext << EOF
2218 [#]line __oline__ "configure"
2219 int main()
2220 {
2221   _Decimal32 d1;
2222   _Decimal64 d2;
2223   _Decimal128 d3;
2224   return 0;
2225 }
2226 EOF
2227
2228     AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2229     if AC_TRY_EVAL(ac_compile); then
2230       AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2231       [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2232       enable_dfp=yes
2233     else
2234       enable_dfp=no
2235     fi
2236     AC_MSG_RESULT($enable_dfp)
2237     rm -f conftest*
2238 ])
2239
2240 dnl
2241 dnl Check for template specializations for the 'wchar_t' type.
2242 dnl
2243 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2244 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2245 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2246 dnl       Where DEFAULT is either `yes' or `no'.
2247 dnl
2248 dnl Necessary support must also be present.
2249 dnl
2250 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2251   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2252
2253   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2254   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2255   AC_MSG_CHECKING([for mbstate_t])
2256   AC_TRY_COMPILE([#include <wchar.h>],
2257   [mbstate_t teststate;],
2258   have_mbstate_t=yes, have_mbstate_t=no)
2259   AC_MSG_RESULT($have_mbstate_t)
2260   if test x"$have_mbstate_t" = xyes; then
2261     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2262   fi
2263
2264   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2265   # ac_has_wchar_h.
2266   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2267
2268   if test x"$enable_wchar_t" = x"yes"; then
2269
2270     AC_LANG_SAVE
2271     AC_LANG_CPLUSPLUS
2272
2273     if test x"$ac_has_wchar_h" = xyes &&
2274        test x"$ac_has_wctype_h" = xyes; then
2275       AC_TRY_COMPILE([#include <wchar.h>
2276                       #include <stddef.h>
2277                       wint_t i;
2278                       long l = WEOF;
2279                       long j = WCHAR_MIN;
2280                       long k = WCHAR_MAX;
2281                       namespace test
2282                       {
2283                         using ::btowc;
2284                         using ::fgetwc;
2285                         using ::fgetws;
2286                         using ::fputwc;
2287                         using ::fputws;
2288                         using ::fwide;
2289                         using ::fwprintf;
2290                         using ::fwscanf;
2291                         using ::getwc;
2292                         using ::getwchar;
2293                         using ::mbrlen;
2294                         using ::mbrtowc;
2295                         using ::mbsinit;
2296                         using ::mbsrtowcs;
2297                         using ::putwc;
2298                         using ::putwchar;
2299                         using ::swprintf;
2300                         using ::swscanf;
2301                         using ::ungetwc;
2302                         using ::vfwprintf;
2303                         using ::vswprintf;
2304                         using ::vwprintf;
2305                         using ::wcrtomb;
2306                         using ::wcscat;
2307                         using ::wcschr;
2308                         using ::wcscmp;
2309                         using ::wcscoll;
2310                         using ::wcscpy;
2311                         using ::wcscspn;
2312                         using ::wcsftime;
2313                         using ::wcslen;
2314                         using ::wcsncat;
2315                         using ::wcsncmp;
2316                         using ::wcsncpy;
2317                         using ::wcspbrk;
2318                         using ::wcsrchr;
2319                         using ::wcsrtombs;
2320                         using ::wcsspn;
2321                         using ::wcsstr;
2322                         using ::wcstod;
2323                         using ::wcstok;
2324                         using ::wcstol;
2325                         using ::wcstoul;
2326                         using ::wcsxfrm;
2327                         using ::wctob;
2328                         using ::wmemchr;
2329                         using ::wmemcmp;
2330                         using ::wmemcpy;
2331                         using ::wmemmove;
2332                         using ::wmemset;
2333                         using ::wprintf;
2334                         using ::wscanf;
2335                       }
2336                      ],[],[], [enable_wchar_t=no])
2337     else
2338       enable_wchar_t=no
2339     fi
2340
2341     AC_LANG_RESTORE
2342   fi
2343
2344   if test x"$enable_wchar_t" = x"yes"; then
2345     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2346               [Define if code specialized for wchar_t should be used.])
2347   fi
2348
2349   AC_MSG_CHECKING([for enabled wchar_t specializations])
2350   AC_MSG_RESULT([$enable_wchar_t])
2351 ])
2352
2353
2354 dnl
2355 dnl Check to see if building and using a C++ precompiled header can be done.
2356 dnl
2357 dnl --enable-libstdcxx-pch=yes
2358 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2359 dnl may work, after some light-hearted attempts to puzzle out compiler
2360 dnl support, flip bits on in include/Makefile.am
2361 dnl
2362 dnl --disable-libstdcxx-pch
2363 dnl turns off attempts to use or build stdc++.h.gch.
2364 dnl
2365 dnl Substs:
2366 dnl  glibcxx_PCHFLAGS
2367 dnl
2368 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2369   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2370   if test $enable_libstdcxx_pch = yes; then
2371     AC_CACHE_CHECK([for compiler with PCH support],
2372       [glibcxx_cv_prog_CXX_pch],
2373       [ac_save_CXXFLAGS="$CXXFLAGS"
2374        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2375        AC_LANG_SAVE
2376        AC_LANG_CPLUSPLUS
2377        echo '#include <math.h>' > conftest.h
2378        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2379                           -o conftest.h.gch 1>&5 2>&1 &&
2380                 echo '#error "pch failed"' > conftest.h &&
2381           echo '#include "conftest.h"' > conftest.cc &&
2382                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2383        then
2384          glibcxx_cv_prog_CXX_pch=yes
2385        else
2386          glibcxx_cv_prog_CXX_pch=no
2387        fi
2388        rm -f conftest*
2389        CXXFLAGS=$ac_save_CXXFLAGS
2390        AC_LANG_RESTORE
2391       ])
2392     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2393   fi
2394
2395   AC_MSG_CHECKING([for enabled PCH])
2396   AC_MSG_RESULT([$enable_libstdcxx_pch])
2397
2398   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2399   if test $enable_libstdcxx_pch = yes; then
2400     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2401   else
2402     glibcxx_PCHFLAGS=""
2403   fi
2404   AC_SUBST(glibcxx_PCHFLAGS)
2405 ])
2406
2407
2408 dnl
2409 dnl Check for atomic builtins.
2410 dnl See:
2411 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2412 dnl
2413 dnl This checks to see if the host supports the compiler-generated
2414 dnl builtins for atomic operations for various integral sizes. Note, this
2415 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2416 dnl that are used should be checked.
2417 dnl
2418 dnl Note:
2419 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2420 dnl
2421 dnl Defines:
2422 dnl  _GLIBCXX_ATOMIC_BUILTINS_1
2423 dnl  _GLIBCXX_ATOMIC_BUILTINS_2
2424 dnl  _GLIBCXX_ATOMIC_BUILTINS_4
2425 dnl  _GLIBCXX_ATOMIC_BUILTINS_8
2426 dnl
2427 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2428   AC_LANG_SAVE
2429   AC_LANG_CPLUSPLUS
2430   old_CXXFLAGS="$CXXFLAGS"
2431
2432   # Do link tests if possible, instead asm tests, limited to some platforms
2433   # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2434   # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2435   atomic_builtins_link_tests=no
2436   if test x$gcc_no_link != xyes; then
2437     # Can do link tests. Limit to some tested platforms
2438     case "$host" in
2439       *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2440         atomic_builtins_link_tests=yes
2441         ;;
2442     esac
2443   fi
2444
2445   if test x$atomic_builtins_link_tests = xyes; then
2446
2447   # Do link tests.
2448
2449   CXXFLAGS="$CXXFLAGS -fno-exceptions"
2450
2451   AC_MSG_CHECKING([for atomic builtins for bool])
2452   AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2453     AC_TRY_LINK(
2454       [ ],
2455       [typedef bool atomic_type;
2456        atomic_type c1;
2457        atomic_type c2;
2458        const atomic_type c3(0);
2459        __sync_fetch_and_add(&c1, c2);
2460        __sync_val_compare_and_swap(&c1, c3, c2);
2461        __sync_lock_test_and_set(&c1, c3);
2462        __sync_lock_release(&c1);
2463        __sync_synchronize();],
2464       [glibcxx_cv_atomic_bool=yes],
2465       [glibcxx_cv_atomic_bool=no])
2466   ])
2467   if test $glibcxx_cv_atomic_bool = yes; then
2468     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2469       [Define if builtin atomic operations for bool are supported on this host.])
2470   fi
2471   AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2472
2473   AC_MSG_CHECKING([for atomic builtins for short])
2474   AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2475     AC_TRY_LINK(
2476       [ ],
2477       [typedef short atomic_type;
2478        atomic_type c1;
2479        atomic_type c2;
2480        const atomic_type c3(0);
2481        __sync_fetch_and_add(&c1, c2);
2482        __sync_val_compare_and_swap(&c1, c3, c2);
2483        __sync_lock_test_and_set(&c1, c3);
2484        __sync_lock_release(&c1);
2485        __sync_synchronize();],
2486       [glibcxx_cv_atomic_short=yes],
2487       [glibcxx_cv_atomic_short=no])
2488   ])
2489   if test $glibcxx_cv_atomic_short = yes; then
2490     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2491       [Define if builtin atomic operations for short are supported on this host.])
2492   fi
2493   AC_MSG_RESULT($glibcxx_cv_atomic_short)
2494
2495   AC_MSG_CHECKING([for atomic builtins for int])
2496   AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2497     AC_TRY_LINK(
2498       [ ],
2499       [typedef int atomic_type;
2500        atomic_type c1;
2501        atomic_type c2;
2502        const atomic_type c3(0);
2503        __sync_fetch_and_add(&c1, c2);
2504        __sync_val_compare_and_swap(&c1, c3, c2);
2505        __sync_lock_test_and_set(&c1, c3);
2506        __sync_lock_release(&c1);
2507        __sync_synchronize();],
2508       [glibcxx_cv_atomic_int=yes],
2509       [glibcxx_cv_atomic_int=no])
2510   ])
2511   if test $glibcxx_cv_atomic_int = yes; then
2512     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2513       [Define if builtin atomic operations for int are supported on this host.])
2514   fi
2515   AC_MSG_RESULT($glibcxx_cv_atomic_int)
2516
2517   AC_MSG_CHECKING([for atomic builtins for long long])
2518   AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2519     AC_TRY_LINK(
2520       [ ],
2521       [typedef long long atomic_type;
2522        atomic_type c1;
2523        atomic_type c2;
2524        const atomic_type c3(0);
2525        __sync_fetch_and_add(&c1, c2);
2526        __sync_val_compare_and_swap(&c1, c3, c2);
2527        __sync_lock_test_and_set(&c1, c3);
2528        __sync_lock_release(&c1);
2529        __sync_synchronize();],
2530       [glibcxx_cv_atomic_long_long=yes],
2531       [glibcxx_cv_atomic_long_long=no])
2532   ])
2533   if test $glibcxx_cv_atomic_long_long = yes; then
2534     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2535       [Define if builtin atomic operations for long long are supported on this host.])
2536   fi
2537   AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2538
2539   else
2540
2541   # Do asm tests.
2542
2543   # Compile unoptimized.
2544   CXXFLAGS='-O0 -S'
2545
2546   # Fake what AC_TRY_COMPILE does.
2547
2548     cat > conftest.$ac_ext << EOF
2549 [#]line __oline__ "configure"
2550 int main()
2551 {
2552   typedef bool atomic_type;
2553   atomic_type c1;
2554   atomic_type c2;
2555   const atomic_type c3(0);
2556   __sync_fetch_and_add(&c1, c2);
2557   __sync_val_compare_and_swap(&c1, c3, c2);
2558   __sync_lock_test_and_set(&c1, c3);
2559   __sync_lock_release(&c1);
2560   __sync_synchronize();
2561   return 0;
2562 }
2563 EOF
2564
2565     AC_MSG_CHECKING([for atomic builtins for bool])
2566     if AC_TRY_EVAL(ac_compile); then
2567       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2568         glibcxx_cv_atomic_bool=no
2569       else
2570       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2571       [Define if builtin atomic operations for bool are supported on this host.])
2572         glibcxx_cv_atomic_bool=yes
2573       fi
2574     fi
2575     AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2576     rm -f conftest*
2577
2578     cat > conftest.$ac_ext << EOF
2579 [#]line __oline__ "configure"
2580 int main()
2581 {
2582   typedef short atomic_type;
2583   atomic_type c1;
2584   atomic_type c2;
2585   const atomic_type c3(0);
2586   __sync_fetch_and_add(&c1, c2);
2587   __sync_val_compare_and_swap(&c1, c3, c2);
2588   __sync_lock_test_and_set(&c1, c3);
2589   __sync_lock_release(&c1);
2590   __sync_synchronize();
2591   return 0;
2592 }
2593 EOF
2594
2595     AC_MSG_CHECKING([for atomic builtins for short])
2596     if AC_TRY_EVAL(ac_compile); then
2597       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2598         glibcxx_cv_atomic_short=no
2599       else
2600       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2601       [Define if builtin atomic operations for short are supported on this host.])
2602         glibcxx_cv_atomic_short=yes
2603       fi
2604     fi
2605     AC_MSG_RESULT($glibcxx_cv_atomic_short)
2606     rm -f conftest*
2607
2608     cat > conftest.$ac_ext << EOF
2609 [#]line __oline__ "configure"
2610 int main()
2611 {
2612   // NB: _Atomic_word not necessarily int.
2613   typedef int atomic_type;
2614   atomic_type c1;
2615   atomic_type c2;
2616   const atomic_type c3(0);
2617   __sync_fetch_and_add(&c1, c2);
2618   __sync_val_compare_and_swap(&c1, c3, c2);
2619   __sync_lock_test_and_set(&c1, c3);
2620   __sync_lock_release(&c1);
2621   __sync_synchronize();
2622   return 0;
2623 }
2624 EOF
2625
2626     AC_MSG_CHECKING([for atomic builtins for int])
2627     if AC_TRY_EVAL(ac_compile); then
2628       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2629         glibcxx_cv_atomic_int=no
2630       else
2631       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2632         [Define if builtin atomic operations for int are supported on this host.])
2633         glibcxx_cv_atomic_int=yes
2634       fi
2635     fi
2636     AC_MSG_RESULT($glibcxx_cv_atomic_int)
2637     rm -f conftest*
2638
2639     cat > conftest.$ac_ext << EOF
2640 [#]line __oline__ "configure"
2641 int main()
2642 {
2643   typedef long long atomic_type;
2644   atomic_type c1;
2645   atomic_type c2;
2646   const atomic_type c3(0);
2647   __sync_fetch_and_add(&c1, c2);
2648   __sync_val_compare_and_swap(&c1, c3, c2);
2649   __sync_lock_test_and_set(&c1, c3);
2650   __sync_lock_release(&c1);
2651   __sync_synchronize();
2652   return 0;
2653 }
2654 EOF
2655
2656     AC_MSG_CHECKING([for atomic builtins for long long])
2657     if AC_TRY_EVAL(ac_compile); then
2658       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2659         glibcxx_cv_atomic_long_long=no
2660       else
2661       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2662       [Define if builtin atomic operations for long long are supported on this host.])
2663         glibcxx_cv_atomic_long_long=yes
2664       fi
2665     fi
2666     AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2667     rm -f conftest*
2668
2669   fi
2670
2671   CXXFLAGS="$old_CXXFLAGS"
2672   AC_LANG_RESTORE
2673
2674   # Set atomicity_dir to builtins if either of above tests pass.
2675   if test $glibcxx_cv_atomic_int = yes || test $glibcxx_cv_atomic_bool = yes ; then
2676     atomicity_dir=cpu/generic/atomicity_builtins
2677   fi
2678
2679   # If still generic, set to mutex.
2680   if test $atomicity_dir = "cpu/generic" ; then
2681     atomicity_dir=cpu/generic/atomicity_mutex
2682     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2683       if test "x$target_thread_file" = xsingle; then
2684         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2685         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2686       else
2687         AC_MSG_WARN([They will be faked using a mutex.])
2688         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2689       fi
2690   fi
2691
2692 ])
2693
2694
2695 dnl
2696 dnl Check for exception handling support.  If an explicit enable/disable
2697 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2698 dnl target may or may not support call frame exceptions.
2699 dnl
2700 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2701 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2702 dnl Neither one forces an attempt at detection.
2703 dnl
2704 dnl Defines:
2705 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2706 dnl
2707 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2708   AC_MSG_CHECKING([for exception model to use])
2709   AC_LANG_SAVE
2710   AC_LANG_CPLUSPLUS
2711   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2712     [force use of builtin_setjmp for exceptions],
2713     [permit yes|no|auto])
2714
2715   if test $enable_sjlj_exceptions = auto; then
2716     # Botheration.  Now we've got to detect the exception model.  Link tests
2717     # against libgcc.a are problematic since we've not been given proper -L
2718     # bits for single-tree newlib and libgloss.
2719     #
2720     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2721     cat > conftest.$ac_ext << EOF
2722 [#]line __oline__ "configure"
2723 struct S { ~S(); };
2724 void bar();
2725 void foo()
2726 {
2727   S s;
2728   bar();
2729 }
2730 EOF
2731     old_CXXFLAGS="$CXXFLAGS"
2732     CXXFLAGS=-S
2733     if AC_TRY_EVAL(ac_compile); then
2734       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2735         enable_sjlj_exceptions=yes
2736       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2737         enable_sjlj_exceptions=no
2738       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2739         enable_sjlj_exceptions=no
2740       fi
2741     fi
2742     CXXFLAGS="$old_CXXFLAGS"
2743     rm -f conftest*
2744   fi
2745
2746   # This is a tad weird, for hysterical raisins.  We have to map
2747   # enable/disable to two different models.
2748   case $enable_sjlj_exceptions in
2749     yes)
2750       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2751         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2752       ac_exception_model_name=sjlj
2753       ;;
2754     no)
2755       ac_exception_model_name="call frame"
2756       ;;
2757     *)
2758       AC_MSG_ERROR([unable to detect exception model])
2759       ;;
2760   esac
2761  AC_LANG_RESTORE
2762  AC_MSG_RESULT($ac_exception_model_name)
2763 ])
2764
2765
2766 dnl
2767 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2768 dnl
2769 dnl --enable-visibility enables attempt to use visibility attributes.
2770 dnl --disable-visibility turns off all use of visibility attributes.
2771 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2772 dnl       Where DEFAULT is 'yes'.
2773 dnl
2774 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2775 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2776
2777 if test x$enable_visibility = xyes ; then
2778   dnl all hail libgfortran
2779   dnl Check whether the target supports hidden visibility.
2780   AC_CACHE_CHECK([whether the target supports hidden visibility],
2781                  glibcxx_cv_have_attribute_visibility, [
2782   save_CFLAGS="$CFLAGS"
2783   CFLAGS="$CFLAGS -Werror"
2784   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2785                  [], glibcxx_cv_have_attribute_visibility=yes,
2786                  glibcxx_cv_have_attribute_visibility=no)
2787   CFLAGS="$save_CFLAGS"])
2788   if test $glibcxx_cv_have_attribute_visibility = no; then
2789     enable_visibility=no
2790   fi
2791 fi
2792
2793 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2794 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2795 ])
2796
2797
2798 dnl
2799 dnl Add version tags to symbols in shared library (or not), additionally
2800 dnl marking other symbols as private/local (or not).
2801 dnl
2802 dnl --enable-symvers=style adds a version script to the linker call when
2803 dnl       creating the shared library.  The choice of version script is
2804 dnl       controlled by 'style'.
2805 dnl --disable-symvers does not.
2806 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2807 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2808 dnl       choose a default style based on linker characteristics.  Passing
2809 dnl       'no' disables versioning.
2810 dnl
2811 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2812
2813 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2814   [enables symbol versioning of the shared library],
2815   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2816
2817 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2818 # don't know enough about $LD to do tricks...
2819 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2820
2821 # Turn a 'yes' into a suitable default.
2822 if test x$enable_symvers = xyes ; then
2823   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2824     enable_symvers=no
2825   else
2826     if test $with_gnu_ld = yes ; then
2827       case ${target_os} in
2828         hpux*)
2829           enable_symvers=no ;;
2830         *)
2831           enable_symvers=gnu ;;
2832       esac
2833     else
2834       case ${target_os} in
2835         darwin*)
2836           enable_symvers=darwin ;;
2837         *)
2838           enable_symvers=no ;;
2839       esac
2840     fi
2841   fi
2842 fi
2843
2844 # Check to see if 'darwin' or 'darwin-export' can win.
2845 if test x$enable_symvers = xdarwin-export ; then
2846     enable_symvers=darwin
2847 fi
2848
2849 # Check to see if 'gnu' can win.
2850 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2851   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2852   AC_MSG_CHECKING([for shared libgcc])
2853   ac_save_CFLAGS="$CFLAGS"
2854   CFLAGS=' -lgcc_s'
2855   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2856   CFLAGS="$ac_save_CFLAGS"
2857   if test $glibcxx_shared_libgcc = no; then
2858     cat > conftest.c <<EOF
2859 int main (void) { return 0; }
2860 EOF
2861 changequote(,)dnl
2862     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2863                              -shared -shared-libgcc -o conftest.so \
2864                              conftest.c -v 2>&1 >/dev/null \
2865                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2866 changequote([,])dnl
2867     rm -f conftest.c conftest.so
2868     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2869       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2870       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2871       CFLAGS="$ac_save_CFLAGS"
2872     fi
2873   fi
2874   AC_MSG_RESULT($glibcxx_shared_libgcc)
2875
2876   # For GNU ld, we need at least this version.  The format is described in
2877   # GLIBCXX_CHECK_LINKER_FEATURES above.
2878   glibcxx_min_gnu_ld_version=21400
2879
2880   # If no shared libgcc, can't win.
2881   if test $glibcxx_shared_libgcc != yes; then
2882       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2883       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2884       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2885       enable_symvers=no
2886   elif test $with_gnu_ld != yes ; then
2887     # just fail for now
2888     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2889     AC_MSG_WARN([=== you are not using the GNU linker.])
2890     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2891     enable_symvers=no
2892   elif test $glibcxx_ld_is_gold = yes ; then
2893     : All versions of gold support symbol versioning.
2894   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2895     # The right tools, the right setup, but too old.  Fallbacks?
2896     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2897     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2898     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2899     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2900     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2901     enable_symvers=no
2902   fi
2903 fi
2904
2905 # Everything parsed; figure out what file to use.
2906 case $enable_symvers in
2907   no)
2908     SYMVER_FILE=config/abi/pre/none.ver
2909     ;;
2910   gnu)
2911     SYMVER_FILE=config/abi/pre/gnu.ver
2912     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2913               [Define to use GNU versioning in the shared library.])
2914     ;;
2915   gnu-versioned-namespace)
2916     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2917     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2918               [Define to use GNU namespace versioning in the shared library.])
2919     ;;
2920   darwin)
2921     SYMVER_FILE=config/abi/pre/gnu.ver
2922     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2923               [Define to use darwin versioning in the shared library.])
2924     ;;
2925 esac
2926
2927 if test x$enable_symvers != xno ; then
2928   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2929          [Define to use symbol versioning in the shared library.])
2930 fi
2931
2932 AC_CACHE_CHECK([whether the target supports .symver directive],
2933                glibcxx_cv_have_as_symver_directive, [
2934   AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
2935                  [], glibcxx_cv_have_as_symver_directive=yes,
2936                  glibcxx_cv_have_as_symver_directive=no)])
2937 if test $glibcxx_cv_have_as_symver_directive = yes; then
2938   AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
2939     [Define to 1 if the target assembler supports .symver directive.])
2940 fi
2941
2942 AC_SUBST(SYMVER_FILE)
2943 AC_SUBST(port_specific_symbol_files)
2944 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2945 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2946 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2947 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2948 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2949
2950 # Now, set up compatibility support, if any.
2951 # In addition, need this to deal with std::size_t mangling in
2952 # src/compatibility.cc.  In a perfect world, could use
2953 # typeid(std::size_t).name()[0] to do direct substitution.
2954 AC_MSG_CHECKING([for size_t as unsigned int])
2955 ac_save_CFLAGS="$CFLAGS"
2956 CFLAGS="-Werror"
2957 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2958                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2959 CFLAGS=$ac_save_CFLAGS
2960 if test "$glibcxx_size_t_is_i" = yes; then
2961   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2962 fi
2963 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2964
2965 AC_MSG_CHECKING([for ptrdiff_t as int])
2966 ac_save_CFLAGS="$CFLAGS"
2967 CFLAGS="-Werror"
2968 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2969                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2970 CFLAGS=$ac_save_CFLAGS
2971 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2972   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2973 fi
2974 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2975 ])
2976
2977
2978 dnl
2979 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2980 dnl We must stage the required headers so that they will be installed
2981 dnl with the library (unlike libgcc, the STL implementation is provided
2982 dnl solely within headers).  Since we must not inject random user-space
2983 dnl macro names into user-provided C++ code, we first stage into <file>-in
2984 dnl and process to <file> with an output command.  The reason for a two-
2985 dnl stage process here is to correctly handle $srcdir!=$objdir without
2986 dnl having to write complex code (the sed commands to clean the macro
2987 dnl namespace are complex and fragile enough as it is).  We must also
2988 dnl add a relative path so that -I- is supported properly.
2989 dnl
2990 dnl Substs:
2991 dnl  glibcxx_thread_h
2992 dnl
2993 dnl Defines:
2994 dnl  HAVE_GTHR_DEFAULT
2995 dnl
2996 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2997   AC_MSG_CHECKING([for thread model used by GCC])
2998   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2999   AC_MSG_RESULT([$target_thread_file])
3000
3001   if test $target_thread_file != single; then
3002     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
3003               [Define if gthr-default.h exists
3004               (meaning that threading support is enabled).])
3005   fi
3006
3007   glibcxx_thread_h=gthr-$target_thread_file.h
3008
3009   dnl Check for __GTHREADS define.
3010   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
3011   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
3012     enable_thread=yes
3013   else
3014    enable_thread=no
3015   fi
3016
3017   AC_SUBST(glibcxx_thread_h)
3018 ])
3019
3020
3021 dnl
3022 dnl Check if gthread implementation defines the types and functions
3023 dnl required by the c++0x thread library.  Conforming gthread
3024 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3025 dnl
3026 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3027   AC_LANG_SAVE
3028   AC_LANG_CPLUSPLUS
3029
3030   ac_save_CXXFLAGS="$CXXFLAGS"
3031   CXXFLAGS="$CXXFLAGS -fno-exceptions -I${toplevel_srcdir}/gcc"
3032
3033   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3034   case $target_thread_file in
3035     posix)
3036       CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3037   esac
3038
3039   AC_MSG_CHECKING([for gthreads library])
3040
3041   AC_TRY_COMPILE([#include "gthr.h"],
3042     [
3043       #ifndef __GTHREADS_CXX0X
3044       #error
3045       #endif
3046
3047       // In case of POSIX threads check _POSIX_TIMEOUTS too.
3048       #if (defined(_PTHREADS) \
3049            && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3050       #error
3051       #endif
3052     ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
3053
3054   AC_MSG_RESULT([$ac_has_gthreads])
3055
3056   if test x"$ac_has_gthreads" = x"yes"; then
3057     AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3058               [Define if gthreads library is available.])
3059   fi
3060
3061   CXXFLAGS="$ac_save_CXXFLAGS"
3062   AC_LANG_RESTORE
3063 ])
3064
3065
3066 # Check whether LC_MESSAGES is available in <locale.h>.
3067 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3068 #
3069 # This file file be copied and used freely without restrictions.  It can
3070 # be used in projects which are not available under the GNU Public License
3071 # but which still want to provide support for the GNU gettext functionality.
3072 # Please note that the actual code is *not* freely available.
3073 AC_DEFUN([AC_LC_MESSAGES], [
3074   AC_CHECK_HEADER(locale.h, [
3075     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3076       [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3077        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3078     if test $ac_cv_val_LC_MESSAGES = yes; then
3079       AC_DEFINE(HAVE_LC_MESSAGES, 1,
3080                 [Define if LC_MESSAGES is available in <locale.h>.])
3081     fi
3082   ])
3083 ])
3084
3085 # Macros from the top-level gcc directory.
3086 m4_include([../config/tls.m4])
3087