GCC 4.2.0 release C++ standard library and runtime support code.

1 files changed, 981 insertions, 377 deletions

diff --git a/contrib/libstdc++/acinclude.m4 b/contrib/libstdc++/acinclude.m4
index cf541ed..214ce30 100644
--- a/contrib/libstdc++/acinclude.m4
+++ b/contrib/libstdc++/acinclude.m4
@@ -27,44 +27,11 @@ AC_DEFUN([GLIBCXX_CHECK_HOST], [
   AC_MSG_NOTICE([OS config directory is $os_include_dir])
 ])
 
-
-dnl
-dnl Initialize basic configure bits.
-dnl
-dnl Substs:
-dnl  multi_basedir
-dnl
-AC_DEFUN([GLIBCXX_TOPREL_CONFIGURE], [
-  # Sets up multi_basedir, which is srcdir/.. plus the usual
-  # "multi_source_toprel_bottom_adjust" lunacy as needed.
-  AM_ENABLE_MULTILIB(, ..)
-
-  # The generated code is exactly the same, except that automake's looks in
-  # ".. $srcdir/.." and autoconf's looks in multi_basedir.  Apparently other
-  # things are triggered on the presence of the two ...AUX_DIR[S], but I don't
-  # know what they are or what the other differences might be (and they keep
-  # changing anyhow).
-  #
-  # Looking in multi_basedir seems smarter, so actually execute that branch.
-  if false; then
-    # this is for automake
-    AC_CONFIG_AUX_DIR(..)
-  else
-    # this is for autoconf
-    AC_CONFIG_AUX_DIRS(${multi_basedir})
-  fi
-
-  dnl XXX Turn this on.
-  dnl AC_LANG_CPLUSPLUS
-])
-
-
 dnl
 dnl Initialize the rest of the library configury.  At this point we have
 dnl variables like $host.
 dnl
 dnl Sets:
-dnl  gcc_version          (x.y.z format)
 dnl  SUBDIRS
 dnl Substs:
 dnl  glibcxx_builddir     (absolute path)
@@ -141,11 +108,6 @@ AC_DEFUN([GLIBCXX_CONFIGURE], [
   AC_SUBST(CFLAGS)
   AC_SUBST(CXXFLAGS)
 
-  # For directory versioning (e.g., headers) and other variables.
-  AC_MSG_CHECKING([for GCC version number])
-  gcc_version=`$CXX -dumpversion`
-  AC_MSG_RESULT($gcc_version)
-
   # 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
@@ -162,14 +124,15 @@ AC_DEFUN([GLIBCXX_CONFIGURE], [
   ## (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
-  enable_wchar_t=no
-  #enable_libstdcxx_debug=no
-  #enable_libstdcxx_pch=no
-  #enable_cheaders=c
-  #c_compatibility=no
-  #enable_abi_check=no
-  #enable_symvers=no
-  #enable_hosted_libstdcxx=yes
+
+  # Check for uClibc since Linux platforms use different configuration
+  # directories depending on the C library in use.
+  AC_EGREP_CPP([_using_uclibc], [
+  #include <stdio.h>
+  #if __UCLIBC__
+    _using_uclibc
+  #endif
+  ], uclibc=yes, uclibc=no)
 
   # Find platform-specific directories containing configuration info.
   # Also possibly modify flags used elsewhere, as needed by the platform.
@@ -177,10 +140,6 @@ AC_DEFUN([GLIBCXX_CONFIGURE], [
 ])
 
 
-m4_include([linkage.m4])
-m4_include([../config/no-executables.m4])
-
-
 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
@@ -237,7 +196,7 @@ dnl safe (like an empty string).
 dnl
 dnl Defines:
 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
-dnl  OPT_LDFLAGS='-Wl,-O1' 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
@@ -272,49 +231,72 @@ AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
 
   # 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 }'`
+  if test x"$with_gnu_ld" = x"yes"; then
+    AC_MSG_CHECKING([for ld version])
+    changequote(,)
+    ldver=`$LD --version 2>/dev/null | head -1 | \
+           sed -e 's/GNU ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\3/'`
+    changequote([,])
+    glibcxx_gnu_ld_version=`echo $ldver | \
+           $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
+    AC_MSG_RESULT($glibcxx_gnu_ld_version)
+  fi
 
   # Set --gc-sections.
-  if test "$with_gnu_ld" = "notbroken"; then
-    # GNU ld it is!  Joy and bunny rabbits!
+  glibcxx_gcsections_min_ld=21602
+  if test x"$with_gnu_ld" = x"yes" && 
+	test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
 
-    # 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++
+    # Sufficiently young GNU ld it is!  Joy and bunny rabbits!
+    # NB: This flag only works reliably after 2.16.1. Configure tests
+    # for this are difficult, so hard wire a value that should work.
+
+    # All these tests are for C++, but run with the "C" compiler driver.
+    # Need to do this so that g++ won't try to link in libstdc++/libsupc++.
     ac_test_CFLAGS="${CFLAGS+set}"
     ac_save_CFLAGS="$CFLAGS"
-    CFLAGS='-x c++  -Wl,--gc-sections'
+    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])
+    AC_TRY_LINK([ int one(void) { return 1; }
+     int two(void) { return 2; }
+	], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
+    if test "$ac_gcsections" = "yes"; then
+      rm -f conftest.c
+      touch conftest.c
+      if $CC -c conftest.c; then
+	if $LD --gc-sections -o conftest conftest.o 2>&1 | \
+	   grep "Warning: gc-sections option ignored" > /dev/null; then
+	  ac_gcsections=no
+	fi
+      fi
+      rm -f conftest.c conftest.o conftest
+    fi
+    if test "$ac_gcsections" = "yes"; then
+      SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
+    fi
+    AC_MSG_RESULT($ac_gcsections)
+
     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
+
+  # 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_sectionLDflags)
+    AC_MSG_RESULT($ac_ld_relro)
   fi
 
   # Set linker optimization flags.
@@ -328,83 +310,21 @@ AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
 
 
 dnl
-dnl Check to see if this target can enable the wchar_t parts.
-dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
-dnl must have been previously checked.)  By default, wide characters are
-dnl disabled.
+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  HAVE_MBSTATE_T if mbstate_t is not in wchar.h
-dnl  _GLIBCXX_USE_WCHAR_T if all the bits are found.
+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_WCHAR_T_SUPPORT], [
-  # Test wchar.h for mbstate_t, which is needed for char_traits and
-  # others even if wchar_t support is not on.
-  AC_MSG_CHECKING([for mbstate_t])
-  AC_TRY_COMPILE([#include <wchar.h>],
-  [mbstate_t teststate;],
-  have_mbstate_t=yes, have_mbstate_t=no)
-  AC_MSG_RESULT($have_mbstate_t)
-  if test x"$have_mbstate_t" = xyes; then
-    AC_DEFINE(HAVE_MBSTATE_T)
-  fi
-
-  # Sanity check for existence of ISO C99 headers for extended encoding.
-  AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
-  AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
+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"$ac_has_wchar_h" = xyes &&
-     test x"$ac_has_wctype_h" = xyes &&
-     test x"$enable_c_mbchar" != xno; then
-
-    # Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
-    # numeric_limits can instantiate type_traits<wchar_t>
-    AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
-    AC_TRY_COMPILE([#include <wchar.h>],
-    [int i = WCHAR_MIN; int j = WCHAR_MAX;],
-    has_wchar_minmax=yes, has_wchar_minmax=no)
-    AC_MSG_RESULT($has_wchar_minmax)
-
-    # Test wchar.h for WEOF, which is what we use to determine whether
-    # to specialize for char_traits<wchar_t> or not.
-    AC_MSG_CHECKING([for WEOF])
-    AC_TRY_COMPILE([
-      #include <wchar.h>
-      #include <stddef.h>],
-    [wint_t i = WEOF;],
-    has_weof=yes, has_weof=no)
-    AC_MSG_RESULT($has_weof)
-
-    # Tests for wide character functions used in char_traits<wchar_t>.
-    ac_wfuncs=yes
-    AC_CHECK_FUNCS([wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset],
-    [],[ac_wfuncs=no])
-
-    # Checks for names injected into std:: by the c_std headers.
-    AC_CHECK_FUNCS([btowc wctob fgetwc fgetws fputwc fputws fwide \
-    fwprintf fwscanf swprintf swscanf vfwprintf vswprintf \
-    vwprintf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
-    mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstol \
-    wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
-    wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr],
-    [],[ac_wfuncs=no])
-
-    # Checks for wide character functions that are not required
-    # for basic wchar_t support.  Don't disable support if they are missing.
-    # Injection of these is wrapped with guard macros.
-    AC_CHECK_FUNCS([vfwscanf vswscanf vwscanf wcstof iswblank],[],[])
-
-    AC_MSG_CHECKING([for ISO C99 wchar_t support])
-    if test x"$has_weof" = xyes &&
-       test x"$has_wchar_minmax" = xyes &&
-       test x"$ac_wfuncs" = xyes;
-    then
-      ac_isoC99_wchar_t=yes
-    else
-      ac_isoC99_wchar_t=no
-    fi
-    AC_MSG_RESULT($ac_isoC99_wchar_t)
+  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).
@@ -412,37 +332,27 @@ AC_DEFUN([GLIBCXX_CHECK_WCHAR_T_SUPPORT], [
     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_CHECK_LIB(iconv, iconv, LIBICONV="-liconv")
     ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $libiconv"
+    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"
 
-    AC_MSG_CHECKING([for XPG2 wchar_t support])
     if test x"$ac_has_iconv_h" = xyes &&
        test x"$ac_has_langinfo_h" = xyes &&
        test x"$ac_XPG2funcs" = xyes;
     then
-      ac_XPG2_wchar_t=yes
-    else
-      ac_XPG2_wchar_t=no
-    fi
-    AC_MSG_RESULT($ac_XPG2_wchar_t)
-
-    # At the moment, only enable wchar_t specializations if all the
-    # above support is present.
-    if test x"$ac_isoC99_wchar_t" = xyes &&
-       test x"$ac_XPG2_wchar_t" = xyes;
-    then
-      AC_DEFINE(_GLIBCXX_USE_WCHAR_T)
-      enable_wchar_t=yes
+      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 wchar_t specializations])
-  AC_MSG_RESULT($enable_wchar_t)
+  AC_MSG_CHECKING([for enabled iconv specializations])
+  AC_MSG_RESULT($enable_iconv)
 ])
 
 
@@ -455,6 +365,7 @@ 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>
@@ -464,6 +375,8 @@ AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
     [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], [
@@ -497,7 +410,9 @@ AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
   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)
+    AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
+              [Define if using setrlimit to set resource limits during
+              "make check"])
   else
     ac_res_limits=no
   fi
@@ -510,6 +425,7 @@ 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>],
@@ -528,11 +444,17 @@ AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
       [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)
+    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)
+    AC_DEFINE(HAVE_S_IFREG, 1,
+              [Define if S_IFREG is available in <sys/stat.h>.])
+    res=S_IFREG
   fi
+  AC_MSG_RESULT($res)
 ])
 
 
@@ -540,6 +462,7 @@ 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>],
@@ -550,8 +473,9 @@ AC_DEFUN([GLIBCXX_CHECK_POLL], [
       [glibcxx_cv_POLL=no])
   ])
   if test $glibcxx_cv_POLL = yes; then
-    AC_DEFINE(HAVE_POLL)
+    AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
   fi
+  AC_MSG_RESULT($glibcxx_cv_POLL)
 ])
 
 
@@ -559,6 +483,7 @@ 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>],
@@ -568,8 +493,9 @@ AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
       [glibcxx_cv_WRITEV=no])
   ])
   if test $glibcxx_cv_WRITEV = yes; then
-    AC_DEFINE(HAVE_WRITEV)
+    AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
   fi
+  AC_MSG_RESULT($glibcxx_cv_WRITEV)
 ])
 
 
@@ -577,6 +503,7 @@ 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>],
@@ -585,8 +512,9 @@ AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
       [glibcxx_cv_INT64_T=no])
   ])
   if test $glibcxx_cv_INT64_T = yes; then
-    AC_DEFINE(HAVE_INT64_T)
+    AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
   fi
+  AC_MSG_RESULT($glibcxx_cv_INT64_T)
 ])
 
 
@@ -598,22 +526,27 @@ AC_DEFUN([GLIBCXX_CHECK_LFS], [
   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);],	
+       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)
+    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
 ])
@@ -633,7 +566,8 @@ 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)
+    AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
+              [Define if a fully dynamic basic_string is wanted.])
   fi
 ])
 
@@ -645,40 +579,38 @@ dnl
 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
 dnl
 dnl Sets:
-dnl  enable_abi_check / GLIBCXX_TEST_ABI
+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 && test $is_hosted = yes; then
+  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 test $enable_symvers = no; then
-      enable_abi_check=no
-    else
-      case "$host" in
-        *-*-cygwin*)
-          enable_abi_check=no ;;
-        *)
-          enable_abi_check=yes ;;
-      esac
-    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)"
+  baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}\$(MULTISUBDIR)"
   AC_SUBST(baseline_dir)
-
-  GLIBCXX_CONDITIONAL(GLIBCXX_TEST_WCHAR_T, test $enable_wchar_t = yes)
-  GLIBCXX_CONDITIONAL(GLIBCXX_TEST_ABI, test $enable_abi_check = yes)
 ])
 
 
@@ -727,7 +659,7 @@ AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
   OPTIMIZE_CXXFLAGS=
   AC_SUBST(OPTIMIZE_CXXFLAGS)
 
-  WARN_FLAGS='-Wall -W -Wwrite-strings -Wcast-qual'
+  WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
   AC_SUBST(WARN_FLAGS)
 ])
 
@@ -744,6 +676,8 @@ dnl
 dnl Assumes cross_compiling bits already done, and with_cross_host in
 dnl particular.
 dnl
+dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
+dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
   glibcxx_toolexecdir=no
   glibcxx_toolexeclibdir=no
@@ -775,7 +709,13 @@ AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
 
   # 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}
+    gxx_include_dir='include/c++/${gcc_version}'
+    if test -n "$with_cross_host" && 
+       test x"$with_cross_host" != x"no"; then	
+      gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
+    else
+      gxx_include_dir='${prefix}/'"$gxx_include_dir"
+    fi
   fi
 
   # Version-specific runtime libs processing.
@@ -785,10 +725,10 @@ AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
     # 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++
+      gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
     fi
     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
-    glibcxx_toolexeclibdir='${toolexecdir}/'$gcc_version'$(MULTISUBDIR)'
+    glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
   fi
 
   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
@@ -867,121 +807,503 @@ 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_c99_math=yes;
   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
-  AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],
-                 [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
+  AC_CACHE_VAL(ac_c99_math, [
   AC_TRY_COMPILE([#include <math.h>],
-                 [islessgreater(0.0,0.0);],, [ac_c99_math=no])
-  AC_TRY_COMPILE([#include <math.h>],
-                 [isunordered(0.0,0.0);],, [ac_c99_math=no])
+	         [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)
+    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_c99_stdio=yes;
   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
-  AC_TRY_COMPILE([#include <stdio.h>],
-                 [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
+  AC_CACHE_VAL(ac_c99_stdio, [
   AC_TRY_COMPILE([#include <stdio.h>
-                  #include <stdarg.h>
+		  #include <stdarg.h>
                   void foo(char* fmt, ...)
-                  {va_list args; va_start(args, fmt);
-                  vfscanf(stderr, "%i", args);}],
-                  [],, [ac_c99_stdio=no])
-  AC_TRY_COMPILE([#include <stdio.h>
-                  #include <stdarg.h>
-                  void foo(char* fmt, ...)
-                  {va_list args; va_start(args, fmt);
-                  vscanf("%i", args);}],
-                  [],, [ac_c99_stdio=no])
-  AC_TRY_COMPILE([#include <stdio.h>
-                  #include <stdarg.h>
-                  void foo(char* fmt, ...)
-                  {va_list args; va_start(args, fmt);
-                  vsnprintf(fmt, 0, "%i", args);}],
-                  [],, [ac_c99_stdio=no])
-  AC_TRY_COMPILE([#include <stdio.h>
-                  #include <stdarg.h>
-                  void foo(char* fmt, ...)
-                  {va_list args; va_start(args, fmt);
-                  vsscanf(fmt, "%i", args);}],
-                  [],, [ac_c99_stdio=no])
+                  {
+	            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_c99_stdlib=yes;
-  AC_MSG_CHECKING([for lldiv_t declaration])
-  AC_CACHE_VAL(ac_c99_lldiv_t, [
-  AC_TRY_COMPILE([#include <stdlib.h>],
-                   [ lldiv_t mydivt;],
-                   [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
-  ])
-  AC_MSG_RESULT($ac_c99_lldiv_t)
-
   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);],, [ac_c99_stdlib=no])
-  AC_TRY_COMPILE([#include <stdlib.h>],
-                 [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
-  AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
-  AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
-  AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
-  AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
-  if test x"$ac_c99_lldiv_t" = x"no"; then
-    ac_c99_stdlib=no;
-  fi;
+                 [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 of <wchar.h> functions used if C99 is enabled.
-  # XXX the wchar.h checks should be rolled into the general C99 bits.
-  ac_c99_wchar=yes;
-  AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
-  AC_TRY_COMPILE([#include <wchar.h>],
-                 [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
-  AC_TRY_COMPILE([#include <wchar.h>],
-                 [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
-  AC_TRY_COMPILE([#include <wchar.h>],
-                 [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
-  AC_MSG_RESULT($ac_c99_wchar)
+  # 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; } ], [],
+ 	    	   [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
+
+    AC_TRY_COMPILE([#include <wctype.h>],
+                   [ wint_t t; int i = iswblank(t);], 
+ 	    	   [AC_DEFINE(HAVE_ISWBLANK,1,
+			[Defined if iswblank exists.])],[])
+
+    AC_MSG_RESULT($ac_c99_wchar)
+  fi
 
-  AC_MSG_CHECKING([for enabled ISO C99 support])
+  # Option parsed, now set things appropriately.
   if test x"$ac_c99_math" = x"no" ||
+     test x"$ac_c99_complex" = x"no" ||
      test x"$ac_c99_stdio" = x"no" ||
      test x"$ac_c99_stdlib" = x"no" ||
      test x"$ac_c99_wchar" = x"no"; then
     enable_c99=no;
-  fi;
+  else
+    AC_DEFINE(_GLIBCXX_USE_C99, 1,
+    [Define if C99 functions or macros from <wchar.h>, <math.h>,
+    <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
+  fi
+
+  AC_LANG_RESTORE
+  fi	
+
+  AC_MSG_CHECKING([for fully enabled ISO C99 support])
   AC_MSG_RESULT($enable_c99)
+])
+
 
-  if test x"$ac_99_math" = x"yes"; then
-    AC_DEFINE(_GLIBCXX_USE_C99_MATH)
+dnl
+dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
+dnl facilities in Chapter 8, "C compatibility".
+dnl
+AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
+
+  AC_LANG_SAVE
+  AC_LANG_CPLUSPLUS
+
+  # Check for the existence of <complex.h> complex math functions used
+  # by tr1/complex.
+  AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
+  ac_c99_complex_tr1=no;
+  if test x"$ac_has_complex_h" = x"yes"; then
+    AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
+    AC_TRY_COMPILE([#include <complex.h>],
+	           [typedef __complex__ float float_type; float_type tmpf;
+	            cacosf(tmpf);
+	            casinf(tmpf);
+	            catanf(tmpf);
+	            cacoshf(tmpf);
+	            casinhf(tmpf);
+	            catanhf(tmpf);
+		    typedef __complex__ double double_type; double_type tmpd;
+	            cacos(tmpd);
+	            casin(tmpd);
+	            catan(tmpd);
+	            cacosh(tmpd);
+	            casinh(tmpd);
+	            catanh(tmpd);
+		    typedef __complex__ long double ld_type; ld_type tmpld;
+	            cacosl(tmpld);
+	            casinl(tmpld);
+	            catanl(tmpld);
+	            cacoshl(tmpld);
+	            casinhl(tmpld);
+	            catanhl(tmpld);
+		   ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
+  fi
+  AC_MSG_RESULT($ac_c99_complex_tr1)
+  if test x"$ac_c99_complex_tr1" = x"yes"; then
+    AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
+              [Define if C99 functions in <complex.h> should be used in
+              <tr1/complex>. Using compiler builtins for these functions
+	      requires corresponding C99 library functions to be present.])
   fi
 
-  # Option parsed, now set things appropriately
-  if test x"$enable_c99" = x"yes"; then
-    AC_DEFINE(_GLIBCXX_USE_C99)
+  # Check for the existence of <ctype.h> functions.
+  AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
+  AC_CACHE_VAL(ac_c99_ctype_tr1, [
+  AC_TRY_COMPILE([#include <ctype.h>],
+	         [int ch;
+	          int ret;
+	          ret = isblank(ch);
+		 ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no])
+  ])
+  AC_MSG_RESULT($ac_c99_ctype_tr1)
+  if test x"$ac_c99_ctype_tr1" = x"yes"; then
+    AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
+              [Define if C99 functions in <ctype.h> should be imported in
+	      <tr1/cctype> in namespace std::tr1.])
+  fi
+
+  # Check for the existence of <fenv.h> functions.
+  AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
+  ac_c99_fenv_tr1=no;
+  if test x"$ac_has_fenv_h" = x"yes"; then
+    AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
+    AC_TRY_COMPILE([#include <fenv.h>],
+	           [int except, mode;
+	            fexcept_t* pflag;
+                    fenv_t* penv;
+	            int ret;
+	            ret = feclearexcept(except);
+	            ret = fegetexceptflag(pflag, except);
+	            ret = feraiseexcept(except);
+	            ret = fesetexceptflag(pflag, except);
+	            ret = fetestexcept(except);
+	            ret = fegetround();
+	            ret = fesetround(mode);
+	            ret = fegetenv(penv);
+	            ret = feholdexcept(penv);
+	            ret = fesetenv(penv);
+	            ret = feupdateenv(penv);
+		   ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
+  fi
+  AC_MSG_RESULT($ac_c99_fenv_tr1)
+  if test x"$ac_c99_fenv_tr1" = x"yes"; then
+    AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
+              [Define if C99 functions in <fenv.h> should be imported in
+	      <tr1/cfenv> in namespace std::tr1.])
+  fi
+
+  # Check for the existence of <stdint.h> types.
+  AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
+  AC_CACHE_VAL(ac_c99_stdint_tr1, [
+  AC_TRY_COMPILE([#include <stdint.h>],
+	         [typedef int8_t          my_int8_t;
+	          typedef int16_t         my_int16_t;
+	          typedef int32_t         my_int32_t;
+	          typedef int64_t         my_int64_t;
+	          typedef int_fast8_t     my_int_fast8_t;
+	          typedef int_fast16_t    my_int_fast16_t;
+	          typedef int_fast32_t    my_int_fast32_t;
+	          typedef int_fast64_t    my_int_fast64_t;	
+	          typedef int_least8_t    my_int_least8_t;
+	          typedef int_least16_t   my_int_least16_t;
+	          typedef int_least32_t   my_int_least32_t;
+	          typedef int_least64_t   my_int_least64_t;
+		  typedef intmax_t        my_intmax_t;
+		  typedef intptr_t        my_intptr_t;
+	          typedef uint8_t         my_uint8_t;
+	          typedef uint16_t        my_uint16_t;
+	          typedef uint32_t        my_uint32_t;
+	          typedef uint64_t        my_uint64_t;
+	          typedef uint_fast8_t    my_uint_fast8_t;
+	          typedef uint_fast16_t   my_uint_fast16_t;
+	          typedef uint_fast32_t   my_uint_fast32_t;
+	          typedef uint_fast64_t   my_uint_fast64_t;	
+	          typedef uint_least8_t   my_uint_least8_t;
+	          typedef uint_least16_t  my_uint_least16_t;
+	          typedef uint_least32_t  my_uint_least32_t;
+	          typedef uint_least64_t  my_uint_least64_t;
+		  typedef uintmax_t       my_uintmax_t;
+		  typedef uintptr_t       my_uintptr_t;
+		 ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no])
+  ])
+  AC_MSG_RESULT($ac_c99_stdint_tr1)
+  if test x"$ac_c99_stdint_tr1" = x"yes"; then
+    AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
+              [Define if C99 types in <stdint.h> should be imported in
+	      <tr1/cstdint> in namespace std::tr1.])
+  fi
+
+  # Check for the existence of <math.h> functions.
+  AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
+  AC_CACHE_VAL(ac_c99_math_tr1, [
+  AC_TRY_COMPILE([#include <math.h>],
+	         [typedef double_t  my_double_t;
+	          typedef float_t   my_float_t;
+	          acosh(0.0);
+	          acoshf(0.0f);
+	          acoshl(0.0l);
+	          asinh(0.0);
+	          asinhf(0.0f);
+	          asinhl(0.0l);
+	          atanh(0.0);
+	          atanhf(0.0f);
+	          atanhl(0.0l);
+	          cbrt(0.0);
+	          cbrtf(0.0f);
+	          cbrtl(0.0l);
+	          copysign(0.0, 0.0);
+	          copysignf(0.0f, 0.0f);
+	          copysignl(0.0l, 0.0l);
+	          erf(0.0);
+	          erff(0.0f);
+	          erfl(0.0l);
+	          erfc(0.0);
+	          erfcf(0.0f);
+	          erfcl(0.0l);
+	          exp2(0.0);
+	          exp2f(0.0f);
+	          exp2l(0.0l);
+	          expm1(0.0);
+	          expm1f(0.0f);
+	          expm1l(0.0l);
+	          fdim(0.0, 0.0);
+	          fdimf(0.0f, 0.0f);
+	          fdiml(0.0l, 0.0l);
+	          fma(0.0, 0.0, 0.0);
+	          fmaf(0.0f, 0.0f, 0.0f);
+	          fmal(0.0l, 0.0l, 0.0l);
+	          fmax(0.0, 0.0);
+	          fmaxf(0.0f, 0.0f);
+	          fmaxl(0.0l, 0.0l);
+	          fmin(0.0, 0.0);
+	          fminf(0.0f, 0.0f);
+	          fminl(0.0l, 0.0l);
+	          hypot(0.0, 0.0);
+	          hypotf(0.0f, 0.0f);
+	          hypotl(0.0l, 0.0l);
+	          ilogb(0.0);
+	          ilogbf(0.0f);
+	          ilogbl(0.0l);
+	          lgamma(0.0);
+	          lgammaf(0.0f);
+	          lgammal(0.0l);
+	          llrint(0.0);
+	          llrintf(0.0f);
+	          llrintl(0.0l);
+	          llround(0.0);
+	          llroundf(0.0f);
+	          llroundl(0.0l);
+	          log1p(0.0);
+	          log1pf(0.0f);
+	          log1pl(0.0l);
+	          log2(0.0);
+	          log2f(0.0f);
+	          log2l(0.0l);
+	          logb(0.0);
+	          logbf(0.0f);
+	          logbl(0.0l);
+	          lrint(0.0);
+	          lrintf(0.0f);
+	          lrintl(0.0l);
+	          lround(0.0);
+	          lroundf(0.0f);
+	          lroundl(0.0l);
+	          nan(0);
+	          nanf(0);
+	          nanl(0);
+	          nearbyint(0.0);
+	          nearbyintf(0.0f);
+	          nearbyintl(0.0l);
+	          nextafter(0.0, 0.0);
+	          nextafterf(0.0f, 0.0f);
+	          nextafterl(0.0l, 0.0l);
+	          nexttoward(0.0, 0.0);
+	          nexttowardf(0.0f, 0.0f);
+	          nexttowardl(0.0l, 0.0l);
+	          remainder(0.0, 0.0);
+	          remainderf(0.0f, 0.0f);
+	          remainderl(0.0l, 0.0l);
+	          remquo(0.0, 0.0, 0);
+	          remquo(0.0f, 0.0f, 0);
+	          remquo(0.0l, 0.0l, 0);
+	          rint(0.0);
+	          rintf(0.0f);
+	          rintl(0.0l);
+	          round(0.0);
+	          roundf(0.0f);
+	          roundl(0.0l);
+	          scalbln(0.0, 0l);
+	          scalblnf(0.0f, 0l);
+	          scalblnl(0.0l, 0l);
+	          scalbn(0.0, 0);
+	          scalbnf(0.0f, 0);
+	          scalbnl(0.0l, 0);
+	          tgamma(0.0);
+	          tgammaf(0.0f);
+	          tgammal(0.0l);
+	          trunc(0.0);
+	          truncf(0.0f);
+	          truncl(0.0l);
+		 ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
+  ])
+  AC_MSG_RESULT($ac_c99_math_tr1)
+  if test x"$ac_c99_math_tr1" = x"yes"; then
+    AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
+              [Define if C99 functions or macros in <math.h> should be imported
+              in <tr1/cmath> in namespace std::tr1.])
   fi
 
+  # Check for the existence of <inttypes.h> functions (NB: doesn't make
+  # sense if the previous check fails, per C99, 7.8/1).
+  ac_c99_inttypes_tr1=no;
+  if test x"$ac_c99_stdint_tr1" = x"yes"; then
+    AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
+    AC_TRY_COMPILE([#include <inttypes.h>],
+	           [intmax_t i, numer, denom, base;
+	            const char* s;
+	            char** endptr;
+	            intmax_t ret = imaxabs(i);
+	            imaxdiv_t dret = imaxdiv(numer, denom);
+	            ret = strtoimax(s, endptr, base);
+	            uintmax_t uret = strtoumax(s, endptr, base);
+        	   ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
+  fi
+  AC_MSG_RESULT($ac_c99_inttypes_tr1)
+  if test x"$ac_c99_inttypes_tr1" = x"yes"; then
+    AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
+              [Define if C99 functions in <inttypes.h> should be imported in
+              <tr1/cinttypes> in namespace std::tr1.])
+  fi
+
+  # Check for the existence of the <stdbool.h> header.	
+  AC_CHECK_HEADERS(stdbool.h)
+
   AC_LANG_RESTORE
 ])
 
+dnl
+dnl Check whether "dev/random" and "dev/urandom" are available for the
+dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
+dnl
+AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
+
+  AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
+  AC_CACHE_VAL(ac_random_tr1, [
+  AC_TRY_RUN([#include <stdio.h>
+	      int main()
+	      {
+                return !(fopen("/dev/random", "r")
+                         && fopen("/dev/urandom", "r"));
+	      }	      
+	     ],
+             [ac_random_tr1=yes], [ac_random_tr1=no],
+	     [ac_random_tr1=no])
+  ])
+  AC_MSG_RESULT($ac_random_tr1)
+  if test x"$ac_random_tr1" = x"yes"; then
+    AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
+              [Define if dev/random and dev/urandom are available for
+	       the random_device of TR1 (Chapter 5.1).])
+  fi
+
+])
 
 dnl
 dnl Check for what type of C headers to use.
@@ -1030,8 +1352,8 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
   # Probe for locale support if no specific model is specified.
   # Default to "generic".
   if test $enable_clocale_flag = auto; then
-    case x${target_os} in
-      xlinux* | xgnu* | xkfreebsd*-gnu | xknetbsd*-gnu)
+    case ${target_os} in
+      linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
         AC_EGREP_CPP([_GLIBCXX_ok], [
         #include <features.h>
         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
@@ -1040,7 +1362,7 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
 
         # Test for bugs early in glibc-2.2.x series
-          if test x$enable_clocale_flag = xgnu; then
+          if test $enable_clocale_flag = gnu; then
           AC_TRY_RUN([
           #define _GNU_SOURCE 1
           #include <locale.h>
@@ -1071,6 +1393,9 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
 
         # ... at some point put __strxfrm_l tests in as well.
         ;;
+      darwin* | freebsd*)
+        enable_clocale_flag=darwin
+	;;
       *)
         enable_clocale_flag=generic
         ;;
@@ -1093,7 +1418,6 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
 
       CLOCALE_H=config/locale/generic/c_locale.h
       CLOCALE_CC=config/locale/generic/c_locale.cc
-      CCODECVT_H=config/locale/generic/codecvt_specializations.h
       CCODECVT_CC=config/locale/generic/codecvt_members.cc
       CCOLLATE_CC=config/locale/generic/collate_members.cc
       CCTYPE_CC=config/locale/generic/ctype_members.cc
@@ -1105,6 +1429,23 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
       CTIME_CC=config/locale/generic/time_members.cc
       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
       ;;
+    darwin)
+      AC_MSG_RESULT(darwin or freebsd)
+
+      CLOCALE_H=config/locale/generic/c_locale.h
+      CLOCALE_CC=config/locale/generic/c_locale.cc
+      CCODECVT_CC=config/locale/generic/codecvt_members.cc
+      CCOLLATE_CC=config/locale/generic/collate_members.cc
+      CCTYPE_CC=config/locale/darwin/ctype_members.cc
+      CMESSAGES_H=config/locale/generic/messages_members.h
+      CMESSAGES_CC=config/locale/generic/messages_members.cc
+      CMONEY_CC=config/locale/generic/monetary_members.cc
+      CNUMERIC_CC=config/locale/generic/numeric_members.cc
+      CTIME_H=config/locale/generic/time_members.h
+      CTIME_CC=config/locale/generic/time_members.cc
+      CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
+      ;;
+	
     gnu)
       AC_MSG_RESULT(gnu)
 
@@ -1128,7 +1469,6 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
 
       CLOCALE_H=config/locale/gnu/c_locale.h
       CLOCALE_CC=config/locale/gnu/c_locale.cc
-      CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
       CCOLLATE_CC=config/locale/gnu/collate_members.cc
       CCTYPE_CC=config/locale/gnu/ctype_members.cc
@@ -1145,7 +1485,6 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
 
       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
-      CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
       CCODECVT_CC=config/locale/generic/codecvt_members.cc
       CCOLLATE_CC=config/locale/generic/collate_members.cc
       CCTYPE_CC=config/locale/generic/ctype_members.cc
@@ -1170,12 +1509,12 @@ AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
   fi
   if test $USE_NLS = yes; then
-    AC_DEFINE(_GLIBCXX_USE_NLS)
+    AC_DEFINE(_GLIBCXX_USE_NLS, 1, 
+              [Define if NLS translations are to be used.])
   fi
 
   AC_SUBST(USE_NLS)
   AC_SUBST(CLOCALE_H)
-  AC_SUBST(CCODECVT_H)
   AC_SUBST(CMESSAGES_H)
   AC_SUBST(CCODECVT_CC)
   AC_SUBST(CCOLLATE_CC)
@@ -1197,24 +1536,31 @@ dnl
 dnl Default is new.
 dnl
 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
-  AC_MSG_CHECKING([for std::allocator base class to use])
+  AC_MSG_CHECKING([for std::allocator base class])
   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
     [use KIND for target std::allocator base],
     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
+
   # If they didn't use this option switch, or if they specified --enable
   # with no specific model, we'll have to look for one.  If they
   # specified --disable (???), do likewise.
-  if test $enable_libstdcxx_allocator = no || test $enable_libstdcxx_allocator = yes; then
+  if test $enable_libstdcxx_allocator = no ||
+     test $enable_libstdcxx_allocator = yes;
+  then
      enable_libstdcxx_allocator=auto
   fi
 
-  # Either a known package, or "auto"
+  # Either a known package, or "auto". Auto implies the default choice
+  # for a particular platform.
   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
 
   # Probe for host-specific support if no specific model is specified.
   # Default to "new".
   if test $enable_libstdcxx_allocator_flag = auto; then
     case ${target_os} in
+      linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
+        enable_libstdcxx_allocator_flag=new
+        ;;
       *)
         enable_libstdcxx_allocator_flag=new
         ;;
@@ -1263,7 +1609,8 @@ dnl
 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
   if test $enable_concept_checks = yes; then
-    AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS)
+    AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
+              [Define to use concept checking code from the boost libraries.])
   fi
 ])
 
@@ -1339,21 +1686,6 @@ AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
 
 
 dnl
-dnl Check for wide character support.  Has the same effect as the option
-dnl in gcc's configure, but in a form that autoconf can mess with.
-dnl
-dnl --enable-c-mbchar requests all the wchar_t stuff.
-dnl --disable-c-mbchar doesn't.
-dnl  +  Usage:  GLIBCXX_ENABLE_C_MBCHAR[(DEFAULT)]
-dnl       Where DEFAULT is either `yes' or `no'.
-dnl
-AC_DEFUN([GLIBCXX_ENABLE_C_MBCHAR], [
-  GLIBCXX_ENABLE(c-mbchar,$1,,[enable multibyte (wide) characters])
-  # Option parsed, now other scripts can test enable_c_mbchar for yes/no.
-])
-
-
-dnl
 dnl Check to see if debugging libraries are to be built.
 dnl
 dnl --enable-libstdcxx-debug
@@ -1424,7 +1756,14 @@ AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
   AC_ARG_ENABLE([hosted-libstdcxx],
     AC_HELP_STRING([--disable-hosted-libstdcxx],
                    [only build freestanding C++ runtime support]),,
-    [enable_hosted_libstdcxx=yes])
+    [case "$host" in
+	arm*-*-symbianelf*) 
+	    enable_hosted_libstdcxx=no
+	    ;;
+        *) 
+	    enable_hosted_libstdcxx=yes
+	    ;;
+     esac])
   if test "$enable_hosted_libstdcxx" = no; then
     AC_MSG_NOTICE([Only freestanding libraries will be built])
     is_hosted=no
@@ -1442,7 +1781,7 @@ AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
 
 
 dnl
-dnl Check for template specializations for the 'long long' type extension.
+dnl Check for template specializations for the 'long long' type.
 dnl The result determines only whether 'long long' I/O is enabled; things
 dnl like numeric_limits<> specializations are always available.
 dnl
@@ -1452,10 +1791,127 @@ dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
 dnl       Where DEFAULT is either `yes' or `no'.
 dnl
 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
-  GLIBCXX_ENABLE(long-long,$1,,[enables I/O support for 'long long'])
+  GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
   if test $enable_long_long = yes; then
-    AC_DEFINE(_GLIBCXX_USE_LONG_LONG)
+    AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1, 
+              [Define if code specialized for long long should be used.])
   fi
+  AC_MSG_CHECKING([for enabled long long specializations])
+  AC_MSG_RESULT([$enable_long_long])
+])
+
+
+dnl
+dnl Check for template specializations for the 'wchar_t' type.
+dnl
+dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
+dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
+dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
+dnl       Where DEFAULT is either `yes' or `no'.
+dnl
+dnl Necessary support must also be present.
+dnl
+AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
+  GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
+
+  # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
+  AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
+  AC_MSG_CHECKING([for mbstate_t])
+  AC_TRY_COMPILE([#include <wchar.h>],
+  [mbstate_t teststate;],
+  have_mbstate_t=yes, have_mbstate_t=no)
+  AC_MSG_RESULT($have_mbstate_t)
+  if test x"$have_mbstate_t" = xyes; then
+    AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
+  fi
+
+  # Test it always, for use in GLIBCXX_ENABLE_C99, together with
+  # ac_has_wchar_h.
+  AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
+  
+  if test x"$enable_wchar_t" = x"yes"; then
+
+    AC_LANG_SAVE
+    AC_LANG_CPLUSPLUS
+    
+    if test x"$ac_has_wchar_h" = xyes &&
+       test x"$ac_has_wctype_h" = xyes; then
+      AC_TRY_COMPILE([#include <wchar.h>
+                      #include <stddef.h>
+                      wint_t i;
+		      long l = WEOF;
+		      long j = WCHAR_MIN;
+		      long k = WCHAR_MAX;
+                      namespace test
+                      {
+			using ::btowc;
+			using ::fgetwc;
+			using ::fgetws;
+			using ::fputwc;
+			using ::fputws;
+			using ::fwide;
+			using ::fwprintf; 
+			using ::fwscanf;
+			using ::getwc;
+			using ::getwchar;
+ 			using ::mbrlen; 
+			using ::mbrtowc; 
+			using ::mbsinit; 
+			using ::mbsrtowcs; 
+			using ::putwc;
+			using ::putwchar;
+			using ::swprintf; 
+			using ::swscanf; 
+			using ::ungetwc;
+			using ::vfwprintf; 
+			using ::vswprintf; 
+			using ::vwprintf; 
+			using ::wcrtomb; 
+			using ::wcscat; 
+			using ::wcschr; 
+			using ::wcscmp; 
+			using ::wcscoll; 
+			using ::wcscpy; 
+			using ::wcscspn; 
+			using ::wcsftime; 
+			using ::wcslen;
+			using ::wcsncat; 
+			using ::wcsncmp; 
+			using ::wcsncpy; 
+			using ::wcspbrk;
+			using ::wcsrchr; 
+			using ::wcsrtombs; 
+			using ::wcsspn; 
+			using ::wcsstr;
+			using ::wcstod; 
+			using ::wcstok; 
+			using ::wcstol;
+			using ::wcstoul; 
+			using ::wcsxfrm; 
+			using ::wctob; 
+			using ::wmemchr;
+			using ::wmemcmp;
+			using ::wmemcpy;
+			using ::wmemmove;
+			using ::wmemset;
+			using ::wprintf; 
+			using ::wscanf; 
+		      }
+		     ],[],[], [enable_wchar_t=no])
+    else
+      enable_wchar_t=no
+    fi
+
+    AC_LANG_RESTORE
+  fi
+
+  if test x"$enable_wchar_t" = x"yes"; then
+    AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
+              [Define if code specialized for wchar_t should be used.])
+  fi
+
+  AC_MSG_CHECKING([for enabled wchar_t specializations])
+  AC_MSG_RESULT([$enable_wchar_t])
 ])
 
 
@@ -1474,10 +1930,7 @@ dnl Substs:
 dnl  glibcxx_PCHFLAGS
 dnl
 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
-  AC_MSG_CHECKING([for enabled PCH])
   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
-  AC_MSG_RESULT([$enable_libstdcxx_pch])
-
   if test $enable_libstdcxx_pch = yes; then
     AC_CACHE_CHECK([for compiler with PCH support],
       [glibcxx_cv_prog_CXX_pch],
@@ -1503,9 +1956,12 @@ AC_DEFUN([GLIBCXX_ENABLE_PCH], [
     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
   fi
 
+  AC_MSG_CHECKING([for enabled PCH])
+  AC_MSG_RESULT([$enable_libstdcxx_pch])
+
   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
   if test $enable_libstdcxx_pch = yes; then
-    glibcxx_PCHFLAGS="-include bits/stdc++.h"
+    glibcxx_PCHFLAGS="-include bits/stdtr1c++.h"
   else
     glibcxx_PCHFLAGS=""
   fi
@@ -1514,6 +1970,69 @@ AC_DEFUN([GLIBCXX_ENABLE_PCH], [
 
 
 dnl
+dnl Check for atomic builtins.
+dnl See:
+dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
+dnl
+dnl This checks to see if the host supports the compiler-generated
+dnl builtins for atomic operations. Note, this is intended to be an
+dnl all-or-nothing switch, so all the atomic operations that are used
+dnl should be checked.
+dnl
+dnl Note:
+dnl libgomp and libgfortran do this with a link test, instead of an asm test.
+dnl see: CHECK_SYNC_FETCH_AND_ADD
+dnl
+dnl Defines:
+dnl  _GLIBCXX_ATOMIC_BUILTINS if the compiler on this target supports atomics.
+dnl
+AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
+  AC_MSG_CHECKING([for atomic builtins])
+  AC_LANG_SAVE
+  AC_LANG_CPLUSPLUS
+
+  # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
+    cat > conftest.$ac_ext << EOF
+[#]line __oline__ "configure"
+int main()
+{
+  // NB: _Atomic_word not necessarily int. 
+  typedef int atomic_type;
+  atomic_type c1;
+  atomic_type c2;
+  const atomic_type c3(0);
+  if (__sync_fetch_and_add(&c1, c2) == c3)
+    {
+      // Do something.
+    }
+   return 0;
+}
+EOF
+    old_CXXFLAGS="$CXXFLAGS"
+    CXXFLAGS=-S
+    if AC_TRY_EVAL(ac_compile); then
+      if grep __sync_fetch_and_add conftest.s >/dev/null 2>&1 ; then
+        enable_atomic_builtins=no
+      else
+      AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
+        [Define if builtin atomic operations are supported on this host.])
+        enable_atomic_builtins=yes
+	atomicity_dir=cpu/generic/atomicity_builtins
+      fi
+    fi
+    CXXFLAGS="$old_CXXFLAGS"
+    rm -f conftest*
+
+   # Now, if still generic, set to mutex.
+  if test $atomicity_dir = "cpu/generic" ; then
+	atomicity_dir=cpu/generic/atomicity_mutex
+  fi
+ AC_LANG_RESTORE
+ AC_MSG_RESULT($enable_atomic_builtins)
+])
+
+
+dnl
 dnl Check for exception handling support.  If an explicit enable/disable
 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
 dnl target may or may not support call frame exceptions.
@@ -1556,14 +2075,16 @@ EOF
         enable_sjlj_exceptions=yes
       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
         enable_sjlj_exceptions=no
+      elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
+        enable_sjlj_exceptions=no
       fi
     fi
     CXXFLAGS="$old_CXXFLAGS"
     rm -f conftest*
   fi
 
-  # This is a tad weird, for hysterical raisins.  We have to map enable/disable 
-  # to two different models.
+  # This is a tad weird, for hysterical raisins.  We have to map
+  # enable/disable to two different models.
   case $enable_sjlj_exceptions in
     yes)
       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
@@ -1583,6 +2104,38 @@ EOF
 
 
 dnl
+dnl Allow visibility attributes to be used on namespaces, objects, etc.
+dnl
+dnl --enable-visibility enables attempt to use visibility attributes.
+dnl --disable-visibility turns off all use of visibility attributes.
+dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
+dnl       Where DEFAULT is 'yes'.
+dnl
+AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
+GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
+
+if test x$enable_visibility = xyes ; then
+  dnl all hail libgfortran
+  dnl Check whether the target supports hidden visibility.
+  AC_CACHE_CHECK([whether the target supports hidden visibility],
+		 have_attribute_visibility, [
+  save_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -Werror"
+  AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
+		 [], have_attribute_visibility=yes,
+		 have_attribute_visibility=no)
+  CFLAGS="$save_CFLAGS"])
+  if test $have_attribute_visibility = no; then
+    enable_visibility=no
+  fi
+fi
+
+GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
+AC_MSG_NOTICE([visibility supported: $enable_visibility])
+])
+
+
+dnl
 dnl Add version tags to symbols in shared library (or not), additionally
 dnl marking other symbols as private/local (or not).
 dnl
@@ -1599,20 +2152,38 @@ AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
 
 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
   [enables symbol versioning of the shared library],
-  [permit yes|no|gnu])
+  [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
 
 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
 # don't know enough about $LD to do tricks...
 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
-# FIXME  The following test is too strict, in theory.
-if test $enable_shared = no ||
-        test "x$LD" = x ||
-        test x$glibcxx_gnu_ld_version = x; then
-  enable_symvers=no
+
+# Turn a 'yes' into a suitable default.
+if test x$enable_symvers = xyes ; then
+  if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
+    enable_symvers=no
+  else
+    if test $with_gnu_ld = yes ; then
+      enable_symvers=gnu
+    else
+      case ${target_os} in
+        darwin*)
+	  enable_symvers=darwin ;;
+        *)
+          enable_symvers=no ;;
+      esac
+    fi
+  fi
+fi
+
+# Check to see if 'darwin' or 'darwin-export' can win.
+if test x$enable_symvers = xdarwin-export ; then
+    enable_symvers=darwin
 fi
 
-# Check to see if libgcc_s exists, indicating that shared libgcc is possible.
-if test $enable_symvers != no; then
+# Check to see if 'gnu' can win.
+if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
+  # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
   AC_MSG_CHECKING([for shared libgcc])
   ac_save_CFLAGS="$CFLAGS"
   CFLAGS=' -lgcc_s'
@@ -1636,44 +2207,29 @@ changequote([,])dnl
     fi
   fi
   AC_MSG_RESULT($glibcxx_shared_libgcc)
-fi
-
-# For GNU ld, we need at least this version.  The format is described in
-# GLIBCXX_CHECK_LINKER_FEATURES above.
-glibcxx_min_gnu_ld_version=21400
-# XXXXXXXXXXX glibcxx_gnu_ld_version=21390
 
-# Check to see if unspecified "yes" value can win, given results above.
-# Change "yes" into either "no" or a style name.
-if test $enable_symvers = yes; then
-  if test $with_gnu_ld = yes &&
-     test $glibcxx_shared_libgcc = yes;
-  then
-    if test $glibcxx_gnu_ld_version -ge $glibcxx_min_gnu_ld_version ; then
-      enable_symvers=gnu
-    else
-      # The right tools, the right setup, but too old.  Fallbacks?
-      AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
-      AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
-      AC_MSG_WARN(=== You would need to upgrade your binutils to version)
-      AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
-      if test $glibcxx_gnu_ld_version -ge 21200 ; then
-        # Globbing fix is present, proper block support is not.
-        dnl AC_MSG_WARN([=== Dude, you are soooo close.  Maybe we can fake it.])
-        dnl enable_symvers=???
-        AC_MSG_WARN([=== Symbol versioning will be disabled.])
-        enable_symvers=no
-      else
-        # 2.11 or older.
-        AC_MSG_WARN([=== Symbol versioning will be disabled.])
-        enable_symvers=no
-      fi
-    fi
-  else
+  # For GNU ld, we need at least this version.  The format is described in
+  # GLIBCXX_CHECK_LINKER_FEATURES above.
+  glibcxx_min_gnu_ld_version=21400
+
+  # If no shared libgcc, can't win.
+  if test $glibcxx_shared_libgcc != yes; then
+      AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
+      AC_MSG_WARN([=== you are not building a shared libgcc_s.])
+      AC_MSG_WARN([=== Symbol versioning will be disabled.])
+      enable_symvers=no
+  elif test $with_gnu_ld != yes ; then
     # just fail for now
-    AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
-    AC_MSG_WARN([=== either you are not using a supported linker, or you are])
-    AC_MSG_WARN([=== not building a shared libgcc_s (which is required).])
+    AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
+    AC_MSG_WARN([=== you are not using the GNU linker.])
+    AC_MSG_WARN([=== Symbol versioning will be disabled.])
+    enable_symvers=no
+  elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
+    # The right tools, the right setup, but too old.  Fallbacks?
+    AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
+    AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
+    AC_MSG_WARN(=== You would need to upgrade your binutils to version)
+    AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
     AC_MSG_WARN([=== Symbol versioning will be disabled.])
     enable_symvers=no
   fi
@@ -1682,18 +2238,63 @@ fi
 # Everything parsed; figure out what file to use.
 case $enable_symvers in
   no)
-    SYMVER_MAP=config/linker-map.dummy
+    SYMVER_FILE=config/abi/pre/none.ver
     ;;
   gnu)
-    SYMVER_MAP=config/linker-map.gnu
-    AC_DEFINE(_GLIBCXX_SYMVER)
+    SYMVER_FILE=config/abi/pre/gnu.ver
+    AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1, 
+              [Define to use GNU versioning in the shared library.])
+    ;;
+  gnu-versioned-namespace)
+    SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
+    AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1, 
+              [Define to use GNU namespace versioning in the shared library.])
+    ;;
+  darwin)
+    SYMVER_FILE=config/abi/pre/gnu.ver
+    AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1, 
+              [Define to use darwin versioning in the shared library.])
     ;;
 esac
 
-AC_SUBST(SYMVER_MAP)
+if test x$enable_symvers != xno ; then
+  AC_DEFINE(_GLIBCXX_SYMVER, 1,
+	 [Define to use symbol versioning in the shared library.])
+fi
+
+AC_SUBST(SYMVER_FILE)
 AC_SUBST(port_specific_symbol_files)
-GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
+GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
+GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
+GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
+GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
+
+# Now, set up compatibility support, if any.
+# In addition, need this to deal with std::size_t mangling in
+# src/compatibility.cc.  In a perfect world, could use
+# typeid(std::size_t).name()[0] to do direct substitution.
+AC_MSG_CHECKING([for size_t as unsigned int])
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS="-Werror"
+AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;], 
+	         [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
+CFLAGS=$ac_save_CFLAGS
+if test "$glibcxx_size_t_is_i" = yes; then
+  AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
+fi
+AC_MSG_RESULT([$glibcxx_size_t_is_i])
+
+AC_MSG_CHECKING([for ptrdiff_t as int])
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS="-Werror"
+AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;], 
+	         [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
+CFLAGS=$ac_save_CFLAGS
+if test "$glibcxx_ptrdiff_t_is_i" = yes; then
+  AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
+fi
+AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
 ])
 
 
@@ -1721,10 +2322,21 @@ AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
   AC_MSG_RESULT([$target_thread_file])
 
   if test $target_thread_file != single; then
-    AC_DEFINE(HAVE_GTHR_DEFAULT)
+    AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
+              [Define if gthr-default.h exists 
+              (meaning that threading support is enabled).])
   fi
 
   glibcxx_thread_h=gthr-$target_thread_file.h
+
+  dnl Check for __GTHREADS define.
+  gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
+  if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
+    enable_thread=yes
+  else
+   enable_thread=no
+  fi
+
   AC_SUBST(glibcxx_thread_h)
 ])
 
@@ -1744,20 +2356,12 @@ AC_DEFUN([AC_LC_MESSAGES], [
       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
     if test $ac_cv_val_LC_MESSAGES = yes; then
-      AC_DEFINE(HAVE_LC_MESSAGES)
+      AC_DEFINE(HAVE_LC_MESSAGES, 1, 
+                [Define if LC_MESSAGES is available in <locale.h>.])
     fi
   ])
 ])
 
+# Macros from the top-level gcc directory.
+m4_include([../config/tls.m4])
 
-sinclude([../libtool.m4])
-dnl The lines below arrange for aclocal not to bring an installed
-dnl libtool.m4 into aclocal.m4, while still arranging for automake to
-dnl add a definition of LIBTOOL to Makefile.in.
-ifelse(,,,[AC_SUBST(LIBTOOL)
-AC_DEFUN([AM_PROG_LIBTOOL])
-AC_DEFUN([AC_LIBTOOL_DLOPEN])
-AC_DEFUN([AC_PROG_LD])
-])
-
-dnl vim:et:ts=2:sw=2