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                        [glibcpp_pch_comp=yes], [glibcpp_pch_comp=no])
1409         AC_LANG_RESTORE
1410       ])
1411     fi
1412     AC_MSG_RESULT([$glibcpp_pch_comp])
1413
1414     CXXFLAGS="$ac_save_CXXFLAGS"
1415   fi
1416
1417   if test x"$enable_pch" = xyes && test x"$glibcpp_pch_comp" = xno; then
1418     enable_pch=no
1419   fi
1420
1421   AC_MSG_CHECKING([for enabled PCH])
1422   AC_MSG_RESULT([$enable_pch])
1423
1424   AM_CONDITIONAL(GLIBCPP_BUILD_PCH, test "$enable_pch" = yes)
1425   if test "$enable_pch" = yes; then
1426         glibcpp_PCHFLAGS="-include bits/stdc++.h"
1427   else
1428         glibcpp_PCHFLAGS=""
1429   fi
1430   AC_SUBST(glibcpp_PCHFLAGS)
1431 ])
1432
1433 dnl
1434 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1435 dnl We must stage the required headers so that they will be installed
1436 dnl with the library (unlike libgcc, the STL implementation is provided
1437 dnl solely within headers).  Since we must not inject random user-space
1438 dnl macro names into user-provided C++ code, we first stage into <file>-in
1439 dnl and process to <file> with an output command.  The reason for a two-
1440 dnl stage process here is to correctly handle $srcdir!=$objdir without
1441 dnl having to write complex code (the sed commands to clean the macro
1442 dnl namespace are complex and fragile enough as it is).  We must also
1443 dnl add a relative path so that -I- is supported properly.
1444 dnl
1445 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1446   AC_MSG_CHECKING([for thread model used by GCC])
1447   target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
1448   AC_MSG_RESULT([$target_thread_file])
1449
1450   if test $target_thread_file != single; then
1451     AC_DEFINE(HAVE_GTHR_DEFAULT)
1452     AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__)
1453   fi
1454
1455   glibcpp_thread_h=gthr-$target_thread_file.h
1456   AC_SUBST(glibcpp_thread_h)
1457 ])
1458
1459
1460 dnl
1461 dnl Check for exception handling support.  If an explicit enable/disable
1462 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1463 dnl target may or may not support call frame exceptions.
1464 dnl
1465 dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS
1466 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1467 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1468 dnl
1469 dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it.
1470 dnl
1471 AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [
1472   AC_MSG_CHECKING([for exception model to use])
1473   AC_LANG_SAVE
1474   AC_LANG_CPLUSPLUS
1475   AC_ARG_ENABLE(sjlj-exceptions,
1476   [  --enable-sjlj-exceptions  force use of builtin_setjmp for exceptions],
1477   [:],
1478   [dnl Botheration.  Now we've got to detect the exception model.
1479    dnl Link tests against libgcc.a are problematic since -- at least
1480    dnl as of this writing -- we've not been given proper -L bits for
1481    dnl single-tree newlib and libgloss.
1482    dnl
1483    dnl This is what AC_TRY_COMPILE would do if it didn't delete the
1484    dnl conftest files before we got a change to grep them first.
1485    cat > conftest.$ac_ext << EOF
1486 [#]line __oline__ "configure"
1487 struct S { ~S(); };
1488 void bar();
1489 void foo()
1490 {
1491   S s;
1492   bar();
1493 }
1494 EOF
1495    old_CXXFLAGS="$CXXFLAGS"
1496    CXXFLAGS=-S
1497    if AC_TRY_EVAL(ac_compile); then
1498      if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1499        enable_sjlj_exceptions=yes
1500      elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1501        enable_sjlj_exceptions=no
1502      fi
1503    fi
1504    CXXFLAGS="$old_CXXFLAGS"
1505    rm -f conftest*])
1506    if test x$enable_sjlj_exceptions = xyes; then
1507      AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1,
1508         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1509      ac_exception_model_name=sjlj
1510    elif test x$enable_sjlj_exceptions = xno; then
1511      ac_exception_model_name="call frame"
1512    else
1513      AC_MSG_ERROR([unable to detect exception model])
1514    fi
1515    AC_LANG_RESTORE
1516    AC_MSG_RESULT($ac_exception_model_name)
1517 ])
1518
1519
1520 dnl
1521 dnl Check for libunwind exception handling support. If enabled then
1522 dnl we assume that the _Unwind_* functions that make up the Unwind ABI
1523 dnl (_Unwind_RaiseException, _Unwind_Resume, etc.) are defined by
1524 dnl libunwind instead of libgcc and that libstdc++ has a dependency
1525 dnl on libunwind as well as libgcc.
1526 dnl
1527 dnl GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS
1528 dnl --enable-libunwind-exceptions forces the use of libunwind.
1529 dnl --disable-libunwind-exceptions assumes there is no libunwind.
1530 dnl
1531 dnl Define _GLIBCPP_LIBUNWIND_EXCEPTIONS if requested.
1532 dnl
1533 AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [
1534   AC_MSG_CHECKING([for use of libunwind])
1535   AC_ARG_ENABLE(libunwind-exceptions,
1536   [  --enable-libunwind-exceptions  force use of libunwind for exceptions],
1537   use_libunwind_exceptions=$enableval,
1538   use_libunwind_exceptions=no)
1539   AC_MSG_RESULT($use_libunwind_exceptions)
1540   dnl Option parsed, now set things appropriately
1541   if test x"$use_libunwind_exceptions" = xyes; then
1542     LIBUNWIND_FLAG="-lunwind"
1543   else
1544     LIBUNWIND_FLAG=""
1545   fi
1546   AC_SUBST(LIBUNWIND_FLAG)
1547 ])
1548
1549 dnl
1550 dnl Check for ISO/IEC 9899:1999 "C99" support.
1551 dnl
1552 dnl GLIBCPP_ENABLE_C99
1553 dnl --enable-c99 defines _GLIBCPP_USE_C99
1554 dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
1555 dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
1556 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1557 dnl       defaults to `no'.
1558 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
1559 dnl
1560 dnl GLIBCPP_ENABLE_C99
1561 AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
1562   define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
1563
1564   AC_ARG_ENABLE(c99,
1565   changequote(<<, >>)dnl
1566   <<--enable-c99            turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
1567   changequote([, ])dnl
1568   [case "$enableval" in
1569    yes) enable_c99=yes ;;
1570    no)  enable_c99=no ;;
1571    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
1572    esac],
1573   enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
1574
1575   AC_LANG_SAVE
1576   AC_LANG_CPLUSPLUS
1577
1578   # Check for the existence of <math.h> functions used if C99 is enabled.
1579   ac_c99_math=yes;
1580   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
1581   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
1582   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
1583   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
1584   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
1585   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
1586   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
1587   AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
1588   AC_TRY_COMPILE([#include <math.h>],
1589                  [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
1590   AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
1591   AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
1592   AC_TRY_COMPILE([#include <math.h>],
1593                  [islessgreater(0.0,0.0);],, [ac_c99_math=no])
1594   AC_TRY_COMPILE([#include <math.h>],
1595                  [isunordered(0.0,0.0);],, [ac_c99_math=no])
1596   AC_MSG_RESULT($ac_c99_math)
1597
1598   # Check for the existence in <stdio.h> of vscanf, et. al.
1599   ac_c99_stdio=yes;
1600   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1601   AC_TRY_COMPILE([#include <stdio.h>],
1602                  [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
1603   AC_TRY_COMPILE([#include <stdio.h>
1604                   #include <stdarg.h>
1605                   void foo(char* fmt, ...)
1606                   {va_list args; va_start(args, fmt);
1607                   vfscanf(stderr, "%i", args);}],
1608                   [],, [ac_c99_stdio=no])
1609   AC_TRY_COMPILE([#include <stdio.h>
1610                   #include <stdarg.h>
1611                   void foo(char* fmt, ...)
1612                   {va_list args; va_start(args, fmt);
1613                   vscanf("%i", args);}],
1614                   [],, [ac_c99_stdio=no])
1615   AC_TRY_COMPILE([#include <stdio.h>
1616                   #include <stdarg.h>
1617                   void foo(char* fmt, ...)
1618                   {va_list args; va_start(args, fmt);
1619                   vsnprintf(fmt, 0, "%i", args);}],
1620                   [],, [ac_c99_stdio=no])
1621   AC_TRY_COMPILE([#include <stdio.h>
1622                   #include <stdarg.h>
1623                   void foo(char* fmt, ...)
1624                   {va_list args; va_start(args, fmt);
1625                   vsscanf(fmt, "%i", args);}],
1626                   [],, [ac_c99_stdio=no])
1627   AC_MSG_RESULT($ac_c99_stdio)
1628
1629   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1630   ac_c99_stdlib=yes;
1631   AC_MSG_CHECKING([for lldiv_t declaration])
1632   AC_CACHE_VAL(ac_c99_lldiv_t, [
1633   AC_TRY_COMPILE([#include <stdlib.h>],
1634                    [ lldiv_t mydivt;],
1635                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1636   ])
1637   AC_MSG_RESULT($ac_c99_lldiv_t)
1638
1639   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1640   AC_TRY_COMPILE([#include <stdlib.h>],
1641                  [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
1642   AC_TRY_COMPILE([#include <stdlib.h>],
1643                  [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
1644   AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
1645   AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
1646   AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
1647   AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
1648   if test x"$ac_c99_lldiv_t" = x"no"; then
1649     ac_c99_stdlib=no;
1650   fi;
1651   AC_MSG_RESULT($ac_c99_stdlib)
1652
1653   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1654   # XXX the wchar.h checks should be rolled into the general C99 bits.
1655   ac_c99_wchar=yes;
1656   AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
1657   AC_TRY_COMPILE([#include <wchar.h>],
1658                  [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
1659   AC_TRY_COMPILE([#include <wchar.h>],
1660                  [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
1661   AC_TRY_COMPILE([#include <wchar.h>],
1662                  [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
1663   AC_MSG_RESULT($ac_c99_wchar)
1664
1665   AC_MSG_CHECKING([for enabled ISO C99 support])
1666   if test x"$ac_c99_math" = x"no" ||
1667      test x"$ac_c99_stdio" = x"no" ||
1668      test x"$ac_c99_stdlib" = x"no" ||
1669      test x"$ac_c99_wchar" = x"no"; then
1670     enable_c99=no;
1671   fi;
1672   AC_MSG_RESULT($enable_c99)
1673
1674   # Option parsed, now set things appropriately
1675   if test x"$enable_c99" = x"yes"; then
1676     AC_DEFINE(_GLIBCPP_USE_C99)
1677   fi
1678
1679   AC_LANG_RESTORE
1680 ])
1681
1682
1683 dnl
1684 dnl Check for template specializations for the 'long long' type extension.
1685 dnl The result determines only whether 'long long' I/O is enabled; things
1686 dnl like numeric_limits<> specializations are always available.
1687 dnl
1688 dnl GLIBCPP_ENABLE_LONG_LONG
1689 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1690 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1691 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1692 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1693 dnl       defaults to `no'.
1694 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1695 dnl
1696 dnl GLIBCPP_ENABLE_LONG_LONG
1697 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1698   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1699
1700   AC_ARG_ENABLE(long-long,
1701   changequote(<<, >>)dnl
1702   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1703   changequote([, ])dnl
1704   [case "$enableval" in
1705    yes) enable_long_long=yes ;;
1706    no)  enable_long_long=no ;;
1707    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1708    esac],
1709   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1710
1711   AC_LANG_SAVE
1712   AC_LANG_CPLUSPLUS
1713
1714   AC_MSG_CHECKING([for enabled long long I/O support])
1715   # iostreams require strtoll, strtoull to compile
1716   AC_TRY_COMPILE([#include <stdlib.h>],
1717                  [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no])
1718   AC_TRY_COMPILE([#include <stdlib.h>],
1719                  [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no])
1720
1721   # Option parsed, now set things appropriately
1722   if test x"$enable_long_long" = xyes; then
1723     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1724   fi
1725   AC_MSG_RESULT($enable_long_long)
1726
1727   AC_LANG_RESTORE
1728 ])
1729
1730
1731 dnl
1732 dnl Check for what type of C headers to use.
1733 dnl
1734 dnl GLIBCPP_ENABLE_CHEADERS
1735 dnl --enable-cheaders= [does stuff].
1736 dnl --disable-cheaders [does not do anything, really].
1737 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1738 dnl       Where DEFAULT is either `c' or `c_std'.
1739 dnl       If ommitted, it defaults to `c_std'.
1740 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1741 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1742 AC_MSG_CHECKING([for c header strategy to use])
1743 AC_ARG_ENABLE(cheaders,
1744 changequote(<<, >>)dnl
1745 <<  --enable-cheaders=MODEL       construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1746 changequote([, ])
1747   [case "$enableval" in
1748    c)
1749         enable_cheaders=c
1750         ;;
1751    c_std)
1752         enable_cheaders=c_std
1753         ;;
1754    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1755         ;;
1756   esac],
1757   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1758   AC_MSG_RESULT($enable_cheaders)
1759
1760   dnl Option parsed, now set things appropriately
1761   case "$enable_cheaders" in
1762     c_std)
1763         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_std'
1764         ;;
1765     c)
1766         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c'
1767         ;;
1768   esac
1769
1770   AC_SUBST(C_INCLUDE_DIR)
1771   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C, test "$enable_cheaders" = c)
1772   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C_STD, test "$enable_cheaders" = c_std)
1773   AM_CONDITIONAL(GLIBCPP_C_HEADERS_COMPATIBILITY, test "$c_compatibility" = yes)
1774 ])
1775
1776
1777 dnl
1778 dnl Check for wide character support.  Has the same effect as the option
1779 dnl in gcc's configure, but in a form that autoconf can mess with.
1780 dnl
1781 dnl GLIBCPP_ENABLE_C_MBCHAR
1782 dnl --enable-c-mbchar requests all the wchar_t stuff.
1783 dnl --disable-c-mbchar doesn't.
1784 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1785 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1786 dnl       defaults to `no'.
1787 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1788 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1789 AC_ARG_ENABLE(c-mbchar,
1790 changequote(<<, >>)dnl
1791 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1792 changequote([, ])dnl
1793 [case "$enableval" in
1794  yes) enable_c_mbchar=yes ;;
1795  no)  enable_c_mbchar=no ;;
1796  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1797  esac],
1798 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1799 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1800 ])
1801
1802
1803 dnl
1804 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1805 dnl
1806 dnl TOPLEVEL_INCLUDES
1807 dnl LIBMATH_INCLUDES
1808 dnl LIBSUPCXX_INCLUDES
1809 dnl
1810 dnl GLIBCPP_EXPORT_INCLUDES
1811 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1812   # Root level of the build directory include sources.
1813   GLIBCPP_INCLUDES="-I${glibcpp_builddir}/include/${target_alias} -I${glibcpp_builddir}/include"
1814
1815   # Passed down for canadian crosses.
1816   if test x"$CANADIAN" = xyes; then
1817     TOPLEVEL_INCLUDES='-I$(includedir)'
1818   fi
1819
1820   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1821
1822   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1823
1824   # Now, export this to all the little Makefiles....
1825   AC_SUBST(GLIBCPP_INCLUDES)
1826   AC_SUBST(TOPLEVEL_INCLUDES)
1827   AC_SUBST(LIBMATH_INCLUDES)
1828   AC_SUBST(LIBSUPCXX_INCLUDES)
1829 ])
1830
1831
1832 dnl
1833 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1834 dnl
1835 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1836   # Optimization flags that are probably a good idea for thrill-seekers. Just
1837   # uncomment the lines below and make, everything else is ready to go...
1838   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1839   OPTIMIZE_CXXFLAGS=
1840   AC_SUBST(OPTIMIZE_CXXFLAGS)
1841
1842   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings'
1843   AC_SUBST(WARN_FLAGS)
1844 ])
1845
1846 dnl
1847 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1848 dnl  calculates gxx_install_dir
1849 dnl  exports glibcpp_toolexecdir
1850 dnl  exports glibcpp_toolexeclibdir
1851 dnl  exports glibcpp_prefixdir
1852 dnl
1853 dnl Assumes cross_compiling bits already done, and with_cross_host in
1854 dnl particular
1855 dnl
1856 dnl GLIBCPP_EXPORT_INSTALL_INFO
1857 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1858 # Assumes glibcpp_builddir, glibcpp_srcdir are alreay set up and
1859 # exported correctly in GLIBCPP_CONFIGURE.
1860 glibcpp_toolexecdir=no
1861 glibcpp_toolexeclibdir=no
1862 glibcpp_prefixdir=${prefix}
1863
1864 # Process the option --with-gxx-include-dir=<path to include-files directory>
1865 AC_MSG_CHECKING([for --with-gxx-include-dir])
1866 AC_ARG_WITH(gxx-include-dir,
1867 [  --with-gxx-include-dir  the installation directory for include files],
1868 [case "${withval}" in
1869   yes)
1870     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1871     gxx_include_dir=no
1872     ;;
1873   no)
1874     gxx_include_dir=no
1875     ;;
1876   *)
1877     gxx_include_dir=${withval}
1878     ;;
1879 esac], [gxx_include_dir=no])
1880 AC_MSG_RESULT($gxx_include_dir)
1881
1882 # Process the option "--enable-version-specific-runtime-libs"
1883 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1884 AC_ARG_ENABLE(version-specific-runtime-libs,
1885 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1886 [case "$enableval" in
1887  yes) version_specific_libs=yes ;;
1888  no)  version_specific_libs=no ;;
1889  *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
1890  esac],
1891 version_specific_libs=no)dnl
1892 # Option set, now we can test it.
1893 AC_MSG_RESULT($version_specific_libs)
1894
1895 # Default case for install directory for include files.
1896 if test $version_specific_libs = no && test $gxx_include_dir = no; then
1897   gxx_include_dir='$(prefix)'/include/c++/${gcc_version}
1898 fi
1899
1900 # Version-specific runtime libs processing.
1901 if test $version_specific_libs = yes; then
1902   # Need the gcc compiler version to know where to install libraries
1903   # and header files if --enable-version-specific-runtime-libs option
1904   # is selected.
1905   if test x"$gxx_include_dir" = x"no"; then
1906     gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/c++
1907   fi
1908   glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1909   glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
1910 fi
1911
1912 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1913 # Install a library built with a cross compiler in tooldir, not libdir.
1914 if test x"$glibcpp_toolexecdir" = x"no"; then
1915   if test -n "$with_cross_host" &&
1916      test x"$with_cross_host" != x"no"; then
1917     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1918     glibcpp_toolexeclibdir='$(toolexecdir)/lib'
1919   else
1920     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1921     glibcpp_toolexeclibdir='$(libdir)'
1922   fi
1923   multi_os_directory=`$CC -print-multi-os-directory`
1924   case $multi_os_directory in
1925   .) ;; # Avoid trailing /.
1926   *) glibcpp_toolexeclibdir=$glibcpp_toolexeclibdir/$multi_os_directory ;;
1927   esac
1928 fi
1929
1930 AC_MSG_CHECKING([for install location])
1931 AC_MSG_RESULT($gxx_include_dir)
1932
1933 AC_SUBST(glibcpp_prefixdir)
1934 AC_SUBST(gxx_include_dir)
1935 AC_SUBST(glibcpp_toolexecdir)
1936 AC_SUBST(glibcpp_toolexeclibdir)
1937 ])
1938
1939
1940 # Check for functions in math library.
1941 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1942 #
1943 # This file can be copied and used freely without restrictions.  It can
1944 # be used in projects which are not available under the GNU Public License
1945 # but which still want to provide support for the GNU gettext functionality.
1946 # Please note that the actual code is *not* freely available.
1947
1948 # serial 1
1949
1950 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1951 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1952 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])])
1953
1954
1955 dnl This macro searches for a GNU version of make.  If a match is found, the
1956 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1957 dnl set to "#". This is useful for  including a special features in a Makefile,
1958 dnl which cannot be handled by other versions of make.  The variable
1959 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1960 dnl the empty string otherwise.
1961 dnl
1962 dnl Here is an example of its use:
1963 dnl
1964 dnl Makefile.in might contain:
1965 dnl
1966 dnl     # A failsafe way of putting a dependency rule into a makefile
1967 dnl     $(DEPEND):
1968 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1969 dnl
1970 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1971 dnl     @ifGNUmake@ include $(DEPEND)
1972 dnl     @ifGNUmake@ endif
1973 dnl
1974 dnl Then configure.in would normally contain:
1975 dnl
1976 dnl     CHECK_GNU_MAKE()
1977 dnl     AC_OUTPUT(Makefile)
1978 dnl
1979 dnl Then perhaps to cause gnu make to override any other make, we could do
1980 dnl something like this (note that GNU make always looks for GNUmakefile first):
1981 dnl
1982 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1983 dnl             mv Makefile GNUmakefile
1984 dnl             echo .DEFAULT: > Makefile ;
1985 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1986 dnl     fi
1987 dnl
1988 dnl Then, if any (well almost any) other make is called, and GNU make also
1989 dnl exists, then the other make wraps the GNU make.
1990 dnl
1991 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1992 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1993 dnl
1994 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1995 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1996 dnl #### conditional's subshell (" --version" is not a command), using a
1997 dnl #### different option to grep(1).
1998 dnl #### -pme
1999 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
2000 dnl #### ${MAKE:-make}).
2001 dnl #### -msokolov
2002 AC_DEFUN(
2003   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
2004           _cv_gnu_make_command='' ;
2005 dnl Search all the common names for GNU make
2006           for a in "${MAKE-make}" make gmake gnumake ; do
2007                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2008                   then
2009                           _cv_gnu_make_command=$a ;
2010                           break;
2011                   fi
2012           done ;
2013   ) ;
2014 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
2015 dnl string, '#' otherwise
2016   if test  "x$_cv_gnu_make_command" != "x"  ; then
2017           ifGNUmake='' ;
2018   else
2019           ifGNUmake='#' ;
2020   fi
2021   AC_SUBST(ifGNUmake)
2022 ])
2023
2024
2025 dnl Check for headers for, and arguments to, the setrlimit() function.
2026 dnl Used only in testsuite_hooks.h.
2027 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT_ancilliary, [
2028   AC_TRY_COMPILE([#include <unistd.h>
2029                   #include <sys/time.h>
2030                   #include <sys/resource.h>
2031                  ], [ int f = RLIMIT_$1 ; ],
2032                  [glibcpp_mresult=1], [glibcpp_mresult=0])
2033   AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcpp_mresult,
2034                      [Only used in build directory testsuite_hooks.h.])
2035 ])
2036 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
2037   setrlimit_have_headers=yes
2038   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
2039                    [],
2040                    setrlimit_have_headers=no)
2041   # If don't have the headers, then we can't run the tests now, and we
2042   # won't be seeing any of these during testsuite compilation.
2043   if test $setrlimit_have_headers = yes; then
2044     # Can't do these in a loop, else the resulting syntax is wrong.
2045     GLIBCPP_CHECK_SETRLIMIT_ancilliary(DATA)
2046     GLIBCPP_CHECK_SETRLIMIT_ancilliary(RSS)
2047     GLIBCPP_CHECK_SETRLIMIT_ancilliary(VMEM)
2048     GLIBCPP_CHECK_SETRLIMIT_ancilliary(AS)
2049
2050     # Check for rlimit, setrlimit.
2051     AC_CACHE_VAL(ac_setrlimit, [
2052       AC_TRY_COMPILE([#include <unistd.h>
2053                   #include <sys/time.h>
2054                   #include <sys/resource.h>
2055                      ],
2056                      [ struct rlimit r; setrlimit(0, &r);],
2057                      [ac_setrlimit=yes], [ac_setrlimit=no])
2058     ])
2059   fi
2060
2061   AC_MSG_CHECKING([for testsuite memory limit support])
2062   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
2063     ac_mem_limits=yes
2064     AC_DEFINE(_GLIBCPP_MEM_LIMITS)
2065   else
2066     ac_mem_limits=no
2067   fi
2068   AC_MSG_RESULT($ac_mem_limits)
2069 ])
2070
2071
2072 dnl
2073 dnl Does any necessary configuration of the testsuite directory.  Generates
2074 dnl the testsuite_hooks.h header.
2075 dnl
2076 dnl GLIBCPP_CONFIGURE_TESTSUITE  [no args]
2077 AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [
2078
2079   if test  x"$GLIBCPP_IS_CROSS_COMPILING" = xfalse; then
2080     # Do checks for memory limit functions.
2081     GLIBCPP_CHECK_SETRLIMIT
2082
2083     # Look for setenv, so that extended locale tests can be performed.
2084     GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
2085   fi
2086
2087   # Export file names for ABI checking.
2088   baseline_dir="${glibcpp_srcdir}/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
2089   AC_SUBST(baseline_dir)
2090
2091   # Determine if checking the ABI is desirable.
2092   if test x$enable_symvers = xno; then
2093     enable_abi_check=no
2094   else
2095     case "$host" in
2096       *-*-cygwin*)
2097         enable_abi_check=no ;;
2098       *)
2099         enable_abi_check=yes ;;
2100     esac
2101   fi
2102
2103   AM_CONDITIONAL(GLIBCPP_TEST_WCHAR_T, test "$enable_wchar_t" = yes)
2104   AM_CONDITIONAL(GLIBCPP_TEST_ABI, test "$enable_abi_check" = yes)
2105 ])
2106
2107
2108 sinclude(../libtool.m4)
2109 dnl The lines below arrange for aclocal not to bring an installed
2110 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
2111 dnl add a definition of LIBTOOL to Makefile.in.
2112 ifelse(,,,[AC_SUBST(LIBTOOL)
2113 AC_DEFUN([AM_PROG_LIBTOOL])
2114 AC_DEFUN([AC_LIBTOOL_DLOPEN])
2115 AC_DEFUN([AC_PROG_LD])
2116 ])
2117
2118 dnl
2119 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
2120 dnl
2121
2122 AC_DEFUN(GLIBCPP_CHECK_S_ISREG_OR_S_IFREG, [
2123   AC_CACHE_VAL(glibcpp_cv_S_ISREG, [
2124     AC_TRY_LINK([#include <sys/stat.h>],
2125                 [struct stat buffer; fstat(0, &buffer); S_ISREG(buffer.st_mode); ],
2126                 [glibcpp_cv_S_ISREG=yes],
2127                 [glibcpp_cv_S_ISREG=no])
2128   ])
2129   AC_CACHE_VAL(glibcpp_cv_S_IFREG, [
2130     AC_TRY_LINK([#include <sys/stat.h>],
2131                 [struct stat buffer; fstat(0, &buffer); S_IFREG & buffer.st_mode; ],
2132                 [glibcpp_cv_S_IFREG=yes],
2133                 [glibcpp_cv_S_IFREG=no])
2134   ])
2135   if test x$glibcpp_cv_S_ISREG = xyes; then
2136     AC_DEFINE(HAVE_S_ISREG)
2137   elif test x$glibcpp_cv_S_IFREG = xyes; then
2138     AC_DEFINE(HAVE_S_IFREG)
2139   fi
2140 ])
2141
2142 dnl
2143 dnl Check whether poll is available in <poll.h>.
2144 dnl
2145
2146 AC_DEFUN(GLIBCPP_CHECK_POLL, [
2147   AC_CACHE_VAL(glibcpp_cv_POLL, [
2148     AC_TRY_COMPILE([#include <poll.h>],
2149                 [struct pollfd pfd[1]; pfd[0].events = POLLIN; poll(pfd, 1, 0); ],
2150                 [glibcpp_cv_POLL=yes],
2151                 [glibcpp_cv_POLL=no])
2152   ])
2153   if test x$glibcpp_cv_POLL = xyes; then
2154     AC_DEFINE(HAVE_POLL)
2155   fi
2156 ])
2157
2158 # Check whether LC_MESSAGES is available in <locale.h>.
2159 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2160 #
2161 # This file file be copied and used freely without restrictions.  It can
2162 # be used in projects which are not available under the GNU Public License
2163 # but which still want to provide support for the GNU gettext functionality.
2164 # Please note that the actual code is *not* freely available.
2165
2166 # serial 1
2167
2168 AC_DEFUN(AC_LC_MESSAGES, [
2169   AC_CHECK_HEADER(locale.h, [
2170     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2171       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2172        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2173     if test $ac_cv_val_LC_MESSAGES = yes; then
2174       AC_DEFINE(HAVE_LC_MESSAGES)
2175     fi
2176   ])
2177 ])
2178
2179
2180 dnl
2181 dnl Check for whether the Boost-derived checks should be turned on.
2182 dnl
2183 dnl GLIBCPP_ENABLE_CONCEPT_CHECKS
2184 dnl --enable-concept-checks turns them on.
2185 dnl --disable-concept-checks leaves them off.
2186 dnl  +  Usage:  GLIBCPP_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2187 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2188 dnl       defaults to `no'.
2189 AC_DEFUN(GLIBCPP_ENABLE_CONCEPT_CHECKS, [dnl
2190 define([GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl
2191 AC_ARG_ENABLE(concept-checks,
2192 changequote(<<, >>)dnl
2193 <<  --enable-concept-checks use Boost-derived template checks [default=>>GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT],
2194 changequote([, ])dnl
2195 [case "$enableval" in
2196  yes) enable_concept_checks=yes ;;
2197  no)  enable_concept_checks=no ;;
2198  *)   AC_MSG_ERROR([Unknown argument to enable/disable concept checks]) ;;
2199  esac],
2200 enable_concept_checks=GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl
2201 dnl Option parsed, now set things appropriately
2202 if test x"$enable_concept_checks" = xyes; then
2203   AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS)
2204 fi
2205 ])
2206
2207
2208 dnl
2209 dnl Add version tags to symbols in shared library (or not), additionally
2210 dnl marking other symbols as private/local (or not).
2211 dnl
2212 dnl GLIBCPP_ENABLE_SYMVERS
2213 dnl --enable-symvers=style adds a version script to the linker call when
2214 dnl       creating the shared library.  The choice of version script is
2215 dnl       controlled by 'style'.
2216 dnl --disable-symvers does not.
2217 dnl  +  Usage:  GLIBCPP_ENABLE_SYMVERS[(DEFAULT)]
2218 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2219 dnl       defaults to `no'.  Passing `yes' tries to choose a default style
2220 dnl       based on linker characteristics.  Passing 'no' disables versioning.
2221 AC_DEFUN(GLIBCPP_ENABLE_SYMVERS, [dnl
2222 define([GLIBCPP_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl
2223 AC_ARG_ENABLE(symvers,
2224 changequote(<<, >>)dnl
2225 <<  --enable-symvers=style  enables symbol versioning of the shared library [default=>>GLIBCPP_ENABLE_SYMVERS_DEFAULT],
2226 changequote([, ])dnl
2227 [case "$enableval" in
2228  yes) enable_symvers=yes ;;
2229  no)  enable_symvers=no ;;
2230  # other names here, just as sanity checks
2231  #gnu|sun|etcetera) enable_symvers=$enableval ;;
2232  gnu) enable_symvers=$enableval ;;
2233  *)   AC_MSG_ERROR([Unknown argument to enable/disable symvers]) ;;
2234  esac],
2235 enable_symvers=GLIBCPP_ENABLE_SYMVERS_DEFAULT)dnl
2236
2237 # If we never went through the GLIBCPP_CHECK_LINKER_FEATURES macro, then we
2238 # don't know enough about $LD to do tricks...
2239 if test x$enable_shared = xno ||
2240         test "x$LD" = x ||
2241         test x$glibcpp_gnu_ld_version = x; then
2242   enable_symvers=no
2243 fi
2244
2245 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2246 if test $enable_symvers != no; then
2247   AC_MSG_CHECKING([for shared libgcc])
2248   ac_save_CFLAGS="$CFLAGS"
2249   CFLAGS=' -lgcc_s'
2250   AC_TRY_LINK(, [return 0], glibcpp_shared_libgcc=yes, glibcpp_shared_libgcc=no)
2251   CFLAGS="$ac_save_CFLAGS"
2252   AC_MSG_RESULT($glibcpp_shared_libgcc)
2253 fi
2254
2255 # For GNU ld, we need at least this version.  It's 2.12 in the same format
2256 # as the tested-for version.  See GLIBCPP_CHECK_LINKER_FEATURES for more.
2257 glibcpp_min_gnu_ld_version=21200
2258
2259 # Check to see if unspecified "yes" value can win, given results
2260 # above.
2261 if test $enable_symvers = yes ; then
2262   if test $with_gnu_ld = yes &&
2263     test $glibcpp_shared_libgcc = yes ;
2264   then
2265     if test $glibcpp_gnu_ld_version -ge $glibcpp_min_gnu_ld_version ; then
2266         enable_symvers=gnu
2267     else
2268       ac_test_CFLAGS="${CFLAGS+set}"
2269       ac_save_CFLAGS="$CFLAGS"
2270       CFLAGS='-shared -Wl,--version-script,conftest.map'
2271       enable_symvers=no
2272       changequote(,)
2273       echo 'FOO { global: f[a-z]o; local: *; };' > conftest.map
2274       changequote([,])
2275       AC_TRY_LINK([int foo;],, enable_symvers=gnu)
2276       if test "$ac_test_CFLAGS" = set; then
2277         CFLAGS="$ac_save_CFLAGS"
2278       else
2279         # this is the suspicious part
2280         CFLAGS=''
2281       fi
2282       rm -f conftest.map
2283     fi
2284   else
2285     # just fail for now
2286     enable_symvers=no
2287   fi
2288 fi
2289
2290 dnl Everything parsed; figure out what file to use.
2291 case $enable_symvers in
2292   no)
2293       SYMVER_MAP=config/linker-map.dummy
2294       ;;
2295   gnu)
2296       SYMVER_MAP=config/linker-map.gnu
2297       AC_DEFINE(_GLIBCPP_SYMVER)
2298       ;;
2299 esac
2300
2301 AC_SUBST(SYMVER_MAP)
2302 AM_CONDITIONAL(GLIBCPP_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
2303 AC_MSG_CHECKING([versioning on shared library symbols])
2304 AC_MSG_RESULT($enable_symvers)
2305 ])
2306