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         tmpf = cprojf(tmpf);
 864         d = cabs(tmpd);
 865         d = carg(tmpd);
 866         tmpd = ccos(tmpd);
 867         tmpd = ccosh(tmpd);
 868         tmpd = cexp(tmpd);
 869         tmpd = clog(tmpd);
 870         tmpd = csin(tmpd);
 871         tmpd = csinh(tmpd);
 872         tmpd = csqrt(tmpd);
 873         tmpd = ctan(tmpd);
 874         tmpd = ctanh(tmpd);
 875         tmpd = cpow(tmpd, tmpd);
 876         tmpd = cproj(tmpd);
 877         ld = cabsl(tmpld);
 878         ld = cargl(tmpld);
 879         tmpld = ccosl(tmpld);
 880         tmpld = ccoshl(tmpld);
 881         tmpld = cexpl(tmpld);
 882         tmpld = clogl(tmpld);
 883         tmpld = csinl(tmpld);
 884         tmpld = csinhl(tmpld);
 885         tmpld = csqrtl(tmpld);
 886         tmpld = ctanl(tmpld);
 887         tmpld = ctanhl(tmpld);
 888         tmpld = cpowl(tmpld, tmpld);
 889         tmpld = cprojl(tmpld);
 890        ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
 891   fi
 892   AC_MSG_RESULT($glibcxx_cv_c99_complex)
 893   if test x"$glibcxx_cv_c99_complex" = x"yes"; then
 894     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 895               [Define if C99 functions in <complex.h> should be used in
 896               <complex>. Using compiler builtins for these functions requires
 897               corresponding C99 library functions to be present.])
 898   fi
 899
 900   # Check for the existence in <stdio.h> of vscanf, et. al.
 901   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 902   AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
 903   GCC_TRY_COMPILE_OR_LINK(
 904      [#include <stdio.h>
 905       #include <stdarg.h>
 906       void foo(char* fmt, ...)
 907       {
 908         va_list args; va_start(args, fmt);
 909         vfscanf(stderr, "%i", args);
 910         vscanf("%i", args);
 911         vsnprintf(fmt, 0, "%i", args);
 912         vsscanf(fmt, "%i", args);
 913       }],
 914      [snprintf("12", 0, "%i");],
 915      [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
 916   ])
 917   AC_MSG_RESULT($glibcxx_cv_c99_stdio)
 918
 919   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
 920   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
 921   AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
 922   GCC_TRY_COMPILE_OR_LINK(
 923      [#include <stdlib.h>
 924       volatile float f;
 925       volatile long double ld;
 926       volatile unsigned long long ll;
 927       lldiv_t mydivt;],
 928      [char* tmp;
 929       f = strtof("gnu", &tmp);
 930       ld = strtold("gnu", &tmp);
 931       ll = strtoll("gnu", &tmp, 10);
 932       ll = strtoull("gnu", &tmp, 10);
 933       ll = llabs(10);
 934       mydivt = lldiv(10,1);
 935       ll = mydivt.quot;
 936       ll = mydivt.rem;
 937       ll = atoll("10");
 938       _Exit(0);
 939       ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
 940   ])
 941   AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
 942
 943   # Check for the existence in <wchar.h> of wcstold, etc.
 944   glibcxx_cv_c99_wchar=no;
 945   if test x"$ac_has_wchar_h" = xyes &&
 946      test x"$ac_has_wctype_h" = xyes; then
 947     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
 948     AC_TRY_COMPILE([#include <wchar.h>
 949                     namespace test
 950                     {
 951                       using ::wcstold;
 952                       using ::wcstoll;
 953                       using ::wcstoull;
 954                     }
 955                    ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
 956
 957     # Checks for wide character functions that may not be present.
 958     # Injection of these is wrapped with guard macros.
 959     # NB: only put functions here, instead of immediately above, if
 960     # absolutely necessary.
 961     AC_TRY_COMPILE([#include <wchar.h>
 962                     namespace test { using ::vfwscanf; } ], [],
 963                    [AC_DEFINE(HAVE_VFWSCANF,1,
 964                         [Defined if vfwscanf exists.])],[])
 965
 966     AC_TRY_COMPILE([#include <wchar.h>
 967                     namespace test { using ::vswscanf; } ], [],
 968                    [AC_DEFINE(HAVE_VSWSCANF,1,
 969                         [Defined if vswscanf exists.])],[])
 970
 971     AC_TRY_COMPILE([#include <wchar.h>
 972                     namespace test { using ::vwscanf; } ], [],
 973                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
 974
 975     AC_TRY_COMPILE([#include <wchar.h>
 976                     namespace test { using ::wcstof; } ], [],
 977                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
 978
 979     AC_TRY_COMPILE([#include <wctype.h>],
 980                    [ wint_t t; int i = iswblank(t);],
 981                    [AC_DEFINE(HAVE_ISWBLANK,1,
 982                         [Defined if iswblank exists.])],[])
 983
 984     AC_MSG_RESULT($glibcxx_cv_c99_wchar)
 985   fi
 986
 987   # Option parsed, now set things appropriately.
 988   if test x"$glibcxx_cv_c99_math" = x"no" ||
 989      test x"$glibcxx_cv_c99_complex" = x"no" ||
 990      test x"$glibcxx_cv_c99_stdio" = x"no" ||
 991      test x"$glibcxx_cv_c99_stdlib" = x"no" ||
 992      test x"$glibcxx_cv_c99_wchar" = x"no"; then
 993     enable_c99=no;
 994   else
 995     AC_DEFINE(_GLIBCXX_USE_C99, 1,
 996     [Define if C99 functions or macros from <wchar.h>, <math.h>,
 997     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
 998   fi
 999
1000   gcc_no_link="$ac_save_gcc_no_link"
1001   LIBS="$ac_save_LIBS"
1002   CXXFLAGS="$ac_save_CXXFLAGS"
1003   AC_LANG_RESTORE
1004   fi
1005
1006   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1007   AC_MSG_RESULT($enable_c99)
1008 ])
1009
1010
1011 dnl
1012 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1013 dnl facilities in Chapter 8, "C compatibility".
1014 dnl
1015 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1016
1017   AC_LANG_SAVE
1018   AC_LANG_CPLUSPLUS
1019
1020   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1021   # undefined and fake C99 facilities may be spuriously enabled.
1022   ac_save_CXXFLAGS="$CXXFLAGS"
1023   CXXFLAGS="$CXXFLAGS -std=c++98"
1024
1025   # Check for the existence of <complex.h> complex math functions used
1026   # by tr1/complex.
1027   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1028   ac_c99_complex_tr1=no;
1029   if test x"$ac_has_complex_h" = x"yes"; then
1030     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1031     AC_TRY_COMPILE([#include <complex.h>],
1032                    [typedef __complex__ float float_type; float_type tmpf;
1033                     cacosf(tmpf);
1034                     casinf(tmpf);
1035                     catanf(tmpf);
1036                     cacoshf(tmpf);
1037                     casinhf(tmpf);
1038                     catanhf(tmpf);
1039                     typedef __complex__ double double_type; double_type tmpd;
1040                     cacos(tmpd);
1041                     casin(tmpd);
1042                     catan(tmpd);
1043                     cacosh(tmpd);
1044                     casinh(tmpd);
1045                     catanh(tmpd);
1046                     typedef __complex__ long double ld_type; ld_type tmpld;
1047                     cacosl(tmpld);
1048                     casinl(tmpld);
1049                     catanl(tmpld);
1050                     cacoshl(tmpld);
1051                     casinhl(tmpld);
1052                     catanhl(tmpld);
1053                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1054   fi
1055   AC_MSG_RESULT($ac_c99_complex_tr1)
1056   if test x"$ac_c99_complex_tr1" = x"yes"; then
1057     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1058               [Define if C99 functions in <complex.h> should be used in
1059               <tr1/complex>. Using compiler builtins for these functions
1060               requires corresponding C99 library functions to be present.])
1061   fi
1062
1063   # Check for the existence of <ctype.h> functions.
1064   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1065   AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1066   AC_TRY_COMPILE([#include <ctype.h>],
1067                  [int ch;
1068                   int ret;
1069                   ret = isblank(ch);
1070                  ],[glibcxx_cv_c99_ctype_tr1=yes], [glibcxx_cv_c99_ctype_tr1=no])
1071   ])
1072   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1073   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1074     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1075               [Define if C99 functions in <ctype.h> should be imported in
1076               <tr1/cctype> in namespace std::tr1.])
1077   fi
1078
1079   # Check for the existence of <fenv.h> functions.
1080   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1081   ac_c99_fenv_tr1=no;
1082   if test x"$ac_has_fenv_h" = x"yes"; then
1083     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1084     AC_TRY_COMPILE([#include <fenv.h>],
1085                    [int except, mode;
1086                     fexcept_t* pflag;
1087                     fenv_t* penv;
1088                     int ret;
1089                     ret = feclearexcept(except);
1090                     ret = fegetexceptflag(pflag, except);
1091                     ret = feraiseexcept(except);
1092                     ret = fesetexceptflag(pflag, except);
1093                     ret = fetestexcept(except);
1094                     ret = fegetround();
1095                     ret = fesetround(mode);
1096                     ret = fegetenv(penv);
1097                     ret = feholdexcept(penv);
1098                     ret = fesetenv(penv);
1099                     ret = feupdateenv(penv);
1100                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1101   fi
1102   AC_MSG_RESULT($ac_c99_fenv_tr1)
1103   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1104     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1105               [Define if C99 functions in <fenv.h> should be imported in
1106               <tr1/cfenv> in namespace std::tr1.])
1107   fi
1108
1109   # Check for the existence of <stdint.h> types.
1110   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1111   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1112   AC_TRY_COMPILE([#include <stdint.h>],
1113                  [typedef int8_t          my_int8_t;
1114                   typedef int16_t         my_int16_t;
1115                   typedef int32_t         my_int32_t;
1116                   typedef int64_t         my_int64_t;
1117                   typedef int_fast8_t     my_int_fast8_t;
1118                   typedef int_fast16_t    my_int_fast16_t;
1119                   typedef int_fast32_t    my_int_fast32_t;
1120                   typedef int_fast64_t    my_int_fast64_t;
1121                   typedef int_least8_t    my_int_least8_t;
1122                   typedef int_least16_t   my_int_least16_t;
1123                   typedef int_least32_t   my_int_least32_t;
1124                   typedef int_least64_t   my_int_least64_t;
1125                   typedef intmax_t        my_intmax_t;
1126                   typedef intptr_t        my_intptr_t;
1127                   typedef uint8_t         my_uint8_t;
1128                   typedef uint16_t        my_uint16_t;
1129                   typedef uint32_t        my_uint32_t;
1130                   typedef uint64_t        my_uint64_t;
1131                   typedef uint_fast8_t    my_uint_fast8_t;
1132                   typedef uint_fast16_t   my_uint_fast16_t;
1133                   typedef uint_fast32_t   my_uint_fast32_t;
1134                   typedef uint_fast64_t   my_uint_fast64_t;
1135                   typedef uint_least8_t   my_uint_least8_t;
1136                   typedef uint_least16_t  my_uint_least16_t;
1137                   typedef uint_least32_t  my_uint_least32_t;
1138                   typedef uint_least64_t  my_uint_least64_t;
1139                   typedef uintmax_t       my_uintmax_t;
1140                   typedef uintptr_t       my_uintptr_t;
1141                  ],[glibcxx_cv_c99_stdint_tr1=yes], [glibcxx_cv_c99_stdint_tr1=no])
1142   ])
1143   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1144   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1145     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1146               [Define if C99 types in <stdint.h> should be imported in
1147               <tr1/cstdint> in namespace std::tr1.])
1148   fi
1149
1150   # Check for the existence of <math.h> functions.
1151   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1152   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1153   AC_TRY_COMPILE([#include <math.h>],
1154                  [typedef double_t  my_double_t;
1155                   typedef float_t   my_float_t;
1156                   acosh(0.0);
1157                   acoshf(0.0f);
1158                   acoshl(0.0l);
1159                   asinh(0.0);
1160                   asinhf(0.0f);
1161                   asinhl(0.0l);
1162                   atanh(0.0);
1163                   atanhf(0.0f);
1164                   atanhl(0.0l);
1165                   cbrt(0.0);
1166                   cbrtf(0.0f);
1167                   cbrtl(0.0l);
1168                   copysign(0.0, 0.0);
1169                   copysignf(0.0f, 0.0f);
1170                   copysignl(0.0l, 0.0l);
1171                   erf(0.0);
1172                   erff(0.0f);
1173                   erfl(0.0l);
1174                   erfc(0.0);
1175                   erfcf(0.0f);
1176                   erfcl(0.0l);
1177                   exp2(0.0);
1178                   exp2f(0.0f);
1179                   exp2l(0.0l);
1180                   expm1(0.0);
1181                   expm1f(0.0f);
1182                   expm1l(0.0l);
1183                   fdim(0.0, 0.0);
1184                   fdimf(0.0f, 0.0f);
1185                   fdiml(0.0l, 0.0l);
1186                   fma(0.0, 0.0, 0.0);
1187                   fmaf(0.0f, 0.0f, 0.0f);
1188                   fmal(0.0l, 0.0l, 0.0l);
1189                   fmax(0.0, 0.0);
1190                   fmaxf(0.0f, 0.0f);
1191                   fmaxl(0.0l, 0.0l);
1192                   fmin(0.0, 0.0);
1193                   fminf(0.0f, 0.0f);
1194                   fminl(0.0l, 0.0l);
1195                   hypot(0.0, 0.0);
1196                   hypotf(0.0f, 0.0f);
1197                   hypotl(0.0l, 0.0l);
1198                   ilogb(0.0);
1199                   ilogbf(0.0f);
1200                   ilogbl(0.0l);
1201                   lgamma(0.0);
1202                   lgammaf(0.0f);
1203                   lgammal(0.0l);
1204                   llrint(0.0);
1205                   llrintf(0.0f);
1206                   llrintl(0.0l);
1207                   llround(0.0);
1208                   llroundf(0.0f);
1209                   llroundl(0.0l);
1210                   log1p(0.0);
1211                   log1pf(0.0f);
1212                   log1pl(0.0l);
1213                   log2(0.0);
1214                   log2f(0.0f);
1215                   log2l(0.0l);
1216                   logb(0.0);
1217                   logbf(0.0f);
1218                   logbl(0.0l);
1219                   lrint(0.0);
1220                   lrintf(0.0f);
1221                   lrintl(0.0l);
1222                   lround(0.0);
1223                   lroundf(0.0f);
1224                   lroundl(0.0l);
1225                   nan(0);
1226                   nanf(0);
1227                   nanl(0);
1228                   nearbyint(0.0);
1229                   nearbyintf(0.0f);
1230                   nearbyintl(0.0l);
1231                   nextafter(0.0, 0.0);
1232                   nextafterf(0.0f, 0.0f);
1233                   nextafterl(0.0l, 0.0l);
1234                   nexttoward(0.0, 0.0);
1235                   nexttowardf(0.0f, 0.0f);
1236                   nexttowardl(0.0l, 0.0l);
1237                   remainder(0.0, 0.0);
1238                   remainderf(0.0f, 0.0f);
1239                   remainderl(0.0l, 0.0l);
1240                   remquo(0.0, 0.0, 0);
1241                   remquo(0.0f, 0.0f, 0);
1242                   remquo(0.0l, 0.0l, 0);
1243                   rint(0.0);
1244                   rintf(0.0f);
1245                   rintl(0.0l);
1246                   round(0.0);
1247                   roundf(0.0f);
1248                   roundl(0.0l);
1249                   scalbln(0.0, 0l);
1250                   scalblnf(0.0f, 0l);
1251                   scalblnl(0.0l, 0l);
1252                   scalbn(0.0, 0);
1253                   scalbnf(0.0f, 0);
1254                   scalbnl(0.0l, 0);
1255                   tgamma(0.0);
1256                   tgammaf(0.0f);
1257                   tgammal(0.0l);
1258                   trunc(0.0);
1259                   truncf(0.0f);
1260                   truncl(0.0l);
1261                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1262   ])
1263   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1264   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1265     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1266               [Define if C99 functions or macros in <math.h> should be imported
1267               in <tr1/cmath> in namespace std::tr1.])
1268   fi
1269
1270   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1271   # sense if the previous check fails, per C99, 7.8/1).
1272   ac_c99_inttypes_tr1=no;
1273   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1274     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1275     AC_TRY_COMPILE([#include <inttypes.h>],
1276                    [intmax_t i, numer, denom, base;
1277                     const char* s;
1278                     char** endptr;
1279                     intmax_t ret = imaxabs(i);
1280                     imaxdiv_t dret = imaxdiv(numer, denom);
1281                     ret = strtoimax(s, endptr, base);
1282                     uintmax_t uret = strtoumax(s, endptr, base);
1283                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1284   fi
1285   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1286   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1287     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1288               [Define if C99 functions in <inttypes.h> should be imported in
1289               <tr1/cinttypes> in namespace std::tr1.])
1290   fi
1291
1292   # Check for the existence of the <stdbool.h> header.
1293   AC_CHECK_HEADERS(stdbool.h)
1294
1295   CXXFLAGS="$ac_save_CXXFLAGS"
1296   AC_LANG_RESTORE
1297 ])
1298
1299 dnl
1300 dnl Check whether "dev/random" and "dev/urandom" are available for the
1301 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1302 dnl
1303 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1304
1305   AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1306   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1307   AC_TRY_RUN([#include <stdio.h>
1308               int main()
1309               {
1310                 return !(fopen("/dev/random", "r")
1311                          && fopen("/dev/urandom", "r"));
1312               }
1313              ],
1314              [glibcxx_cv_random_tr1=yes], [glibcxx_cv_random_tr1=no],
1315              [glibcxx_cv_random_tr1=no])
1316   ])
1317   AC_MSG_RESULT($glibcxx_cv_random_tr1)
1318   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1319     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1320               [Define if dev/random and dev/urandom are available for
1321                the random_device of TR1 (Chapter 5.1).])
1322   fi
1323
1324 ])
1325
1326 dnl
1327 dnl Check whether macros, etc are present for <system_error>
1328 dnl
1329 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1330
1331 m4_pushdef([n_syserr], [1])dnl
1332 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1333                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1334                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY],
1335 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1336 AC_MSG_CHECKING([for syserr])
1337 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1338 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1339                                    [int i = syserr;])],
1340                   [glibcxx_cv_system_error[]n_syserr=yes],
1341                   [glibcxx_cv_system_error[]n_syserr=no])
1342 ])
1343 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1344 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1345   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1346 fi
1347 m4_define([n_syserr], m4_incr(n_syserr))dnl
1348 m4_popdef([SYSERR])dnl
1349 ])
1350 m4_popdef([n_syserr])dnl
1351 ])
1352
1353 dnl
1354 dnl Check whether C++200x's standard layout types are supported.
1355 dnl
1356 AC_DEFUN([GLIBCXX_CHECK_STANDARD_LAYOUT], [
1357
1358   AC_MSG_CHECKING([for ISO C++200x standard layout type support])
1359   AC_CACHE_VAL(ac_standard_layout, [
1360   AC_LANG_SAVE
1361   AC_LANG_CPLUSPLUS
1362   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1363   ac_save_CXXFLAGS="$CXXFLAGS"
1364   CXXFLAGS='-std=gnu++0x'
1365
1366   AC_TRY_COMPILE([struct b
1367                   {
1368                     bool t;
1369
1370                     // Need standard layout relaxation from POD
1371                     private:
1372                     b& operator=(const b&);
1373                     b(const b&);
1374                     };
1375
1376                     int main()
1377                     {
1378                       b tst1 = { false };
1379                        return 0;
1380                     }],,
1381              [ac_standard_layout=yes], [ac_standard_layout=no])
1382
1383   CXXFLAGS="$ac_save_CXXFLAGS"
1384   AC_LANG_RESTORE
1385   ])
1386   AC_MSG_RESULT($ac_standard_layout)
1387   if test x"$ac_standard_layout" = x"yes"; then
1388     AC_DEFINE(_GLIBCXX_USE_STANDARD_LAYOUT, 1,
1389               [Define if standard layout types are supported in C++200x.])
1390   fi
1391 ])
1392
1393 dnl
1394 dnl Check for what type of C headers to use.
1395 dnl
1396 dnl --enable-cheaders= [does stuff].
1397 dnl --disable-cheaders [does not do anything, really].
1398 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1399 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1400 dnl
1401 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1402   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1403     [construct "C" headers for g++], [permit c|c_std|c_global])
1404   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1405
1406   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1407
1408   # Allow overrides to configure.host here.
1409   if test $enable_cheaders = c_global; then
1410      c_compatibility=yes
1411   fi
1412
1413   if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1414      c_extra=yes
1415   fi
1416
1417   AC_SUBST(C_INCLUDE_DIR)
1418   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1419   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1420   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1421   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1422   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1423 ])
1424
1425
1426 dnl
1427 dnl Check for which locale library to use.  The choice is mapped to
1428 dnl a subdirectory of config/locale.
1429 dnl
1430 dnl Default is generic.
1431 dnl
1432 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1433   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1434     [use MODEL for target locale package],
1435     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1436
1437   # Deal with gettext issues.  Default to not using it (=no) until we detect
1438   # support for it later.  Let the user turn it off via --e/d, but let that
1439   # default to on for easier handling.
1440   USE_NLS=no
1441   AC_ARG_ENABLE(nls,
1442     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1443     [],
1444     [enable_nls=yes])
1445
1446   # Either a known packaage, or "auto"
1447   if test $enable_clocale = no || test $enable_clocale = yes; then
1448      enable_clocale=auto
1449   fi
1450   enable_clocale_flag=$enable_clocale
1451
1452   # Probe for locale model to use if none specified.
1453   # Default to "generic".
1454   if test $enable_clocale_flag = auto; then
1455     case ${target_os} in
1456       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1457         enable_clocale_flag=gnu
1458         ;;
1459       darwin* | freebsd*)
1460         enable_clocale_flag=darwin
1461         ;;
1462       *)
1463         enable_clocale_flag=generic
1464         ;;
1465     esac
1466   fi
1467
1468   # Sanity check model, and test for special functionality.
1469   if test $enable_clocale_flag = gnu; then
1470     AC_EGREP_CPP([_GLIBCXX_ok], [
1471     #include <features.h>
1472     #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1473       _GLIBCXX_ok
1474     #endif
1475     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1476
1477     if test $enable_clocale = auto; then
1478       # Test for bugs early in glibc-2.2.x series
1479       AC_TRY_RUN([
1480       #define _GNU_SOURCE 1
1481       #include <locale.h>
1482       #include <string.h>
1483       #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1484       extern __typeof(newlocale) __newlocale;
1485       extern __typeof(duplocale) __duplocale;
1486       extern __typeof(strcoll_l) __strcoll_l;
1487       #endif
1488       int main()
1489       {
1490         const char __one[] = "Äuglein Augmen";
1491         const char __two[] = "Äuglein";
1492         int i;
1493         int j;
1494         __locale_t        loc;
1495         __locale_t        loc_dup;
1496         loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1497         loc_dup = __duplocale(loc);
1498         i = __strcoll_l(__one, __two, loc);
1499         j = __strcoll_l(__one, __two, loc_dup);
1500         return 0;
1501       }
1502       ],
1503       [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1504       [enable_clocale_flag=generic])
1505     fi
1506
1507     # Set it to scream when it hurts.
1508     ac_save_CFLAGS="$CFLAGS"
1509     CFLAGS="-Wimplicit-function-declaration -Werror"
1510
1511     # Use strxfrm_l if available.
1512     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1513                     #include <string.h>
1514                     #include <locale.h>],
1515                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1516                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1517                     [Define if strxfrm_l is available in <string.h>.]),)
1518
1519     # Use strerror_l if available.
1520     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1521                     #include <string.h>
1522                     #include <locale.h>],
1523                     [__locale_t loc; strerror_l(5, loc);],
1524                     AC_DEFINE(HAVE_STRERROR_L, 1,
1525                     [Define if strerror_l is available in <string.h>.]),)
1526
1527     CFLAGS="$ac_save_CFLAGS"
1528   fi
1529
1530   # Perhaps use strerror_r if available, and strerror_l isn't.
1531   ac_save_CFLAGS="$CFLAGS"
1532   CFLAGS="-Wimplicit-function-declaration -Werror"
1533   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1534                   #include <string.h>
1535                   #include <locale.h>],
1536                   [char s[128]; strerror_r(5, s, 128);],
1537                   AC_DEFINE(HAVE_STRERROR_R, 1,
1538                   [Define if strerror_r is available in <string.h>.]),)
1539   CFLAGS="$ac_save_CFLAGS"
1540
1541   # Set configure bits for specified locale package
1542   AC_MSG_CHECKING([for C locale to use])
1543   case ${enable_clocale_flag} in
1544     generic)
1545       AC_MSG_RESULT(generic)
1546
1547       CLOCALE_H=config/locale/generic/c_locale.h
1548       CLOCALE_CC=config/locale/generic/c_locale.cc
1549       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1550       CCOLLATE_CC=config/locale/generic/collate_members.cc
1551       CCTYPE_CC=config/locale/generic/ctype_members.cc
1552       CMESSAGES_H=config/locale/generic/messages_members.h
1553       CMESSAGES_CC=config/locale/generic/messages_members.cc
1554       CMONEY_CC=config/locale/generic/monetary_members.cc
1555       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1556       CTIME_H=config/locale/generic/time_members.h
1557       CTIME_CC=config/locale/generic/time_members.cc
1558       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1559       ;;
1560     darwin)
1561       AC_MSG_RESULT(darwin or freebsd)
1562
1563       CLOCALE_H=config/locale/generic/c_locale.h
1564       CLOCALE_CC=config/locale/generic/c_locale.cc
1565       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1566       CCOLLATE_CC=config/locale/generic/collate_members.cc
1567       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1568       CMESSAGES_H=config/locale/generic/messages_members.h
1569       CMESSAGES_CC=config/locale/generic/messages_members.cc
1570       CMONEY_CC=config/locale/generic/monetary_members.cc
1571       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1572       CTIME_H=config/locale/generic/time_members.h
1573       CTIME_CC=config/locale/generic/time_members.cc
1574       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1575       ;;
1576
1577     gnu)
1578       AC_MSG_RESULT(gnu)
1579
1580       # Declare intention to use gettext, and add support for specific
1581       # languages.
1582       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1583       ALL_LINGUAS="de fr"
1584
1585       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1586       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1587       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1588         USE_NLS=yes
1589       fi
1590       # Export the build objects.
1591       for ling in $ALL_LINGUAS; do \
1592         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1593         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1594       done
1595       AC_SUBST(glibcxx_MOFILES)
1596       AC_SUBST(glibcxx_POFILES)
1597
1598       CLOCALE_H=config/locale/gnu/c_locale.h
1599       CLOCALE_CC=config/locale/gnu/c_locale.cc
1600       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1601       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1602       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1603       CMESSAGES_H=config/locale/gnu/messages_members.h
1604       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1605       CMONEY_CC=config/locale/gnu/monetary_members.cc
1606       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1607       CTIME_H=config/locale/gnu/time_members.h
1608       CTIME_CC=config/locale/gnu/time_members.cc
1609       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1610       ;;
1611     ieee_1003.1-2001)
1612       AC_MSG_RESULT(IEEE 1003.1)
1613
1614       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1615       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1616       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1617       CCOLLATE_CC=config/locale/generic/collate_members.cc
1618       CCTYPE_CC=config/locale/generic/ctype_members.cc
1619       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1620       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1621       CMONEY_CC=config/locale/generic/monetary_members.cc
1622       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1623       CTIME_H=config/locale/generic/time_members.h
1624       CTIME_CC=config/locale/generic/time_members.cc
1625       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1626       ;;
1627   esac
1628
1629   # This is where the testsuite looks for locale catalogs, using the
1630   # -DLOCALEDIR define during testsuite compilation.
1631   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1632   AC_SUBST(glibcxx_localedir)
1633
1634   # A standalone libintl (e.g., GNU libintl) may be in use.
1635   if test $USE_NLS = yes; then
1636     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1637     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1638   fi
1639   if test $USE_NLS = yes; then
1640     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1641               [Define if NLS translations are to be used.])
1642   fi
1643
1644   AC_SUBST(USE_NLS)
1645   AC_SUBST(CLOCALE_H)
1646   AC_SUBST(CMESSAGES_H)
1647   AC_SUBST(CCODECVT_CC)
1648   AC_SUBST(CCOLLATE_CC)
1649   AC_SUBST(CCTYPE_CC)
1650   AC_SUBST(CMESSAGES_CC)
1651   AC_SUBST(CMONEY_CC)
1652   AC_SUBST(CNUMERIC_CC)
1653   AC_SUBST(CTIME_H)
1654   AC_SUBST(CTIME_CC)
1655   AC_SUBST(CLOCALE_CC)
1656   AC_SUBST(CLOCALE_INTERNAL_H)
1657 ])
1658
1659
1660 dnl
1661 dnl Check for which std::allocator base class to use.  The choice is
1662 dnl mapped from a subdirectory of include/ext.
1663 dnl
1664 dnl Default is new.
1665 dnl
1666 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1667   AC_MSG_CHECKING([for std::allocator base class])
1668   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1669     [use KIND for target std::allocator base],
1670     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1671
1672   # If they didn't use this option switch, or if they specified --enable
1673   # with no specific model, we'll have to look for one.  If they
1674   # specified --disable (???), do likewise.
1675   if test $enable_libstdcxx_allocator = no ||
1676      test $enable_libstdcxx_allocator = yes;
1677   then
1678      enable_libstdcxx_allocator=auto
1679   fi
1680
1681   # Either a known package, or "auto". Auto implies the default choice
1682   # for a particular platform.
1683   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1684
1685   # Probe for host-specific support if no specific model is specified.
1686   # Default to "new".
1687   if test $enable_libstdcxx_allocator_flag = auto; then
1688     case ${target_os} in
1689       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1690         enable_libstdcxx_allocator_flag=new
1691         ;;
1692       *)
1693         enable_libstdcxx_allocator_flag=new
1694         ;;
1695     esac
1696   fi
1697   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1698
1699
1700   # Set configure bits for specified locale package
1701   case ${enable_libstdcxx_allocator_flag} in
1702     bitmap)
1703       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1704       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1705       ;;
1706     malloc)
1707       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1708       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1709       ;;
1710     mt)
1711       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1712       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1713       ;;
1714     new)
1715       ALLOCATOR_H=config/allocator/new_allocator_base.h
1716       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1717       ;;
1718     pool)
1719       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1720       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1721       ;;
1722   esac
1723
1724   AC_SUBST(ALLOCATOR_H)
1725   AC_SUBST(ALLOCATOR_NAME)
1726 ])
1727
1728
1729 dnl
1730 dnl Check for whether the Boost-derived checks should be turned on.
1731 dnl
1732 dnl --enable-concept-checks turns them on.
1733 dnl --disable-concept-checks leaves them off.
1734 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1735 dnl       Where DEFAULT is either `yes' or `no'.
1736 dnl
1737 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1738   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1739   if test $enable_concept_checks = yes; then
1740     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1741               [Define to use concept checking code from the boost libraries.])
1742   fi
1743 ])
1744
1745 dnl
1746 dnl Check for parallel mode pre-requisites, including OpenMP support.
1747 dnl
1748 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
1749 dnl
1750 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
1751
1752   enable_parallel=no;
1753
1754   # See if configured libgomp/omp.h exists. (libgomp may be in
1755   # noconfigdirs but not explicitly disabled.)
1756   if test -f $glibcxx_builddir/../libgomp/omp.h; then
1757     enable_parallel=yes;
1758   else
1759     AC_MSG_NOTICE([$glibcxx_builddir/../libgomp/omp.h not found])
1760   fi
1761
1762   AC_MSG_CHECKING([for parallel mode support])
1763   AC_MSG_RESULT([$enable_parallel])
1764   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
1765 ])
1766
1767
1768 dnl
1769 dnl Check for which I/O library to use:  stdio, or something specific.
1770 dnl
1771 dnl Default is stdio.
1772 dnl
1773 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1774   AC_MSG_CHECKING([for underlying I/O to use])
1775   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1776     [use target-specific I/O package], [permit stdio])
1777
1778   # Now that libio has been removed, you can have any color you want as long
1779   # as it's black.  This is one big no-op until other packages are added, but
1780   # showing the framework never hurts.
1781   case ${enable_cstdio} in
1782     stdio)
1783       CSTDIO_H=config/io/c_io_stdio.h
1784       BASIC_FILE_H=config/io/basic_file_stdio.h
1785       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1786       AC_MSG_RESULT(stdio)
1787       ;;
1788   esac
1789
1790   AC_SUBST(CSTDIO_H)
1791   AC_SUBST(BASIC_FILE_H)
1792   AC_SUBST(BASIC_FILE_CC)
1793 ])
1794
1795
1796 dnl
1797 dnl Check for "unusual" flags to pass to the compiler while building.
1798 dnl
1799 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1800 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1801 dnl --disable-cxx-flags passes nothing.
1802 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1803 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1804 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1805 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1806 dnl       If "default flags" is an empty string, the effect is the same
1807 dnl       as --disable or --enable=no.
1808 dnl
1809 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1810   AC_MSG_CHECKING([for extra compiler flags for building])
1811   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1812     [pass compiler FLAGS when building library],
1813     [case "x$enable_cxx_flags" in
1814       xno | x)   enable_cxx_flags= ;;
1815       x-*)       ;;
1816       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1817      esac])
1818
1819   # Run through flags (either default or command-line) and set anything
1820   # extra (e.g., #defines) that must accompany particular g++ options.
1821   if test -n "$enable_cxx_flags"; then
1822     for f in $enable_cxx_flags; do
1823       case "$f" in
1824         -fhonor-std)  ;;
1825         -*)  ;;
1826         *)   # and we're trying to pass /what/ exactly?
1827              AC_MSG_ERROR([compiler flags start with a -]) ;;
1828       esac
1829     done
1830   fi
1831
1832   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1833   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1834   AC_SUBST(EXTRA_CXX_FLAGS)
1835 ])
1836
1837
1838 dnl
1839 dnl Check to see if debugging libraries are to be built.
1840 dnl
1841 dnl --enable-libstdcxx-debug
1842 dnl builds a separate set of debugging libraries in addition to the
1843 dnl normal (shared, static) libstdc++ binaries.
1844 dnl
1845 dnl --disable-libstdcxx-debug
1846 dnl builds only one (non-debug) version of libstdc++.
1847 dnl
1848 dnl --enable-libstdcxx-debug-flags=FLAGS
1849 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1850 dnl
1851 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1852 dnl       Where DEFAULT is either `yes' or `no'.
1853 dnl
1854 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1855   AC_MSG_CHECKING([for additional debug build])
1856   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1857   AC_MSG_RESULT($enable_libstdcxx_debug)
1858   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1859 ])
1860
1861
1862 dnl
1863 dnl Check for explicit debug flags.
1864 dnl
1865 dnl --enable-libstdcxx-debug-flags='-O1'
1866 dnl is a general method for passing flags to be used when
1867 dnl building debug libraries with --enable-debug.
1868 dnl
1869 dnl --disable-libstdcxx-debug-flags does nothing.
1870 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1871 dnl       If "default flags" is an empty string, the effect is the same
1872 dnl       as --disable or --enable=no.
1873 dnl
1874 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1875   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1876     [pass compiler FLAGS when building debug library],
1877     [case "x$enable_libstdcxx_debug_flags" in
1878       xno | x)    enable_libstdcxx_debug_flags= ;;
1879       x-*)        ;;
1880       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1881      esac])
1882
1883   # Option parsed, now set things appropriately
1884   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1885   AC_SUBST(DEBUG_FLAGS)
1886
1887   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1888 ])
1889
1890
1891 dnl
1892 dnl Check if the user only wants a freestanding library implementation.
1893 dnl
1894 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1895 dnl installing only the headers required by [17.4.1.3] and the language
1896 dnl support library.  More than that will be built (to keep the Makefiles
1897 dnl conveniently clean), but not installed.
1898 dnl
1899 dnl Sets:
1900 dnl  is_hosted  (yes/no)
1901 dnl
1902 dnl Defines:
1903 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1904 dnl
1905 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1906   AC_ARG_ENABLE([hosted-libstdcxx],
1907     AC_HELP_STRING([--disable-hosted-libstdcxx],
1908                    [only build freestanding C++ runtime support]),,
1909     [case "$host" in
1910         arm*-*-symbianelf*)
1911             enable_hosted_libstdcxx=no
1912             ;;
1913         *)
1914             enable_hosted_libstdcxx=yes
1915             ;;
1916      esac])
1917   if test "$enable_hosted_libstdcxx" = no; then
1918     AC_MSG_NOTICE([Only freestanding libraries will be built])
1919     is_hosted=no
1920     hosted_define=0
1921     enable_abi_check=no
1922     enable_libstdcxx_pch=no
1923   else
1924     is_hosted=yes
1925     hosted_define=1
1926   fi
1927   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1928   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1929     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1930 ])
1931
1932
1933 dnl
1934 dnl Check for template specializations for the 'long long' type.
1935 dnl The result determines only whether 'long long' I/O is enabled; things
1936 dnl like numeric_limits<> specializations are always available.
1937 dnl
1938 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1939 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1940 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1941 dnl       Where DEFAULT is either `yes' or `no'.
1942 dnl
1943 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1944   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1945   if test $enable_long_long = yes; then
1946     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1947               [Define if code specialized for long long should be used.])
1948   fi
1949   AC_MSG_CHECKING([for enabled long long specializations])
1950   AC_MSG_RESULT([$enable_long_long])
1951 ])
1952
1953
1954 dnl
1955 dnl Check for template specializations for the 'wchar_t' type.
1956 dnl
1957 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1958 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1959 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1960 dnl       Where DEFAULT is either `yes' or `no'.
1961 dnl
1962 dnl Necessary support must also be present.
1963 dnl
1964 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1965   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1966
1967   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
1968   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
1969   AC_MSG_CHECKING([for mbstate_t])
1970   AC_TRY_COMPILE([#include <wchar.h>],
1971   [mbstate_t teststate;],
1972   have_mbstate_t=yes, have_mbstate_t=no)
1973   AC_MSG_RESULT($have_mbstate_t)
1974   if test x"$have_mbstate_t" = xyes; then
1975     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
1976   fi
1977
1978   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
1979   # ac_has_wchar_h.
1980   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
1981
1982   if test x"$enable_wchar_t" = x"yes"; then
1983
1984     AC_LANG_SAVE
1985     AC_LANG_CPLUSPLUS
1986
1987     if test x"$ac_has_wchar_h" = xyes &&
1988        test x"$ac_has_wctype_h" = xyes; then
1989       AC_TRY_COMPILE([#include <wchar.h>
1990                       #include <stddef.h>
1991                       wint_t i;
1992                       long l = WEOF;
1993                       long j = WCHAR_MIN;
1994                       long k = WCHAR_MAX;
1995                       namespace test
1996                       {
1997                         using ::btowc;
1998                         using ::fgetwc;
1999                         using ::fgetws;
2000                         using ::fputwc;
2001                         using ::fputws;
2002                         using ::fwide;
2003                         using ::fwprintf;
2004                         using ::fwscanf;
2005                         using ::getwc;
2006                         using ::getwchar;
2007                         using ::mbrlen;
2008                         using ::mbrtowc;
2009                         using ::mbsinit;
2010                         using ::mbsrtowcs;
2011                         using ::putwc;
2012                         using ::putwchar;
2013                         using ::swprintf;
2014                         using ::swscanf;
2015                         using ::ungetwc;
2016                         using ::vfwprintf;
2017                         using ::vswprintf;
2018                         using ::vwprintf;
2019                         using ::wcrtomb;
2020                         using ::wcscat;
2021                         using ::wcschr;
2022                         using ::wcscmp;
2023                         using ::wcscoll;
2024                         using ::wcscpy;
2025                         using ::wcscspn;
2026                         using ::wcsftime;
2027                         using ::wcslen;
2028                         using ::wcsncat;
2029                         using ::wcsncmp;
2030                         using ::wcsncpy;
2031                         using ::wcspbrk;
2032                         using ::wcsrchr;
2033                         using ::wcsrtombs;
2034                         using ::wcsspn;
2035                         using ::wcsstr;
2036                         using ::wcstod;
2037                         using ::wcstok;
2038                         using ::wcstol;
2039                         using ::wcstoul;
2040                         using ::wcsxfrm;
2041                         using ::wctob;
2042                         using ::wmemchr;
2043                         using ::wmemcmp;
2044                         using ::wmemcpy;
2045                         using ::wmemmove;
2046                         using ::wmemset;
2047                         using ::wprintf;
2048                         using ::wscanf;
2049                       }
2050                      ],[],[], [enable_wchar_t=no])
2051     else
2052       enable_wchar_t=no
2053     fi
2054
2055     AC_LANG_RESTORE
2056   fi
2057
2058   if test x"$enable_wchar_t" = x"yes"; then
2059     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2060               [Define if code specialized for wchar_t should be used.])
2061   fi
2062
2063   AC_MSG_CHECKING([for enabled wchar_t specializations])
2064   AC_MSG_RESULT([$enable_wchar_t])
2065 ])
2066
2067
2068 dnl
2069 dnl Check to see if building and using a C++ precompiled header can be done.
2070 dnl
2071 dnl --enable-libstdcxx-pch=yes
2072 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2073 dnl may work, after some light-hearted attempts to puzzle out compiler
2074 dnl support, flip bits on in include/Makefile.am
2075 dnl
2076 dnl --disable-libstdcxx-pch
2077 dnl turns off attempts to use or build stdc++.h.gch.
2078 dnl
2079 dnl Substs:
2080 dnl  glibcxx_PCHFLAGS
2081 dnl
2082 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2083   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2084   if test $enable_libstdcxx_pch = yes; then
2085     AC_CACHE_CHECK([for compiler with PCH support],
2086       [glibcxx_cv_prog_CXX_pch],
2087       [ac_save_CXXFLAGS="$CXXFLAGS"
2088        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2089        AC_LANG_SAVE
2090        AC_LANG_CPLUSPLUS
2091        echo '#include <math.h>' > conftest.h
2092        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2093                           -o conftest.h.gch 1>&5 2>&1 &&
2094                 echo '#error "pch failed"' > conftest.h &&
2095           echo '#include "conftest.h"' > conftest.cc &&
2096                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2097        then
2098          glibcxx_cv_prog_CXX_pch=yes
2099        else
2100          glibcxx_cv_prog_CXX_pch=no
2101        fi
2102        rm -f conftest*
2103        CXXFLAGS=$ac_save_CXXFLAGS
2104        AC_LANG_RESTORE
2105       ])
2106     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2107   fi
2108
2109   AC_MSG_CHECKING([for enabled PCH])
2110   AC_MSG_RESULT([$enable_libstdcxx_pch])
2111
2112   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2113   if test $enable_libstdcxx_pch = yes; then
2114     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2115   else
2116     glibcxx_PCHFLAGS=""
2117   fi
2118   AC_SUBST(glibcxx_PCHFLAGS)
2119 ])
2120
2121
2122 dnl
2123 dnl Check for atomic builtins.
2124 dnl See:
2125 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2126 dnl
2127 dnl This checks to see if the host supports the compiler-generated
2128 dnl builtins for atomic operations for various integral sizes. Note, this
2129 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2130 dnl that are used should be checked.
2131 dnl
2132 dnl Note:
2133 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
2134 dnl see: CHECK_SYNC_FETCH_AND_ADD
2135 dnl
2136 dnl Defines:
2137 dnl  _GLIBCXX_ATOMIC_BUILTINS_1
2138 dnl  _GLIBCXX_ATOMIC_BUILTINS_4
2139 dnl
2140 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2141   AC_LANG_SAVE
2142   AC_LANG_CPLUSPLUS
2143   old_CXXFLAGS="$CXXFLAGS"
2144
2145   # Compile unoptimized.
2146   CXXFLAGS='-O0 -S'
2147
2148   # Fake what AC_TRY_COMPILE does, without linking as this is
2149   # unnecessary for a builtins test.
2150
2151     cat > conftest.$ac_ext << EOF
2152 [#]line __oline__ "configure"
2153 int main()
2154 {
2155   // NB: _Atomic_word not necessarily int.
2156   typedef int atomic_type;
2157   atomic_type c1;
2158   atomic_type c2;
2159   const atomic_type c3(0);
2160   __sync_fetch_and_add(&c1, c2);
2161   __sync_val_compare_and_swap(&c1, c3, c2);
2162   __sync_lock_test_and_set(&c1, c3);
2163   __sync_lock_release(&c1);
2164   __sync_synchronize();
2165   return 0;
2166 }
2167 EOF
2168
2169     AC_MSG_CHECKING([for atomic builtins for int])
2170     if AC_TRY_EVAL(ac_compile); then
2171       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2172         enable_atomic_builtinsi=no
2173       else
2174       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2175         [Define if builtin atomic operations for int are supported on this host.])
2176         enable_atomic_builtinsi=yes
2177       fi
2178     fi
2179     AC_MSG_RESULT($enable_atomic_builtinsi)
2180     rm -f conftest*
2181
2182     cat > conftest.$ac_ext << EOF
2183 [#]line __oline__ "configure"
2184 int main()
2185 {
2186   typedef bool atomic_type;
2187   atomic_type c1;
2188   atomic_type c2;
2189   const atomic_type c3(0);
2190   __sync_fetch_and_add(&c1, c2);
2191   __sync_val_compare_and_swap(&c1, c3, c2);
2192   __sync_lock_test_and_set(&c1, c3);
2193   __sync_lock_release(&c1);
2194   __sync_synchronize();
2195   return 0;
2196 }
2197 EOF
2198
2199     AC_MSG_CHECKING([for atomic builtins for bool])
2200     if AC_TRY_EVAL(ac_compile); then
2201       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2202         enable_atomic_builtinsb=no
2203       else
2204       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2205       [Define if builtin atomic operations for bool are supported on this host.])
2206         enable_atomic_builtinsb=yes
2207       fi
2208     fi
2209     AC_MSG_RESULT($enable_atomic_builtinsb)
2210     rm -f conftest*
2211
2212   CXXFLAGS="$old_CXXFLAGS"
2213   AC_LANG_RESTORE
2214
2215   # Set atomicity_dir to builtins if either of above tests pass.
2216   if test $enable_atomic_builtinsi = yes || test $enable_atomic_builtinsb = yes ; then
2217     atomicity_dir=cpu/generic/atomicity_builtins
2218   fi
2219
2220   # If still generic, set to mutex.
2221   if test $atomicity_dir = "cpu/generic" ; then
2222     atomicity_dir=cpu/generic/atomicity_mutex
2223     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2224       if test $target_thread_file = single; then
2225         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2226         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2227       else
2228         AC_MSG_WARN([They will be faked using a mutex.])
2229         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2230       fi
2231   fi
2232
2233 ])
2234
2235
2236 dnl
2237 dnl Check for exception handling support.  If an explicit enable/disable
2238 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2239 dnl target may or may not support call frame exceptions.
2240 dnl
2241 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2242 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2243 dnl Neither one forces an attempt at detection.
2244 dnl
2245 dnl Defines:
2246 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2247 dnl
2248 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2249   AC_MSG_CHECKING([for exception model to use])
2250   AC_LANG_SAVE
2251   AC_LANG_CPLUSPLUS
2252   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2253     [force use of builtin_setjmp for exceptions],
2254     [permit yes|no|auto])
2255
2256   if test $enable_sjlj_exceptions = auto; then
2257     # Botheration.  Now we've got to detect the exception model.  Link tests
2258     # against libgcc.a are problematic since we've not been given proper -L
2259     # bits for single-tree newlib and libgloss.
2260     #
2261     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2262     cat > conftest.$ac_ext << EOF
2263 [#]line __oline__ "configure"
2264 struct S { ~S(); };
2265 void bar();
2266 void foo()
2267 {
2268   S s;
2269   bar();
2270 }
2271 EOF
2272     old_CXXFLAGS="$CXXFLAGS"
2273     CXXFLAGS=-S
2274     if AC_TRY_EVAL(ac_compile); then
2275       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2276         enable_sjlj_exceptions=yes
2277       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2278         enable_sjlj_exceptions=no
2279       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2280         enable_sjlj_exceptions=no
2281       fi
2282     fi
2283     CXXFLAGS="$old_CXXFLAGS"
2284     rm -f conftest*
2285   fi
2286
2287   # This is a tad weird, for hysterical raisins.  We have to map
2288   # enable/disable to two different models.
2289   case $enable_sjlj_exceptions in
2290     yes)
2291       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2292         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2293       ac_exception_model_name=sjlj
2294       ;;
2295     no)
2296       ac_exception_model_name="call frame"
2297       ;;
2298     *)
2299       AC_MSG_ERROR([unable to detect exception model])
2300       ;;
2301   esac
2302  AC_LANG_RESTORE
2303  AC_MSG_RESULT($ac_exception_model_name)
2304 ])
2305
2306
2307 dnl
2308 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2309 dnl
2310 dnl --enable-visibility enables attempt to use visibility attributes.
2311 dnl --disable-visibility turns off all use of visibility attributes.
2312 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2313 dnl       Where DEFAULT is 'yes'.
2314 dnl
2315 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2316 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2317
2318 if test x$enable_visibility = xyes ; then
2319   dnl all hail libgfortran
2320   dnl Check whether the target supports hidden visibility.
2321   AC_CACHE_CHECK([whether the target supports hidden visibility],
2322                  glibcxx_cv_have_attribute_visibility, [
2323   save_CFLAGS="$CFLAGS"
2324   CFLAGS="$CFLAGS -Werror"
2325   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2326                  [], glibcxx_cv_have_attribute_visibility=yes,
2327                  glibcxx_cv_have_attribute_visibility=no)
2328   CFLAGS="$save_CFLAGS"])
2329   if test $glibcxx_cv_have_attribute_visibility = no; then
2330     enable_visibility=no
2331   fi
2332 fi
2333
2334 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2335 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2336 ])
2337
2338
2339 dnl
2340 dnl Add version tags to symbols in shared library (or not), additionally
2341 dnl marking other symbols as private/local (or not).
2342 dnl
2343 dnl --enable-symvers=style adds a version script to the linker call when
2344 dnl       creating the shared library.  The choice of version script is
2345 dnl       controlled by 'style'.
2346 dnl --disable-symvers does not.
2347 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2348 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2349 dnl       choose a default style based on linker characteristics.  Passing
2350 dnl       'no' disables versioning.
2351 dnl
2352 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2353
2354 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2355   [enables symbol versioning of the shared library],
2356   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2357
2358 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2359 # don't know enough about $LD to do tricks...
2360 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2361
2362 # Turn a 'yes' into a suitable default.
2363 if test x$enable_symvers = xyes ; then
2364   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2365     enable_symvers=no
2366   else
2367     if test $with_gnu_ld = yes ; then
2368       enable_symvers=gnu
2369     else
2370       case ${target_os} in
2371         darwin*)
2372           enable_symvers=darwin ;;
2373         *)
2374           enable_symvers=no ;;
2375       esac
2376     fi
2377   fi
2378 fi
2379
2380 # Check to see if 'darwin' or 'darwin-export' can win.
2381 if test x$enable_symvers = xdarwin-export ; then
2382     enable_symvers=darwin
2383 fi
2384
2385 # Check to see if 'gnu' can win.
2386 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2387   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2388   AC_MSG_CHECKING([for shared libgcc])
2389   ac_save_CFLAGS="$CFLAGS"
2390   CFLAGS=' -lgcc_s'
2391   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2392   CFLAGS="$ac_save_CFLAGS"
2393   if test $glibcxx_shared_libgcc = no; then
2394     cat > conftest.c <<EOF
2395 int main (void) { return 0; }
2396 EOF
2397 changequote(,)dnl
2398     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2399                              -shared -shared-libgcc -o conftest.so \
2400                              conftest.c -v 2>&1 >/dev/null \
2401                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2402 changequote([,])dnl
2403     rm -f conftest.c conftest.so
2404     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2405       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2406       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2407       CFLAGS="$ac_save_CFLAGS"
2408     fi
2409   fi
2410   AC_MSG_RESULT($glibcxx_shared_libgcc)
2411
2412   # For GNU ld, we need at least this version.  The format is described in
2413   # GLIBCXX_CHECK_LINKER_FEATURES above.
2414   glibcxx_min_gnu_ld_version=21400
2415
2416   # If no shared libgcc, can't win.
2417   if test $glibcxx_shared_libgcc != yes; then
2418       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2419       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2420       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2421       enable_symvers=no
2422   elif test $with_gnu_ld != yes ; then
2423     # just fail for now
2424     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2425     AC_MSG_WARN([=== you are not using the GNU linker.])
2426     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2427     enable_symvers=no
2428   elif test $glibcxx_ld_is_gold = yes ; then
2429     : All versions of gold support symbol versioning.
2430   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2431     # The right tools, the right setup, but too old.  Fallbacks?
2432     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2433     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2434     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2435     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2436     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2437     enable_symvers=no
2438   fi
2439 fi
2440
2441 # Everything parsed; figure out what file to use.
2442 case $enable_symvers in
2443   no)
2444     SYMVER_FILE=config/abi/pre/none.ver
2445     ;;
2446   gnu)
2447     SYMVER_FILE=config/abi/pre/gnu.ver
2448     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2449               [Define to use GNU versioning in the shared library.])
2450     ;;
2451   gnu-versioned-namespace)
2452     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2453     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2454               [Define to use GNU namespace versioning in the shared library.])
2455     ;;
2456   darwin)
2457     SYMVER_FILE=config/abi/pre/gnu.ver
2458     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2459               [Define to use darwin versioning in the shared library.])
2460     ;;
2461 esac
2462
2463 if test x$enable_symvers != xno ; then
2464   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2465          [Define to use symbol versioning in the shared library.])
2466 fi
2467
2468 AC_SUBST(SYMVER_FILE)
2469 AC_SUBST(port_specific_symbol_files)
2470 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2471 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2472 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2473 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2474 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2475
2476 # Now, set up compatibility support, if any.
2477 # In addition, need this to deal with std::size_t mangling in
2478 # src/compatibility.cc.  In a perfect world, could use
2479 # typeid(std::size_t).name()[0] to do direct substitution.
2480 AC_MSG_CHECKING([for size_t as unsigned int])
2481 ac_save_CFLAGS="$CFLAGS"
2482 CFLAGS="-Werror"
2483 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2484                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2485 CFLAGS=$ac_save_CFLAGS
2486 if test "$glibcxx_size_t_is_i" = yes; then
2487   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2488 fi
2489 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2490
2491 AC_MSG_CHECKING([for ptrdiff_t as int])
2492 ac_save_CFLAGS="$CFLAGS"
2493 CFLAGS="-Werror"
2494 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2495                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2496 CFLAGS=$ac_save_CFLAGS
2497 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2498   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2499 fi
2500 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2501 ])
2502
2503
2504 dnl
2505 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2506 dnl We must stage the required headers so that they will be installed
2507 dnl with the library (unlike libgcc, the STL implementation is provided
2508 dnl solely within headers).  Since we must not inject random user-space
2509 dnl macro names into user-provided C++ code, we first stage into <file>-in
2510 dnl and process to <file> with an output command.  The reason for a two-
2511 dnl stage process here is to correctly handle $srcdir!=$objdir without
2512 dnl having to write complex code (the sed commands to clean the macro
2513 dnl namespace are complex and fragile enough as it is).  We must also
2514 dnl add a relative path so that -I- is supported properly.
2515 dnl
2516 dnl Substs:
2517 dnl  glibcxx_thread_h
2518 dnl
2519 dnl Defines:
2520 dnl  HAVE_GTHR_DEFAULT
2521 dnl
2522 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2523   AC_MSG_CHECKING([for thread model used by GCC])
2524   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2525   AC_MSG_RESULT([$target_thread_file])
2526
2527   if test $target_thread_file != single; then
2528     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2529               [Define if gthr-default.h exists
2530               (meaning that threading support is enabled).])
2531   fi
2532
2533   glibcxx_thread_h=gthr-$target_thread_file.h
2534
2535   dnl Check for __GTHREADS define.
2536   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2537   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2538     enable_thread=yes
2539   else
2540    enable_thread=no
2541   fi
2542
2543   AC_SUBST(glibcxx_thread_h)
2544 ])
2545
2546
2547 # Check whether LC_MESSAGES is available in <locale.h>.
2548 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2549 #
2550 # This file file be copied and used freely without restrictions.  It can
2551 # be used in projects which are not available under the GNU Public License
2552 # but which still want to provide support for the GNU gettext functionality.
2553 # Please note that the actual code is *not* freely available.
2554 AC_DEFUN([AC_LC_MESSAGES], [
2555   AC_CHECK_HEADER(locale.h, [
2556     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2557       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2558        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2559     if test $ac_cv_val_LC_MESSAGES = yes; then
2560       AC_DEFINE(HAVE_LC_MESSAGES, 1,
2561                 [Define if LC_MESSAGES is available in <locale.h>.])
2562     fi
2563   ])
2564 ])
2565
2566 # Macros from the top-level gcc directory.
2567 m4_include([../config/tls.m4])
2568