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