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