2003-07-04 Benjamin Kosnik <bkoz@redhat.com>

	Move from CPP to CXX.
	* include/bits/c++config: Move to GLIBCXX from GLIBCPP.
	* testsuite/Makefile.am: Same.
	* testsuite/Makefile.in: Regenerate.
	* po/Makefile.am: Same.
	* po/Makefile.in: Regenerate.
	* libsupc++/Makefile.am: Same.
	* libsupc++/Makefile.in: Regenerate.
	* libmath/Makefile.am: Same.
	* libmath/Makefile.in: Regenerate.
	* include/Makefile.am: Same.
	* include/Makefile.in: Regenerate.
	* src/Makefile.am: Same.
	* src/Makefile.in: Regenerate.
	* acconfig.h: Same.
	* configure.host: Same.
	* configure.in: Same.
	* configure: Regenerate.
	* acinclude.m4: Same.
	* aclocal.m4: Same.
	* src: Change all files in this directory.
	* testsuite: Same.
	* include: Same, standardize include guards.
	* config: Same.
	* libsupc++: Same.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@68958 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 355 insertions, 355 deletions

diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4
index 21402896eb3..64c4d813875 100644
--- a/libstdc++-v3/acinclude.m4
+++ b/libstdc++-v3/acinclude.m4
@@ -1,8 +1,8 @@
 dnl
 dnl Initialize basic configure bits, set toplevel_srcdir for Makefiles.
 dnl
-dnl GLIBCPP_TOPREL_CONFIGURE
-AC_DEFUN(GLIBCPP_TOPREL_CONFIGURE, [
+dnl GLIBCXX_TOPREL_CONFIGURE
+AC_DEFUN(GLIBCXX_TOPREL_CONFIGURE, [
   dnl Default to --enable-multilib (this is also passed by default
   dnl from the ubercommon-top-level configure)
   AC_ARG_ENABLE(multilib,
@@ -39,19 +39,19 @@ AC_DEFUN(GLIBCPP_TOPREL_CONFIGURE, [
 dnl
 dnl Initialize the rest of the library configury.
 dnl
-dnl GLIBCPP_CONFIGURE
-AC_DEFUN(GLIBCPP_CONFIGURE, [
+dnl GLIBCXX_CONFIGURE
+AC_DEFUN(GLIBCXX_CONFIGURE, [
   # Export build and source directories.
   # 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.
-  glibcpp_builddir=`${PWDCMD-pwd}`
+  glibcxx_builddir=`${PWDCMD-pwd}`
   case $srcdir in
-  [\\/$]* | ?:[\\/]*) glibcpp_srcdir=${srcdir} ;;
-  *) glibcpp_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
+  [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
+  *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
   esac
-  AC_SUBST(glibcpp_builddir)
-  AC_SUBST(glibcpp_srcdir)
+  AC_SUBST(glibcxx_builddir)
+  AC_SUBST(glibcxx_srcdir)
 
   dnl This is here just to satisfy automake.
   ifelse(not,equal,[AC_CONFIG_AUX_DIR(..)])
@@ -73,8 +73,8 @@ AC_DEFUN(GLIBCPP_CONFIGURE, [
   AC_ARG_WITH(newlib,
   [  --with-newlib                    Configuring with newlib])
 
-  glibcpp_basedir=$srcdir/$toprel/$1/libstdc++-v3
-  AC_SUBST(glibcpp_basedir)
+  glibcxx_basedir=$srcdir/$toprel/$1/libstdc++-v3
+  AC_SUBST(glibcxx_basedir)
 
   # Never versions of autoconf add an underscore to these functions.
   # Prevent future problems ...
@@ -131,15 +131,15 @@ AC_DEFUN(GLIBCPP_CONFIGURE, [
   [AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
   dnl Fool anybody using AC_PROG_CXX.
   AC_PROVIDE([AC_PROG_CXX])
-  # Use glibcpp_CXX so that we do not cause CXX to be cached with the
+  # Use glibcxx_CXX so that we do not cause CXX to be cached with the
   # flags that come in CXX while configuring libstdc++.  They're different
   # from those used for all other target libraries.  If CXX is set in
   # the environment, respect that here.
-  glibcpp_CXX=$CXX
-  AC_CHECK_PROGS(glibcpp_CXX, $CCC c++ g++ gcc CC cxx cc++, gcc)
-  AC_SUBST(glibcpp_CXX)
-  CXX=$glibcpp_CXX
-  test -z "$glibcpp_CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH])
+  glibcxx_CXX=$CXX
+  AC_CHECK_PROGS(glibcxx_CXX, $CCC c++ g++ gcc CC cxx cc++, gcc)
+  AC_SUBST(glibcxx_CXX)
+  CXX=$glibcxx_CXX
+  test -z "$glibcxx_CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH])
 
   AC_PROG_CXX_GNU
 
@@ -169,7 +169,7 @@ AC_DEFUN(GLIBCPP_CONFIGURE, [
 
   # For directory versioning (e.g., headers) and other variables.
   AC_MSG_CHECKING([for GCC version number])
-  gcc_version=`$glibcpp_CXX -dumpversion`
+  gcc_version=`$glibcxx_CXX -dumpversion`
   AC_MSG_RESULT($gcc_version)
 
   # For some reason, gettext needs this.
@@ -197,16 +197,16 @@ AC_DEFUN(GLIBCPP_CONFIGURE, [
     AC_EXEEXT
   fi
 
-  case [$]{glibcpp_basedir} in
-    /* | [A-Za-z]:[\\/]*) libgcj_flagbasedir=[$]{glibcpp_basedir} ;;
-    *) glibcpp_flagbasedir='[$](top_builddir)/'[$]{glibcpp_basedir} ;;
+  case [$]{glibcxx_basedir} in
+    /* | [A-Za-z]:[\\/]*) libgcj_flagbasedir=[$]{glibcxx_basedir} ;;
+    *) glibcxx_flagbasedir='[$](top_builddir)/'[$]{glibcxx_basedir} ;;
   esac
 
   # Set up safe default values for all subsequent AM_CONDITIONAL tests.
   need_libmath=no
   enable_wchar_t=no
   #enable_debug=no
-  #glibcpp_pch_comp=no
+  #glibcxx_pch_comp=no
   #enable_cheaders=c
   #c_compatibility=no
   #enable_abi_check=no
@@ -214,7 +214,7 @@ AC_DEFUN(GLIBCPP_CONFIGURE, [
 
   # Find platform-specific directories containing configuration info.  In
   # addition to possibly modifying the same flags, it also sets up symlinks.
-  GLIBCPP_CHECK_HOST
+  GLIBCXX_CHECK_HOST
 ])
 
 
@@ -222,8 +222,8 @@ dnl
 dnl Check to see if g++ can compile this library, and if so, if any version-
 dnl specific precautions need to be taken.
 dnl
-dnl GLIBCPP_CHECK_COMPILER_VERSION
-AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
+dnl GLIBCXX_CHECK_COMPILER_VERSION
+AC_DEFUN(GLIBCXX_CHECK_COMPILER_VERSION, [
 if test ! -f stamp-sanity-compiler; then
   AC_MSG_CHECKING([for g++ that will successfully compile libstdc++-v3])
   AC_LANG_SAVE
@@ -252,11 +252,11 @@ dnl
 dnl Define SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 dnl compiler supports it and the user has not requested debug mode.
 dnl
-dnl GLIBCPP_CHECK_COMPILER_FEATURES
-AC_DEFUN(GLIBCPP_CHECK_COMPILER_FEATURES, [
+dnl GLIBCXX_CHECK_COMPILER_FEATURES
+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 GLIBCPP_CONFIGURE.
+  # found in GLIBCXX_CONFIGURE.
   AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_test_CXXFLAGS="${CXXFLAGS+set}"
@@ -298,11 +298,11 @@ dnl safe (like an empty string).
 dnl
 dnl Define SECTION_LDFLAGS='-Wl,--gc-sections' if possible.
 dnl Define OPT_LDFLAGS='-Wl,-O1' if possible.
-dnl Define LD, with_gnu_ld, and (possibly) glibcpp_gnu_ld_version as
+dnl Define LD, with_gnu_ld, and (possibly) glibcxx_gnu_ld_version as
 dnl side-effects of testing.
 dnl
-dnl GLIBCPP_CHECK_LINKER_FEATURES
-AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [
+dnl GLIBCXX_CHECK_LINKER_FEATURES
+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...
@@ -331,7 +331,7 @@ AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [
   ldver=`$LD --version 2>/dev/null | head -1 | \
          sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
   changequote([,])
-  glibcpp_gnu_ld_version=`echo $ldver | \
+  glibcxx_gnu_ld_version=`echo $ldver | \
          $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
 
   # Set --gc-sections.
@@ -387,11 +387,11 @@ dnl Check to see if the (math function) argument passed is
 dnl declared when using the c++ compiler
 dnl ASSUMES argument is a math function with ONE parameter
 dnl
-dnl GLIBCPP_CHECK_MATH_DECL_1
-AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_1, [
+dnl GLIBCXX_CHECK_MATH_DECL_1
+AC_DEFUN(GLIBCXX_CHECK_MATH_DECL_1, [
   AC_MSG_CHECKING([for $1 declaration])
-  if test x${glibcpp_cv_func_$1_use+set} != xset; then
-    AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
+  if test x${glibcxx_cv_func_$1_use+set} != xset; then
+    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
       AC_LANG_SAVE
       AC_LANG_CPLUSPLUS
       AC_TRY_COMPILE([#include <math.h>
@@ -400,11 +400,11 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_1, [
 		      #endif
 		     ],
                      [ $1(0);],
-                     [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
+                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
       AC_LANG_RESTORE
     ])
   fi
-  AC_MSG_RESULT($glibcpp_cv_func_$1_use)
+  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 ])
 
 dnl
@@ -419,14 +419,14 @@ dnl argument 1 is name of function to check
 dnl
 dnl ASSUMES argument is a math function with ONE parameter
 dnl
-dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1
-AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [
-  GLIBCPP_CHECK_MATH_DECL_1($1)
-  if test x$glibcpp_cv_func_$1_use = x"yes"; then
+dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1
+AC_DEFUN(GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1, [
+  GLIBCXX_CHECK_MATH_DECL_1($1)
+  if test x$glibcxx_cv_func_$1_use = x"yes"; then
     AC_CHECK_FUNCS($1)
   else
-    GLIBCPP_CHECK_MATH_DECL_1(_$1)
-    if test x$glibcpp_cv_func__$1_use = x"yes"; then
+    GLIBCXX_CHECK_MATH_DECL_1(_$1)
+    if test x$glibcxx_cv_func__$1_use = x"yes"; then
       AC_CHECK_FUNCS(_$1)
     fi
   fi
@@ -434,22 +434,22 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [
 
 
 dnl
-dnl Like GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
+dnl Like GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
 dnl of functions at once.  It's an all-or-nothing check -- either
 dnl HAVE_XYZ is defined for each of the functions, or for none of them.
 dnl Doing it this way saves significant configure time.
-AC_DEFUN(GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1, [
+AC_DEFUN(GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1, [
   AC_MSG_CHECKING([for $1 functions])
-  AC_CACHE_VAL(glibcpp_cv_func_$2_use, [
+  AC_CACHE_VAL(glibcxx_cv_func_$2_use, [
     AC_LANG_SAVE
     AC_LANG_CPLUSPLUS
     AC_TRY_COMPILE([#include <math.h>],
                    [ `for x in $3; do echo "$x (0);"; done` ],
-                   [glibcpp_cv_func_$2_use=yes],
-                   [glibcpp_cv_func_$2_use=no])
+                   [glibcxx_cv_func_$2_use=yes],
+                   [glibcxx_cv_func_$2_use=no])
     AC_LANG_RESTORE])
-  AC_MSG_RESULT($glibcpp_cv_func_$2_use)
-  if test x$glibcpp_cv_func_$2_use = x"yes"; then
+  AC_MSG_RESULT($glibcxx_cv_func_$2_use)
+  if test x$glibcxx_cv_func_$2_use = x"yes"; then
     AC_CHECK_FUNCS($3)
   fi
 ])
@@ -459,20 +459,20 @@ dnl Check to see if the (math function) argument passed is
 dnl declared when using the c++ compiler
 dnl ASSUMES argument is a math function with TWO parameters
 dnl
-dnl GLIBCPP_CHECK_MATH_DECL_2
-AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_2, [
+dnl GLIBCXX_CHECK_MATH_DECL_2
+AC_DEFUN(GLIBCXX_CHECK_MATH_DECL_2, [
   AC_MSG_CHECKING([for $1 declaration])
-  if test x${glibcpp_cv_func_$1_use+set} != xset; then
-    AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
+  if test x${glibcxx_cv_func_$1_use+set} != xset; then
+    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
       AC_LANG_SAVE
       AC_LANG_CPLUSPLUS
       AC_TRY_COMPILE([#include <math.h>],
                      [ $1(0, 0);],
-                     [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
+                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
       AC_LANG_RESTORE
     ])
   fi
-  AC_MSG_RESULT($glibcpp_cv_func_$1_use)
+  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 ])
 
 dnl
@@ -486,14 +486,14 @@ dnl argument 1 is name of function to check
 dnl
 dnl ASSUMES argument is a math function with TWO parameters
 dnl
-dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2
-AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [
-  GLIBCPP_CHECK_MATH_DECL_2($1)
-  if test x$glibcpp_cv_func_$1_use = x"yes"; then
+dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2
+AC_DEFUN(GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2, [
+  GLIBCXX_CHECK_MATH_DECL_2($1)
+  if test x$glibcxx_cv_func_$1_use = x"yes"; then
     AC_CHECK_FUNCS($1)
   else
-    GLIBCPP_CHECK_MATH_DECL_2(_$1)
-    if test x$glibcpp_cv_func__$1_use = x"yes"; then
+    GLIBCXX_CHECK_MATH_DECL_2(_$1)
+    if test x$glibcxx_cv_func__$1_use = x"yes"; then
       AC_CHECK_FUNCS(_$1)
     fi
   fi
@@ -505,20 +505,20 @@ dnl Check to see if the (math function) argument passed is
 dnl declared when using the c++ compiler
 dnl ASSUMES argument is a math function with THREE parameters
 dnl
-dnl GLIBCPP_CHECK_MATH_DECL_3
-AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_3, [
+dnl GLIBCXX_CHECK_MATH_DECL_3
+AC_DEFUN(GLIBCXX_CHECK_MATH_DECL_3, [
   AC_MSG_CHECKING([for $1 declaration])
-  if test x${glibcpp_cv_func_$1_use+set} != xset; then
-    AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
+  if test x${glibcxx_cv_func_$1_use+set} != xset; then
+    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
       AC_LANG_SAVE
       AC_LANG_CPLUSPLUS
       AC_TRY_COMPILE([#include <math.h>],
                      [ $1(0, 0, 0);],
-                     [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
+                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
       AC_LANG_RESTORE
     ])
   fi
-  AC_MSG_RESULT($glibcpp_cv_func_$1_use)
+  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 ])
 
 dnl
@@ -532,14 +532,14 @@ dnl argument 1 is name of function to check
 dnl
 dnl ASSUMES argument is a math function with THREE parameters
 dnl
-dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3
-AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [
-  GLIBCPP_CHECK_MATH_DECL_3($1)
-  if test x$glibcpp_cv_func_$1_use = x"yes"; then
+dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3
+AC_DEFUN(GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3, [
+  GLIBCXX_CHECK_MATH_DECL_3($1)
+  if test x$glibcxx_cv_func_$1_use = x"yes"; then
     AC_CHECK_FUNCS($1)
   else
-    GLIBCPP_CHECK_MATH_DECL_3(_$1)
-    if test x$glibcpp_cv_func__$1_use = x"yes"; then
+    GLIBCXX_CHECK_MATH_DECL_3(_$1)
+    if test x$glibcxx_cv_func__$1_use = x"yes"; then
       AC_CHECK_FUNCS(_$1)
     fi
   fi
@@ -555,21 +555,21 @@ dnl argument 1 is name of function to check
 dnl
 dnl ASSUMES argument is a math function with TWO parameters
 dnl
-dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2
-AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2, [
+dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2
+AC_DEFUN(GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2, [
   AC_MSG_CHECKING([for $1 declaration])
-  if test x${glibcpp_cv_func_$1_use+set} != xset; then
-    AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
+  if test x${glibcxx_cv_func_$1_use+set} != xset; then
+    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
       AC_LANG_SAVE
       AC_LANG_CPLUSPLUS
       AC_TRY_COMPILE([#include <stdlib.h>],
                      [ $1(0, 0);],
-                     [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
+                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
       AC_LANG_RESTORE
     ])
   fi
-  AC_MSG_RESULT($glibcpp_cv_func_$1_use)
-  if test x$glibcpp_cv_func_$1_use = x"yes"; then
+  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
+  if test x$glibcxx_cv_func_$1_use = x"yes"; then
     AC_CHECK_FUNCS($1)
   fi
 ])
@@ -584,21 +584,21 @@ dnl argument 1 is name of function to check
 dnl
 dnl ASSUMES argument is a function with THREE parameters
 dnl
-dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3
-AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3, [
+dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3
+AC_DEFUN(GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3, [
   AC_MSG_CHECKING([for $1 declaration])
-  if test x${glibcpp_cv_func_$1_use+set} != xset; then
-    AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
+  if test x${glibcxx_cv_func_$1_use+set} != xset; then
+    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
       AC_LANG_SAVE
       AC_LANG_CPLUSPLUS
       AC_TRY_COMPILE([#include <stdlib.h>],
                      [ $1(0, 0, 0);],
-                     [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
+                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
       AC_LANG_RESTORE
     ])
   fi
-  AC_MSG_RESULT($glibcpp_cv_func_$1_use)
-  if test x$glibcpp_cv_func_$1_use = x"yes"; then
+  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
+  if test x$glibcxx_cv_func_$1_use = x"yes"; then
     AC_CHECK_FUNCS($1)
   fi
 ])
@@ -616,31 +616,31 @@ dnl argument 1 is name of function to check
 dnl
 dnl ASSUMES argument is a math function with ONE parameter
 dnl
-dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
-AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
+dnl GLIBCXX_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
+AC_DEFUN(GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
   AC_MSG_CHECKING([for $1 declaration])
-  if test x${glibcpp_cv_func_$1_use+set} != xset; then
-    AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
+  if test x${glibcxx_cv_func_$1_use+set} != xset; then
+    AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
       AC_LANG_SAVE
       AC_LANG_CPLUSPLUS
       AC_TRY_COMPILE([#include <math.h>],
                      [ $1(0);],
-                     [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
+                     [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
       AC_LANG_RESTORE
     ])
   fi
-  AC_MSG_RESULT($glibcpp_cv_func_$1_use)
-  if test x$glibcpp_cv_func_$1_use = x"yes"; then
+  AC_MSG_RESULT($glibcxx_cv_func_$1_use)
+  if test x$glibcxx_cv_func_$1_use = x"yes"; then
     AC_MSG_CHECKING([for $1 linkage])
-    if test x${glibcpp_cv_func_$1_link+set} != xset; then
-      AC_CACHE_VAL(glibcpp_cv_func_$1_link, [
+    if test x${glibcxx_cv_func_$1_link+set} != xset; then
+      AC_CACHE_VAL(glibcxx_cv_func_$1_link, [
         AC_TRY_LINK([#include <math.h>],
                     [ $1(0);],
-                    [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no])
+                    [glibcxx_cv_func_$1_link=yes], [glibcxx_cv_func_$1_link=no])
       ])
     fi
-    AC_MSG_RESULT($glibcpp_cv_func_$1_link)
-    if test x$glibcpp_cv_func_$1_link = x"yes"; then
+    AC_MSG_RESULT($glibcxx_cv_func_$1_link)
+    if test x$glibcxx_cv_func_$1_link = x"yes"; then
       ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
       AC_DEFINE_UNQUOTED(${ac_tr_func})
     fi
@@ -666,27 +666,27 @@ dnl check for __builtin_cosf
 dnl check for __builtin_cos
 dnl check for __builtin_cosl
 dnl
-dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
-AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
+dnl GLIBCXX_CHECK_BUILTIN_MATH_SUPPORT
+AC_DEFUN(GLIBCXX_CHECK_BUILTIN_MATH_SUPPORT, [
   dnl Test for builtin math functions.
   dnl These are made in gcc/c-common.c
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
 
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrt)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrt)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
 
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
 
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
-  GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
+  GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
 
   dnl There is, without a doubt, a more elegant way to have these
   dnl names exported so that they won't be stripped out of acconfig.h by
@@ -724,14 +724,14 @@ dnl Define HAVE_STRTOLD if "strtold" is declared and links
 dnl Define HAVE_STRTOF if "strtof" is declared and links
 dnl Define HAVE_DRAND48 if "drand48" is declared and links
 dnl
-dnl GLIBCPP_CHECK_STDLIB_SUPPORT
-AC_DEFUN(GLIBCPP_CHECK_STDLIB_SUPPORT, [
+dnl GLIBCXX_CHECK_STDLIB_SUPPORT
+AC_DEFUN(GLIBCXX_CHECK_STDLIB_SUPPORT, [
   ac_test_CXXFLAGS="${CXXFLAGS+set}"
   ac_save_CXXFLAGS="$CXXFLAGS"
   CXXFLAGS='-fno-builtin -D_GNU_SOURCE'
 
-  GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
-  GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof)
+  GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
+  GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof)
   AC_CHECK_FUNCS(drand48)
 
   CXXFLAGS="$ac_save_CXXFLAGS"
@@ -746,8 +746,8 @@ dnl This might seem like overkill but experience has shown that it's not...
 dnl
 dnl Define HAVE_CARGF etc if "cargf" is found.
 dnl
-dnl GLIBCPP_CHECK_MATH_SUPPORT
-AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
+dnl GLIBCXX_CHECK_MATH_SUPPORT
+AC_DEFUN(GLIBCXX_CHECK_MATH_SUPPORT, [
   ac_test_CXXFLAGS="${CXXFLAGS+set}"
   ac_save_CXXFLAGS="$CXXFLAGS"
   CXXFLAGS='-fno-builtin -D_GNU_SOURCE'
@@ -758,67 +758,67 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
   LIBS="$LIBS $libm"
 
   dnl Check to see if certain C math functions exist.
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypot)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypot)
 
   dnl Check to see if basic C math functions have float versions.
-  GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
+  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
                                           float_trig,
                                           acosf asinf atanf \
                                           cosf sinf tanf \
                                           coshf sinhf tanhf)
-  GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
+  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
                                           float_round,
                                           ceilf floorf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
 
   dnl Check to see if basic C math functions have long double versions.
-  GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
+  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
                                           long_double_trig,
                                           acosl asinl atanl \
                                           cosl sinl tanl \
                                           coshl sinhl tanhl)
-  GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
+  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
                                           long_double_round,
                                           ceill floorl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
-  GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
+  GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
 
   dnl Some runtimes have these functions with a preceding underscore. Please
   dnl keep this sync'd with the one above. And if you add any new symbol,
@@ -826,22 +826,22 @@ AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
   dnl Check to see if certain C math functions exist.
 
   dnl Check to see if basic C math functions have float versions.
-  GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float trig,
+  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(_float trig,
                                           _float_trig,
                                           _acosf _asinf _atanf \
                                           _cosf _sinf _tanf \
                                           _coshf _sinhf _tanhf)
-  GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float round,
+  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(_float round,
                                           _float_round,
                                           _ceilf _floorf)
 
   dnl Check to see if basic C math functions have long double versions.
-  GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double trig,
+  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double trig,
                                           _long_double_trig,
                                           _acosl _asinl _atanl \
                                           _cosl _sinl _tanl \
                                           _coshl _sinhl _tanhl)
-  GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double round,
+  GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double round,
                                           _long_double_round,
                                           _ceill _floorl)
 
@@ -857,8 +857,8 @@ dnl Don't compile bits in math/* if native support exits.
 dnl
 dnl Define USE_COMPLEX_LONG_DOUBLE etc if "copysignl" is found.
 dnl
-dnl GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT
-AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
+dnl GLIBCXX_CHECK_COMPLEX_MATH_SUPPORT
+AC_DEFUN(GLIBCXX_CHECK_COMPLEX_MATH_SUPPORT, [
   dnl Check for complex versions of math functions of platform.  This will
   dnl always pass if libm is available, and fail if it isn't.  If it is
   dnl available, we assume we'll need it later, so add it to LIBS.
@@ -872,7 +872,7 @@ AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
   dnl Compile the long double complex functions only if the function
   dnl provides the non-complex long double functions that are needed.
   dnl Currently this includes copysignl, which should be
-  dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
+  dnl cached from the GLIBCXX_CHECK_MATH_SUPPORT macro, above.
   if test x$ac_cv_func_copysignl = x"yes"; then
     AC_CHECK_FUNCS([__signbitl], , [LIBMATHOBJS="$LIBMATHOBJS signbitl.lo"])
   fi
@@ -888,9 +888,9 @@ 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
-dnl GLIBCPP_CHECK_HOST
-AC_DEFUN(GLIBCPP_CHECK_HOST, [
-  . [$]{glibcpp_basedir}/configure.host
+dnl GLIBCXX_CHECK_HOST
+AC_DEFUN(GLIBCXX_CHECK_HOST, [
+  . [$]{glibcxx_basedir}/configure.host
   AC_MSG_RESULT(CPU config directory is $cpu_include_dir)
   AC_MSG_RESULT(OS config directory is $os_include_dir)
 ])
@@ -901,11 +901,11 @@ dnl Check to see if this target can enable the wchar_t parts of libstdc++.
 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
 dnl must have been previously checked.)
 dnl
-dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found
+dnl Define _GLIBCXX_USE_WCHAR_T if all the bits are found
 dnl Define HAVE_MBSTATE_T if mbstate_t is not in wchar.h
 dnl
-dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT
-AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
+dnl GLIBCXX_CHECK_WCHAR_T_SUPPORT
+AC_DEFUN(GLIBCXX_CHECK_WCHAR_T_SUPPORT, [
   dnl Wide characters disabled by default.
 
   dnl Test wchar.h for mbstate_t, which is needed for char_traits and
@@ -999,7 +999,7 @@ AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
     dnl above support is present.
     if test x"$ac_isoC99_wchar_t" = xyes && 
 	test x"$ac_XPG2_wchar_t" = xyes; then
-      AC_DEFINE(_GLIBCPP_USE_WCHAR_T)
+      AC_DEFINE(_GLIBCXX_USE_WCHAR_T)
       enable_wchar_t=yes
     fi
   fi
@@ -1011,7 +1011,7 @@ AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
 dnl
 dnl Check to see if debugging libraries are to be built.
 dnl
-dnl GLIBCPP_ENABLE_DEBUG
+dnl GLIBCXX_ENABLE_DEBUG
 dnl
 dnl --enable-libstdcxx-debug
 dnl builds a separate set of debugging libraries in addition to the
@@ -1023,53 +1023,53 @@ dnl
 dnl --enable-libstdcxx-debug-flags=FLAGS
 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
 dnl
-dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG[(DEFAULT)]
+dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
 dnl       defaults to `no'.
-AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl
-define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
+AC_DEFUN(GLIBCXX_ENABLE_DEBUG, [dnl
+define([GLIBCXX_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
 AC_ARG_ENABLE(libstdcxx_debug,
 changequote(<<, >>)dnl
-<<  --enable-libstdcxx-debug          build extra debug library [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT],
+<<  --enable-libstdcxx-debug          build extra debug library [default=>>GLIBCXX_ENABLE_DEBUG_DEFAULT],
 changequote([, ])dnl
 [case "${enableval}" in
  yes) enable_libstdcxx_debug=yes ;;
  no)  enable_libstdcxx_debug=no ;;
  *)   AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;;
  esac],
-enable_libstdcxx_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl
+enable_libstdcxx_debug=GLIBCXX_ENABLE_DEBUG_DEFAULT)dnl
 AC_MSG_CHECKING([for additional debug build])
 AC_MSG_RESULT($enable_libstdcxx_debug)
-AM_CONDITIONAL(GLIBCPP_BUILD_DEBUG, test "$enable_libstdcxx_debug" = yes)
+AM_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test "$enable_libstdcxx_debug" = yes)
 ])
 
 
 dnl Check for explicit debug flags.
 dnl
-dnl GLIBCPP_ENABLE_DEBUG_FLAGS
+dnl GLIBCXX_ENABLE_DEBUG_FLAGS
 dnl
 dnl --enable-libstdcxx-debug-flags='-O1'
 dnl is a general method for passing flags to be used when
 dnl building debug libraries with --enable-debug.
 dnl
 dnl --disable-libstdcxx-debug-flags does nothing.
-dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG_FLAGS(default flags)
+dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
 dnl       If "default flags" is an empty string (or "none"), the effect is
 dnl       the same as --disable or --enable=no.
-AC_DEFUN(GLIBCPP_ENABLE_DEBUG_FLAGS, [dnl
-define([GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
+AC_DEFUN(GLIBCXX_ENABLE_DEBUG_FLAGS, [dnl
+define([GLIBCXX_ENABLE_DEBUG_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
 AC_ARG_ENABLE(libstdcxx_debug_flags,
 changequote(<<, >>)dnl
 <<  --enable-libstdcxx-debug-flags=FLAGS    pass compiler FLAGS when building 
                                             debug library;
-                                [default=>>GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT],
+                                [default=>>GLIBCXX_ENABLE_DEBUG_FLAGS_DEFAULT],
 changequote([, ])dnl
 [case "${enableval}" in
  none)  ;;
  -*) enable_libstdcxx_debug_flags="${enableval}" ;;
  *)   AC_MSG_ERROR([Unknown argument to extra debugging flags]) ;;
  esac],
-enable_libstdcxx_debug_flags=GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT)dnl
+enable_libstdcxx_debug_flags=GLIBCXX_ENABLE_DEBUG_FLAGS_DEFAULT)dnl
 
 dnl Option parsed, now set things appropriately
 case x"$enable_libstdcxx_debug" in
@@ -1095,7 +1095,7 @@ AC_MSG_RESULT($DEBUG_FLAGS)
 dnl
 dnl Check for "unusual" flags to pass to the compiler while building.
 dnl
-dnl GLIBCPP_ENABLE_CXX_FLAGS
+dnl GLIBCXX_ENABLE_CXX_FLAGS
 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
 dnl     experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc.
 dnl     Somehow this same set of flags must be passed when [re]building
@@ -1104,16 +1104,16 @@ dnl --disable-cxx-flags passes nothing.
 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
-dnl  +  Usage:  GLIBCPP_ENABLE_CXX_FLAGS(default flags)
+dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
 dnl       If "default flags" is an empty string (or "none"), the effect is
 dnl       the same as --disable or --enable=no.
-AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl
-define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
+AC_DEFUN(GLIBCXX_ENABLE_CXX_FLAGS, [dnl
+define([GLIBCXX_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
 AC_MSG_CHECKING([for extra compiler flags for building])
 AC_ARG_ENABLE(cxx_flags,
 changequote(<<, >>)dnl
 <<  --enable-cxx-flags=FLAGS     pass compiler FLAGS when building library;
-                                  [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT],
+                                  [default=>>GLIBCXX_ENABLE_CXX_FLAGS_DEFAULT],
 changequote([, ])dnl
 [case "x$enable_cxx_flags" in
   xyes)
@@ -1123,7 +1123,7 @@ changequote([, ])dnl
   *)
     enable_cxx_flags="$enableval" ;;
 esac],
-enable_cxx_flags=GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT)
+enable_cxx_flags=GLIBCXX_ENABLE_CXX_FLAGS_DEFAULT)
 
 dnl Run through flags (either default or command-line) and set anything
 dnl extra (e.g., #defines) that must accompany particular g++ options.
@@ -1146,13 +1146,13 @@ AC_SUBST(EXTRA_CXX_FLAGS)
 dnl
 dnl Check for which locale library to use:  gnu or generic.
 dnl
-dnl GLIBCPP_ENABLE_CLOCALE
+dnl GLIBCXX_ENABLE_CLOCALE
 dnl --enable-clocale=gnu sets config/locale/c_locale_gnu.cc and friends
 dnl --enable-clocale=generic sets config/locale/c_locale_generic.cc and friends
 dnl
 dnl default is generic
 dnl
-AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
+AC_DEFUN(GLIBCXX_ENABLE_CLOCALE, [
   AC_MSG_CHECKING([for clocale to use])
   AC_ARG_ENABLE(clocale,
   [  --enable-clocale        enable model for target locale package.
@@ -1170,10 +1170,10 @@ AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
   if test x$enable_clocale_flag = xno; then
     case x${target_os} in
       xlinux* | xgnu*)
-	AC_EGREP_CPP([_GLIBCPP_ok], [
+	AC_EGREP_CPP([_GLIBCXX_ok], [
         #include <features.h>
         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
-          _GLIBCPP_ok
+          _GLIBCXX_ok
         #endif
         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
 
@@ -1255,11 +1255,11 @@ AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
       fi
       # Export the build objects.
       for ling in $ALL_LINGUAS; do \
-        glibcpp_MOFILES="$glibcpp_MOFILES $ling.mo"; \
-        glibcpp_POFILES="$glibcpp_POFILES $ling.po"; \
+        glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
+        glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
       done
-      AC_SUBST(glibcpp_MOFILES)
-      AC_SUBST(glibcpp_POFILES)
+      AC_SUBST(glibcxx_MOFILES)
+      AC_SUBST(glibcxx_POFILES)
 
       CLOCALE_H=config/locale/gnu/c_locale.h
       CLOCALE_CC=config/locale/gnu/c_locale.cc
@@ -1300,8 +1300,8 @@ AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
 
   # This is where the testsuite looks for locale catalogs, using the
   # -DLOCALEDIR define during testsuite compilation.
-  glibcpp_localedir=${glibcpp_builddir}/po/share/locale
-  AC_SUBST(glibcpp_localedir)
+  glibcxx_localedir=${glibcxx_builddir}/po/share/locale
+  AC_SUBST(glibcxx_localedir)
 
   # A standalone libintl (e.g., GNU libintl) may be in use.
   if test $USE_NLS = yes; then
@@ -1309,7 +1309,7 @@ AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
   fi
   if test $USE_NLS = yes; then
-    AC_DEFINE(_GLIBCPP_USE_NLS)
+    AC_DEFINE(_GLIBCXX_USE_NLS)
   fi
 
   AC_SUBST(USE_NLS)
@@ -1332,11 +1332,11 @@ AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
 dnl
 dnl Check for which I/O library to use:  stdio, or something specific.
 dnl
-dnl GLIBCPP_ENABLE_CSTDIO
+dnl GLIBCXX_ENABLE_CSTDIO
 dnl
 dnl default is stdio
 dnl
-AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
+AC_DEFUN(GLIBCXX_ENABLE_CSTDIO, [
   AC_MSG_CHECKING([for cstdio to use])
   AC_ARG_ENABLE(cstdio,
   [  --enable-cstdio         enable stdio for target io package.
@@ -1377,7 +1377,7 @@ AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
 dnl
 dnl Check to see if building and using a C++ precompiled header can be done.
 dnl
-dnl GLIBCPP_ENABLE_PCH
+dnl GLIBCXX_ENABLE_PCH
 dnl
 dnl --enable-libstdcxx-pch=yes
 dnl default, this shows intent to use stdc++.h.gch If it looks like it
@@ -1387,18 +1387,18 @@ dnl
 dnl --disable-libstdcxx-pch
 dnl turns off attempts to use or build stdc++.h.gch.
 dnl
-AC_DEFUN(GLIBCPP_ENABLE_PCH, [dnl
-define([GLIBCPP_ENABLE_PCH_DEFAULT], ifelse($1,,, $1))dnl
+AC_DEFUN(GLIBCXX_ENABLE_PCH, [dnl
+define([GLIBCXX_ENABLE_PCH_DEFAULT], ifelse($1,,, $1))dnl
 AC_ARG_ENABLE(libstdcxx_pch,
 changequote(<<, >>)dnl
-<<  --enable-libstdcxx-pch     build pre-compiled libstdc++ includes [default=>>GLIBCPP_ENABLE_PCH_DEFAULT],
+<<  --enable-libstdcxx-pch     build pre-compiled libstdc++ includes [default=>>GLIBCXX_ENABLE_PCH_DEFAULT],
 changequote([, ])dnl
 [case "${enableval}" in
  yes) enable_libstdcxx_pch=yes ;;
  no)  enable_libstdcxx_pch=no ;;
  *)   AC_MSG_ERROR([Unknown argument to enable/disable PCH]) ;;
  esac],
-enable_libstdcxx_pch=GLIBCPP_ENABLE_PCH_DEFAULT)dnl
+enable_libstdcxx_pch=GLIBCXX_ENABLE_PCH_DEFAULT)dnl
 
   if test x$enable_libstdcxx_pch = xyes; then
     ac_test_CXXFLAGS="${CXXFLAGS+set}"
@@ -1427,13 +1427,13 @@ enable_libstdcxx_pch=GLIBCPP_ENABLE_PCH_DEFAULT)dnl
   AC_MSG_CHECKING([for enabled PCH])
   AC_MSG_RESULT([$enable_libstdcxx_pch])
 
-  AM_CONDITIONAL(GLIBCPP_BUILD_PCH, test "$enable_libstdcxx_pch" = yes)
+  AM_CONDITIONAL(GLIBCXX_BUILD_PCH, test "$enable_libstdcxx_pch" = yes)
   if test "$enable_libstdcxx_pch" = yes; then
-	glibcpp_PCHFLAGS="-include bits/stdc++.h"
+	glibcxx_PCHFLAGS="-include bits/stdc++.h"
   else
-	glibcpp_PCHFLAGS=""
+	glibcxx_PCHFLAGS=""
   fi
-  AC_SUBST(glibcpp_PCHFLAGS)
+  AC_SUBST(glibcxx_PCHFLAGS)
 ])
 
 dnl
@@ -1448,18 +1448,18 @@ dnl having to write complex code (the sed commands to clean the macro
 dnl namespace are complex and fragile enough as it is).  We must also
 dnl add a relative path so that -I- is supported properly.
 dnl
-AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
+AC_DEFUN(GLIBCXX_ENABLE_THREADS, [
   AC_MSG_CHECKING([for thread model used by GCC])
   target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
   AC_MSG_RESULT([$target_thread_file])
 
   if test $target_thread_file != single; then
     AC_DEFINE(HAVE_GTHR_DEFAULT)
-    AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__)
+    AC_DEFINE(_GLIBCXX_SUPPORTS_WEAK, __GXX_WEAK__)
   fi
 
-  glibcpp_thread_h=gthr-$target_thread_file.h
-  AC_SUBST(glibcpp_thread_h)
+  glibcxx_thread_h=gthr-$target_thread_file.h
+  AC_SUBST(glibcxx_thread_h)
 ])
 
 
@@ -1468,13 +1468,13 @@ 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.
 dnl
-dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS
+dnl GLIBCXX_ENABLE_SJLJ_EXCEPTIONS
 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
 dnl
-dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it.
+dnl Define _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it.
 dnl
-AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [
+AC_DEFUN(GLIBCXX_ENABLE_SJLJ_EXCEPTIONS, [
   AC_MSG_CHECKING([for exception model to use])
   AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
@@ -1510,7 +1510,7 @@ EOF
    CXXFLAGS="$old_CXXFLAGS"
    rm -f conftest*])
    if test x$enable_sjlj_exceptions = xyes; then
-     AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1,
+     AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
         [Define if the compiler is configured for setjmp/longjmp exceptions.])
      ac_exception_model_name=sjlj
    elif test x$enable_sjlj_exceptions = xno; then
@@ -1530,13 +1530,13 @@ dnl (_Unwind_RaiseException, _Unwind_Resume, etc.) are defined by
 dnl libunwind instead of libgcc and that libstdc++ has a dependency
 dnl on libunwind as well as libgcc.
 dnl
-dnl GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS
+dnl GLIBCXX_ENABLE_LIBUNWIND_EXCEPTIONS
 dnl --enable-libunwind-exceptions forces the use of libunwind.
 dnl --disable-libunwind-exceptions assumes there is no libunwind.
 dnl
-dnl Define _GLIBCPP_LIBUNWIND_EXCEPTIONS if requested.
+dnl Define _GLIBCXX_LIBUNWIND_EXCEPTIONS if requested.
 dnl
-AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [
+AC_DEFUN(GLIBCXX_ENABLE_LIBUNWIND_EXCEPTIONS, [
   AC_MSG_CHECKING([for use of libunwind])
   AC_ARG_ENABLE(libunwind-exceptions,
   [  --enable-libunwind-exceptions  force use of libunwind for exceptions],
@@ -1555,28 +1555,28 @@ AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [
 dnl
 dnl Check for ISO/IEC 9899:1999 "C99" support.
 dnl
-dnl GLIBCPP_ENABLE_C99
-dnl --enable-c99 defines _GLIBCPP_USE_C99
-dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
-dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
+dnl GLIBCXX_ENABLE_C99
+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'.  If omitted, it
 dnl       defaults to `no'.
 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
 dnl
-dnl GLIBCPP_ENABLE_C99
-AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
-  define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
+dnl GLIBCXX_ENABLE_C99
+AC_DEFUN(GLIBCXX_ENABLE_C99, [dnl
+  define([GLIBCXX_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
 
   AC_ARG_ENABLE(c99,
   changequote(<<, >>)dnl
-  <<--enable-c99            turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
+  <<--enable-c99            turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCXX_ENABLE_C99_DEFAULT],
   changequote([, ])dnl
   [case "$enableval" in
    yes) enable_c99=yes ;;
    no)  enable_c99=no ;;
    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
    esac],
-  enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
+  enable_c99=GLIBCXX_ENABLE_C99_DEFAULT)dnl
 
   AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
@@ -1679,7 +1679,7 @@ AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
 
   # Option parsed, now set things appropriately
   if test x"$enable_c99" = x"yes"; then
-    AC_DEFINE(_GLIBCPP_USE_C99)
+    AC_DEFINE(_GLIBCXX_USE_C99)
   fi
 
   AC_LANG_RESTORE
@@ -1691,28 +1691,28 @@ dnl Check for template specializations for the 'long long' type extension.
 dnl The result determines only whether 'long long' I/O is enabled; things
 dnl like numeric_limits<> specializations are always available.
 dnl
-dnl GLIBCPP_ENABLE_LONG_LONG
-dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
-dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
-dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
+dnl GLIBCXX_ENABLE_LONG_LONG
+dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
+dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
+dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
 dnl       defaults to `no'.
 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
 dnl
-dnl GLIBCPP_ENABLE_LONG_LONG
-AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
-  define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
+dnl GLIBCXX_ENABLE_LONG_LONG
+AC_DEFUN(GLIBCXX_ENABLE_LONG_LONG, [dnl
+  define([GLIBCXX_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
 
   AC_ARG_ENABLE(long-long,
   changequote(<<, >>)dnl
-  <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
+  <<--enable-long-long      turns on 'long long' [default=>>GLIBCXX_ENABLE_LONG_LONG_DEFAULT],
   changequote([, ])dnl
   [case "$enableval" in
    yes) enable_long_long=yes ;;
    no)  enable_long_long=no ;;
    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
    esac],
-  enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
+  enable_long_long=GLIBCXX_ENABLE_LONG_LONG_DEFAULT)dnl
 
   AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
@@ -1726,7 +1726,7 @@ AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
 
   # Option parsed, now set things appropriately
   if test x"$enable_long_long" = xyes; then
-    AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
+    AC_DEFINE(_GLIBCXX_USE_LONG_LONG)
   fi
   AC_MSG_RESULT($enable_long_long)
 
@@ -1737,18 +1737,18 @@ AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
 dnl
 dnl Check for what type of C headers to use.
 dnl
-dnl GLIBCPP_ENABLE_CHEADERS
+dnl GLIBCXX_ENABLE_CHEADERS
 dnl --enable-cheaders= [does stuff].
 dnl --disable-cheaders [does not do anything, really].
-dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
+dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
 dnl       Where DEFAULT is either `c' or `c_std'.
 dnl       If ommitted, it defaults to `c_std'.
-AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
-define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
+AC_DEFUN(GLIBCXX_ENABLE_CHEADERS, [dnl
+define([GLIBCXX_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
 AC_MSG_CHECKING([for c header strategy to use])
 AC_ARG_ENABLE(cheaders,
 changequote(<<, >>)dnl
-<<  --enable-cheaders=MODEL       construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
+<<  --enable-cheaders=MODEL       construct "C" header files for g++ [default=>>GLIBCXX_ENABLE_CHEADERS_DEFAULT],
 changequote([, ])
   [case "$enableval" in
    c)
@@ -1760,23 +1760,23 @@ changequote([, ])
    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
         ;;
   esac],
-  enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
+  enable_cheaders=GLIBCXX_ENABLE_CHEADERS_DEFAULT)
   AC_MSG_RESULT($enable_cheaders)
 
   dnl Option parsed, now set things appropriately
   case "$enable_cheaders" in
     c_std)
-        C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_std'
+        C_INCLUDE_DIR='${glibcxx_srcdir}/include/c_std'
         ;;
     c)
-        C_INCLUDE_DIR='${glibcpp_srcdir}/include/c'
+        C_INCLUDE_DIR='${glibcxx_srcdir}/include/c'
         ;;
   esac
 
   AC_SUBST(C_INCLUDE_DIR)
-  AM_CONDITIONAL(GLIBCPP_C_HEADERS_C, test "$enable_cheaders" = c)
-  AM_CONDITIONAL(GLIBCPP_C_HEADERS_C_STD, test "$enable_cheaders" = c_std)
-  AM_CONDITIONAL(GLIBCPP_C_HEADERS_COMPATIBILITY, test "$c_compatibility" = yes)
+  AM_CONDITIONAL(GLIBCXX_C_HEADERS_C, test "$enable_cheaders" = c)
+  AM_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test "$enable_cheaders" = c_std)
+  AM_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test "$c_compatibility" = yes)
 ])
 
 
@@ -1784,24 +1784,24 @@ 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 GLIBCPP_ENABLE_C_MBCHAR
+dnl GLIBCXX_ENABLE_C_MBCHAR
 dnl --enable-c-mbchar requests all the wchar_t stuff.
 dnl --disable-c-mbchar doesn't.
-dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
+dnl  +  Usage:  GLIBCXX_ENABLE_C_MBCHAR[(DEFAULT)]
 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
 dnl       defaults to `no'.
-AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
-define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
+AC_DEFUN(GLIBCXX_ENABLE_C_MBCHAR, [dnl
+define([GLIBCXX_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
 AC_ARG_ENABLE(c-mbchar,
 changequote(<<, >>)dnl
-<<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
+<<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCXX_ENABLE_C_MBCHAR_DEFAULT],
 changequote([, ])dnl
 [case "$enableval" in
  yes) enable_c_mbchar=yes ;;
  no)  enable_c_mbchar=no ;;
  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
  esac],
-enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
+enable_c_mbchar=GLIBCXX_ENABLE_C_MBCHAR_DEFAULT)dnl
 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
 ])
 
@@ -1813,10 +1813,10 @@ dnl TOPLEVEL_INCLUDES
 dnl LIBMATH_INCLUDES
 dnl LIBSUPCXX_INCLUDES
 dnl
-dnl GLIBCPP_EXPORT_INCLUDES
-AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
+dnl GLIBCXX_EXPORT_INCLUDES
+AC_DEFUN(GLIBCXX_EXPORT_INCLUDES, [
   # Root level of the build directory include sources.
-  GLIBCPP_INCLUDES="-I${glibcpp_builddir}/include/${target_alias} -I${glibcpp_builddir}/include"
+  GLIBCXX_INCLUDES="-I${glibcxx_builddir}/include/${target_alias} -I${glibcxx_builddir}/include"
 
   # Passed down for canadian crosses.
   if test x"$CANADIAN" = xyes; then
@@ -1828,7 +1828,7 @@ AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
 
   # Now, export this to all the little Makefiles....
-  AC_SUBST(GLIBCPP_INCLUDES)
+  AC_SUBST(GLIBCXX_INCLUDES)
   AC_SUBST(TOPLEVEL_INCLUDES)
   AC_SUBST(LIBMATH_INCLUDES)
   AC_SUBST(LIBSUPCXX_INCLUDES)
@@ -1838,7 +1838,7 @@ AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
 dnl
 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
 dnl
-AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
+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
@@ -1850,22 +1850,22 @@ AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
 ])
 
 dnl
-dnl  GLIBCPP_EXPORT_INSTALL_INFO
+dnl  GLIBCXX_EXPORT_INSTALL_INFO
 dnl  calculates gxx_install_dir
-dnl  exports glibcpp_toolexecdir
-dnl  exports glibcpp_toolexeclibdir
-dnl  exports glibcpp_prefixdir
+dnl  exports glibcxx_toolexecdir
+dnl  exports glibcxx_toolexeclibdir
+dnl  exports glibcxx_prefixdir
 dnl
 dnl Assumes cross_compiling bits already done, and with_cross_host in
 dnl particular
 dnl
-dnl GLIBCPP_EXPORT_INSTALL_INFO
-AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
-# Assumes glibcpp_builddir, glibcpp_srcdir are alreay set up and
-# exported correctly in GLIBCPP_CONFIGURE.
-glibcpp_toolexecdir=no
-glibcpp_toolexeclibdir=no
-glibcpp_prefixdir=${prefix}
+dnl GLIBCXX_EXPORT_INSTALL_INFO
+AC_DEFUN(GLIBCXX_EXPORT_INSTALL_INFO, [
+# Assumes glibcxx_builddir, glibcxx_srcdir are alreay set up and
+# exported correctly in GLIBCXX_CONFIGURE.
+glibcxx_toolexecdir=no
+glibcxx_toolexeclibdir=no
+glibcxx_prefixdir=${prefix}
 
 # Process the option --with-gxx-include-dir=<path to include-files directory>
 AC_MSG_CHECKING([for --with-gxx-include-dir])
@@ -1911,35 +1911,35 @@ if test $version_specific_libs = yes; then
   if test x"$gxx_include_dir" = x"no"; then
     gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/c++
   fi
-  glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
-  glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
+  glibcxx_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
+  glibcxx_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
 fi
 
-# Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
+# Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
 # Install a library built with a cross compiler in tooldir, not libdir.
-if test x"$glibcpp_toolexecdir" = x"no"; then
+if test x"$glibcxx_toolexecdir" = x"no"; then
   if test -n "$with_cross_host" &&
      test x"$with_cross_host" != x"no"; then
-    glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
-    glibcpp_toolexeclibdir='$(toolexecdir)/lib'
+    glibcxx_toolexecdir='$(exec_prefix)/$(target_alias)'
+    glibcxx_toolexeclibdir='$(toolexecdir)/lib'
   else
-    glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
-    glibcpp_toolexeclibdir='$(libdir)'
+    glibcxx_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
+    glibcxx_toolexeclibdir='$(libdir)'
   fi
   multi_os_directory=`$CC -print-multi-os-directory`
   case $multi_os_directory in
   .) ;; # Avoid trailing /.
-  *) glibcpp_toolexeclibdir=$glibcpp_toolexeclibdir/$multi_os_directory ;;
+  *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
   esac
 fi
 
 AC_MSG_CHECKING([for install location])
 AC_MSG_RESULT($gxx_include_dir)
 
-AC_SUBST(glibcpp_prefixdir)
+AC_SUBST(glibcxx_prefixdir)
 AC_SUBST(gxx_include_dir)
-AC_SUBST(glibcpp_toolexecdir)
-AC_SUBST(glibcpp_toolexeclibdir)
+AC_SUBST(glibcxx_toolexecdir)
+AC_SUBST(glibcxx_toolexeclibdir)
 ])
 
 
@@ -1998,7 +1998,7 @@ dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
 dnl
 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
-dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
+dnl #### GLIBCXX_ to the macro name; adding the :-make fallback in the
 dnl #### conditional's subshell (" --version" is not a command), using a
 dnl #### different option to grep(1).
 dnl #### -pme
@@ -2006,7 +2006,7 @@ dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
 dnl #### ${MAKE:-make}).
 dnl #### -msokolov
 AC_DEFUN(
-  GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
+  GLIBCXX_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
           _cv_gnu_make_command='' ;
 dnl Search all the common names for GNU make
           for a in "${MAKE-make}" make gmake gnumake ; do
@@ -2030,16 +2030,16 @@ dnl string, '#' otherwise
 
 dnl Check for headers for, and arguments to, the setrlimit() function.
 dnl Used only in testsuite_hooks.h.
-AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT_ancilliary, [
+AC_DEFUN(GLIBCXX_CHECK_SETRLIMIT_ancilliary, [
   AC_TRY_COMPILE([#include <unistd.h>
                   #include <sys/time.h>
                   #include <sys/resource.h>
                  ], [ int f = RLIMIT_$1 ; ],
-                 [glibcpp_mresult=1], [glibcpp_mresult=0])
-  AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcpp_mresult,
+                 [glibcxx_mresult=1], [glibcxx_mresult=0])
+  AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcxx_mresult,
                      [Only used in build directory testsuite_hooks.h.])
 ])
-AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
+AC_DEFUN(GLIBCXX_CHECK_SETRLIMIT, [
   setrlimit_have_headers=yes
   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
                    [],
@@ -2048,10 +2048,10 @@ AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
   # 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.
-    GLIBCPP_CHECK_SETRLIMIT_ancilliary(DATA)
-    GLIBCPP_CHECK_SETRLIMIT_ancilliary(RSS)
-    GLIBCPP_CHECK_SETRLIMIT_ancilliary(VMEM)
-    GLIBCPP_CHECK_SETRLIMIT_ancilliary(AS)
+    GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
+    GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
+    GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
+    GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
 
     # Check for rlimit, setrlimit.
     AC_CACHE_VAL(ac_setrlimit, [
@@ -2067,7 +2067,7 @@ AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
   AC_MSG_CHECKING([for testsuite memory limit support])
   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
     ac_mem_limits=yes
-    AC_DEFINE(_GLIBCPP_MEM_LIMITS)
+    AC_DEFINE(_GLIBCXX_MEM_LIMITS)
   else
     ac_mem_limits=no
   fi
@@ -2079,19 +2079,19 @@ dnl
 dnl Does any necessary configuration of the testsuite directory.  Generates
 dnl the testsuite_hooks.h header.
 dnl
-dnl GLIBCPP_CONFIGURE_TESTSUITE  [no args]
-AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [
+dnl GLIBCXX_CONFIGURE_TESTSUITE  [no args]
+AC_DEFUN(GLIBCXX_CONFIGURE_TESTSUITE, [
 
-  if test  x"$GLIBCPP_IS_CROSS_COMPILING" = xfalse; then
+  if test  x"$GLIBCXX_IS_CROSS_COMPILING" = xfalse; then
     # Do checks for memory limit functions.
-    GLIBCPP_CHECK_SETRLIMIT
+    GLIBCXX_CHECK_SETRLIMIT
 
     # Look for setenv, so that extended locale tests can be performed.
-    GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
+    GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
   fi
 
   # Export file names for ABI checking.
-  baseline_dir="${glibcpp_srcdir}/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
+  baseline_dir="${glibcxx_srcdir}/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
   AC_SUBST(baseline_dir)
 
   # Determine if checking the ABI is desirable.
@@ -2106,8 +2106,8 @@ AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [
     esac
   fi
 
-  AM_CONDITIONAL(GLIBCPP_TEST_WCHAR_T, test "$enable_wchar_t" = yes)	
-  AM_CONDITIONAL(GLIBCPP_TEST_ABI, test "$enable_abi_check" = yes)
+  AM_CONDITIONAL(GLIBCXX_TEST_WCHAR_T, test "$enable_wchar_t" = yes)	
+  AM_CONDITIONAL(GLIBCXX_TEST_ABI, test "$enable_abi_check" = yes)
 ])
 
 
@@ -2125,22 +2125,22 @@ dnl
 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
 dnl
 
-AC_DEFUN(GLIBCPP_CHECK_S_ISREG_OR_S_IFREG, [
-  AC_CACHE_VAL(glibcpp_cv_S_ISREG, [
+AC_DEFUN(GLIBCXX_CHECK_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); ],
-                [glibcpp_cv_S_ISREG=yes],
-                [glibcpp_cv_S_ISREG=no])
+                [glibcxx_cv_S_ISREG=yes],
+                [glibcxx_cv_S_ISREG=no])
   ])
-  AC_CACHE_VAL(glibcpp_cv_S_IFREG, [
+  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; ],
-                [glibcpp_cv_S_IFREG=yes],
-                [glibcpp_cv_S_IFREG=no])
+                [glibcxx_cv_S_IFREG=yes],
+                [glibcxx_cv_S_IFREG=no])
   ])
-  if test x$glibcpp_cv_S_ISREG = xyes; then
+  if test x$glibcxx_cv_S_ISREG = xyes; then
     AC_DEFINE(HAVE_S_ISREG)
-  elif test x$glibcpp_cv_S_IFREG = xyes; then
+  elif test x$glibcxx_cv_S_IFREG = xyes; then
     AC_DEFINE(HAVE_S_IFREG)
   fi
 ])
@@ -2149,14 +2149,14 @@ dnl
 dnl Check whether poll is available in <poll.h>.
 dnl
 
-AC_DEFUN(GLIBCPP_CHECK_POLL, [
-  AC_CACHE_VAL(glibcpp_cv_POLL, [
+AC_DEFUN(GLIBCXX_CHECK_POLL, [
+  AC_CACHE_VAL(glibcxx_cv_POLL, [
     AC_TRY_COMPILE([#include <poll.h>],
                 [struct pollfd pfd[1]; pfd[0].events = POLLIN; poll(pfd, 1, 0); ],
-                [glibcpp_cv_POLL=yes],
-                [glibcpp_cv_POLL=no])
+                [glibcxx_cv_POLL=yes],
+                [glibcxx_cv_POLL=no])
   ])
-  if test x$glibcpp_cv_POLL = xyes; then
+  if test x$glibcxx_cv_POLL = xyes; then
     AC_DEFINE(HAVE_POLL)
   fi
 ])
@@ -2186,27 +2186,27 @@ AC_DEFUN(AC_LC_MESSAGES, [
 dnl
 dnl Check for whether the Boost-derived checks should be turned on.
 dnl
-dnl GLIBCPP_ENABLE_CONCEPT_CHECKS
+dnl GLIBCXX_ENABLE_CONCEPT_CHECKS
 dnl --enable-concept-checks turns them on.
 dnl --disable-concept-checks leaves them off.
-dnl  +  Usage:  GLIBCPP_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
+dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
 dnl       defaults to `no'.
-AC_DEFUN(GLIBCPP_ENABLE_CONCEPT_CHECKS, [dnl
-define([GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl
+AC_DEFUN(GLIBCXX_ENABLE_CONCEPT_CHECKS, [dnl
+define([GLIBCXX_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl
 AC_ARG_ENABLE(concept-checks,
 changequote(<<, >>)dnl
-<<  --enable-concept-checks use Boost-derived template checks [default=>>GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT],
+<<  --enable-concept-checks use Boost-derived template checks [default=>>GLIBCXX_ENABLE_CONCEPT_CHECKS_DEFAULT],
 changequote([, ])dnl
 [case "$enableval" in
  yes) enable_concept_checks=yes ;;
  no)  enable_concept_checks=no ;;
  *)   AC_MSG_ERROR([Unknown argument to enable/disable concept checks]) ;;
  esac],
-enable_concept_checks=GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl
+enable_concept_checks=GLIBCXX_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl
 dnl Option parsed, now set things appropriately
 if test x"$enable_concept_checks" = xyes; then
-  AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS)
+  AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS)
 fi
 ])
 
@@ -2215,20 +2215,20 @@ dnl
 dnl Add version tags to symbols in shared library (or not), additionally
 dnl marking other symbols as private/local (or not).
 dnl
-dnl GLIBCPP_ENABLE_SYMVERS
+dnl GLIBCXX_ENABLE_SYMVERS
 dnl --enable-symvers=style adds a version script to the linker call when
 dnl       creating the shared library.  The choice of version script is
 dnl       controlled by 'style'.
 dnl --disable-symvers does not.
-dnl  +  Usage:  GLIBCPP_ENABLE_SYMVERS[(DEFAULT)]
+dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
 dnl       defaults to `no'.  Passing `yes' tries to choose a default style
 dnl       based on linker characteristics.  Passing 'no' disables versioning.
-AC_DEFUN(GLIBCPP_ENABLE_SYMVERS, [dnl
-define([GLIBCPP_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl
+AC_DEFUN(GLIBCXX_ENABLE_SYMVERS, [dnl
+define([GLIBCXX_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl
 AC_ARG_ENABLE(symvers,
 changequote(<<, >>)dnl
-<<  --enable-symvers=style  enables symbol versioning of the shared library [default=>>GLIBCPP_ENABLE_SYMVERS_DEFAULT],
+<<  --enable-symvers=style  enables symbol versioning of the shared library [default=>>GLIBCXX_ENABLE_SYMVERS_DEFAULT],
 changequote([, ])dnl
 [case "$enableval" in
  yes) enable_symvers=yes ;;
@@ -2238,13 +2238,13 @@ changequote([, ])dnl
  gnu) enable_symvers=$enableval ;;
  *)   AC_MSG_ERROR([Unknown argument to enable/disable symvers]) ;;
  esac],
-enable_symvers=GLIBCPP_ENABLE_SYMVERS_DEFAULT)dnl
+enable_symvers=GLIBCXX_ENABLE_SYMVERS_DEFAULT)dnl
 
-# If we never went through the GLIBCPP_CHECK_LINKER_FEATURES macro, then we
+# If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
 # don't know enough about $LD to do tricks...
 if test x$enable_shared = xno ||
 	test "x$LD" = x ||
-	test x$glibcpp_gnu_ld_version = x; then
+	test x$glibcxx_gnu_ld_version = x; then
   enable_symvers=no
 fi
 
@@ -2253,22 +2253,22 @@ if test $enable_symvers != no; then
   AC_MSG_CHECKING([for shared libgcc])
   ac_save_CFLAGS="$CFLAGS"
   CFLAGS=' -lgcc_s'
-  AC_TRY_LINK(, [return 0], glibcpp_shared_libgcc=yes, glibcpp_shared_libgcc=no)
+  AC_TRY_LINK(, [return 0], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
   CFLAGS="$ac_save_CFLAGS"
-  AC_MSG_RESULT($glibcpp_shared_libgcc)
+  AC_MSG_RESULT($glibcxx_shared_libgcc)
 fi
 
 # For GNU ld, we need at least this version.  It's 2.12 in the same format
-# as the tested-for version.  See GLIBCPP_CHECK_LINKER_FEATURES for more.
-glibcpp_min_gnu_ld_version=21200
+# as the tested-for version.  See GLIBCXX_CHECK_LINKER_FEATURES for more.
+glibcxx_min_gnu_ld_version=21200
 
 # Check to see if unspecified "yes" value can win, given results
 # above.
 if test $enable_symvers = yes ; then
   if test $with_gnu_ld = yes &&
-    test $glibcpp_shared_libgcc = yes ;
+    test $glibcxx_shared_libgcc = yes ;
   then
-    if test $glibcpp_gnu_ld_version -ge $glibcpp_min_gnu_ld_version ; then
+    if test $glibcxx_gnu_ld_version -ge $glibcxx_min_gnu_ld_version ; then
         enable_symvers=gnu
     else
       ac_test_CFLAGS="${CFLAGS+set}"
@@ -2300,12 +2300,12 @@ case $enable_symvers in
       ;;
   gnu)
       SYMVER_MAP=config/linker-map.gnu
-      AC_DEFINE(_GLIBCPP_SYMVER)
+      AC_DEFINE(_GLIBCXX_SYMVER)
       ;;
 esac
 
 AC_SUBST(SYMVER_MAP)
-AM_CONDITIONAL(GLIBCPP_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
+AM_CONDITIONAL(GLIBCXX_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
 AC_MSG_CHECKING([versioning on shared library symbols])
 AC_MSG_RESULT($enable_symvers)
 ])