libstdc++-v3/acinclude.m4

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