libstdc++-v3/acinclude.m4

   1 dnl
   2 dnl Initialize basic configure bits, set toplevel_srcdir for Makefiles.
   3 dnl
   4 dnl GLIBCPP_TOPREL_CONFIGURE
   5 AC_DEFUN(GLIBCPP_TOPREL_CONFIGURE, [
   6   dnl Default to --enable-multilib (this is also passed by default
   7   dnl from the ubercommon-top-level configure)
   8   AC_ARG_ENABLE(multilib,
   9   [  --enable-multilib       build hella library versions (default)],
  10   [case "${enableval}" in
  11     yes) multilib=yes ;;
  12     no)  multilib=no ;;
  13     *)   AC_MSG_ERROR(bad value ${enableval} for multilib option) ;;
  14    esac], [multilib=yes])dnl
  15
  16   # When building with srcdir == objdir, links to the source files will
  17   # be created in directories within the target_subdir.  We have to
  18   # adjust toplevel_srcdir accordingly, so that configure finds
  19   # install-sh and other auxiliary files that live in the top-level
  20   # source directory.
  21   if test "${srcdir}" = "."; then
  22     if test -z "${with_target_subdir}"; then
  23       toprel=".."
  24     else
  25       if test "${with_target_subdir}" != "."; then
  26         toprel="${with_multisrctop}../.."
  27       else
  28         toprel="${with_multisrctop}.."
  29       fi
  30     fi
  31   else
  32     toprel=".."
  33   fi
  34   AC_CONFIG_AUX_DIR(${srcdir}/$toprel)
  35   toplevel_srcdir=\${top_srcdir}/$toprel
  36   AC_SUBST(toplevel_srcdir)
  37 ])
  38
  39 dnl
  40 dnl Initialize the rest of the library configury.
  41 dnl
  42 dnl GLIBCPP_CONFIGURE
  43 AC_DEFUN(GLIBCPP_CONFIGURE, [
  44   # Export build and source directories.
  45   # These need to be absolute paths, yet at the same time need to
  46   # canonicalize only relative paths, because then amd will not unmount
  47   # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
  48   glibcpp_builddir=`${PWDCMD-pwd}`
  49   case $srcdir in
  50   [\\/$]* | ?:[\\/]*) glibcpp_srcdir=${srcdir} ;;
  51   *) glibcpp_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
  52   esac
  53   AC_SUBST(glibcpp_builddir)
  54   AC_SUBST(glibcpp_srcdir)
  55
  56   dnl This is here just to satisfy automake.
  57   ifelse(not,equal,[AC_CONFIG_AUX_DIR(..)])
  58
  59   AC_PROG_AWK
  60   # Will set LN_S to either 'ln -s' or 'ln'.  With autoconf 2.5x, can also
  61   # be 'cp -p' if linking isn't available.  Uncomment the next line to
  62   # force a particular method.
  63   #ac_cv_prog_LN_S='cp -p'
  64   AC_PROG_LN_S
  65
  66   # We use these options to decide which functions to include.
  67   AC_ARG_WITH(target-subdir,
  68   [  --with-target-subdir=SUBDIR
  69                           configuring in a subdirectory])
  70   AC_ARG_WITH(cross-host,
  71   [  --with-cross-host=HOST  configuring with a cross compiler])
  72
  73   AC_ARG_WITH(newlib,
  74   [  --with-newlib                    Configuring with newlib])
  75
  76   glibcpp_basedir=$srcdir/$toprel/$1/libstdc++-v3
  77   AC_SUBST(glibcpp_basedir)
  78
  79   # Never versions of autoconf add an underscore to these functions.
  80   # Prevent future problems ...
  81   ifdef([AC_PROG_CC_G],[],[define([AC_PROG_CC_G],defn([_AC_PROG_CC_G]))])
  82   ifdef([AC_PROG_CC_GNU],[],[define([AC_PROG_CC_GNU],defn([_AC_PROG_CC_GNU]))])
  83   ifdef([AC_PROG_CXX_G],[],[define([AC_PROG_CXX_G],defn([_AC_PROG_CXX_G]))])
  84   ifdef([AC_PROG_CXX_GNU],[],[define([AC_PROG_CXX_GNU],defn([_AC_PROG_CXX_GNU]))])
  85
  86   # AC_PROG_CC
  87   # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
  88   # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
  89   # are probably using a cross compiler, which will not be able to fully
  90   # link an executable.  This is addressed in later versions of autoconf.
  91
  92   AC_DEFUN(LIB_AC_PROG_CC,
  93   [AC_BEFORE([$0], [AC_PROG_CPP])dnl
  94   dnl Fool anybody using AC_PROG_CC.
  95   AC_PROVIDE([AC_PROG_CC])
  96   AC_CHECK_PROG(CC, gcc, gcc)
  97   if test -z "$CC"; then
  98     AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
  99     test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
 100   fi
 101
 102   AC_PROG_CC_GNU
 103
 104   if test $ac_cv_prog_gcc = yes; then
 105     GCC=yes
 106   dnl Check whether -g works, even if CFLAGS is set, in case the package
 107   dnl plays around with CFLAGS (such as to build both debugging and
 108   dnl normal versions of a library), tasteless as that idea is.
 109     ac_test_CFLAGS="${CFLAGS+set}"
 110     ac_save_CFLAGS="$CFLAGS"
 111     CFLAGS=
 112     AC_PROG_CC_G
 113     if test "$ac_test_CFLAGS" = set; then
 114       CFLAGS="$ac_save_CFLAGS"
 115     elif test $ac_cv_prog_cc_g = yes; then
 116       CFLAGS="-g -O2"
 117     else
 118       CFLAGS="-O2"
 119     fi
 120   else
 121     GCC=
 122     test "${CFLAGS+set}" = set || CFLAGS="-g"
 123   fi
 124   ])
 125
 126   LIB_AC_PROG_CC
 127
 128   # Likewise for AC_PROG_CXX.  We can't just call it directly because g++
 129   # will try to link in libstdc++.
 130   AC_DEFUN(LIB_AC_PROG_CXX,
 131   [AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
 132   dnl Fool anybody using AC_PROG_CXX.
 133   AC_PROVIDE([AC_PROG_CXX])
 134   # Use glibcpp_CXX so that we do not cause CXX to be cached with the
 135   # flags that come in CXX while configuring libstdc++.  They're different
 136   # from those used for all other target libraries.  If CXX is set in
 137   # the environment, respect that here.
 138   glibcpp_CXX=$CXX
 139   AC_CHECK_PROGS(glibcpp_CXX, $CCC c++ g++ gcc CC cxx cc++, gcc)
 140   AC_SUBST(glibcpp_CXX)
 141   CXX=$glibcpp_CXX
 142   test -z "$glibcpp_CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH])
 143
 144   AC_PROG_CXX_GNU
 145
 146   if test $ac_cv_prog_gxx = yes; then
 147     GXX=yes
 148     dnl Check whether -g works, even if CXXFLAGS is set, in case the package
 149     dnl plays around with CXXFLAGS (such as to build both debugging and
 150     dnl normal versions of a library), tasteless as that idea is.
 151     ac_test_CXXFLAGS="${CXXFLAGS+set}"
 152     ac_save_CXXFLAGS="$CXXFLAGS"
 153     CXXFLAGS=
 154     AC_PROG_CXX_G
 155     if test "$ac_test_CXXFLAGS" = set; then
 156       CXXFLAGS="$ac_save_CXXFLAGS"
 157     elif test $ac_cv_prog_cxx_g = yes; then
 158       CXXFLAGS="-g -O2"
 159     else
 160       CXXFLAGS="-O2"
 161     fi
 162   else
 163     GXX=
 164     test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
 165   fi
 166   ])
 167
 168   LIB_AC_PROG_CXX
 169
 170   # For directory versioning (e.g., headers) and other variables.
 171   AC_MSG_CHECKING([for GCC version number])
 172   gcc_version=`$glibcpp_CXX -dumpversion`
 173   AC_MSG_RESULT($gcc_version)
 174
 175   # For some reason, gettext needs this.
 176   AC_ISC_POSIX
 177
 178   AC_CHECK_TOOL(AS, as)
 179   AC_CHECK_TOOL(AR, ar)
 180   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
 181   AC_PROG_INSTALL
 182
 183   AM_MAINTAINER_MODE
 184
 185   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
 186   # at least currently, we never actually build a program, so we never
 187   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
 188   # fails, because we are probably configuring with a cross compiler
 189   # which can't create executables.  So we include AC_EXEEXT to keep
 190   # automake happy, but we don't execute it, since we don't care about
 191   # the result.
 192   if false; then
 193     # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands
 194     # to nothing, so nothing would remain between `then' and `fi' if it
 195     # were not for the `:' below.
 196     :
 197     AC_EXEEXT
 198   fi
 199
 200   case [$]{glibcpp_basedir} in
 201     /* | [A-Za-z]:[\\/]*) libgcj_flagbasedir=[$]{glibcpp_basedir} ;;
 202     *) glibcpp_flagbasedir='[$](top_builddir)/'[$]{glibcpp_basedir} ;;
 203   esac
 204
 205   # Set up safe default values for all subsequent AM_CONDITIONAL tests.
 206   need_libmath=no
 207   enable_wchar_t=no
 208   #enable_debug=no
 209   #glibcpp_pch_comp=no
 210   #enable_cheaders=c
 211   #c_compatibility=no
 212   #enable_abi_check=no
 213   #enable_symvers=no
 214
 215   # Find platform-specific directories containing configuration info.  In
 216   # addition to possibly modifying the same flags, it also sets up symlinks.
 217   GLIBCPP_CHECK_HOST
 218 ])
 219
 220
 221 dnl
 222 dnl Check to see if g++ can compile this library, and if so, if any version-
 223 dnl specific precautions need to be taken.
 224 dnl
 225 dnl GLIBCPP_CHECK_COMPILER_VERSION
 226 AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
 227 if test ! -f stamp-sanity-compiler; then
 228   AC_MSG_CHECKING([for g++ that will successfully compile libstdc++-v3])
 229   AC_LANG_SAVE
 230   AC_LANG_CPLUSPLUS
 231   AC_TRY_COMPILE(, [
 232   #if __GNUC__ < 3
 233     not_ok
 234   #endif
 235   ], gpp_satisfactory=yes, AC_MSG_ERROR([please upgrade to GCC 3.0 or above]))
 236   AC_LANG_RESTORE
 237   AC_MSG_RESULT($gpp_satisfactory)
 238   touch stamp-sanity-compiler
 239 fi
 240 ])
 241
 242
 243 dnl
 244 dnl Tests for newer compiler features, or features that are present in newer
 245 dnl compiler versions but not older compiler versions still in use, should
 246 dnl be placed here.
 247 dnl
 248 dnl Define WERROR='-Werror' if requested and possible; g++'s that lack the
 249 dnl new inlining code or the new system_header pragma will die on -Werror.
 250 dnl Leave it out by default and use maint-mode to use it.
 251 dnl
 252 dnl Define SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 253 dnl compiler supports it and the user has not requested debug mode.
 254 dnl
 255 dnl GLIBCPP_CHECK_COMPILER_FEATURES
 256 AC_DEFUN(GLIBCPP_CHECK_COMPILER_FEATURES, [
 257   # All these tests are for C++; save the language and the compiler flags.
 258   # The CXXFLAGS thing is suspicious, but based on similar bits previously
 259   # found in GLIBCPP_CONFIGURE.
 260   AC_LANG_SAVE
 261   AC_LANG_CPLUSPLUS
 262   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 263   ac_save_CXXFLAGS="$CXXFLAGS"
 264
 265   # Check for maintainer-mode bits.
 266   if test x"$USE_MAINTAINER_MODE" = xno; then
 267     WERROR=''
 268   else
 269     WERROR='-Werror'
 270   fi
 271
 272   # Check for -ffunction-sections -fdata-sections
 273   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
 274   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
 275   AC_TRY_COMPILE(, [int foo;
 276   ], [ac_fdsections=yes], [ac_fdsections=no])
 277   if test "$ac_test_CXXFLAGS" = set; then
 278     CXXFLAGS="$ac_save_CXXFLAGS"
 279   else
 280     # this is the suspicious part
 281     CXXFLAGS=''
 282   fi
 283   if test x"$ac_fdsections" = x"yes"; then
 284     SECTION_FLAGS='-ffunction-sections -fdata-sections'
 285   fi
 286   AC_MSG_RESULT($ac_fdsections)
 287
 288   AC_LANG_RESTORE
 289   AC_SUBST(WERROR)
 290   AC_SUBST(SECTION_FLAGS)
 291 ])
 292
 293
 294 dnl
 295 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
 296 dnl the native linker is in use, all variables will be defined to something
 297 dnl safe (like an empty string).
 298 dnl
 299 dnl Define SECTION_LDFLAGS='-Wl,--gc-sections' if possible.
 300 dnl Define OPT_LDFLAGS='-Wl,-O1' if possible.
 301 dnl Define LD, with_gnu_ld, and (possibly) glibcpp_gnu_ld_version as
 302 dnl side-effects of testing.
 303 dnl
 304 dnl GLIBCPP_CHECK_LINKER_FEATURES
 305 AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [
 306   # If we're not using GNU ld, then there's no point in even trying these
 307   # tests.  Check for that first.  We should have already tested for gld
 308   # by now (in libtool), but require it now just to be safe...
 309   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
 310   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
 311   AC_REQUIRE([AC_PROG_LD])
 312
 313   # The name set by libtool depends on the version of libtool.  Shame on us
 314   # for depending on an impl detail, but c'est la vie.  Older versions used
 315   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
 316   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
 317   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
 318   # set (hence we're using an older libtool), then set it.
 319   if test x${with_gnu_ld+set} != xset; then
 320     if test x${ac_cv_prog_gnu_ld+set} != xset; then
 321       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
 322       with_gnu_ld=no
 323     else
 324       with_gnu_ld=$ac_cv_prog_gnu_ld
 325     fi
 326   fi
 327
 328   # Start by getting the version number.  I think the libtool test already
 329   # does some of this, but throws away the result.
 330   changequote(,)
 331   ldver=`$LD --version 2>/dev/null | head -1 | \
 332          sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
 333   changequote([,])
 334   glibcpp_gnu_ld_version=`echo $ldver | \
 335          $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
 336
 337   # Set --gc-sections.
 338   if test "$with_gnu_ld" = "notbroken"; then
 339     # GNU ld it is!  Joy and bunny rabbits!
 340
 341     # All these tests are for C++; save the language and the compiler flags.
 342     # Need to do this so that g++ won't try to link in libstdc++
 343     ac_test_CFLAGS="${CFLAGS+set}"
 344     ac_save_CFLAGS="$CFLAGS"
 345     CFLAGS='-x c++  -Wl,--gc-sections'
 346
 347     # Check for -Wl,--gc-sections
 348     # XXX This test is broken at the moment, as symbols required for
 349     # linking are now in libsupc++ (not built yet.....). In addition,
 350     # this test has cored on solaris in the past. In addition,
 351     # --gc-sections doesn't really work at the moment (keeps on discarding
 352     # used sections, first .eh_frame and now some of the glibc sections for
 353     # iconv). Bzzzzt. Thanks for playing, maybe next time.
 354     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
 355     AC_TRY_RUN([
 356      int main(void)
 357      {
 358        try { throw 1; }
 359        catch (...) { };
 360        return 0;
 361      }
 362     ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
 363     if test "$ac_test_CFLAGS" = set; then
 364       CFLAGS="$ac_save_CFLAGS"
 365     else
 366       # this is the suspicious part
 367       CFLAGS=''
 368     fi
 369     if test "$ac_sectionLDflags" = "yes"; then
 370       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
 371     fi
 372     AC_MSG_RESULT($ac_sectionLDflags)
 373   fi
 374
 375   # Set linker optimization flags.
 376   if test x"$with_gnu_ld" = x"yes"; then
 377     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
 378   fi
 379
 380   AC_SUBST(SECTION_LDFLAGS)
 381   AC_SUBST(OPT_LDFLAGS)
 382 ])
 383
 384
 385 dnl
 386 dnl Check to see if the (math function) argument passed is
 387 dnl declared when using the c++ compiler
 388 dnl ASSUMES argument is a math function with ONE parameter
 389 dnl
 390 dnl GLIBCPP_CHECK_MATH_DECL_1
 391 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_1, [
 392   AC_MSG_CHECKING([for $1 declaration])
 393   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 394     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 395       AC_LANG_SAVE
 396       AC_LANG_CPLUSPLUS
 397       AC_TRY_COMPILE([#include <math.h>
 398                       #ifdef HAVE_IEEEFP_H
 399                       #include <ieeefp.h>
 400                       #endif
 401                      ],
 402                      [ $1(0);],
 403                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 404       AC_LANG_RESTORE
 405     ])
 406   fi
 407   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 408 ])
 409
 410 dnl
 411 dnl Check to see if the (math function) argument passed is
 412 dnl 1) declared when using the c++ compiler
 413 dnl 2) has "C" linkage
 414 dnl 3) if not, see if 1) and 2) for argument prepended with '_'
 415 dnl
 416 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 417 dnl
 418 dnl argument 1 is name of function to check
 419 dnl
 420 dnl ASSUMES argument is a math function with ONE parameter
 421 dnl
 422 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1
 423 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [
 424   GLIBCPP_CHECK_MATH_DECL_1($1)
 425   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 426     AC_CHECK_FUNCS($1)
 427   else
 428     GLIBCPP_CHECK_MATH_DECL_1(_$1)
 429     if test x$glibcpp_cv_func__$1_use = x"yes"; then
 430       AC_CHECK_FUNCS(_$1)
 431     fi
 432   fi
 433 ])
 434
 435
 436 dnl
 437 dnl Like GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
 438 dnl of functions at once.  It's an all-or-nothing check -- either
 439 dnl HAVE_XYZ is defined for each of the functions, or for none of them.
 440 dnl Doing it this way saves significant configure time.
 441 AC_DEFUN(GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1, [
 442   AC_MSG_CHECKING([for $1 functions])
 443   AC_CACHE_VAL(glibcpp_cv_func_$2_use, [
 444     AC_LANG_SAVE
 445     AC_LANG_CPLUSPLUS
 446     AC_TRY_COMPILE([#include <math.h>],
 447                    [ `for x in $3; do echo "$x (0);"; done` ],
 448                    [glibcpp_cv_func_$2_use=yes],
 449                    [glibcpp_cv_func_$2_use=no])
 450     AC_LANG_RESTORE])
 451   AC_MSG_RESULT($glibcpp_cv_func_$2_use)
 452   if test x$glibcpp_cv_func_$2_use = x"yes"; then
 453     AC_CHECK_FUNCS($3)
 454   fi
 455 ])
 456
 457 dnl
 458 dnl Check to see if the (math function) argument passed is
 459 dnl declared when using the c++ compiler
 460 dnl ASSUMES argument is a math function with TWO parameters
 461 dnl
 462 dnl GLIBCPP_CHECK_MATH_DECL_2
 463 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_2, [
 464   AC_MSG_CHECKING([for $1 declaration])
 465   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 466     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 467       AC_LANG_SAVE
 468       AC_LANG_CPLUSPLUS
 469       AC_TRY_COMPILE([#include <math.h>],
 470                      [ $1(0, 0);],
 471                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 472       AC_LANG_RESTORE
 473     ])
 474   fi
 475   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 476 ])
 477
 478 dnl
 479 dnl Check to see if the (math function) argument passed is
 480 dnl 1) declared when using the c++ compiler
 481 dnl 2) has "C" linkage
 482 dnl
 483 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 484 dnl
 485 dnl argument 1 is name of function to check
 486 dnl
 487 dnl ASSUMES argument is a math function with TWO parameters
 488 dnl
 489 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2
 490 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [
 491   GLIBCPP_CHECK_MATH_DECL_2($1)
 492   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 493     AC_CHECK_FUNCS($1)
 494   else
 495     GLIBCPP_CHECK_MATH_DECL_2(_$1)
 496     if test x$glibcpp_cv_func__$1_use = x"yes"; then
 497       AC_CHECK_FUNCS(_$1)
 498     fi
 499   fi
 500 ])
 501
 502
 503 dnl
 504 dnl Check to see if the (math function) argument passed is
 505 dnl declared when using the c++ compiler
 506 dnl ASSUMES argument is a math function with THREE parameters
 507 dnl
 508 dnl GLIBCPP_CHECK_MATH_DECL_3
 509 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_3, [
 510   AC_MSG_CHECKING([for $1 declaration])
 511   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 512     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 513       AC_LANG_SAVE
 514       AC_LANG_CPLUSPLUS
 515       AC_TRY_COMPILE([#include <math.h>],
 516                      [ $1(0, 0, 0);],
 517                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 518       AC_LANG_RESTORE
 519     ])
 520   fi
 521   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 522 ])
 523
 524 dnl
 525 dnl Check to see if the (math function) argument passed is
 526 dnl 1) declared when using the c++ compiler
 527 dnl 2) has "C" linkage
 528 dnl
 529 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 530 dnl
 531 dnl argument 1 is name of function to check
 532 dnl
 533 dnl ASSUMES argument is a math function with THREE parameters
 534 dnl
 535 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3
 536 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [
 537   GLIBCPP_CHECK_MATH_DECL_3($1)
 538   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 539     AC_CHECK_FUNCS($1)
 540   else
 541     GLIBCPP_CHECK_MATH_DECL_3(_$1)
 542     if test x$glibcpp_cv_func__$1_use = x"yes"; then
 543       AC_CHECK_FUNCS(_$1)
 544     fi
 545   fi
 546 ])
 547
 548
 549 dnl
 550 dnl Check to see if the (stdlib function) argument passed is
 551 dnl 1) declared when using the c++ compiler
 552 dnl 2) has "C" linkage
 553 dnl
 554 dnl argument 1 is name of function to check
 555 dnl
 556 dnl ASSUMES argument is a math function with TWO parameters
 557 dnl
 558 dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2
 559 AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2, [
 560   AC_MSG_CHECKING([for $1 declaration])
 561   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 562     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 563       AC_LANG_SAVE
 564       AC_LANG_CPLUSPLUS
 565       AC_TRY_COMPILE([#include <stdlib.h>],
 566                      [ $1(0, 0);],
 567                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 568       AC_LANG_RESTORE
 569     ])
 570   fi
 571   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 572   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 573     AC_CHECK_FUNCS($1)
 574   fi
 575 ])
 576
 577
 578 dnl
 579 dnl Check to see if the (stdlib function) argument passed is
 580 dnl 1) declared when using the c++ compiler
 581 dnl 2) has "C" linkage
 582 dnl
 583 dnl argument 1 is name of function to check
 584 dnl
 585 dnl ASSUMES argument is a function with THREE parameters
 586 dnl
 587 dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3
 588 AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3, [
 589   AC_MSG_CHECKING([for $1 declaration])
 590   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 591     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 592       AC_LANG_SAVE
 593       AC_LANG_CPLUSPLUS
 594       AC_TRY_COMPILE([#include <stdlib.h>],
 595                      [ $1(0, 0, 0);],
 596                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 597       AC_LANG_RESTORE
 598     ])
 599   fi
 600   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 601   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 602     AC_CHECK_FUNCS($1)
 603   fi
 604 ])
 605
 606 dnl
 607 dnl Because the builtins are picky picky picky about the arguments they take,
 608 dnl do an explict linkage tests here.
 609 dnl Check to see if the (math function) argument passed is
 610 dnl 1) declared when using the c++ compiler
 611 dnl 2) has "C" linkage
 612 dnl
 613 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 614 dnl
 615 dnl argument 1 is name of function to check
 616 dnl
 617 dnl ASSUMES argument is a math function with ONE parameter
 618 dnl
 619 dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
 620 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
 621   AC_MSG_CHECKING([for $1 declaration])
 622   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 623     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 624       AC_LANG_SAVE
 625       AC_LANG_CPLUSPLUS
 626       AC_TRY_COMPILE([#include <math.h>],
 627                      [ $1(0);],
 628                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 629       AC_LANG_RESTORE
 630     ])
 631   fi
 632   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 633   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 634     AC_MSG_CHECKING([for $1 linkage])
 635     if test x${glibcpp_cv_func_$1_link+set} != xset; then
 636       AC_CACHE_VAL(glibcpp_cv_func_$1_link, [
 637         AC_TRY_LINK([#include <math.h>],
 638                     [ $1(0);],
 639                     [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no])
 640       ])
 641     fi
 642     AC_MSG_RESULT($glibcpp_cv_func_$1_link)
 643     if test x$glibcpp_cv_func_$1_link = x"yes"; then
 644       ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 645       AC_DEFINE_UNQUOTED(${ac_tr_func})
 646     fi
 647   fi
 648 ])
 649
 650
 651 dnl
 652 dnl Check to see what builtin math functions are supported
 653 dnl
 654 dnl check for __builtin_abs
 655 dnl check for __builtin_fabsf
 656 dnl check for __builtin_fabs
 657 dnl check for __builtin_fabl
 658 dnl check for __builtin_labs
 659 dnl check for __builtin_sqrtf
 660 dnl check for __builtin_sqrtl
 661 dnl check for __builtin_sqrt
 662 dnl check for __builtin_sinf
 663 dnl check for __builtin_sin
 664 dnl check for __builtin_sinl
 665 dnl check for __builtin_cosf
 666 dnl check for __builtin_cos
 667 dnl check for __builtin_cosl
 668 dnl
 669 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
 670 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
 671   dnl Test for builtin math functions.
 672   dnl These are made in gcc/c-common.c
 673   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
 674   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
 675   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
 676   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
 677   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
 678
 679   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
 680   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrt)
 681   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
 682
 683   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
 684   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
 685   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
 686
 687   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
 688   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
 689   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
 690
 691   dnl There is, without a doubt, a more elegant way to have these
 692   dnl names exported so that they won't be stripped out of acconfig.h by
 693   dnl autoheader. I leave this as an exercise to somebody less frustrated
 694   dnl than I.... please email the libstdc++ list if you can figure out a
 695   dnl more elegant approach (see autoconf/acgen.m4 and specifically
 696   dnl AC_CHECK_FUNC for things to steal.)
 697   dummyvar=no
 698   if test x$dummyvar = x"yes"; then
 699     AC_DEFINE(HAVE___BUILTIN_ABS)
 700     AC_DEFINE(HAVE___BUILTIN_LABS)
 701     AC_DEFINE(HAVE___BUILTIN_COS)
 702     AC_DEFINE(HAVE___BUILTIN_COSF)
 703     AC_DEFINE(HAVE___BUILTIN_COSL)
 704     AC_DEFINE(HAVE___BUILTIN_FABS)
 705     AC_DEFINE(HAVE___BUILTIN_FABSF)
 706     AC_DEFINE(HAVE___BUILTIN_FABSL)
 707     AC_DEFINE(HAVE___BUILTIN_SIN)
 708     AC_DEFINE(HAVE___BUILTIN_SINF)
 709     AC_DEFINE(HAVE___BUILTIN_SINL)
 710     AC_DEFINE(HAVE___BUILTIN_SQRT)
 711     AC_DEFINE(HAVE___BUILTIN_SQRTF)
 712     AC_DEFINE(HAVE___BUILTIN_SQRTL)
 713   fi
 714 ])
 715
 716 dnl
 717 dnl Check to see what the underlying c library is like
 718 dnl These checks need to do two things:
 719 dnl 1) make sure the name is declared when using the c++ compiler
 720 dnl 2) make sure the name has "C" linkage
 721 dnl This might seem like overkill but experience has shown that it's not...
 722 dnl
 723 dnl Define HAVE_STRTOLD if "strtold" is declared and links
 724 dnl Define HAVE_STRTOF if "strtof" is declared and links
 725 dnl Define HAVE_DRAND48 if "drand48" is declared and links
 726 dnl
 727 dnl GLIBCPP_CHECK_STDLIB_SUPPORT
 728 AC_DEFUN(GLIBCPP_CHECK_STDLIB_SUPPORT, [
 729   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 730   ac_save_CXXFLAGS="$CXXFLAGS"
 731   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 732
 733   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
 734   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof)
 735   AC_CHECK_FUNCS(drand48)
 736
 737   CXXFLAGS="$ac_save_CXXFLAGS"
 738 ])
 739
 740 dnl
 741 dnl Check to see what the underlying c library or math library is like.
 742 dnl These checks need to do two things:
 743 dnl 1) make sure the name is declared when using the c++ compiler
 744 dnl 2) make sure the name has "C" linkage
 745 dnl This might seem like overkill but experience has shown that it's not...
 746 dnl
 747 dnl Define HAVE_CARGF etc if "cargf" is found.
 748 dnl
 749 dnl GLIBCPP_CHECK_MATH_SUPPORT
 750 AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
 751   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 752   ac_save_CXXFLAGS="$CXXFLAGS"
 753   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 754
 755   dnl Check libm
 756   AC_CHECK_LIB(m, sin, libm="-lm")
 757   ac_save_LIBS="$LIBS"
 758   LIBS="$LIBS $libm"
 759
 760   dnl Check to see if certain C math functions exist.
 761   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
 762   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
 763   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
 764   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
 765   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
 766   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
 767   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
 768   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypot)
 769
 770   dnl Check to see if basic C math functions have float versions.
 771   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
 772                                           float_trig,
 773                                           acosf asinf atanf \
 774                                           cosf sinf tanf \
 775                                           coshf sinhf tanhf)
 776   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
 777                                           float_round,
 778                                           ceilf floorf)
 779   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
 780   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
 781   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
 782   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
 783   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
 784   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
 785   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
 786   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf)
 787   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
 788   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
 789   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
 790   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
 791   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
 792   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
 793   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
 794   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
 795
 796   dnl Check to see if basic C math functions have long double versions.
 797   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
 798                                           long_double_trig,
 799                                           acosl asinl atanl \
 800                                           cosl sinl tanl \
 801                                           coshl sinhl tanhl)
 802   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
 803                                           long_double_round,
 804                                           ceill floorl)
 805   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
 806   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
 807   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
 808   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
 809   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
 810   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
 811   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
 812   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
 813   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl)
 814   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
 815   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
 816   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
 817   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
 818   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
 819   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
 820   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
 821   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
 822
 823   dnl Some runtimes have these functions with a preceding underscore. Please
 824   dnl keep this sync'd with the one above. And if you add any new symbol,
 825   dnl please add the corresponding block in the @BOTTOM@ section of acconfig.h.
 826   dnl Check to see if certain C math functions exist.
 827
 828   dnl Check to see if basic C math functions have float versions.
 829   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float trig,
 830                                           _float_trig,
 831                                           _acosf _asinf _atanf \
 832                                           _cosf _sinf _tanf \
 833                                           _coshf _sinhf _tanhf)
 834   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float round,
 835                                           _float_round,
 836                                           _ceilf _floorf)
 837
 838   dnl Check to see if basic C math functions have long double versions.
 839   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double trig,
 840                                           _long_double_trig,
 841                                           _acosl _asinl _atanl \
 842                                           _cosl _sinl _tanl \
 843                                           _coshl _sinhl _tanhl)
 844   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double round,
 845                                           _long_double_round,
 846                                           _ceill _floorl)
 847
 848   LIBS="$ac_save_LIBS"
 849   CXXFLAGS="$ac_save_CXXFLAGS"
 850 ])
 851
 852
 853 dnl
 854 dnl Check to see if there is native support for complex
 855 dnl
 856 dnl Don't compile bits in math/* if native support exits.
 857 dnl
 858 dnl Define USE_COMPLEX_LONG_DOUBLE etc if "copysignl" is found.
 859 dnl
 860 dnl GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT
 861 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
 862   dnl Check for complex versions of math functions of platform.  This will
 863   dnl always pass if libm is available, and fail if it isn't.  If it is
 864   dnl available, we assume we'll need it later, so add it to LIBS.
 865   AC_CHECK_LIB(m, main)
 866   AC_REPLACE_MATHFUNCS(nan copysignf)
 867
 868   dnl For __signbit to signbit conversions.
 869   AC_CHECK_FUNCS([__signbit], , [LIBMATHOBJS="$LIBMATHOBJS signbit.lo"])
 870   AC_CHECK_FUNCS([__signbitf], , [LIBMATHOBJS="$LIBMATHOBJS signbitf.lo"])
 871
 872   dnl Compile the long double complex functions only if the function
 873   dnl provides the non-complex long double functions that are needed.
 874   dnl Currently this includes copysignl, which should be
 875   dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
 876   if test x$ac_cv_func_copysignl = x"yes"; then
 877     AC_CHECK_FUNCS([__signbitl], , [LIBMATHOBJS="$LIBMATHOBJS signbitl.lo"])
 878   fi
 879
 880   if test -n "$LIBMATHOBJS"; then
 881     need_libmath=yes
 882   fi
 883   AC_SUBST(LIBMATHOBJS)
 884 ])
 885
 886
 887 dnl Check to see what architecture and operating system we are compiling
 888 dnl for.  Also, if architecture- or OS-specific flags are required for
 889 dnl compilation, pick them up here.
 890 dnl
 891 dnl GLIBCPP_CHECK_HOST
 892 AC_DEFUN(GLIBCPP_CHECK_HOST, [
 893   . [$]{glibcpp_basedir}/configure.host
 894   AC_MSG_RESULT(CPU config directory is $cpu_include_dir)
 895   AC_MSG_RESULT(OS config directory is $os_include_dir)
 896 ])
 897
 898
 899 dnl
 900 dnl Check to see if this target can enable the wchar_t parts of libstdc++.
 901 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
 902 dnl must have been previously checked.)
 903 dnl
 904 dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found
 905 dnl Define HAVE_MBSTATE_T if mbstate_t is not in wchar.h
 906 dnl
 907 dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT
 908 AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
 909   dnl Wide characters disabled by default.
 910
 911   dnl Test wchar.h for mbstate_t, which is needed for char_traits and
 912   dnl others even if wchar_t support is not on.
 913   AC_MSG_CHECKING([for mbstate_t])
 914   AC_TRY_COMPILE([#include <wchar.h>],
 915   [mbstate_t teststate;],
 916   have_mbstate_t=yes, have_mbstate_t=no)
 917   AC_MSG_RESULT($have_mbstate_t)
 918   if test x"$have_mbstate_t" = xyes; then
 919     AC_DEFINE(HAVE_MBSTATE_T)
 920   fi
 921
 922   dnl Sanity check for existence of ISO C99 headers for extended encoding.
 923   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
 924   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
 925
 926   dnl Only continue checking if the ISO C99 headers exist and support is on.
 927   if test x"$ac_has_wchar_h" = xyes &&
 928      test x"$ac_has_wctype_h" = xyes &&
 929      test x"$enable_c_mbchar" != xno; then
 930
 931     dnl Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
 932     dnl numeric_limits can instantiate type_traits<wchar_t>
 933     AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
 934     AC_TRY_COMPILE([#include <wchar.h>],
 935     [int i = WCHAR_MIN; int j = WCHAR_MAX;],
 936     has_wchar_minmax=yes, has_wchar_minmax=no)
 937     AC_MSG_RESULT($has_wchar_minmax)
 938
 939     dnl Test wchar.h for WEOF, which is what we use to determine whether
 940     dnl to specialize for char_traits<wchar_t> or not.
 941     AC_MSG_CHECKING([for WEOF])
 942     AC_TRY_COMPILE([
 943       #include <wchar.h>
 944       #include <stddef.h>],
 945     [wint_t i = WEOF;],
 946     has_weof=yes, has_weof=no)
 947     AC_MSG_RESULT($has_weof)
 948
 949     dnl Tests for wide character functions used in char_traits<wchar_t>.
 950     ac_wfuncs=yes
 951     AC_CHECK_FUNCS(wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset,, \
 952     ac_wfuncs=no)
 953
 954     dnl Checks for names injected into std:: by the c_std headers.
 955     AC_CHECK_FUNCS(btowc wctob fgetwc fgetws fputwc fputws fwide \
 956     fwprintf fwscanf swprintf swscanf vfwprintf vfwscanf vswprintf vswscanf \
 957     vwprintf vwscanf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
 958     mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstof wcstol \
 959     wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
 960     wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr,, \
 961     ac_wfuncs=no)
 962
 963     AC_MSG_CHECKING([for ISO C99 wchar_t support])
 964     if test x"$has_weof" = xyes &&
 965        test x"$has_wchar_minmax" = xyes &&
 966        test x"$ac_wfuncs" = xyes; then
 967       ac_isoC99_wchar_t=yes
 968     else
 969       ac_isoC99_wchar_t=no
 970     fi
 971     AC_MSG_RESULT($ac_isoC99_wchar_t)
 972
 973     dnl Use iconv for wchar_t to char conversions. As such, check for
 974     dnl X/Open Portability Guide, version 2 features (XPG2).
 975     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
 976     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
 977
 978     dnl Check for existence of libiconv.a providing XPG2 wchar_t support.
 979     AC_CHECK_LIB(iconv, iconv, libiconv="-liconv")
 980     ac_save_LIBS="$LIBS"
 981     LIBS="$LIBS $libiconv"
 982
 983     AC_CHECK_FUNCS(iconv_open iconv_close iconv nl_langinfo, \
 984     ac_XPG2funcs=yes, ac_XPG2funcs=no)
 985
 986     LIBS="$ac_save_LIBS"
 987
 988     AC_MSG_CHECKING([for XPG2 wchar_t support])
 989     if test x"$ac_has_iconv_h" = xyes &&
 990        test x"$ac_has_langinfo_h" = xyes &&
 991        test x"$ac_XPG2funcs" = xyes; then
 992       ac_XPG2_wchar_t=yes
 993     else
 994       ac_XPG2_wchar_t=no
 995     fi
 996     AC_MSG_RESULT($ac_XPG2_wchar_t)
 997
 998     dnl At the moment, only enable wchar_t specializations if all the
 999     dnl above support is present.
1000     if test x"$ac_isoC99_wchar_t" = xyes &&
1001         test x"$ac_XPG2_wchar_t" = xyes; then
1002       AC_DEFINE(_GLIBCPP_USE_WCHAR_T)
1003       enable_wchar_t=yes
1004     fi
1005   fi
1006   AC_MSG_CHECKING([for enabled wchar_t specializations])
1007   AC_MSG_RESULT($enable_wchar_t)
1008 ])
1009
1010
1011 dnl
1012 dnl Check to see if debugging libraries are to be built.
1013 dnl
1014 dnl GLIBCPP_ENABLE_DEBUG
1015 dnl
1016 dnl --enable-debug
1017 dnl builds a separate set of debugging libraries in addition to the
1018 dnl normal (shared, static) libstdc++ binaries.
1019 dnl
1020 dnl --disable-debug
1021 dnl builds only one (non-debug) version of libstdc++.
1022 dnl
1023 dnl --enable-debug-flags=FLAGS
1024 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1025 dnl
1026 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG[(DEFAULT)]
1027 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1028 dnl       defaults to `no'.
1029 AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl
1030 define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
1031 AC_ARG_ENABLE(debug,
1032 changequote(<<, >>)dnl
1033 <<  --enable-debug          build extra debug library [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT],
1034 changequote([, ])dnl
1035 [case "${enableval}" in
1036  yes) enable_debug=yes ;;
1037  no)  enable_debug=no ;;
1038  *)   AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;;
1039  esac],
1040 enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl
1041 AC_MSG_CHECKING([for additional debug build])
1042 AC_MSG_RESULT($enable_debug)
1043 AM_CONDITIONAL(GLIBCPP_BUILD_DEBUG, test "$enable_debug" = yes)
1044 ])
1045
1046
1047 dnl Check for explicit debug flags.
1048 dnl
1049 dnl GLIBCPP_ENABLE_DEBUG_FLAGS
1050 dnl
1051 dnl --enable-debug-flags='-O1'
1052 dnl is a general method for passing flags to be used when
1053 dnl building debug libraries with --enable-debug.
1054 dnl
1055 dnl --disable-debug-flags does nothing.
1056 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG_FLAGS(default flags)
1057 dnl       If "default flags" is an empty string (or "none"), the effect is
1058 dnl       the same as --disable or --enable=no.
1059 AC_DEFUN(GLIBCPP_ENABLE_DEBUG_FLAGS, [dnl
1060 define([GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1061 AC_ARG_ENABLE(debug_flags,
1062 changequote(<<, >>)dnl
1063 <<  --enable-debug-flags=FLAGS    pass compiler FLAGS when building debug
1064                         library;[default=>>GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT],
1065 changequote([, ])dnl
1066 [case "${enableval}" in
1067  none)  ;;
1068  -*) enable_debug_flags="${enableval}" ;;
1069  *)   AC_MSG_ERROR([Unknown argument to extra debugging flags]) ;;
1070  esac],
1071 enable_debug_flags=GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT)dnl
1072
1073 dnl Option parsed, now set things appropriately
1074 case x"$enable_debug" in
1075     xyes)
1076         case "$enable_debug_flags" in
1077           none)
1078             DEBUG_FLAGS="-g3 -O0";;
1079           -*) #valid input
1080             DEBUG_FLAGS="${enableval}"
1081         esac
1082         ;;
1083     xno)
1084         DEBUG_FLAGS=""
1085         ;;
1086 esac
1087 AC_SUBST(DEBUG_FLAGS)
1088
1089 AC_MSG_CHECKING([for debug build flags])
1090 AC_MSG_RESULT($DEBUG_FLAGS)
1091 ])
1092
1093
1094 dnl
1095 dnl Check for "unusual" flags to pass to the compiler while building.
1096 dnl
1097 dnl GLIBCPP_ENABLE_CXX_FLAGS
1098 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1099 dnl     experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc.
1100 dnl     Somehow this same set of flags must be passed when [re]building
1101 dnl     libgcc.
1102 dnl --disable-cxx-flags passes nothing.
1103 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1104 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1105 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1106 dnl  +  Usage:  GLIBCPP_ENABLE_CXX_FLAGS(default flags)
1107 dnl       If "default flags" is an empty string (or "none"), the effect is
1108 dnl       the same as --disable or --enable=no.
1109 AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl
1110 define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1111 AC_MSG_CHECKING([for extra compiler flags for building])
1112 AC_ARG_ENABLE(cxx_flags,
1113 changequote(<<, >>)dnl
1114 <<  --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
1115                                   [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT],
1116 changequote([, ])dnl
1117 [case "x$enable_cxx_flags" in
1118   xyes)
1119     AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;;
1120   xno | xnone | x)
1121     enable_cxx_flags='' ;;
1122   *)
1123     enable_cxx_flags="$enableval" ;;
1124 esac],
1125 enable_cxx_flags=GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT)
1126
1127 dnl Run through flags (either default or command-line) and set anything
1128 dnl extra (e.g., #defines) that must accompany particular g++ options.
1129 if test -n "$enable_cxx_flags"; then
1130   for f in $enable_cxx_flags; do
1131     case "$f" in
1132       -fhonor-std)  ;;
1133       -*)  ;;
1134       *)   # and we're trying to pass /what/ exactly?
1135            AC_MSG_ERROR([compiler flags start with a -]) ;;
1136     esac
1137   done
1138 fi
1139 EXTRA_CXX_FLAGS="$enable_cxx_flags"
1140 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1141 AC_SUBST(EXTRA_CXX_FLAGS)
1142 ])
1143
1144
1145 dnl
1146 dnl Check for which locale library to use:  gnu or generic.
1147 dnl
1148 dnl GLIBCPP_ENABLE_CLOCALE
1149 dnl --enable-clocale=gnu sets config/locale/c_locale_gnu.cc and friends
1150 dnl --enable-clocale=generic sets config/locale/c_locale_generic.cc and friends
1151 dnl
1152 dnl default is generic
1153 dnl
1154 AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
1155   AC_MSG_CHECKING([for clocale to use])
1156   AC_ARG_ENABLE(clocale,
1157   [  --enable-clocale        enable model for target locale package.
1158   --enable-clocale=MODEL  use MODEL target-speific locale package. [default=generic]
1159   ],
1160   if test x$enable_clocale = xno; then
1161      enable_clocale=no
1162   fi,
1163      enable_clocale=no)
1164
1165   enable_clocale_flag=$enable_clocale
1166
1167   dnl Probe for locale support if no specific model is specified.
1168   dnl Default to "generic"
1169   if test x$enable_clocale_flag = xno; then
1170     case x${target_os} in
1171       xlinux* | xgnu*)
1172         AC_EGREP_CPP([_GLIBCPP_ok], [
1173         #include <features.h>
1174         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1175           _GLIBCPP_ok
1176         #endif
1177         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1178
1179         # Test for bugs early in glibc-2.2.x series
1180         if test x$enable_clocale_flag = xgnu; then
1181           AC_TRY_RUN([
1182           #define _GNU_SOURCE 1
1183           #include <locale.h>
1184           #include <string.h>
1185           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1186           extern __typeof(newlocale) __newlocale;
1187           extern __typeof(duplocale) __duplocale;
1188           extern __typeof(strcoll_l) __strcoll_l;
1189           #endif
1190           int main()
1191           {
1192             const char __one[] = "Äuglein Augmen";
1193             const char __two[] = "Äuglein";
1194             int i;
1195             int j;
1196             __locale_t  loc;
1197             __locale_t  loc_dup;
1198             loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1199             loc_dup = __duplocale(loc);
1200             i = __strcoll_l(__one, __two, loc);
1201             j = __strcoll_l(__one, __two, loc_dup);
1202             return 0;
1203           }
1204           ],
1205           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1206           [enable_clocale_flag=generic])
1207         fi
1208
1209         # ... at some point put __strxfrm_l tests in as well.
1210         ;;
1211       *)
1212         enable_clocale_flag=generic
1213         ;;
1214     esac
1215   fi
1216
1217   dnl Deal with gettext issues.
1218   AC_ARG_ENABLE(nls,
1219   [  --enable-nls            use Native Language Support (default)],
1220   , enable_nls=yes)
1221   USE_NLS=no
1222
1223   dnl Set configure bits for specified locale package
1224   case x${enable_clocale_flag} in
1225     xgeneric)
1226       AC_MSG_RESULT(generic)
1227
1228       CLOCALE_H=config/locale/generic/c_locale.h
1229       CLOCALE_CC=config/locale/generic/c_locale.cc
1230       CCODECVT_H=config/locale/generic/codecvt_specializations.h
1231       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1232       CCOLLATE_CC=config/locale/generic/collate_members.cc
1233       CCTYPE_CC=config/locale/generic/ctype_members.cc
1234       CMESSAGES_H=config/locale/generic/messages_members.h
1235       CMESSAGES_CC=config/locale/generic/messages_members.cc
1236       CMONEY_CC=config/locale/generic/monetary_members.cc
1237       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1238       CTIME_H=config/locale/generic/time_members.h
1239       CTIME_CC=config/locale/generic/time_members.cc
1240       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1241       ;;
1242     xgnu)
1243       AC_MSG_RESULT(gnu)
1244
1245       # Declare intention to use gettext, and add support for specific
1246       # languages.
1247       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1248       ALL_LINGUAS="de fr"
1249
1250       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1251       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1252       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1253         USE_NLS=yes
1254       fi
1255       # Export the build objects.
1256       for ling in $ALL_LINGUAS; do \
1257         glibcpp_MOFILES="$glibcpp_MOFILES $ling.mo"; \
1258         glibcpp_POFILES="$glibcpp_POFILES $ling.po"; \
1259       done
1260       AC_SUBST(glibcpp_MOFILES)
1261       AC_SUBST(glibcpp_POFILES)
1262
1263       CLOCALE_H=config/locale/gnu/c_locale.h
1264       CLOCALE_CC=config/locale/gnu/c_locale.cc
1265       CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1266       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1267       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1268       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1269       CMESSAGES_H=config/locale/gnu/messages_members.h
1270       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1271       CMONEY_CC=config/locale/gnu/monetary_members.cc
1272       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1273       CTIME_H=config/locale/gnu/time_members.h
1274       CTIME_CC=config/locale/gnu/time_members.cc
1275       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1276       ;;
1277     xieee_1003.1-2001)
1278       AC_MSG_RESULT(IEEE 1003.1)
1279
1280       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1281       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1282       CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1283       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1284       CCOLLATE_CC=config/locale/generic/collate_members.cc
1285       CCTYPE_CC=config/locale/generic/ctype_members.cc
1286       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1287       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1288       CMONEY_CC=config/locale/generic/monetary_members.cc
1289       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1290       CTIME_H=config/locale/generic/time_members.h
1291       CTIME_CC=config/locale/generic/time_members.cc
1292       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1293       ;;
1294     *)
1295       echo "$enable_clocale is an unknown locale package" 1>&2
1296       exit 1
1297       ;;
1298   esac
1299
1300   # This is where the testsuite looks for locale catalogs, using the
1301   # -DLOCALEDIR define during testsuite compilation.
1302   glibcpp_localedir=${glibcpp_builddir}/po/share/locale
1303   AC_SUBST(glibcpp_localedir)
1304
1305   # A standalone libintl (e.g., GNU libintl) may be in use.
1306   if test $USE_NLS = yes; then
1307     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1308     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1309   fi
1310   if test $USE_NLS = yes; then
1311     AC_DEFINE(_GLIBCPP_USE_NLS)
1312   fi
1313
1314   AC_SUBST(USE_NLS)
1315   AC_SUBST(CLOCALE_H)
1316   AC_SUBST(CCODECVT_H)
1317   AC_SUBST(CMESSAGES_H)
1318   AC_SUBST(CCODECVT_CC)
1319   AC_SUBST(CCOLLATE_CC)
1320   AC_SUBST(CCTYPE_CC)
1321   AC_SUBST(CMESSAGES_CC)
1322   AC_SUBST(CMONEY_CC)
1323   AC_SUBST(CNUMERIC_CC)
1324   AC_SUBST(CTIME_H)
1325   AC_SUBST(CTIME_CC)
1326   AC_SUBST(CLOCALE_CC)
1327   AC_SUBST(CLOCALE_INTERNAL_H)
1328 ])
1329
1330
1331 dnl
1332 dnl Check for which I/O library to use:  stdio, or something specific.
1333 dnl
1334 dnl GLIBCPP_ENABLE_CSTDIO
1335 dnl
1336 dnl default is stdio
1337 dnl
1338 AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
1339   AC_MSG_CHECKING([for cstdio to use])
1340   AC_ARG_ENABLE(cstdio,
1341   [  --enable-cstdio         enable stdio for target io package.
1342   --enable-cstdio=LIB     use LIB target-speific io package. [default=stdio]
1343   ],
1344   if test x$enable_cstdio = xno; then
1345      enable_cstdio=stdio
1346   fi,
1347      enable_cstdio=stdio)
1348
1349   enable_cstdio_flag=$enable_cstdio
1350
1351   dnl Check if a valid I/O package
1352   case x${enable_cstdio_flag} in
1353     xstdio | x | xno | xnone | xyes)
1354       # default
1355       CSTDIO_H=config/io/c_io_stdio.h
1356       BASIC_FILE_H=config/io/basic_file_stdio.h
1357       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1358       AC_MSG_RESULT(stdio)
1359       ;;
1360     *)
1361       echo "$enable_cstdio is an unknown io package" 1>&2
1362       exit 1
1363       ;;
1364   esac
1365   AC_SUBST(CSTDIO_H)
1366   AC_SUBST(BASIC_FILE_H)
1367   AC_SUBST(BASIC_FILE_CC)
1368 ])
1369
1370
1371 dnl
1372 dnl Check to see if building and using a C++ precompiled header can be done.
1373 dnl
1374 dnl GLIBCPP_ENABLE_PCH
1375 dnl
1376 dnl --enable-pch=yes
1377 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1378 dnl may work, after some light-hearted attempts to puzzle out compiler
1379 dnl support, flip bits on in include/Makefile.am
1380 dnl
1381 dnl --disable-pch
1382 dnl turns off attempts to use or build stdc++.h.gch.
1383 dnl
1384 AC_DEFUN(GLIBCPP_ENABLE_PCH, [dnl
1385 define([GLIBCPP_ENABLE_PCH_DEFAULT], ifelse($1,,, $1))dnl
1386 AC_ARG_ENABLE(pch,
1387 changequote(<<, >>)dnl
1388 <<  --enable-pch         build pre-compiled libstdc++ includes [default=>>GLIBCPP_ENABLE_PCH_DEFAULT],
1389 changequote([, ])dnl
1390 [case "${enableval}" in
1391  yes) enable_pch=yes ;;
1392  no)  enable_pch=no ;;
1393  *)   AC_MSG_ERROR([Unknown argument to enable/disable PCH]) ;;
1394  esac],
1395 enable_pch=GLIBCPP_ENABLE_PCH_DEFAULT)dnl
1396
1397   if test x$enable_pch = xyes; then
1398     ac_test_CXXFLAGS="${CXXFLAGS+set}"
1399     ac_save_CXXFLAGS="$CXXFLAGS"
1400     CXXFLAGS='-Werror -Winvalid-pch -Wno-deprecated -x c++-header'
1401
1402     AC_MSG_CHECKING([for compiler that seems to compile .gch files])
1403     if test x${glibcpp_pch_comp+set} != xset; then
1404       AC_CACHE_VAL(glibcpp_pch_comp, [
1405         AC_LANG_SAVE
1406         AC_LANG_CPLUSPLUS
1407         AC_TRY_COMPILE([#include <math.h>
1408                      ],
1409                      [ $1(0);],
1410                      [glibcpp_pch_comp=yes], [glibcpp_pch_comp=no])
1411         AC_LANG_RESTORE
1412       ])
1413     fi
1414     AC_MSG_RESULT([$glibcpp_pch_comp])
1415
1416     CXXFLAGS="$ac_save_CXXFLAGS"
1417   fi
1418
1419   if test x"$enable_pch" = xyes && test x"$glibcpp_pch_comp" = xno; then
1420     enable_pch=no
1421   fi
1422
1423   AC_MSG_CHECKING([for enabled PCH])
1424   AC_MSG_RESULT([$enable_pch])
1425
1426   AM_CONDITIONAL(GLIBCPP_BUILD_PCH, test "$enable_pch" = yes)
1427   if test "$enable_pch" = yes; then
1428         glibcpp_PCHFLAGS="-include bits/stdc++.h"
1429   else
1430         glibcpp_PCHFLAGS=""
1431   fi
1432   AC_SUBST(glibcpp_PCHFLAGS)
1433 ])
1434
1435 dnl
1436 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1437 dnl We must stage the required headers so that they will be installed
1438 dnl with the library (unlike libgcc, the STL implementation is provided
1439 dnl solely within headers).  Since we must not inject random user-space
1440 dnl macro names into user-provided C++ code, we first stage into <file>-in
1441 dnl and process to <file> with an output command.  The reason for a two-
1442 dnl stage process here is to correctly handle $srcdir!=$objdir without
1443 dnl having to write complex code (the sed commands to clean the macro
1444 dnl namespace are complex and fragile enough as it is).  We must also
1445 dnl add a relative path so that -I- is supported properly.
1446 dnl
1447 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1448   AC_MSG_CHECKING([for thread model used by GCC])
1449   target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
1450   AC_MSG_RESULT([$target_thread_file])
1451
1452   if test $target_thread_file != single; then
1453     AC_DEFINE(HAVE_GTHR_DEFAULT)
1454     AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__)
1455   fi
1456
1457   glibcpp_thread_h=gthr-$target_thread_file.h
1458   AC_SUBST(glibcpp_thread_h)
1459 ])
1460
1461
1462 dnl
1463 dnl Check for exception handling support.  If an explicit enable/disable
1464 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1465 dnl target may or may not support call frame exceptions.
1466 dnl
1467 dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS
1468 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1469 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1470 dnl
1471 dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it.
1472 dnl
1473 AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [
1474   AC_MSG_CHECKING([for exception model to use])
1475   AC_LANG_SAVE
1476   AC_LANG_CPLUSPLUS
1477   AC_ARG_ENABLE(sjlj-exceptions,
1478   [  --enable-sjlj-exceptions  force use of builtin_setjmp for exceptions],
1479   [:],
1480   [dnl Botheration.  Now we've got to detect the exception model.
1481    dnl Link tests against libgcc.a are problematic since -- at least
1482    dnl as of this writing -- we've not been given proper -L bits for
1483    dnl single-tree newlib and libgloss.
1484    dnl
1485    dnl This is what AC_TRY_COMPILE would do if it didn't delete the
1486    dnl conftest files before we got a change to grep them first.
1487    cat > conftest.$ac_ext << EOF
1488 [#]line __oline__ "configure"
1489 struct S { ~S(); };
1490 void bar();
1491 void foo()
1492 {
1493   S s;
1494   bar();
1495 }
1496 EOF
1497    old_CXXFLAGS="$CXXFLAGS"
1498    CXXFLAGS=-S
1499    if AC_TRY_EVAL(ac_compile); then
1500      if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1501        enable_sjlj_exceptions=yes
1502      elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1503        enable_sjlj_exceptions=no
1504      fi
1505    fi
1506    CXXFLAGS="$old_CXXFLAGS"
1507    rm -f conftest*])
1508    if test x$enable_sjlj_exceptions = xyes; then
1509      AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1,
1510         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1511      ac_exception_model_name=sjlj
1512    elif test x$enable_sjlj_exceptions = xno; then
1513      ac_exception_model_name="call frame"
1514    else
1515      AC_MSG_ERROR([unable to detect exception model])
1516    fi
1517    AC_LANG_RESTORE
1518    AC_MSG_RESULT($ac_exception_model_name)
1519 ])
1520
1521
1522 dnl
1523 dnl Check for libunwind exception handling support. If enabled then
1524 dnl we assume that the _Unwind_* functions that make up the Unwind ABI
1525 dnl (_Unwind_RaiseException, _Unwind_Resume, etc.) are defined by
1526 dnl libunwind instead of libgcc and that libstdc++ has a dependency
1527 dnl on libunwind as well as libgcc.
1528 dnl
1529 dnl GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS
1530 dnl --enable-libunwind-exceptions forces the use of libunwind.
1531 dnl --disable-libunwind-exceptions assumes there is no libunwind.
1532 dnl
1533 dnl Define _GLIBCPP_LIBUNWIND_EXCEPTIONS if requested.
1534 dnl
1535 AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [
1536   AC_MSG_CHECKING([for use of libunwind])
1537   AC_ARG_ENABLE(libunwind-exceptions,
1538   [  --enable-libunwind-exceptions  force use of libunwind for exceptions],
1539   use_libunwind_exceptions=$enableval,
1540   use_libunwind_exceptions=no)
1541   AC_MSG_RESULT($use_libunwind_exceptions)
1542   dnl Option parsed, now set things appropriately
1543   if test x"$use_libunwind_exceptions" = xyes; then
1544     LIBUNWIND_FLAG="-lunwind"
1545   else
1546     LIBUNWIND_FLAG=""
1547   fi
1548   AC_SUBST(LIBUNWIND_FLAG)
1549 ])
1550
1551 dnl
1552 dnl Check for ISO/IEC 9899:1999 "C99" support.
1553 dnl
1554 dnl GLIBCPP_ENABLE_C99
1555 dnl --enable-c99 defines _GLIBCPP_USE_C99
1556 dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
1557 dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
1558 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1559 dnl       defaults to `no'.
1560 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
1561 dnl
1562 dnl GLIBCPP_ENABLE_C99
1563 AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
1564   define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
1565
1566   AC_ARG_ENABLE(c99,
1567   changequote(<<, >>)dnl
1568   <<--enable-c99            turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
1569   changequote([, ])dnl
1570   [case "$enableval" in
1571    yes) enable_c99=yes ;;
1572    no)  enable_c99=no ;;
1573    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
1574    esac],
1575   enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
1576
1577   AC_LANG_SAVE
1578   AC_LANG_CPLUSPLUS
1579
1580   # Check for the existence of <math.h> functions used if C99 is enabled.
1581   ac_c99_math=yes;
1582   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
1583   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
1584   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
1585   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
1586   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
1587   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
1588   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
1589   AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
1590   AC_TRY_COMPILE([#include <math.h>],
1591                  [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
1592   AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
1593   AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
1594   AC_TRY_COMPILE([#include <math.h>],
1595                  [islessgreater(0.0,0.0);],, [ac_c99_math=no])
1596   AC_TRY_COMPILE([#include <math.h>],
1597                  [isunordered(0.0,0.0);],, [ac_c99_math=no])
1598   AC_MSG_RESULT($ac_c99_math)
1599
1600   # Check for the existence in <stdio.h> of vscanf, et. al.
1601   ac_c99_stdio=yes;
1602   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1603   AC_TRY_COMPILE([#include <stdio.h>],
1604                  [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
1605   AC_TRY_COMPILE([#include <stdio.h>
1606                   #include <stdarg.h>
1607                   void foo(char* fmt, ...)
1608                   {va_list args; va_start(args, fmt);
1609                   vfscanf(stderr, "%i", args);}],
1610                   [],, [ac_c99_stdio=no])
1611   AC_TRY_COMPILE([#include <stdio.h>
1612                   #include <stdarg.h>
1613                   void foo(char* fmt, ...)
1614                   {va_list args; va_start(args, fmt);
1615                   vscanf("%i", args);}],
1616                   [],, [ac_c99_stdio=no])
1617   AC_TRY_COMPILE([#include <stdio.h>
1618                   #include <stdarg.h>
1619                   void foo(char* fmt, ...)
1620                   {va_list args; va_start(args, fmt);
1621                   vsnprintf(fmt, 0, "%i", args);}],
1622                   [],, [ac_c99_stdio=no])
1623   AC_TRY_COMPILE([#include <stdio.h>
1624                   #include <stdarg.h>
1625                   void foo(char* fmt, ...)
1626                   {va_list args; va_start(args, fmt);
1627                   vsscanf(fmt, "%i", args);}],
1628                   [],, [ac_c99_stdio=no])
1629   AC_MSG_RESULT($ac_c99_stdio)
1630
1631   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1632   ac_c99_stdlib=yes;
1633   AC_MSG_CHECKING([for lldiv_t declaration])
1634   AC_CACHE_VAL(ac_c99_lldiv_t, [
1635   AC_TRY_COMPILE([#include <stdlib.h>],
1636                    [ lldiv_t mydivt;],
1637                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1638   ])
1639   AC_MSG_RESULT($ac_c99_lldiv_t)
1640
1641   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1642   AC_TRY_COMPILE([#include <stdlib.h>],
1643                  [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
1644   AC_TRY_COMPILE([#include <stdlib.h>],
1645                  [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
1646   AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
1647   AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
1648   AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
1649   AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
1650   if test x"$ac_c99_lldiv_t" = x"no"; then
1651     ac_c99_stdlib=no;
1652   fi;
1653   AC_MSG_RESULT($ac_c99_stdlib)
1654
1655   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1656   # XXX the wchar.h checks should be rolled into the general C99 bits.
1657   ac_c99_wchar=yes;
1658   AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
1659   AC_TRY_COMPILE([#include <wchar.h>],
1660                  [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
1661   AC_TRY_COMPILE([#include <wchar.h>],
1662                  [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
1663   AC_TRY_COMPILE([#include <wchar.h>],
1664                  [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
1665   AC_MSG_RESULT($ac_c99_wchar)
1666
1667   AC_MSG_CHECKING([for enabled ISO C99 support])
1668   if test x"$ac_c99_math" = x"no" ||
1669      test x"$ac_c99_stdio" = x"no" ||
1670      test x"$ac_c99_stdlib" = x"no" ||
1671      test x"$ac_c99_wchar" = x"no"; then
1672     enable_c99=no;
1673   fi;
1674   AC_MSG_RESULT($enable_c99)
1675
1676   # Option parsed, now set things appropriately
1677   if test x"$enable_c99" = x"yes"; then
1678     AC_DEFINE(_GLIBCPP_USE_C99)
1679   fi
1680
1681   AC_LANG_RESTORE
1682 ])
1683
1684
1685 dnl
1686 dnl Check for template specializations for the 'long long' type extension.
1687 dnl The result determines only whether 'long long' I/O is enabled; things
1688 dnl like numeric_limits<> specializations are always available.
1689 dnl
1690 dnl GLIBCPP_ENABLE_LONG_LONG
1691 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1692 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1693 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1694 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1695 dnl       defaults to `no'.
1696 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1697 dnl
1698 dnl GLIBCPP_ENABLE_LONG_LONG
1699 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1700   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1701
1702   AC_ARG_ENABLE(long-long,
1703   changequote(<<, >>)dnl
1704   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1705   changequote([, ])dnl
1706   [case "$enableval" in
1707    yes) enable_long_long=yes ;;
1708    no)  enable_long_long=no ;;
1709    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1710    esac],
1711   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1712
1713   AC_LANG_SAVE
1714   AC_LANG_CPLUSPLUS
1715
1716   AC_MSG_CHECKING([for enabled long long I/O support])
1717   # iostreams require strtoll, strtoull to compile
1718   AC_TRY_COMPILE([#include <stdlib.h>],
1719                  [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no])
1720   AC_TRY_COMPILE([#include <stdlib.h>],
1721                  [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no])
1722
1723   # Option parsed, now set things appropriately
1724   if test x"$enable_long_long" = xyes; then
1725     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1726   fi
1727   AC_MSG_RESULT($enable_long_long)
1728
1729   AC_LANG_RESTORE
1730 ])
1731
1732
1733 dnl
1734 dnl Check for what type of C headers to use.
1735 dnl
1736 dnl GLIBCPP_ENABLE_CHEADERS
1737 dnl --enable-cheaders= [does stuff].
1738 dnl --disable-cheaders [does not do anything, really].
1739 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1740 dnl       Where DEFAULT is either `c' or `c_std'.
1741 dnl       If ommitted, it defaults to `c_std'.
1742 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1743 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1744 AC_MSG_CHECKING([for c header strategy to use])
1745 AC_ARG_ENABLE(cheaders,
1746 changequote(<<, >>)dnl
1747 <<  --enable-cheaders=MODEL       construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1748 changequote([, ])
1749   [case "$enableval" in
1750    c)
1751         enable_cheaders=c
1752         ;;
1753    c_std)
1754         enable_cheaders=c_std
1755         ;;
1756    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1757         ;;
1758   esac],
1759   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1760   AC_MSG_RESULT($enable_cheaders)
1761
1762   dnl Option parsed, now set things appropriately
1763   case "$enable_cheaders" in
1764     c_std)
1765         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_std'
1766         ;;
1767     c)
1768         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c'
1769         ;;
1770   esac
1771
1772   AC_SUBST(C_INCLUDE_DIR)
1773   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C, test "$enable_cheaders" = c)
1774   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C_STD, test "$enable_cheaders" = c_std)
1775   AM_CONDITIONAL(GLIBCPP_C_HEADERS_COMPATIBILITY, test "$c_compatibility" = yes)
1776 ])
1777
1778
1779 dnl
1780 dnl Check for wide character support.  Has the same effect as the option
1781 dnl in gcc's configure, but in a form that autoconf can mess with.
1782 dnl
1783 dnl GLIBCPP_ENABLE_C_MBCHAR
1784 dnl --enable-c-mbchar requests all the wchar_t stuff.
1785 dnl --disable-c-mbchar doesn't.
1786 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1787 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1788 dnl       defaults to `no'.
1789 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1790 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1791 AC_ARG_ENABLE(c-mbchar,
1792 changequote(<<, >>)dnl
1793 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1794 changequote([, ])dnl
1795 [case "$enableval" in
1796  yes) enable_c_mbchar=yes ;;
1797  no)  enable_c_mbchar=no ;;
1798  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1799  esac],
1800 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1801 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1802 ])
1803
1804
1805 dnl
1806 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1807 dnl
1808 dnl TOPLEVEL_INCLUDES
1809 dnl LIBMATH_INCLUDES
1810 dnl LIBSUPCXX_INCLUDES
1811 dnl
1812 dnl GLIBCPP_EXPORT_INCLUDES
1813 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1814   # Root level of the build directory include sources.
1815   GLIBCPP_INCLUDES="-I${glibcpp_builddir}/include/${target_alias} -I${glibcpp_builddir}/include"
1816
1817   # Passed down for canadian crosses.
1818   if test x"$CANADIAN" = xyes; then
1819     TOPLEVEL_INCLUDES='-I$(includedir)'
1820   fi
1821
1822   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1823
1824   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1825
1826   # Now, export this to all the little Makefiles....
1827   AC_SUBST(GLIBCPP_INCLUDES)
1828   AC_SUBST(TOPLEVEL_INCLUDES)
1829   AC_SUBST(LIBMATH_INCLUDES)
1830   AC_SUBST(LIBSUPCXX_INCLUDES)
1831 ])
1832
1833
1834 dnl
1835 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1836 dnl
1837 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1838   # Optimization flags that are probably a good idea for thrill-seekers. Just
1839   # uncomment the lines below and make, everything else is ready to go...
1840   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1841   OPTIMIZE_CXXFLAGS=
1842   AC_SUBST(OPTIMIZE_CXXFLAGS)
1843
1844   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings'
1845   AC_SUBST(WARN_FLAGS)
1846 ])
1847
1848 dnl
1849 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1850 dnl  calculates gxx_install_dir
1851 dnl  exports glibcpp_toolexecdir
1852 dnl  exports glibcpp_toolexeclibdir
1853 dnl  exports glibcpp_prefixdir
1854 dnl
1855 dnl Assumes cross_compiling bits already done, and with_cross_host in
1856 dnl particular
1857 dnl
1858 dnl GLIBCPP_EXPORT_INSTALL_INFO
1859 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1860 # Assumes glibcpp_builddir, glibcpp_srcdir are alreay set up and
1861 # exported correctly in GLIBCPP_CONFIGURE.
1862 glibcpp_toolexecdir=no
1863 glibcpp_toolexeclibdir=no
1864 glibcpp_prefixdir=${prefix}
1865
1866 # Process the option --with-gxx-include-dir=<path to include-files directory>
1867 AC_MSG_CHECKING([for --with-gxx-include-dir])
1868 AC_ARG_WITH(gxx-include-dir,
1869 [  --with-gxx-include-dir  the installation directory for include files],
1870 [case "${withval}" in
1871   yes)
1872     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1873     gxx_include_dir=no
1874     ;;
1875   no)
1876     gxx_include_dir=no
1877     ;;
1878   *)
1879     gxx_include_dir=${withval}
1880     ;;
1881 esac], [gxx_include_dir=no])
1882 AC_MSG_RESULT($gxx_include_dir)
1883
1884 # Process the option "--enable-version-specific-runtime-libs"
1885 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1886 AC_ARG_ENABLE(version-specific-runtime-libs,
1887 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1888 [case "$enableval" in
1889  yes) version_specific_libs=yes ;;
1890  no)  version_specific_libs=no ;;
1891  *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
1892  esac],
1893 version_specific_libs=no)dnl
1894 # Option set, now we can test it.
1895 AC_MSG_RESULT($version_specific_libs)
1896
1897 # Default case for install directory for include files.
1898 if test $version_specific_libs = no && test $gxx_include_dir = no; then
1899   gxx_include_dir='$(prefix)'/include/c++/${gcc_version}
1900 fi
1901
1902 # Version-specific runtime libs processing.
1903 if test $version_specific_libs = yes; then
1904   # Need the gcc compiler version to know where to install libraries
1905   # and header files if --enable-version-specific-runtime-libs option
1906   # is selected.
1907   if test x"$gxx_include_dir" = x"no"; then
1908     gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/c++
1909   fi
1910   glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1911   glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
1912 fi
1913
1914 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1915 # Install a library built with a cross compiler in tooldir, not libdir.
1916 if test x"$glibcpp_toolexecdir" = x"no"; then
1917   if test -n "$with_cross_host" &&
1918      test x"$with_cross_host" != x"no"; then
1919     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1920     glibcpp_toolexeclibdir='$(toolexecdir)/lib'
1921   else
1922     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1923     glibcpp_toolexeclibdir='$(libdir)'
1924   fi
1925   multi_os_directory=`$CC -print-multi-os-directory`
1926   case $multi_os_directory in
1927   .) ;; # Avoid trailing /.
1928   *) glibcpp_toolexeclibdir=$glibcpp_toolexeclibdir/$multi_os_directory ;;
1929   esac
1930 fi
1931
1932 AC_MSG_CHECKING([for install location])
1933 AC_MSG_RESULT($gxx_include_dir)
1934
1935 AC_SUBST(glibcpp_prefixdir)
1936 AC_SUBST(gxx_include_dir)
1937 AC_SUBST(glibcpp_toolexecdir)
1938 AC_SUBST(glibcpp_toolexeclibdir)
1939 ])
1940
1941
1942 # Check for functions in math library.
1943 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1944 #
1945 # This file can be copied and used freely without restrictions.  It can
1946 # be used in projects which are not available under the GNU Public License
1947 # but which still want to provide support for the GNU gettext functionality.
1948 # Please note that the actual code is *not* freely available.
1949
1950 # serial 1
1951
1952 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1953 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1954 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])])
1955
1956
1957 dnl This macro searches for a GNU version of make.  If a match is found, the
1958 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1959 dnl set to "#". This is useful for  including a special features in a Makefile,
1960 dnl which cannot be handled by other versions of make.  The variable
1961 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1962 dnl the empty string otherwise.
1963 dnl
1964 dnl Here is an example of its use:
1965 dnl
1966 dnl Makefile.in might contain:
1967 dnl
1968 dnl     # A failsafe way of putting a dependency rule into a makefile
1969 dnl     $(DEPEND):
1970 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1971 dnl
1972 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1973 dnl     @ifGNUmake@ include $(DEPEND)
1974 dnl     @ifGNUmake@ endif
1975 dnl
1976 dnl Then configure.in would normally contain:
1977 dnl
1978 dnl     CHECK_GNU_MAKE()
1979 dnl     AC_OUTPUT(Makefile)
1980 dnl
1981 dnl Then perhaps to cause gnu make to override any other make, we could do
1982 dnl something like this (note that GNU make always looks for GNUmakefile first):
1983 dnl
1984 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1985 dnl             mv Makefile GNUmakefile
1986 dnl             echo .DEFAULT: > Makefile ;
1987 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1988 dnl     fi
1989 dnl
1990 dnl Then, if any (well almost any) other make is called, and GNU make also
1991 dnl exists, then the other make wraps the GNU make.
1992 dnl
1993 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1994 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1995 dnl
1996 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1997 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1998 dnl #### conditional's subshell (" --version" is not a command), using a
1999 dnl #### different option to grep(1).
2000 dnl #### -pme
2001 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
2002 dnl #### ${MAKE:-make}).
2003 dnl #### -msokolov
2004 AC_DEFUN(
2005   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
2006           _cv_gnu_make_command='' ;
2007 dnl Search all the common names for GNU make
2008           for a in "${MAKE-make}" make gmake gnumake ; do
2009                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2010                   then
2011                           _cv_gnu_make_command=$a ;
2012                           break;
2013                   fi
2014           done ;
2015   ) ;
2016 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
2017 dnl string, '#' otherwise
2018   if test  "x$_cv_gnu_make_command" != "x"  ; then
2019           ifGNUmake='' ;
2020   else
2021           ifGNUmake='#' ;
2022   fi
2023   AC_SUBST(ifGNUmake)
2024 ])
2025
2026
2027 dnl Check for headers for, and arguments to, the setrlimit() function.
2028 dnl Used only in testsuite_hooks.h.
2029 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT_ancilliary, [
2030   AC_TRY_COMPILE([#include <unistd.h>
2031                   #include <sys/time.h>
2032                   #include <sys/resource.h>
2033                  ], [ int f = RLIMIT_$1 ; ],
2034                  [glibcpp_mresult=1], [glibcpp_mresult=0])
2035   AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcpp_mresult,
2036                      [Only used in build directory testsuite_hooks.h.])
2037 ])
2038 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
2039   setrlimit_have_headers=yes
2040   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
2041                    [],
2042                    setrlimit_have_headers=no)
2043   # If don't have the headers, then we can't run the tests now, and we
2044   # won't be seeing any of these during testsuite compilation.
2045   if test $setrlimit_have_headers = yes; then
2046     # Can't do these in a loop, else the resulting syntax is wrong.
2047     GLIBCPP_CHECK_SETRLIMIT_ancilliary(DATA)
2048     GLIBCPP_CHECK_SETRLIMIT_ancilliary(RSS)
2049     GLIBCPP_CHECK_SETRLIMIT_ancilliary(VMEM)
2050     GLIBCPP_CHECK_SETRLIMIT_ancilliary(AS)
2051
2052     # Check for rlimit, setrlimit.
2053     AC_CACHE_VAL(ac_setrlimit, [
2054       AC_TRY_COMPILE([#include <unistd.h>
2055                   #include <sys/time.h>
2056                   #include <sys/resource.h>
2057                      ],
2058                      [ struct rlimit r; setrlimit(0, &r);],
2059                      [ac_setrlimit=yes], [ac_setrlimit=no])
2060     ])
2061   fi
2062
2063   AC_MSG_CHECKING([for testsuite memory limit support])
2064   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
2065     ac_mem_limits=yes
2066     AC_DEFINE(_GLIBCPP_MEM_LIMITS)
2067   else
2068     ac_mem_limits=no
2069   fi
2070   AC_MSG_RESULT($ac_mem_limits)
2071 ])
2072
2073
2074 dnl
2075 dnl Does any necessary configuration of the testsuite directory.  Generates
2076 dnl the testsuite_hooks.h header.
2077 dnl
2078 dnl GLIBCPP_CONFIGURE_TESTSUITE  [no args]
2079 AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [
2080
2081   if test  x"$GLIBCPP_IS_CROSS_COMPILING" = xfalse; then
2082     # Do checks for memory limit functions.
2083     GLIBCPP_CHECK_SETRLIMIT
2084
2085     # Look for setenv, so that extended locale tests can be performed.
2086     GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
2087   fi
2088
2089   # Export file names for ABI checking.
2090   baseline_dir="${glibcpp_srcdir}/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
2091   AC_SUBST(baseline_dir)
2092
2093   # Determine if checking the ABI is desirable.
2094   if test x$enable_symvers = xno; then
2095     enable_abi_check=no
2096   else
2097     case "$host" in
2098       *-*-cygwin*)
2099         enable_abi_check=no ;;
2100       *)
2101         enable_abi_check=yes ;;
2102     esac
2103   fi
2104
2105   AM_CONDITIONAL(GLIBCPP_TEST_WCHAR_T, test "$enable_wchar_t" = yes)
2106   AM_CONDITIONAL(GLIBCPP_TEST_ABI, test "$enable_abi_check" = yes)
2107 ])
2108
2109
2110 sinclude(../libtool.m4)
2111 dnl The lines below arrange for aclocal not to bring an installed
2112 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
2113 dnl add a definition of LIBTOOL to Makefile.in.
2114 ifelse(,,,[AC_SUBST(LIBTOOL)
2115 AC_DEFUN([AM_PROG_LIBTOOL])
2116 AC_DEFUN([AC_LIBTOOL_DLOPEN])
2117 AC_DEFUN([AC_PROG_LD])
2118 ])
2119
2120 dnl
2121 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
2122 dnl
2123
2124 AC_DEFUN(GLIBCPP_CHECK_S_ISREG_OR_S_IFREG, [
2125   AC_CACHE_VAL(glibcpp_cv_S_ISREG, [
2126     AC_TRY_LINK([#include <sys/stat.h>],
2127                 [struct stat buffer; fstat(0, &buffer); S_ISREG(buffer.st_mode); ],
2128                 [glibcpp_cv_S_ISREG=yes],
2129                 [glibcpp_cv_S_ISREG=no])
2130   ])
2131   AC_CACHE_VAL(glibcpp_cv_S_IFREG, [
2132     AC_TRY_LINK([#include <sys/stat.h>],
2133                 [struct stat buffer; fstat(0, &buffer); S_IFREG & buffer.st_mode; ],
2134                 [glibcpp_cv_S_IFREG=yes],
2135                 [glibcpp_cv_S_IFREG=no])
2136   ])
2137   if test x$glibcpp_cv_S_ISREG = xyes; then
2138     AC_DEFINE(HAVE_S_ISREG)
2139   elif test x$glibcpp_cv_S_IFREG = xyes; then
2140     AC_DEFINE(HAVE_S_IFREG)
2141   fi
2142 ])
2143
2144 dnl
2145 dnl Check whether poll is available in <poll.h>.
2146 dnl
2147
2148 AC_DEFUN(GLIBCPP_CHECK_POLL, [
2149   AC_CACHE_VAL(glibcpp_cv_POLL, [
2150     AC_TRY_COMPILE([#include <poll.h>],
2151                 [struct pollfd pfd[1]; pfd[0].events = POLLIN; poll(pfd, 1, 0); ],
2152                 [glibcpp_cv_POLL=yes],
2153                 [glibcpp_cv_POLL=no])
2154   ])
2155   if test x$glibcpp_cv_POLL = xyes; then
2156     AC_DEFINE(HAVE_POLL)
2157   fi
2158 ])
2159
2160 # Check whether LC_MESSAGES is available in <locale.h>.
2161 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2162 #
2163 # This file file be copied and used freely without restrictions.  It can
2164 # be used in projects which are not available under the GNU Public License
2165 # but which still want to provide support for the GNU gettext functionality.
2166 # Please note that the actual code is *not* freely available.
2167
2168 # serial 1
2169
2170 AC_DEFUN(AC_LC_MESSAGES, [
2171   AC_CHECK_HEADER(locale.h, [
2172     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2173       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2174        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2175     if test $ac_cv_val_LC_MESSAGES = yes; then
2176       AC_DEFINE(HAVE_LC_MESSAGES)
2177     fi
2178   ])
2179 ])
2180
2181
2182 dnl
2183 dnl Check for whether the Boost-derived checks should be turned on.
2184 dnl
2185 dnl GLIBCPP_ENABLE_CONCEPT_CHECKS
2186 dnl --enable-concept-checks turns them on.
2187 dnl --disable-concept-checks leaves them off.
2188 dnl  +  Usage:  GLIBCPP_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2189 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2190 dnl       defaults to `no'.
2191 AC_DEFUN(GLIBCPP_ENABLE_CONCEPT_CHECKS, [dnl
2192 define([GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl
2193 AC_ARG_ENABLE(concept-checks,
2194 changequote(<<, >>)dnl
2195 <<  --enable-concept-checks use Boost-derived template checks [default=>>GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT],
2196 changequote([, ])dnl
2197 [case "$enableval" in
2198  yes) enable_concept_checks=yes ;;
2199  no)  enable_concept_checks=no ;;
2200  *)   AC_MSG_ERROR([Unknown argument to enable/disable concept checks]) ;;
2201  esac],
2202 enable_concept_checks=GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl
2203 dnl Option parsed, now set things appropriately
2204 if test x"$enable_concept_checks" = xyes; then
2205   AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS)
2206 fi
2207 ])
2208
2209
2210 dnl
2211 dnl Add version tags to symbols in shared library (or not), additionally
2212 dnl marking other symbols as private/local (or not).
2213 dnl
2214 dnl GLIBCPP_ENABLE_SYMVERS
2215 dnl --enable-symvers=style adds a version script to the linker call when
2216 dnl       creating the shared library.  The choice of version script is
2217 dnl       controlled by 'style'.
2218 dnl --disable-symvers does not.
2219 dnl  +  Usage:  GLIBCPP_ENABLE_SYMVERS[(DEFAULT)]
2220 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2221 dnl       defaults to `no'.  Passing `yes' tries to choose a default style
2222 dnl       based on linker characteristics.  Passing 'no' disables versioning.
2223 AC_DEFUN(GLIBCPP_ENABLE_SYMVERS, [dnl
2224 define([GLIBCPP_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl
2225 AC_ARG_ENABLE(symvers,
2226 changequote(<<, >>)dnl
2227 <<  --enable-symvers=style  enables symbol versioning of the shared library [default=>>GLIBCPP_ENABLE_SYMVERS_DEFAULT],
2228 changequote([, ])dnl
2229 [case "$enableval" in
2230  yes) enable_symvers=yes ;;
2231  no)  enable_symvers=no ;;
2232  # other names here, just as sanity checks
2233  #gnu|sun|etcetera) enable_symvers=$enableval ;;
2234  gnu) enable_symvers=$enableval ;;
2235  *)   AC_MSG_ERROR([Unknown argument to enable/disable symvers]) ;;
2236  esac],
2237 enable_symvers=GLIBCPP_ENABLE_SYMVERS_DEFAULT)dnl
2238
2239 # If we never went through the GLIBCPP_CHECK_LINKER_FEATURES macro, then we
2240 # don't know enough about $LD to do tricks...
2241 if test x$enable_shared = xno ||
2242         test "x$LD" = x ||
2243         test x$glibcpp_gnu_ld_version = x; then
2244   enable_symvers=no
2245 fi
2246
2247 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2248 if test $enable_symvers != no; then
2249   AC_MSG_CHECKING([for shared libgcc])
2250   ac_save_CFLAGS="$CFLAGS"
2251   CFLAGS=' -lgcc_s'
2252   AC_TRY_LINK(, [return 0], glibcpp_shared_libgcc=yes, glibcpp_shared_libgcc=no)
2253   CFLAGS="$ac_save_CFLAGS"
2254   AC_MSG_RESULT($glibcpp_shared_libgcc)
2255 fi
2256
2257 # For GNU ld, we need at least this version.  It's 2.12 in the same format
2258 # as the tested-for version.  See GLIBCPP_CHECK_LINKER_FEATURES for more.
2259 glibcpp_min_gnu_ld_version=21200
2260
2261 # Check to see if unspecified "yes" value can win, given results
2262 # above.
2263 if test $enable_symvers = yes ; then
2264   if test $with_gnu_ld = yes &&
2265     test $glibcpp_shared_libgcc = yes ;
2266   then
2267     if test $glibcpp_gnu_ld_version -ge $glibcpp_min_gnu_ld_version ; then
2268         enable_symvers=gnu
2269     else
2270       ac_test_CFLAGS="${CFLAGS+set}"
2271       ac_save_CFLAGS="$CFLAGS"
2272       CFLAGS='-shared -Wl,--version-script,conftest.map'
2273       enable_symvers=no
2274       changequote(,)
2275       echo 'FOO { global: f[a-z]o; local: *; };' > conftest.map
2276       changequote([,])
2277       AC_TRY_LINK([int foo;],, enable_symvers=gnu)
2278       if test "$ac_test_CFLAGS" = set; then
2279         CFLAGS="$ac_save_CFLAGS"
2280       else
2281         # this is the suspicious part
2282         CFLAGS=''
2283       fi
2284       rm -f conftest.map
2285     fi
2286   else
2287     # just fail for now
2288     enable_symvers=no
2289   fi
2290 fi
2291
2292 dnl Everything parsed; figure out what file to use.
2293 case $enable_symvers in
2294   no)
2295       SYMVER_MAP=config/linker-map.dummy
2296       ;;
2297   gnu)
2298       SYMVER_MAP=config/linker-map.gnu
2299       AC_DEFINE(_GLIBCPP_SYMVER)
2300       ;;
2301 esac
2302
2303 AC_SUBST(SYMVER_MAP)
2304 AM_CONDITIONAL(GLIBCPP_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
2305 AC_MSG_CHECKING([versioning on shared library symbols])
2306 AC_MSG_RESULT($enable_symvers)
2307 ])
2308