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