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