Subversion Repositories scarts

dnl

dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)

dnl

dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the

dnl end of configure.  This lets tested variables be reassigned, and the

dnl conditional will depend on the final state of the variable.  For a simple

dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.

dnl

m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl

AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl

  m4_divert_text([glibcxx_diversion],dnl

   AM_CONDITIONAL([$1],[$2])

  )dnl

])dnl

AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl

dnl

dnl Check to see what architecture and operating system we are compiling

dnl for.  Also, if architecture- or OS-specific flags are required for

dnl compilation, pick them up here.

dnl

AC_DEFUN([GLIBCXX_CHECK_HOST], [

  . $glibcxx_srcdir/configure.host

  AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])

  AC_MSG_NOTICE([OS config directory is $os_include_dir])

])

dnl

dnl Initialize the rest of the library configury.  At this point we have

dnl variables like $host.

dnl

dnl Sets:

dnl  SUBDIRS

dnl Substs:

dnl  glibcxx_builddir     (absolute path)

dnl  glibcxx_srcdir       (absolute path)

dnl  toplevel_srcdir      (absolute path)

dnl  with_cross_host

dnl  with_newlib

dnl  with_target_subdir

dnl plus

dnl  - the variables in GLIBCXX_CHECK_HOST / configure.host

dnl  - default settings for all AM_CONFITIONAL test variables

dnl  - lots of tools, like CC and CXX

dnl

AC_DEFUN([GLIBCXX_CONFIGURE], [

  # Keep these sync'd with the list in Makefile.am.  The first provides an

  # expandable list at autoconf time; the second provides an expandable list

  # (i.e., shell variable) at configure time.

  m4_define([glibcxx_SUBDIRS],[include libmath libsupc++ src po testsuite])

  SUBDIRS='glibcxx_SUBDIRS'

  # These need to be absolute paths, yet at the same time need to

  # canonicalize only relative paths, because then amd will not unmount

  # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.

  glibcxx_builddir=`${PWDCMD-pwd}`

  case $srcdir in

    [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;

    *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;

  esac

  toplevel_srcdir=${glibcxx_srcdir}/..

  AC_SUBST(glibcxx_builddir)

  AC_SUBST(glibcxx_srcdir)

  AC_SUBST(toplevel_srcdir)

  # We use these options to decide which functions to include.  They are

  # set from the top level.

  AC_ARG_WITH([target-subdir],

    AC_HELP_STRING([--with-target-subdir=SUBDIR],

                   [configuring in a subdirectory]))

  AC_ARG_WITH([cross-host],

    AC_HELP_STRING([--with-cross-host=HOST],

                   [configuring with a cross compiler]))

  AC_ARG_WITH([newlib],

    AC_HELP_STRING([--with-newlib],

                   [assume newlib as a system C library]))

  # We're almost certainly being configured before anything else which uses

  # C++, so all of our AC_PROG_* discoveries will be cached.  It's vital that

  # we not cache the value of CXX that we "discover" here, because it's set

  # to something unique for us and libjava.  Other target libraries need to

  # find CXX for themselves.  We yank the rug out from under the normal AC_*

  # process by sneakily renaming the cache variable.  This also lets us debug

  # the value of "our" CXX in postmortems.

  #

  # We must also force CXX to /not/ be a precious variable, otherwise the

  # wrong (non-multilib-adjusted) value will be used in multilibs.  This

  # little trick also affects CPPFLAGS, CXXFLAGS, and LDFLAGS.  And as a side

  # effect, CXXFLAGS is no longer automagically subst'd, so we have to do

  # that ourselves.  Un-preciousing AC_PROG_CC also affects CC and CFLAGS.

  #

  # -fno-builtin must be present here so that a non-conflicting form of

  # std::exit can be guessed by AC_PROG_CXX, and used in later tests.

  m4_define([ac_cv_prog_CXX],[glibcxx_cv_prog_CXX])

  m4_rename([_AC_ARG_VAR_PRECIOUS],[glibcxx_PRECIOUS])

  m4_define([_AC_ARG_VAR_PRECIOUS],[])

  save_CXXFLAGS="$CXXFLAGS"

  CXXFLAGS="$CXXFLAGS -fno-builtin"

  AC_PROG_CC

  AC_PROG_CXX

  CXXFLAGS="$save_CXXFLAGS"

  m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])

  AC_SUBST(CFLAGS)

  AC_SUBST(CXXFLAGS)

  # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't

  # available).  Uncomment the next line to force a particular method.

  AC_PROG_LN_S

  #LN_S='cp -p'

  AC_CHECK_TOOL(AS, as)

  AC_CHECK_TOOL(AR, ar)

  AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)

  AM_MAINTAINER_MODE

  # Set up safe default values for all subsequent AM_CONDITIONAL tests

  # which are themselves conditionally expanded.

  ## (Right now, this only matters for enable_wchar_t, but nothing prevents

  ## other macros from doing the same.  This should be automated.)  -pme

  need_libmath=no

  # Find platform-specific directories containing configuration info.

  # Also possibly modify flags used elsewhere, as needed by the platform.

  GLIBCXX_CHECK_HOST

])

dnl

dnl Tests for newer compiler features, or features that are present in newer

dnl compiler versions but not older compiler versions still in use, should

dnl be placed here.

dnl

dnl Defines:

dnl  WERROR='-Werror' if requested and possible; g++'s that lack the

dnl   new inlining code or the new system_header pragma will die on -Werror.

dnl   Leave it out by default and use maint-mode to use it.

dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if

dnl   compiler supports it and the user has not requested debug mode.

dnl

AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [

  # All these tests are for C++; save the language and the compiler flags.

  # The CXXFLAGS thing is suspicious, but based on similar bits previously

  # found in GLIBCXX_CONFIGURE.

  AC_LANG_SAVE

  AC_LANG_CPLUSPLUS

  ac_test_CXXFLAGS="${CXXFLAGS+set}"

  ac_save_CXXFLAGS="$CXXFLAGS"

  # Check for maintainer-mode bits.

  if test x"$USE_MAINTAINER_MODE" = xno; then

    WERROR=''

  else

    WERROR='-Werror'

  fi

  # Check for -ffunction-sections -fdata-sections

  AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])

  CXXFLAGS='-Werror -ffunction-sections -fdata-sections'

  AC_TRY_COMPILE(, [int foo;], [ac_fdsections=yes], [ac_fdsections=no])

  if test "$ac_test_CXXFLAGS" = set; then

    CXXFLAGS="$ac_save_CXXFLAGS"

  else

    # this is the suspicious part

    CXXFLAGS=''

  fi

  if test x"$ac_fdsections" = x"yes"; then

    SECTION_FLAGS='-ffunction-sections -fdata-sections'

  fi

  AC_MSG_RESULT($ac_fdsections)

  AC_LANG_RESTORE

  AC_SUBST(WERROR)

  AC_SUBST(SECTION_FLAGS)

])

dnl

dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If

dnl the native linker is in use, all variables will be defined to something

dnl safe (like an empty string).

dnl

dnl Defines:

dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible

dnl  OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible

dnl  LD (as a side effect of testing)

dnl Sets:

dnl  with_gnu_ld

dnl  glibcxx_gnu_ld_version (possibly)

dnl

dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will

dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.

dnl

AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [

  # If we're not using GNU ld, then there's no point in even trying these

  # tests.  Check for that first.  We should have already tested for gld

  # by now (in libtool), but require it now just to be safe...

  test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''

  test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''

  AC_REQUIRE([AC_PROG_LD])

  AC_REQUIRE([AC_PROG_AWK])

  # The name set by libtool depends on the version of libtool.  Shame on us

  # for depending on an impl detail, but c'est la vie.  Older versions used

  # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on

  # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually

  # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't

  # set (hence we're using an older libtool), then set it.

  if test x${with_gnu_ld+set} != xset; then

    if test x${ac_cv_prog_gnu_ld+set} != xset; then

      # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?

      with_gnu_ld=no

    else

      with_gnu_ld=$ac_cv_prog_gnu_ld

    fi

  fi

  # Start by getting the version number.  I think the libtool test already

  # does some of this, but throws away the result.

  changequote(,)

  ldver=`$LD --version 2>/dev/null | head -1 | \

         sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`

  changequote([,])

  glibcxx_gnu_ld_version=`echo $ldver | \

         $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`

  # Set --gc-sections.

  if test "$with_gnu_ld" = "notbroken"; then

    # GNU ld it is!  Joy and bunny rabbits!

    # All these tests are for C++; save the language and the compiler flags.

    # Need to do this so that g++ won't try to link in libstdc++

    ac_test_CFLAGS="${CFLAGS+set}"

    ac_save_CFLAGS="$CFLAGS"

    CFLAGS='-x c++  -Wl,--gc-sections'

    # Check for -Wl,--gc-sections

    # XXX This test is broken at the moment, as symbols required for linking

    # are now in libsupc++ (not built yet).  In addition, this test has

    # cored on solaris in the past.  In addition, --gc-sections doesn't

    # really work at the moment (keeps on discarding used sections, first

    # .eh_frame and now some of the glibc sections for iconv).

    # Bzzzzt.  Thanks for playing, maybe next time.

    AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])

    AC_TRY_RUN([

     int main(void)

     {

       try { throw 1; }

       catch (...) { };

       return 0;

     }

    ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])

    if test "$ac_test_CFLAGS" = set; then

      CFLAGS="$ac_save_CFLAGS"

    else

      # this is the suspicious part

      CFLAGS=''

    fi

    if test "$ac_sectionLDflags" = "yes"; then

      SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"

    fi

    AC_MSG_RESULT($ac_sectionLDflags)

  fi

  # Set -z,relro.

  # Note this is only for shared objects

  ac_ld_relro=no

  if test x"$with_gnu_ld" = x"yes"; then

    AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])

    cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`

    if test -n "$cxx_z_relo"; then

      OPT_LDFLAGS="-Wl,-z,relro"

      ac_ld_relro=yes

    fi

    AC_MSG_RESULT($ac_ld_relro)

  fi

  # Set linker optimization flags.

  if test x"$with_gnu_ld" = x"yes"; then

    OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"

  fi

  AC_SUBST(SECTION_LDFLAGS)

  AC_SUBST(OPT_LDFLAGS)

])

dnl

dnl Check to see if this target can enable the iconv specializations.

dnl If --disable-c-mbchar was given, no wchar_t specialization is enabled.

dnl (This must have been previously checked, along with the rest of C99

dnl support.) By default, iconv support is disabled.

dnl

dnl Defines:

dnl  _GLIBCXX_USE_ICONV if all the bits are found.

dnl Substs:

dnl  LIBICONV to a -l string containing the iconv library, if needed.

dnl

AC_DEFUN([GLIBCXX_CHECK_ICONV_SUPPORT], [

  enable_iconv=no

  # Only continue checking if the ISO C99 headers exist and support is on.

  if test x"$enable_wchar_t" = xyes; then

    # Use iconv for wchar_t to char conversions. As such, check for

    # X/Open Portability Guide, version 2 features (XPG2).

    AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)

    AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)

    # Check for existence of libiconv.a providing XPG2 wchar_t support.

    AC_CHECK_LIB(iconv, iconv, LIBICONV="-liconv")

    ac_save_LIBS="$LIBS"

    LIBS="$LIBS $LIBICONV"

    AC_SUBST(LIBICONV)

    AC_CHECK_FUNCS([iconv_open iconv_close iconv nl_langinfo],

    [ac_XPG2funcs=yes], [ac_XPG2funcs=no])

    LIBS="$ac_save_LIBS"

    if test x"$ac_has_iconv_h" = xyes &&

       test x"$ac_has_langinfo_h" = xyes &&

       test x"$ac_XPG2funcs" = xyes;

    then

      AC_DEFINE([_GLIBCXX_USE_ICONV],1,

                [Define if iconv and related functions exist and are usable.])

      enable_iconv=yes

    fi

  fi

  AC_MSG_CHECKING([for enabled iconv specializations])

  AC_MSG_RESULT($enable_iconv)

])

dnl

dnl Check for headers for, and arguments to, the setrlimit() function.

dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.

dnl

dnl Defines:

dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits

dnl  various HAVE_LIMIT_* for individual limit names

dnl

AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [

  AC_MSG_CHECKING([for RLIMIT_$1])

  AC_TRY_COMPILE(

    [#include <unistd.h>

     #include <sys/time.h>

     #include <sys/resource.h>

    ],

    [ int f = RLIMIT_$1 ; ],

    [glibcxx_mresult=1], [glibcxx_mresult=0])

  AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,

                     [Only used in build directory testsuite_hooks.h.])

  if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi

  AC_MSG_RESULT($res)

])

AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [

  setrlimit_have_headers=yes

  AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,

                   [],

                   [setrlimit_have_headers=no])

  # If don't have the headers, then we can't run the tests now, and we

  # won't be seeing any of these during testsuite compilation.

  if test $setrlimit_have_headers = yes; then

    # Can't do these in a loop, else the resulting syntax is wrong.

    GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)

    GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)

    GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)

    GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)

    GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)

    # Check for rlimit, setrlimit.

    AC_CACHE_VAL(ac_setrlimit, [

      AC_TRY_COMPILE(

        [#include <unistd.h>

         #include <sys/time.h>

         #include <sys/resource.h>

        ],

        [struct rlimit r;

         setrlimit(0, &r);],

        [ac_setrlimit=yes], [ac_setrlimit=no])

    ])

  fi

  AC_MSG_CHECKING([for testsuite resource limits support])

  if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then

    ac_res_limits=yes

    AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,

              [Define if using setrlimit to set resource limits during

              "make check"])

  else

    ac_res_limits=no

  fi

  AC_MSG_RESULT($ac_res_limits)

])

dnl

dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.

dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.

dnl

AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [

  AC_MSG_CHECKING([for S_ISREG or S_IFREG])

  AC_CACHE_VAL(glibcxx_cv_S_ISREG, [

    AC_TRY_LINK(

      [#include <sys/stat.h>],

      [struct stat buffer;

       fstat(0, &buffer);

       S_ISREG(buffer.st_mode);],

      [glibcxx_cv_S_ISREG=yes],

      [glibcxx_cv_S_ISREG=no])

  ])

  AC_CACHE_VAL(glibcxx_cv_S_IFREG, [

    AC_TRY_LINK(

      [#include <sys/stat.h>],

      [struct stat buffer;

       fstat(0, &buffer);

       S_IFREG & buffer.st_mode;],

      [glibcxx_cv_S_IFREG=yes],

      [glibcxx_cv_S_IFREG=no])

  ])

  res=no

  if test $glibcxx_cv_S_ISREG = yes; then

    AC_DEFINE(HAVE_S_ISREG, 1,

              [Define if S_IFREG is available in <sys/stat.h>.])

    res=S_ISREG

  elif test $glibcxx_cv_S_IFREG = yes; then

    AC_DEFINE(HAVE_S_IFREG, 1,

              [Define if S_IFREG is available in <sys/stat.h>.])

    res=S_IFREG

  fi

  AC_MSG_RESULT($res)

])

dnl

dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.

dnl

AC_DEFUN([GLIBCXX_CHECK_POLL], [

  AC_MSG_CHECKING([for poll])

  AC_CACHE_VAL(glibcxx_cv_POLL, [

    AC_TRY_LINK(

      [#include <poll.h>],

      [struct pollfd pfd[1];

       pfd[0].events = POLLIN;

       poll(pfd, 1, 0);],

      [glibcxx_cv_POLL=yes],

      [glibcxx_cv_POLL=no])

  ])

  if test $glibcxx_cv_POLL = yes; then

    AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])

  fi

  AC_MSG_RESULT($glibcxx_cv_POLL)

])

dnl

dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.

dnl

AC_DEFUN([GLIBCXX_CHECK_WRITEV], [

  AC_MSG_CHECKING([for writev])

  AC_CACHE_VAL(glibcxx_cv_WRITEV, [

    AC_TRY_LINK(

      [#include <sys/uio.h>],

      [struct iovec iov[2];

       writev(0, iov, 0);],

      [glibcxx_cv_WRITEV=yes],

      [glibcxx_cv_WRITEV=no])

  ])

  if test $glibcxx_cv_WRITEV = yes; then

    AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])

  fi

  AC_MSG_RESULT($glibcxx_cv_WRITEV)

])

dnl

dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.

dnl

AC_DEFUN([GLIBCXX_CHECK_INT64_T], [

  AC_MSG_CHECKING([for int64_t])

  AC_CACHE_VAL(glibcxx_cv_INT64_T, [

    AC_TRY_COMPILE(

      [#include <stdint.h>],

      [int64_t var;],

      [glibcxx_cv_INT64_T=yes],

      [glibcxx_cv_INT64_T=no])

  ])

  if test $glibcxx_cv_INT64_T = yes; then

    AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])

  fi

  AC_MSG_RESULT($glibcxx_cv_INT64_T)

])

dnl

dnl Check whether LFS support is available.

dnl

AC_DEFUN([GLIBCXX_CHECK_LFS], [

  AC_LANG_SAVE

  AC_LANG_CPLUSPLUS

  ac_save_CXXFLAGS="$CXXFLAGS"

  CXXFLAGS="$CXXFLAGS -fno-exceptions"

  AC_MSG_CHECKING([for LFS support])

  AC_CACHE_VAL(glibcxx_cv_LFS, [

    AC_TRY_LINK(

      [#include <unistd.h>

       #include <stdio.h>

       #include <sys/stat.h>

      ],

      [FILE* fp;

       fopen64("t", "w");

       fseeko64(fp, 0, SEEK_CUR);

       ftello64(fp);

       lseek64(1, 0, SEEK_CUR);

       struct stat64 buf;

       fstat64(1, &buf);],

      [glibcxx_cv_LFS=yes],

      [glibcxx_cv_LFS=no])

  ])

  if test $glibcxx_cv_LFS = yes; then

    AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])

  fi

  AC_MSG_RESULT($glibcxx_cv_LFS)

  CXXFLAGS="$ac_save_CXXFLAGS"

  AC_LANG_RESTORE

])

dnl

dnl Check for whether a fully dynamic basic_string implementation should

dnl be turned on, that does not put empty objects in per-process static

dnl memory (mostly useful together with shared memory allocators, see PR

dnl libstdc++/16612 for details).

dnl

dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING

dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined

dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]

dnl       Where DEFAULT is either `yes' or `no'.

dnl

AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [

  GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])

  if test $enable_fully_dynamic_string = yes; then

    AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,

              [Define if a fully dynamic basic_string is wanted.])

  fi

])

dnl

dnl Does any necessary configuration of the testsuite directory.  Generates

dnl the testsuite_hooks.h header.

dnl

dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.

dnl

dnl Sets:

dnl  enable_abi_check

dnl  GLIBCXX_TEST_WCHAR_T

dnl  GLIBCXX_TEST_THREAD

dnl Substs:

dnl  baseline_dir

dnl

AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [

  if $GLIBCXX_IS_NATIVE ; then

    # Do checks for resource limit functions.

    GLIBCXX_CHECK_SETRLIMIT

    # Look for setenv, so that extended locale tests can be performed.

    GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)

  fi

  if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&

     test $enable_symvers != no; then

    case "$host" in

      *-*-cygwin*)

        enable_abi_check=no ;;

      *)

        enable_abi_check=yes ;;

    esac

  else

    # Only build this as native, since automake does not understand

    # CXX_FOR_BUILD.

    enable_abi_check=no

  fi

  # Export file names for ABI checking.

  baseline_dir="$glibcxx_srcdir/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"

  AC_SUBST(baseline_dir)

])

dnl

dnl Set up *_INCLUDES variables for all sundry Makefile.am's.

dnl

dnl Substs:

dnl  GLIBCXX_INCLUDES

dnl  TOPLEVEL_INCLUDES

dnl

AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [

  # Used for every C++ compile we perform.

  GLIBCXX_INCLUDES="\

-I$glibcxx_builddir/include/$host_alias \

-I$glibcxx_builddir/include \

-I$glibcxx_srcdir/libsupc++"

  # For Canadian crosses, pick this up too.

  if test $CANADIAN = yes; then

    GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"

  fi

  # Stuff in the actual top level.  Currently only used by libsupc++ to

  # get unwind* headers from the gcc dir.

  #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'

  TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'

  # Now, export this to all the little Makefiles....

  AC_SUBST(GLIBCXX_INCLUDES)

  AC_SUBST(TOPLEVEL_INCLUDES)

])

dnl

dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.

dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)

dnl

dnl Substs:

dnl  OPTIMIZE_CXXFLAGS

dnl  WARN_FLAGS

dnl

AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [

  # Optimization flags that are probably a good idea for thrill-seekers. Just

  # uncomment the lines below and make, everything else is ready to go...

  # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc

  OPTIMIZE_CXXFLAGS=

  AC_SUBST(OPTIMIZE_CXXFLAGS)

  WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'

  AC_SUBST(WARN_FLAGS)

])

dnl

dnl All installation directory information is determined here.

dnl

dnl Substs:

dnl  gxx_install_dir

dnl  glibcxx_prefixdir

dnl  glibcxx_toolexecdir

dnl  glibcxx_toolexeclibdir

dnl

dnl Assumes cross_compiling bits already done, and with_cross_host in

dnl particular.

dnl

AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [

  glibcxx_toolexecdir=no

  glibcxx_toolexeclibdir=no

  glibcxx_prefixdir=$prefix

  AC_MSG_CHECKING([for gxx-include-dir])

  AC_ARG_WITH([gxx-include-dir],

    AC_HELP_STRING([--with-gxx-include-dir=DIR],

                   [installation directory for include files]),

    [case "$withval" in

      yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;

      no)  gxx_include_dir=no ;;

      *)   gxx_include_dir=$withval ;;

     esac],

    [gxx_include_dir=no])

  AC_MSG_RESULT($gxx_include_dir)

  AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])

  AC_ARG_ENABLE([version-specific-runtime-libs],

    AC_HELP_STRING([--enable-version-specific-runtime-libs],

                   [Specify that runtime libraries should be installed in a compiler-specific directory]),

    [case "$enableval" in

      yes) version_specific_libs=yes ;;

      no)  version_specific_libs=no ;;

      *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;

     esac],

    [version_specific_libs=no])

  AC_MSG_RESULT($version_specific_libs)

  # Default case for install directory for include files.

  if test $version_specific_libs = no && test $gxx_include_dir = no; then

    gxx_include_dir='${prefix}/include/c++/${gcc_version}'

  fi

  # Version-specific runtime libs processing.

  if test $version_specific_libs = yes; then

    # Need the gcc compiler version to know where to install libraries

    # and header files if --enable-version-specific-runtime-libs option

    # is selected.  FIXME: these variables are misnamed, there are

    # no executables installed in _toolexecdir or _toolexeclibdir.

    if test x"$gxx_include_dir" = x"no"; then

      gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'

    fi

    glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'

    glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'

  fi

  # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir

  # Install a library built with a cross compiler in tooldir, not libdir.

  if test x"$glibcxx_toolexecdir" = x"no"; then

    if test -n "$with_cross_host" &&

       test x"$with_cross_host" != x"no"; then

      glibcxx_toolexecdir='${exec_prefix}/${host_alias}'

      glibcxx_toolexeclibdir='${toolexecdir}/lib'

    else

      glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'

      glibcxx_toolexeclibdir='${libdir}'

    fi

    multi_os_directory=`$CXX -print-multi-os-directory`

    case $multi_os_directory in

      .) ;; # Avoid trailing /.

      *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;

    esac

  fi

  AC_MSG_CHECKING([for install location])

  AC_MSG_RESULT($gxx_include_dir)

  AC_SUBST(glibcxx_prefixdir)

  AC_SUBST(gxx_include_dir)

  AC_SUBST(glibcxx_toolexecdir)

  AC_SUBST(glibcxx_toolexeclibdir)

])

dnl

dnl GLIBCXX_ENABLE

dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)

dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)

dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)

dnl

dnl See docs/html/17_intro/configury.html#enable for documentation.

dnl

m4_define([GLIBCXX_ENABLE],[dnl

m4_define([_g_switch],[--enable-$1])dnl

m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl

 AC_ARG_ENABLE($1,_g_help,

  m4_bmatch([$5],

   [^permit ],

     [[

      case "$enableval" in

       m4_bpatsubst([$5],[permit ])) ;;

       *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;

          dnl Idea for future:  generate a URL pointing to

          dnl "onlinedocs/configopts.html#whatever"

      esac

     ]],

   [^$],

     [[

      case "$enableval" in

       yes|no) ;;

       *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;

      esac

     ]],

   [[$5]]),

  [enable_]m4_bpatsubst([$1],-,_)[=][$2])

m4_undefine([_g_switch])dnl

m4_undefine([_g_help])dnl

])

dnl

dnl Check for ISO/IEC 9899:1999 "C99" support.

dnl

dnl --enable-c99 defines _GLIBCXX_USE_C99

dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined

dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]

dnl       Where DEFAULT is either `yes' or `no'.

dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.

dnl

AC_DEFUN([GLIBCXX_ENABLE_C99], [

  GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])

  if test x"$enable_c99" = x"yes"; then

  AC_LANG_SAVE

  AC_LANG_CPLUSPLUS

  # Check for the existence of <math.h> functions used if C99 is enabled.

  AC_MSG_CHECKING([for ISO C99 support in <math.h>])

  AC_CACHE_VAL(ac_c99_math, [

  AC_TRY_COMPILE([#include <math.h>],

                 [fpclassify(0.0);

                  isfinite(0.0);

                  isinf(0.0);

                  isnan(0.0);

                  isnormal(0.0);

                  signbit(0.0);

                  isgreater(0.0,0.0);

                  isgreaterequal(0.0,0.0);

                  isless(0.0,0.0);

                  islessequal(0.0,0.0);

                  islessgreater(0.0,0.0);

                  islessgreater(0.0,0.0);

                  isunordered(0.0,0.0);

                 ],[ac_c99_math=yes], [ac_c99_math=no])

  ])

  AC_MSG_RESULT($ac_c99_math)

  if test x"$ac_c99_math" = x"yes"; then

    AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,

              [Define if C99 functions or macros in <math.h> should be imported

              in <cmath> in namespace std.])

  fi

  # Check for the existence of <complex.h> complex math functions.

  # This is necessary even though libstdc++ uses the builtin versions

  # of these functions, because if the builtin cannot be used, a reference

  # to the library function is emitted.

  AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)

  ac_c99_complex=no;

  if test x"$ac_has_complex_h" = x"yes"; then

    AC_MSG_CHECKING([for ISO C99 support in <complex.h>])

    AC_TRY_COMPILE([#include <complex.h>],

                   [typedef __complex__ float float_type; float_type tmpf;

                    cabsf(tmpf);

                    cargf(tmpf);

                    ccosf(tmpf);

                    ccoshf(tmpf);

                    cexpf(tmpf);

                    clogf(tmpf);

                    csinf(tmpf);

                    csinhf(tmpf);

                    csqrtf(tmpf);

                    ctanf(tmpf);

                    ctanhf(tmpf);

                    cpowf(tmpf, tmpf);

                    typedef __complex__ double double_type; double_type tmpd;

                    cabs(tmpd);

                    carg(tmpd);

                    ccos(tmpd);

                    ccosh(tmpd);

                    cexp(tmpd);

                    clog(tmpd);

                    csin(tmpd);

                    csinh(tmpd);

                    csqrt(tmpd);

                    ctan(tmpd);

                    ctanh(tmpd);

                    cpow(tmpd, tmpd);

                    typedef __complex__ long double ld_type; ld_type tmpld;

                    cabsl(tmpld);

                    cargl(tmpld);

                    ccosl(tmpld);

                    ccoshl(tmpld);

                    cexpl(tmpld);

                    clogl(tmpld);

                    csinl(tmpld);

                    csinhl(tmpld);

                    csqrtl(tmpld);

                    ctanl(tmpld);

                    ctanhl(tmpld);

                    cpowl(tmpld, tmpld);

                   ],[ac_c99_complex=yes], [ac_c99_complex=no])

  fi

  AC_MSG_RESULT($ac_c99_complex)

  if test x"$ac_c99_complex" = x"yes"; then

    AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,

              [Define if C99 functions in <complex.h> should be used in

              <complex>. Using compiler builtins for these functions requires

              corresponding C99 library functions to be present.])

  fi

  # Check for the existence in <stdio.h> of vscanf, et. al.

  AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])

  AC_CACHE_VAL(ac_c99_stdio, [

  AC_TRY_COMPILE([#include <stdio.h>

                  #include <stdarg.h>

                  void foo(char* fmt, ...)

                  {

                    va_list args; va_start(args, fmt);

                    vfscanf(stderr, "%i", args);

                    vscanf("%i", args);

                    vsnprintf(fmt, 0, "%i", args);

                    vsscanf(fmt, "%i", args);

                  }],

                 [snprintf("12", 0, "%i");],

                 [ac_c99_stdio=yes], [ac_c99_stdio=no])

  ])

  AC_MSG_RESULT($ac_c99_stdio)

  # Check for the existence in <stdlib.h> of lldiv_t, et. al.

  AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])

  AC_CACHE_VAL(ac_c99_stdlib, [

  AC_TRY_COMPILE([#include <stdlib.h>],

                 [char* tmp;

                  strtof("gnu", &tmp);

                  strtold("gnu", &tmp);

                  strtoll("gnu", &tmp, 10);

                  strtoull("gnu", &tmp, 10);

                  llabs(10);

                  lldiv(10,1);

                  atoll("10");

                  _Exit(0);

                  lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])

  ])

  AC_MSG_RESULT($ac_c99_stdlib)

  # Check for the existence in <wchar.h> of wcstold, etc.

  ac_c99_wchar=no;

  if test x"$ac_has_wchar_h" = xyes &&

     test x"$ac_has_wctype_h" = xyes; then

    AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])

    AC_TRY_COMPILE([#include <wchar.h>

                    namespace test

                    {

                      using ::wcstold;

                      using ::wcstoll;

                      using ::wcstoull;

                    }

                   ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])

    # Checks for wide character functions that may not be present.

    # Injection of these is wrapped with guard macros.

    # NB: only put functions here, instead of immediately above, if

    # absolutely necessary.

    AC_TRY_COMPILE([#include <wchar.h>

                    namespace test { using ::vfwscanf; } ], [],

                   [AC_DEFINE(HAVE_VFWSCANF,1,

                        [Defined if vfwscanf exists.])],[])

    AC_TRY_COMPILE([#include <wchar.h>

                    namespace test { using ::vswscanf; } ], [],

                   [AC_DEFINE(HAVE_VSWSCANF,1,

                        [Defined if vswscanf exists.])],[])

    AC_TRY_COMPILE([#include <wchar.h>

                    namespace test { using ::vwscanf; } ], [],

                   [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])

    AC_TRY_COMPILE([#include <wchar.h>

                    namespace test { using ::wcstof; } ], [],