libstdc++-v3/acinclude.m4

   1
   2 dnl
   3 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
   4 dnl
   5 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
   6 dnl end of configure.  This lets tested variables be reassigned, and the
   7 dnl conditional will depend on the final state of the variable.  For a simple
   8 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
   9 dnl
  10 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
  11 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
  12   m4_divert_text([glibcxx_diversion],dnl
  13    AM_CONDITIONAL([$1],[$2])
  14   )dnl
  15 ])dnl
  16 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
  17
  18
  19 dnl
  20 dnl Check to see what architecture and operating system we are compiling
  21 dnl for.  Also, if architecture- or OS-specific flags are required for
  22 dnl compilation, pick them up here.
  23 dnl
  24 AC_DEFUN([GLIBCXX_CHECK_HOST], [
  25   . $glibcxx_srcdir/configure.host
  26   AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
  27   AC_MSG_NOTICE([OS config directory is $os_include_dir])
  28 ])
  29
  30 dnl
  31 dnl Initialize the rest of the library configury.  At this point we have
  32 dnl variables like $host.
  33 dnl
  34 dnl Sets:
  35 dnl  SUBDIRS
  36 dnl Substs:
  37 dnl  glibcxx_builddir     (absolute path)
  38 dnl  glibcxx_srcdir       (absolute path)
  39 dnl  toplevel_srcdir      (absolute path)
  40 dnl  with_cross_host
  41 dnl  with_newlib
  42 dnl  with_target_subdir
  43 dnl plus
  44 dnl  - the variables in GLIBCXX_CHECK_HOST / configure.host
  45 dnl  - default settings for all AM_CONFITIONAL test variables
  46 dnl  - lots of tools, like CC and CXX
  47 dnl
  48 AC_DEFUN([GLIBCXX_CONFIGURE], [
  49   # Keep these sync'd with the list in Makefile.am.  The first provides an
  50   # expandable list at autoconf time; the second provides an expandable list
  51   # (i.e., shell variable) at configure time.
  52   m4_define([glibcxx_SUBDIRS],[include libmath libsupc++ src po testsuite])
  53   SUBDIRS='glibcxx_SUBDIRS'
  54
  55   # These need to be absolute paths, yet at the same time need to
  56   # canonicalize only relative paths, because then amd will not unmount
  57   # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
  58   glibcxx_builddir=`${PWDCMD-pwd}`
  59   case $srcdir in
  60     [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
  61     *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
  62   esac
  63   toplevel_srcdir=${glibcxx_srcdir}/..
  64   AC_SUBST(glibcxx_builddir)
  65   AC_SUBST(glibcxx_srcdir)
  66   AC_SUBST(toplevel_srcdir)
  67
  68   # We use these options to decide which functions to include.  They are
  69   # set from the top level.
  70   AC_ARG_WITH([target-subdir],
  71     AC_HELP_STRING([--with-target-subdir=SUBDIR],
  72                    [configuring in a subdirectory]))
  73
  74   AC_ARG_WITH([cross-host],
  75     AC_HELP_STRING([--with-cross-host=HOST],
  76                    [configuring with a cross compiler]))
  77
  78   AC_ARG_WITH([newlib],
  79     AC_HELP_STRING([--with-newlib],
  80                    [assume newlib as a system C library]))
  81
  82   # We're almost certainly being configured before anything else which uses
  83   # C++, so all of our AC_PROG_* discoveries will be cached.  It's vital that
  84   # we not cache the value of CXX that we "discover" here, because it's set
  85   # to something unique for us and libjava.  Other target libraries need to
  86   # find CXX for themselves.  We yank the rug out from under the normal AC_*
  87   # process by sneakily renaming the cache variable.  This also lets us debug
  88   # the value of "our" CXX in postmortems.
  89   #
  90   # We must also force CXX to /not/ be a precious variable, otherwise the
  91   # wrong (non-multilib-adjusted) value will be used in multilibs.  This
  92   # little trick also affects CPPFLAGS, CXXFLAGS, and LDFLAGS.  And as a side
  93   # effect, CXXFLAGS is no longer automagically subst'd, so we have to do
  94   # that ourselves.  Un-preciousing AC_PROG_CC also affects CC and CFLAGS.
  95   #
  96   # -fno-builtin must be present here so that a non-conflicting form of
  97   # std::exit can be guessed by AC_PROG_CXX, and used in later tests.
  98
  99   m4_define([ac_cv_prog_CXX],[glibcxx_cv_prog_CXX])
 100   m4_rename([_AC_ARG_VAR_PRECIOUS],[glibcxx_PRECIOUS])
 101   m4_define([_AC_ARG_VAR_PRECIOUS],[])
 102   save_CXXFLAGS="$CXXFLAGS"
 103   CXXFLAGS="$CXXFLAGS -fno-builtin"
 104   AC_PROG_CC
 105   AC_PROG_CXX
 106   CXXFLAGS="$save_CXXFLAGS"
 107   m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
 108   AC_SUBST(CFLAGS)
 109   AC_SUBST(CXXFLAGS)
 110
 111   # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
 112   # available).  Uncomment the next line to force a particular method.
 113   AC_PROG_LN_S
 114   #LN_S='cp -p'
 115
 116   AC_CHECK_TOOL(AS, as)
 117   AC_CHECK_TOOL(AR, ar)
 118   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
 119
 120   AM_MAINTAINER_MODE
 121
 122   # Set up safe default values for all subsequent AM_CONDITIONAL tests
 123   # which are themselves conditionally expanded.
 124   ## (Right now, this only matters for enable_wchar_t, but nothing prevents
 125   ## other macros from doing the same.  This should be automated.)  -pme
 126   need_libmath=no
 127
 128   # Check for uClibc since Linux platforms use different configuration
 129   # directories depending on the C library in use.
 130   AC_EGREP_CPP([_using_uclibc], [
 131   #include <stdio.h>
 132   #if __UCLIBC__
 133     _using_uclibc
 134   #endif
 135   ], uclibc=yes, uclibc=no)
 136
 137   # Find platform-specific directories containing configuration info.
 138   # Also possibly modify flags used elsewhere, as needed by the platform.
 139   GLIBCXX_CHECK_HOST
 140 ])
 141
 142
 143 dnl
 144 dnl Tests for newer compiler features, or features that are present in newer
 145 dnl compiler versions but not older compiler versions still in use, should
 146 dnl be placed here.
 147 dnl
 148 dnl Defines:
 149 dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
 150 dnl   new inlining code or the new system_header pragma will die on -Werror.
 151 dnl   Leave it out by default and use maint-mode to use it.
 152 dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 153 dnl   compiler supports it and the user has not requested debug mode.
 154 dnl
 155 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
 156   # All these tests are for C++; save the language and the compiler flags.
 157   # The CXXFLAGS thing is suspicious, but based on similar bits previously
 158   # found in GLIBCXX_CONFIGURE.
 159   AC_LANG_SAVE
 160   AC_LANG_CPLUSPLUS
 161   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 162   ac_save_CXXFLAGS="$CXXFLAGS"
 163
 164   # Check for maintainer-mode bits.
 165   if test x"$USE_MAINTAINER_MODE" = xno; then
 166     WERROR=''
 167   else
 168     WERROR='-Werror'
 169   fi
 170
 171   # Check for -ffunction-sections -fdata-sections
 172   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
 173   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
 174   AC_TRY_COMPILE(, [int foo;], [ac_fdsections=yes], [ac_fdsections=no])
 175   if test "$ac_test_CXXFLAGS" = set; then
 176     CXXFLAGS="$ac_save_CXXFLAGS"
 177   else
 178     # this is the suspicious part
 179     CXXFLAGS=''
 180   fi
 181   if test x"$ac_fdsections" = x"yes"; then
 182     SECTION_FLAGS='-ffunction-sections -fdata-sections'
 183   fi
 184   AC_MSG_RESULT($ac_fdsections)
 185
 186   AC_LANG_RESTORE
 187   AC_SUBST(WERROR)
 188   AC_SUBST(SECTION_FLAGS)
 189 ])
 190
 191
 192 dnl
 193 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
 194 dnl the native linker is in use, all variables will be defined to something
 195 dnl safe (like an empty string).
 196 dnl
 197 dnl Defines:
 198 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
 199 dnl  OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
 200 dnl  LD (as a side effect of testing)
 201 dnl Sets:
 202 dnl  with_gnu_ld
 203 dnl  glibcxx_gnu_ld_version (possibly)
 204 dnl
 205 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
 206 dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
 207 dnl
 208 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
 209   # If we're not using GNU ld, then there's no point in even trying these
 210   # tests.  Check for that first.  We should have already tested for gld
 211   # by now (in libtool), but require it now just to be safe...
 212   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
 213   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
 214   AC_REQUIRE([AC_PROG_LD])
 215   AC_REQUIRE([AC_PROG_AWK])
 216
 217   # The name set by libtool depends on the version of libtool.  Shame on us
 218   # for depending on an impl detail, but c'est la vie.  Older versions used
 219   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
 220   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
 221   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
 222   # set (hence we're using an older libtool), then set it.
 223   if test x${with_gnu_ld+set} != xset; then
 224     if test x${ac_cv_prog_gnu_ld+set} != xset; then
 225       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
 226       with_gnu_ld=no
 227     else
 228       with_gnu_ld=$ac_cv_prog_gnu_ld
 229     fi
 230   fi
 231
 232   # Start by getting the version number.  I think the libtool test already
 233   # does some of this, but throws away the result.
 234   if test x"$with_gnu_ld" = x"yes"; then
 235     AC_MSG_CHECKING([for ld version])
 236     changequote(,)
 237     ldver=`$LD --version 2>/dev/null | head -1 | \
 238            sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
 239     changequote([,])
 240     glibcxx_gnu_ld_version=`echo $ldver | \
 241            $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
 242     AC_MSG_RESULT($glibcxx_gnu_ld_version)
 243   fi
 244
 245   # Set --gc-sections.
 246   glibcxx_gcsections_min_ld=21602
 247   if test x"$with_gnu_ld" = x"yes" &&
 248         test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
 249
 250     # Sufficiently young GNU ld it is!  Joy and bunny rabbits!
 251     # NB: This flag only works reliably after 2.16.1. Configure tests
 252     # for this are difficult, so hard wire a value that should work.
 253
 254     # All these tests are for C++, but run with the "C" compiler driver.
 255     # Need to do this so that g++ won't try to link in libstdc++/libsupc++.
 256     ac_test_CFLAGS="${CFLAGS+set}"
 257     ac_save_CFLAGS="$CFLAGS"
 258     CFLAGS='-x c++ -Wl,--gc-sections'
 259
 260     # Check for -Wl,--gc-sections
 261     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
 262     AC_TRY_LINK([ int one(void) { return 1; }
 263      int two(void) { return 2; }
 264         ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
 265     if test "$ac_gcsections" = "yes"; then
 266       rm -f conftest.c
 267       touch conftest.c
 268       if $CC -c conftest.c; then
 269         if $LD --gc-sections -o conftest conftest.o 2>&1 | \
 270            grep "Warning: gc-sections option ignored" > /dev/null; then
 271           ac_gcsections=no
 272         fi
 273       fi
 274       rm -f conftest.c conftest.o conftest
 275     fi
 276     if test "$ac_gcsections" = "yes"; then
 277       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
 278     fi
 279     AC_MSG_RESULT($ac_gcsections)
 280
 281     if test "$ac_test_CFLAGS" = set; then
 282       CFLAGS="$ac_save_CFLAGS"
 283     else
 284       # this is the suspicious part
 285       CFLAGS=''
 286     fi
 287   fi
 288
 289   # Set -z,relro.
 290   # Note this is only for shared objects.
 291   ac_ld_relro=no
 292   if test x"$with_gnu_ld" = x"yes"; then
 293     AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
 294     cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
 295     if test -n "$cxx_z_relo"; then
 296       OPT_LDFLAGS="-Wl,-z,relro"
 297       ac_ld_relro=yes
 298     fi
 299     AC_MSG_RESULT($ac_ld_relro)
 300   fi
 301
 302   # Set linker optimization flags.
 303   if test x"$with_gnu_ld" = x"yes"; then
 304     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
 305   fi
 306
 307   AC_SUBST(SECTION_LDFLAGS)
 308   AC_SUBST(OPT_LDFLAGS)
 309 ])
 310
 311
 312 dnl
 313 dnl Check to see if this target can enable the iconv specializations.
 314 dnl If --disable-c-mbchar was given, no wchar_t specialization is enabled.
 315 dnl (This must have been previously checked, along with the rest of C99
 316 dnl support.) By default, iconv support is disabled.
 317 dnl
 318 dnl Defines:
 319 dnl  _GLIBCXX_USE_ICONV if all the bits are found.
 320 dnl Substs:
 321 dnl  LIBICONV to a -l string containing the iconv library, if needed.
 322 dnl
 323 AC_DEFUN([GLIBCXX_CHECK_ICONV_SUPPORT], [
 324
 325   enable_iconv=no
 326   # Only continue checking if the ISO C99 headers exist and support is on.
 327   if test x"$enable_wchar_t" = xyes; then
 328
 329     # From Bruno Haible's AM_ICONV, but without link tests.
 330     # Check for existence of libiconv.a providing XPG2 wchar_t support.
 331     # Some systems have iconv in libc, some have it in libiconv (OSF/1 and
 332     # those with the standalone portable GNU libiconv installed).
 333     AC_ARG_WITH([libiconv-prefix],
 334 [  --with-libiconv-prefix=DIR  search for libiconv in DIR/include and DIR/lib], [  for dir in `echo "$withval" | tr : ' '`; do
 335       if test -d $dir/include; then CPPFLAGS="$CPPFLAGS -I$dir/include"; fi
 336       if test -d $dir/lib; then LIBICONV="$LIBICONV -L$dir/lib"; fi
 337     done
 338     LIBICONV="$LIBICONV -liconv"
 339    ])
 340    if test x"$LIBICONV" != x; then
 341      AC_MSG_NOTICE([--with-libiconv-prefix is $LIBICONV])
 342    fi
 343
 344     # Use iconv for wchar_t to char conversions. As such, check for
 345     # X/Open Portability Guide, version 2 features (XPG2).
 346     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
 347     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
 348
 349     ac_save_LIBS="$LIBS"
 350     LIBS="$LIBS $LIBICONV"
 351     AC_CHECK_FUNCS([iconv_open iconv_close iconv nl_langinfo],
 352     [ac_XPG2funcs=yes], [ac_XPG2funcs=no])
 353     LIBS="$ac_save_LIBS"
 354
 355     if test x"$ac_has_iconv_h" = xyes &&
 356        test x"$ac_has_langinfo_h" = xyes &&
 357        test x"$ac_XPG2funcs" = xyes;
 358     then
 359       AC_DEFINE([_GLIBCXX_USE_ICONV],1,
 360                 [Define if iconv and related functions exist and are usable.])
 361       enable_iconv=yes
 362       AC_SUBST(LIBICONV)
 363     fi
 364   fi
 365   AC_MSG_CHECKING([for enabled iconv specializations])
 366   AC_MSG_RESULT($enable_iconv)
 367 ])
 368
 369
 370 dnl
 371 dnl Check for headers for, and arguments to, the setrlimit() function.
 372 dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
 373 dnl
 374 dnl Defines:
 375 dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits
 376 dnl  various HAVE_LIMIT_* for individual limit names
 377 dnl
 378 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
 379   AC_MSG_CHECKING([for RLIMIT_$1])
 380   AC_TRY_COMPILE(
 381     [#include <unistd.h>
 382      #include <sys/time.h>
 383      #include <sys/resource.h>
 384     ],
 385     [ int f = RLIMIT_$1 ; ],
 386     [glibcxx_mresult=1], [glibcxx_mresult=0])
 387   AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
 388                      [Only used in build directory testsuite_hooks.h.])
 389   if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
 390   AC_MSG_RESULT($res)
 391 ])
 392
 393 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
 394   setrlimit_have_headers=yes
 395   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
 396                    [],
 397                    [setrlimit_have_headers=no])
 398   # If don't have the headers, then we can't run the tests now, and we
 399   # won't be seeing any of these during testsuite compilation.
 400   if test $setrlimit_have_headers = yes; then
 401     # Can't do these in a loop, else the resulting syntax is wrong.
 402     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
 403     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
 404     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
 405     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
 406     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
 407
 408     # Check for rlimit, setrlimit.
 409     AC_CACHE_VAL(ac_setrlimit, [
 410       AC_TRY_COMPILE(
 411         [#include <unistd.h>
 412          #include <sys/time.h>
 413          #include <sys/resource.h>
 414         ],
 415         [struct rlimit r;
 416          setrlimit(0, &r);],
 417         [ac_setrlimit=yes], [ac_setrlimit=no])
 418     ])
 419   fi
 420
 421   AC_MSG_CHECKING([for testsuite resource limits support])
 422   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
 423     ac_res_limits=yes
 424     AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
 425               [Define if using setrlimit to set resource limits during
 426               "make check"])
 427   else
 428     ac_res_limits=no
 429   fi
 430   AC_MSG_RESULT($ac_res_limits)
 431 ])
 432
 433
 434 dnl
 435 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
 436 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
 437 dnl
 438 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
 439   AC_MSG_CHECKING([for S_ISREG or S_IFREG])
 440   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
 441     AC_TRY_LINK(
 442       [#include <sys/stat.h>],
 443       [struct stat buffer;
 444        fstat(0, &buffer);
 445        S_ISREG(buffer.st_mode);],
 446       [glibcxx_cv_S_ISREG=yes],
 447       [glibcxx_cv_S_ISREG=no])
 448   ])
 449   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
 450     AC_TRY_LINK(
 451       [#include <sys/stat.h>],
 452       [struct stat buffer;
 453        fstat(0, &buffer);
 454        S_IFREG & buffer.st_mode;],
 455       [glibcxx_cv_S_IFREG=yes],
 456       [glibcxx_cv_S_IFREG=no])
 457   ])
 458   res=no
 459   if test $glibcxx_cv_S_ISREG = yes; then
 460     AC_DEFINE(HAVE_S_ISREG, 1,
 461               [Define if S_IFREG is available in <sys/stat.h>.])
 462     res=S_ISREG
 463   elif test $glibcxx_cv_S_IFREG = yes; then
 464     AC_DEFINE(HAVE_S_IFREG, 1,
 465               [Define if S_IFREG is available in <sys/stat.h>.])
 466     res=S_IFREG
 467   fi
 468   AC_MSG_RESULT($res)
 469 ])
 470
 471
 472 dnl
 473 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
 474 dnl
 475 AC_DEFUN([GLIBCXX_CHECK_POLL], [
 476   AC_MSG_CHECKING([for poll])
 477   AC_CACHE_VAL(glibcxx_cv_POLL, [
 478     AC_TRY_LINK(
 479       [#include <poll.h>],
 480       [struct pollfd pfd[1];
 481        pfd[0].events = POLLIN;
 482        poll(pfd, 1, 0);],
 483       [glibcxx_cv_POLL=yes],
 484       [glibcxx_cv_POLL=no])
 485   ])
 486   if test $glibcxx_cv_POLL = yes; then
 487     AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
 488   fi
 489   AC_MSG_RESULT($glibcxx_cv_POLL)
 490 ])
 491
 492
 493 dnl
 494 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
 495 dnl
 496 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
 497   AC_MSG_CHECKING([for writev])
 498   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
 499     AC_TRY_LINK(
 500       [#include <sys/uio.h>],
 501       [struct iovec iov[2];
 502        writev(0, iov, 0);],
 503       [glibcxx_cv_WRITEV=yes],
 504       [glibcxx_cv_WRITEV=no])
 505   ])
 506   if test $glibcxx_cv_WRITEV = yes; then
 507     AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
 508   fi
 509   AC_MSG_RESULT($glibcxx_cv_WRITEV)
 510 ])
 511
 512
 513 dnl
 514 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
 515 dnl
 516 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
 517   AC_MSG_CHECKING([for int64_t])
 518   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
 519     AC_TRY_COMPILE(
 520       [#include <stdint.h>],
 521       [int64_t var;],
 522       [glibcxx_cv_INT64_T=yes],
 523       [glibcxx_cv_INT64_T=no])
 524   ])
 525   if test $glibcxx_cv_INT64_T = yes; then
 526     AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
 527   fi
 528   AC_MSG_RESULT($glibcxx_cv_INT64_T)
 529 ])
 530
 531
 532 dnl
 533 dnl Check whether LFS support is available.
 534 dnl
 535 AC_DEFUN([GLIBCXX_CHECK_LFS], [
 536   AC_LANG_SAVE
 537   AC_LANG_CPLUSPLUS
 538   ac_save_CXXFLAGS="$CXXFLAGS"
 539   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 540   AC_MSG_CHECKING([for LFS support])
 541   AC_CACHE_VAL(glibcxx_cv_LFS, [
 542     AC_TRY_LINK(
 543       [#include <unistd.h>
 544        #include <stdio.h>
 545        #include <sys/stat.h>
 546       ],
 547       [FILE* fp;
 548        fopen64("t", "w");
 549        fseeko64(fp, 0, SEEK_CUR);
 550        ftello64(fp);
 551        lseek64(1, 0, SEEK_CUR);
 552        struct stat64 buf;
 553        fstat64(1, &buf);],
 554       [glibcxx_cv_LFS=yes],
 555       [glibcxx_cv_LFS=no])
 556   ])
 557   if test $glibcxx_cv_LFS = yes; then
 558     AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
 559   fi
 560   AC_MSG_RESULT($glibcxx_cv_LFS)
 561   CXXFLAGS="$ac_save_CXXFLAGS"
 562   AC_LANG_RESTORE
 563 ])
 564
 565
 566 dnl
 567 dnl Check for whether a fully dynamic basic_string implementation should
 568 dnl be turned on, that does not put empty objects in per-process static
 569 dnl memory (mostly useful together with shared memory allocators, see PR
 570 dnl libstdc++/16612 for details).
 571 dnl
 572 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
 573 dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
 574 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
 575 dnl       Where DEFAULT is either `yes' or `no'.
 576 dnl
 577 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
 578   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
 579   if test $enable_fully_dynamic_string = yes; then
 580     AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
 581               [Define if a fully dynamic basic_string is wanted.])
 582   fi
 583 ])
 584
 585
 586 dnl
 587 dnl Does any necessary configuration of the testsuite directory.  Generates
 588 dnl the testsuite_hooks.h header.
 589 dnl
 590 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
 591 dnl
 592 dnl Sets:
 593 dnl  enable_abi_check
 594 dnl  GLIBCXX_TEST_WCHAR_T
 595 dnl  GLIBCXX_TEST_THREAD
 596 dnl Substs:
 597 dnl  baseline_dir
 598 dnl
 599 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
 600   if $GLIBCXX_IS_NATIVE ; then
 601     # Do checks for resource limit functions.
 602     GLIBCXX_CHECK_SETRLIMIT
 603
 604     # Look for setenv, so that extended locale tests can be performed.
 605     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
 606   fi
 607
 608   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
 609      test $enable_symvers != no; then
 610     case "$host" in
 611       *-*-cygwin*)
 612         enable_abi_check=no ;;
 613       *)
 614         enable_abi_check=yes ;;
 615     esac
 616   else
 617     # Only build this as native, since automake does not understand
 618     # CXX_FOR_BUILD.
 619     enable_abi_check=no
 620   fi
 621
 622   # Export file names for ABI checking.
 623   baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}\$(MULTISUBDIR)"
 624   AC_SUBST(baseline_dir)
 625 ])
 626
 627
 628 dnl
 629 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
 630 dnl
 631 dnl Substs:
 632 dnl  GLIBCXX_INCLUDES
 633 dnl  TOPLEVEL_INCLUDES
 634 dnl
 635 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
 636   # Used for every C++ compile we perform.
 637   GLIBCXX_INCLUDES="\
 638 -I$glibcxx_builddir/include/$host_alias \
 639 -I$glibcxx_builddir/include \
 640 -I$glibcxx_srcdir/libsupc++"
 641
 642   # For Canadian crosses, pick this up too.
 643   if test $CANADIAN = yes; then
 644     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
 645   fi
 646
 647   # Stuff in the actual top level.  Currently only used by libsupc++ to
 648   # get unwind* headers from the gcc dir.
 649   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
 650   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
 651
 652   # Now, export this to all the little Makefiles....
 653   AC_SUBST(GLIBCXX_INCLUDES)
 654   AC_SUBST(TOPLEVEL_INCLUDES)
 655 ])
 656
 657
 658 dnl
 659 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
 660 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
 661 dnl
 662 dnl Substs:
 663 dnl  OPTIMIZE_CXXFLAGS
 664 dnl  WARN_FLAGS
 665 dnl
 666 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
 667   # Optimization flags that are probably a good idea for thrill-seekers. Just
 668   # uncomment the lines below and make, everything else is ready to go...
 669   # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
 670   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
 671   AC_SUBST(OPTIMIZE_CXXFLAGS)
 672
 673   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
 674   AC_SUBST(WARN_FLAGS)
 675 ])
 676
 677
 678 dnl
 679 dnl All installation directory information is determined here.
 680 dnl
 681 dnl Substs:
 682 dnl  gxx_install_dir
 683 dnl  glibcxx_prefixdir
 684 dnl  glibcxx_toolexecdir
 685 dnl  glibcxx_toolexeclibdir
 686 dnl
 687 dnl Assumes cross_compiling bits already done, and with_cross_host in
 688 dnl particular.
 689 dnl
 690 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
 691 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
 692 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
 693   glibcxx_toolexecdir=no
 694   glibcxx_toolexeclibdir=no
 695   glibcxx_prefixdir=$prefix
 696
 697   AC_MSG_CHECKING([for gxx-include-dir])
 698   AC_ARG_WITH([gxx-include-dir],
 699     AC_HELP_STRING([--with-gxx-include-dir=DIR],
 700                    [installation directory for include files]),
 701     [case "$withval" in
 702       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
 703       no)  gxx_include_dir=no ;;
 704       *)   gxx_include_dir=$withval ;;
 705      esac],
 706     [gxx_include_dir=no])
 707   AC_MSG_RESULT($gxx_include_dir)
 708
 709   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
 710   AC_ARG_ENABLE([version-specific-runtime-libs],
 711     AC_HELP_STRING([--enable-version-specific-runtime-libs],
 712                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
 713     [case "$enableval" in
 714       yes) version_specific_libs=yes ;;
 715       no)  version_specific_libs=no ;;
 716       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
 717      esac],
 718     [version_specific_libs=no])
 719   AC_MSG_RESULT($version_specific_libs)
 720
 721   # Default case for install directory for include files.
 722   if test $version_specific_libs = no && test $gxx_include_dir = no; then
 723     gxx_include_dir='include/c++/${gcc_version}'
 724     if test -n "$with_cross_host" &&
 725        test x"$with_cross_host" != x"no"; then
 726       gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
 727     else
 728       gxx_include_dir='${prefix}/'"$gxx_include_dir"
 729     fi
 730   fi
 731
 732   # Version-specific runtime libs processing.
 733   if test $version_specific_libs = yes; then
 734     # Need the gcc compiler version to know where to install libraries
 735     # and header files if --enable-version-specific-runtime-libs option
 736     # is selected.  FIXME: these variables are misnamed, there are
 737     # no executables installed in _toolexecdir or _toolexeclibdir.
 738     if test x"$gxx_include_dir" = x"no"; then
 739       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
 740     fi
 741     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 742     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
 743   fi
 744
 745   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
 746   # Install a library built with a cross compiler in tooldir, not libdir.
 747   if test x"$glibcxx_toolexecdir" = x"no"; then
 748     if test -n "$with_cross_host" &&
 749        test x"$with_cross_host" != x"no"; then
 750       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
 751       glibcxx_toolexeclibdir='${toolexecdir}/lib'
 752     else
 753       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 754       glibcxx_toolexeclibdir='${libdir}'
 755     fi
 756     multi_os_directory=`$CXX -print-multi-os-directory`
 757     case $multi_os_directory in
 758       .) ;; # Avoid trailing /.
 759       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
 760     esac
 761   fi
 762
 763   AC_MSG_CHECKING([for install location])
 764   AC_MSG_RESULT($gxx_include_dir)
 765
 766   AC_SUBST(glibcxx_prefixdir)
 767   AC_SUBST(gxx_include_dir)
 768   AC_SUBST(glibcxx_toolexecdir)
 769   AC_SUBST(glibcxx_toolexeclibdir)
 770 ])
 771
 772
 773 dnl
 774 dnl GLIBCXX_ENABLE
 775 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
 776 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
 777 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
 778 dnl
 779 dnl See docs/html/17_intro/configury.html#enable for documentation.
 780 dnl
 781 m4_define([GLIBCXX_ENABLE],[dnl
 782 m4_define([_g_switch],[--enable-$1])dnl
 783 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
 784  AC_ARG_ENABLE($1,_g_help,
 785   m4_bmatch([$5],
 786    [^permit ],
 787      [[
 788       case "$enableval" in
 789        m4_bpatsubst([$5],[permit ])) ;;
 790        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
 791           dnl Idea for future:  generate a URL pointing to
 792           dnl "onlinedocs/configopts.html#whatever"
 793       esac
 794      ]],
 795    [^$],
 796      [[
 797       case "$enableval" in
 798        yes|no) ;;
 799        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
 800       esac
 801      ]],
 802    [[$5]]),
 803   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
 804 m4_undefine([_g_switch])dnl
 805 m4_undefine([_g_help])dnl
 806 ])
 807
 808
 809 dnl
 810 dnl Check for ISO/IEC 9899:1999 "C99" support.
 811 dnl
 812 dnl --enable-c99 defines _GLIBCXX_USE_C99
 813 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
 814 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
 815 dnl       Where DEFAULT is either `yes' or `no'.
 816 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
 817 dnl
 818 AC_DEFUN([GLIBCXX_ENABLE_C99], [
 819   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
 820
 821   if test x"$enable_c99" = x"yes"; then
 822
 823   AC_LANG_SAVE
 824   AC_LANG_CPLUSPLUS
 825
 826   # Check for the existence of <math.h> functions used if C99 is enabled.
 827   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
 828   AC_CACHE_VAL(ac_c99_math, [
 829   AC_TRY_COMPILE([#include <math.h>],
 830                  [fpclassify(0.0);
 831                   isfinite(0.0);
 832                   isinf(0.0);
 833                   isnan(0.0);
 834                   isnormal(0.0);
 835                   signbit(0.0);
 836                   isgreater(0.0,0.0);
 837                   isgreaterequal(0.0,0.0);
 838                   isless(0.0,0.0);
 839                   islessequal(0.0,0.0);
 840                   islessgreater(0.0,0.0);
 841                   islessgreater(0.0,0.0);
 842                   isunordered(0.0,0.0);
 843                  ],[ac_c99_math=yes], [ac_c99_math=no])
 844   ])
 845   AC_MSG_RESULT($ac_c99_math)
 846   if test x"$ac_c99_math" = x"yes"; then
 847     AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
 848               [Define if C99 functions or macros in <math.h> should be imported
 849               in <cmath> in namespace std.])
 850   fi
 851
 852   # Check for the existence of <complex.h> complex math functions.
 853   # This is necessary even though libstdc++ uses the builtin versions
 854   # of these functions, because if the builtin cannot be used, a reference
 855   # to the library function is emitted.
 856   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 857   ac_c99_complex=no;
 858   if test x"$ac_has_complex_h" = x"yes"; then
 859     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
 860     AC_TRY_COMPILE([#include <complex.h>],
 861                    [typedef __complex__ float float_type; float_type tmpf;
 862                     cabsf(tmpf);
 863                     cargf(tmpf);
 864                     ccosf(tmpf);
 865                     ccoshf(tmpf);
 866                     cexpf(tmpf);
 867                     clogf(tmpf);
 868                     csinf(tmpf);
 869                     csinhf(tmpf);
 870                     csqrtf(tmpf);
 871                     ctanf(tmpf);
 872                     ctanhf(tmpf);
 873                     cpowf(tmpf, tmpf);
 874                     typedef __complex__ double double_type; double_type tmpd;
 875                     cabs(tmpd);
 876                     carg(tmpd);
 877                     ccos(tmpd);
 878                     ccosh(tmpd);
 879                     cexp(tmpd);
 880                     clog(tmpd);
 881                     csin(tmpd);
 882                     csinh(tmpd);
 883                     csqrt(tmpd);
 884                     ctan(tmpd);
 885                     ctanh(tmpd);
 886                     cpow(tmpd, tmpd);
 887                     typedef __complex__ long double ld_type; ld_type tmpld;
 888                     cabsl(tmpld);
 889                     cargl(tmpld);
 890                     ccosl(tmpld);
 891                     ccoshl(tmpld);
 892                     cexpl(tmpld);
 893                     clogl(tmpld);
 894                     csinl(tmpld);
 895                     csinhl(tmpld);
 896                     csqrtl(tmpld);
 897                     ctanl(tmpld);
 898                     ctanhl(tmpld);
 899                     cpowl(tmpld, tmpld);
 900                    ],[ac_c99_complex=yes], [ac_c99_complex=no])
 901   fi
 902   AC_MSG_RESULT($ac_c99_complex)
 903   if test x"$ac_c99_complex" = x"yes"; then
 904     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 905               [Define if C99 functions in <complex.h> should be used in
 906               <complex>. Using compiler builtins for these functions requires
 907               corresponding C99 library functions to be present.])
 908   fi
 909
 910   # Check for the existence in <stdio.h> of vscanf, et. al.
 911   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 912   AC_CACHE_VAL(ac_c99_stdio, [
 913   AC_TRY_COMPILE([#include <stdio.h>
 914                   #include <stdarg.h>
 915                   void foo(char* fmt, ...)
 916                   {
 917                     va_list args; va_start(args, fmt);
 918                     vfscanf(stderr, "%i", args);
 919                     vscanf("%i", args);
 920                     vsnprintf(fmt, 0, "%i", args);
 921                     vsscanf(fmt, "%i", args);
 922                   }],
 923                  [snprintf("12", 0, "%i");],
 924                  [ac_c99_stdio=yes], [ac_c99_stdio=no])
 925   ])
 926   AC_MSG_RESULT($ac_c99_stdio)
 927
 928   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
 929   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
 930   AC_CACHE_VAL(ac_c99_stdlib, [
 931   AC_TRY_COMPILE([#include <stdlib.h>],
 932                  [char* tmp;
 933                   strtof("gnu", &tmp);
 934                   strtold("gnu", &tmp);
 935                   strtoll("gnu", &tmp, 10);
 936                   strtoull("gnu", &tmp, 10);
 937                   llabs(10);
 938                   lldiv(10,1);
 939                   atoll("10");
 940                   _Exit(0);
 941                   lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
 942   ])
 943   AC_MSG_RESULT($ac_c99_stdlib)
 944
 945   # Check for the existence in <wchar.h> of wcstold, etc.
 946   ac_c99_wchar=no;
 947   if test x"$ac_has_wchar_h" = xyes &&
 948      test x"$ac_has_wctype_h" = xyes; then
 949     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
 950     AC_TRY_COMPILE([#include <wchar.h>
 951                     namespace test
 952                     {
 953                       using ::wcstold;
 954                       using ::wcstoll;
 955                       using ::wcstoull;
 956                     }
 957                    ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
 958
 959     # Checks for wide character functions that may not be present.
 960     # Injection of these is wrapped with guard macros.
 961     # NB: only put functions here, instead of immediately above, if
 962     # absolutely necessary.
 963     AC_TRY_COMPILE([#include <wchar.h>
 964                     namespace test { using ::vfwscanf; } ], [],
 965                    [AC_DEFINE(HAVE_VFWSCANF,1,
 966                         [Defined if vfwscanf exists.])],[])
 967
 968     AC_TRY_COMPILE([#include <wchar.h>
 969                     namespace test { using ::vswscanf; } ], [],
 970                    [AC_DEFINE(HAVE_VSWSCANF,1,
 971                         [Defined if vswscanf exists.])],[])
 972
 973     AC_TRY_COMPILE([#include <wchar.h>
 974                     namespace test { using ::vwscanf; } ], [],
 975                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
 976
 977     AC_TRY_COMPILE([#include <wchar.h>
 978                     namespace test { using ::wcstof; } ], [],
 979                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
 980
 981     AC_TRY_COMPILE([#include <wctype.h>],
 982                    [ wint_t t; int i = iswblank(t);],
 983                    [AC_DEFINE(HAVE_ISWBLANK,1,
 984                         [Defined if iswblank exists.])],[])
 985
 986     AC_MSG_RESULT($ac_c99_wchar)
 987   fi
 988
 989   # Option parsed, now set things appropriately.
 990   if test x"$ac_c99_math" = x"no" ||
 991      test x"$ac_c99_complex" = x"no" ||
 992      test x"$ac_c99_stdio" = x"no" ||
 993      test x"$ac_c99_stdlib" = x"no" ||
 994      test x"$ac_c99_wchar" = x"no"; then
 995     enable_c99=no;
 996   else
 997     AC_DEFINE(_GLIBCXX_USE_C99, 1,
 998     [Define if C99 functions or macros from <wchar.h>, <math.h>,
 999     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1000   fi
1001
1002   AC_LANG_RESTORE
1003   fi
1004
1005   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1006   AC_MSG_RESULT($enable_c99)
1007 ])
1008
1009
1010 dnl
1011 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1012 dnl facilities in Chapter 8, "C compatibility".
1013 dnl
1014 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1015
1016   AC_LANG_SAVE
1017   AC_LANG_CPLUSPLUS
1018
1019   # Check for the existence of <complex.h> complex math functions used
1020   # by tr1/complex.
1021   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1022   ac_c99_complex_tr1=no;
1023   if test x"$ac_has_complex_h" = x"yes"; then
1024     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1025     AC_TRY_COMPILE([#include <complex.h>],
1026                    [typedef __complex__ float float_type; float_type tmpf;
1027                     cacosf(tmpf);
1028                     casinf(tmpf);
1029                     catanf(tmpf);
1030                     cacoshf(tmpf);
1031                     casinhf(tmpf);
1032                     catanhf(tmpf);
1033                     typedef __complex__ double double_type; double_type tmpd;
1034                     cacos(tmpd);
1035                     casin(tmpd);
1036                     catan(tmpd);
1037                     cacosh(tmpd);
1038                     casinh(tmpd);
1039                     catanh(tmpd);
1040                     typedef __complex__ long double ld_type; ld_type tmpld;
1041                     cacosl(tmpld);
1042                     casinl(tmpld);
1043                     catanl(tmpld);
1044                     cacoshl(tmpld);
1045                     casinhl(tmpld);
1046                     catanhl(tmpld);
1047                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1048   fi
1049   AC_MSG_RESULT($ac_c99_complex_tr1)
1050   if test x"$ac_c99_complex_tr1" = x"yes"; then
1051     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1052               [Define if C99 functions in <complex.h> should be used in
1053               <tr1/complex>. Using compiler builtins for these functions
1054               requires corresponding C99 library functions to be present.])
1055   fi
1056
1057   # Check for the existence of <ctype.h> functions.
1058   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1059   AC_CACHE_VAL(ac_c99_ctype_tr1, [
1060   AC_TRY_COMPILE([#include <ctype.h>],
1061                  [int ch;
1062                   int ret;
1063                   ret = isblank(ch);
1064                  ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no])
1065   ])
1066   AC_MSG_RESULT($ac_c99_ctype_tr1)
1067   if test x"$ac_c99_ctype_tr1" = x"yes"; then
1068     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1069               [Define if C99 functions in <ctype.h> should be imported in
1070               <tr1/cctype> in namespace std::tr1.])
1071   fi
1072
1073   # Check for the existence of <fenv.h> functions.
1074   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1075   ac_c99_fenv_tr1=no;
1076   if test x"$ac_has_fenv_h" = x"yes"; then
1077     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1078     AC_TRY_COMPILE([#include <fenv.h>],
1079                    [int except, mode;
1080                     fexcept_t* pflag;
1081                     fenv_t* penv;
1082                     int ret;
1083                     ret = feclearexcept(except);
1084                     ret = fegetexceptflag(pflag, except);
1085                     ret = feraiseexcept(except);
1086                     ret = fesetexceptflag(pflag, except);
1087                     ret = fetestexcept(except);
1088                     ret = fegetround();
1089                     ret = fesetround(mode);
1090                     ret = fegetenv(penv);
1091                     ret = feholdexcept(penv);
1092                     ret = fesetenv(penv);
1093                     ret = feupdateenv(penv);
1094                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1095   fi
1096   AC_MSG_RESULT($ac_c99_fenv_tr1)
1097   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1098     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1099               [Define if C99 functions in <fenv.h> should be imported in
1100               <tr1/cfenv> in namespace std::tr1.])
1101   fi
1102
1103   # Check for the existence of <stdint.h> types.
1104   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1105   AC_CACHE_VAL(ac_c99_stdint_tr1, [
1106   AC_TRY_COMPILE([#include <stdint.h>],
1107                  [typedef int8_t          my_int8_t;
1108                   typedef int16_t         my_int16_t;
1109                   typedef int32_t         my_int32_t;
1110                   typedef int64_t         my_int64_t;
1111                   typedef int_fast8_t     my_int_fast8_t;
1112                   typedef int_fast16_t    my_int_fast16_t;
1113                   typedef int_fast32_t    my_int_fast32_t;
1114                   typedef int_fast64_t    my_int_fast64_t;
1115                   typedef int_least8_t    my_int_least8_t;
1116                   typedef int_least16_t   my_int_least16_t;
1117                   typedef int_least32_t   my_int_least32_t;
1118                   typedef int_least64_t   my_int_least64_t;
1119                   typedef intmax_t        my_intmax_t;
1120                   typedef intptr_t        my_intptr_t;
1121                   typedef uint8_t         my_uint8_t;
1122                   typedef uint16_t        my_uint16_t;
1123                   typedef uint32_t        my_uint32_t;
1124                   typedef uint64_t        my_uint64_t;
1125                   typedef uint_fast8_t    my_uint_fast8_t;
1126                   typedef uint_fast16_t   my_uint_fast16_t;
1127                   typedef uint_fast32_t   my_uint_fast32_t;
1128                   typedef uint_fast64_t   my_uint_fast64_t;
1129                   typedef uint_least8_t   my_uint_least8_t;
1130                   typedef uint_least16_t  my_uint_least16_t;
1131                   typedef uint_least32_t  my_uint_least32_t;
1132                   typedef uint_least64_t  my_uint_least64_t;
1133                   typedef uintmax_t       my_uintmax_t;
1134                   typedef uintptr_t       my_uintptr_t;
1135                  ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no])
1136   ])
1137   AC_MSG_RESULT($ac_c99_stdint_tr1)
1138   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1139     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1140               [Define if C99 types in <stdint.h> should be imported in
1141               <tr1/cstdint> in namespace std::tr1.])
1142   fi
1143
1144   # Check for the existence of <math.h> functions.
1145   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1146   AC_CACHE_VAL(ac_c99_math_tr1, [
1147   AC_TRY_COMPILE([#include <math.h>],
1148                  [typedef double_t  my_double_t;
1149                   typedef float_t   my_float_t;
1150                   acosh(0.0);
1151                   acoshf(0.0f);
1152                   acoshl(0.0l);
1153                   asinh(0.0);
1154                   asinhf(0.0f);
1155                   asinhl(0.0l);
1156                   atanh(0.0);
1157                   atanhf(0.0f);
1158                   atanhl(0.0l);
1159                   cbrt(0.0);
1160                   cbrtf(0.0f);
1161                   cbrtl(0.0l);
1162                   copysign(0.0, 0.0);
1163                   copysignf(0.0f, 0.0f);
1164                   copysignl(0.0l, 0.0l);
1165                   erf(0.0);
1166                   erff(0.0f);
1167                   erfl(0.0l);
1168                   erfc(0.0);
1169                   erfcf(0.0f);
1170                   erfcl(0.0l);
1171                   exp2(0.0);
1172                   exp2f(0.0f);
1173                   exp2l(0.0l);
1174                   expm1(0.0);
1175                   expm1f(0.0f);
1176                   expm1l(0.0l);
1177                   fdim(0.0, 0.0);
1178                   fdimf(0.0f, 0.0f);
1179                   fdiml(0.0l, 0.0l);
1180                   fma(0.0, 0.0, 0.0);
1181                   fmaf(0.0f, 0.0f, 0.0f);
1182                   fmal(0.0l, 0.0l, 0.0l);
1183                   fmax(0.0, 0.0);
1184                   fmaxf(0.0f, 0.0f);
1185                   fmaxl(0.0l, 0.0l);
1186                   fmin(0.0, 0.0);
1187                   fminf(0.0f, 0.0f);
1188                   fminl(0.0l, 0.0l);
1189                   hypot(0.0, 0.0);
1190                   hypotf(0.0f, 0.0f);
1191                   hypotl(0.0l, 0.0l);
1192                   ilogb(0.0);
1193                   ilogbf(0.0f);
1194                   ilogbl(0.0l);
1195                   lgamma(0.0);
1196                   lgammaf(0.0f);
1197                   lgammal(0.0l);
1198                   llrint(0.0);
1199                   llrintf(0.0f);
1200                   llrintl(0.0l);
1201                   llround(0.0);
1202                   llroundf(0.0f);
1203                   llroundl(0.0l);
1204                   log1p(0.0);
1205                   log1pf(0.0f);
1206                   log1pl(0.0l);
1207                   log2(0.0);
1208                   log2f(0.0f);
1209                   log2l(0.0l);
1210                   logb(0.0);
1211                   logbf(0.0f);
1212                   logbl(0.0l);
1213                   lrint(0.0);
1214                   lrintf(0.0f);
1215                   lrintl(0.0l);
1216                   lround(0.0);
1217                   lroundf(0.0f);
1218                   lroundl(0.0l);
1219                   nan(0);
1220                   nanf(0);
1221                   nanl(0);
1222                   nearbyint(0.0);
1223                   nearbyintf(0.0f);
1224                   nearbyintl(0.0l);
1225                   nextafter(0.0, 0.0);
1226                   nextafterf(0.0f, 0.0f);
1227                   nextafterl(0.0l, 0.0l);
1228                   nexttoward(0.0, 0.0);
1229                   nexttowardf(0.0f, 0.0f);
1230                   nexttowardl(0.0l, 0.0l);
1231                   remainder(0.0, 0.0);
1232                   remainderf(0.0f, 0.0f);
1233                   remainderl(0.0l, 0.0l);
1234                   remquo(0.0, 0.0, 0);
1235                   remquo(0.0f, 0.0f, 0);
1236                   remquo(0.0l, 0.0l, 0);
1237                   rint(0.0);
1238                   rintf(0.0f);
1239                   rintl(0.0l);
1240                   round(0.0);
1241                   roundf(0.0f);
1242                   roundl(0.0l);
1243                   scalbln(0.0, 0l);
1244                   scalblnf(0.0f, 0l);
1245                   scalblnl(0.0l, 0l);
1246                   scalbn(0.0, 0);
1247                   scalbnf(0.0f, 0);
1248                   scalbnl(0.0l, 0);
1249                   tgamma(0.0);
1250                   tgammaf(0.0f);
1251                   tgammal(0.0l);
1252                   trunc(0.0);
1253                   truncf(0.0f);
1254                   truncl(0.0l);
1255                  ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
1256   ])
1257   AC_MSG_RESULT($ac_c99_math_tr1)
1258   if test x"$ac_c99_math_tr1" = x"yes"; then
1259     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1260               [Define if C99 functions or macros in <math.h> should be imported
1261               in <tr1/cmath> in namespace std::tr1.])
1262   fi
1263
1264   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1265   # sense if the previous check fails, per C99, 7.8/1).
1266   ac_c99_inttypes_tr1=no;
1267   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1268     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1269     AC_TRY_COMPILE([#include <inttypes.h>],
1270                    [intmax_t i, numer, denom, base;
1271                     const char* s;
1272                     char** endptr;
1273                     intmax_t ret = imaxabs(i);
1274                     imaxdiv_t dret = imaxdiv(numer, denom);
1275                     ret = strtoimax(s, endptr, base);
1276                     uintmax_t uret = strtoumax(s, endptr, base);
1277                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1278   fi
1279   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1280   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1281     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1282               [Define if C99 functions in <inttypes.h> should be imported in
1283               <tr1/cinttypes> in namespace std::tr1.])
1284   fi
1285
1286   # Check for the existence of the <stdbool.h> header.
1287   AC_CHECK_HEADERS(stdbool.h)
1288
1289   AC_LANG_RESTORE
1290 ])
1291
1292 dnl
1293 dnl Check whether "dev/random" and "dev/urandom" are available for the
1294 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1295 dnl
1296 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1297
1298   AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1299   AC_CACHE_VAL(ac_random_tr1, [
1300   AC_TRY_RUN([#include <stdio.h>
1301               int main()
1302               {
1303                 return !(fopen("/dev/random", "r")
1304                          && fopen("/dev/urandom", "r"));
1305               }
1306              ],
1307              [ac_random_tr1=yes], [ac_random_tr1=no],
1308              [ac_random_tr1=no])
1309   ])
1310   AC_MSG_RESULT($ac_random_tr1)
1311   if test x"$ac_random_tr1" = x"yes"; then
1312     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1313               [Define if dev/random and dev/urandom are available for
1314                the random_device of TR1 (Chapter 5.1).])
1315   fi
1316
1317 ])
1318
1319 dnl
1320 dnl Check for what type of C headers to use.
1321 dnl
1322 dnl --enable-cheaders= [does stuff].
1323 dnl --disable-cheaders [does not do anything, really].
1324 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1325 dnl       Where DEFAULT is either `c' or `c_std'.
1326 dnl
1327 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1328   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1329     [construct "C" headers for g++], [permit c|c_std])
1330   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1331
1332   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1333
1334   AC_SUBST(C_INCLUDE_DIR)
1335   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1336   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1337   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1338 ])
1339
1340
1341 dnl
1342 dnl Check for which locale library to use.  The choice is mapped to
1343 dnl a subdirectory of config/locale.
1344 dnl
1345 dnl Default is generic.
1346 dnl
1347 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1348   AC_MSG_CHECKING([for C locale to use])
1349   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1350     [use MODEL for target locale package],
1351     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1352
1353   # If they didn't use this option switch, or if they specified --enable
1354   # with no specific model, we'll have to look for one.  If they
1355   # specified --disable (???), do likewise.
1356   if test $enable_clocale = no || test $enable_clocale = yes; then
1357      enable_clocale=auto
1358   fi
1359
1360   # Either a known package, or "auto"
1361   enable_clocale_flag=$enable_clocale
1362
1363   # Probe for locale support if no specific model is specified.
1364   # Default to "generic".
1365   if test $enable_clocale_flag = auto; then
1366     case ${target_os} in
1367       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1368         AC_EGREP_CPP([_GLIBCXX_ok], [
1369         #include <features.h>
1370         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1371           _GLIBCXX_ok
1372         #endif
1373         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1374
1375         # Test for bugs early in glibc-2.2.x series
1376           if test $enable_clocale_flag = gnu; then
1377           AC_TRY_RUN([
1378           #define _GNU_SOURCE 1
1379           #include <locale.h>
1380           #include <string.h>
1381           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1382           extern __typeof(newlocale) __newlocale;
1383           extern __typeof(duplocale) __duplocale;
1384           extern __typeof(strcoll_l) __strcoll_l;
1385           #endif
1386           int main()
1387           {
1388               const char __one[] = "Äuglein Augmen";
1389               const char __two[] = "Äuglein";
1390               int i;
1391               int j;
1392               __locale_t        loc;
1393                __locale_t        loc_dup;
1394               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1395               loc_dup = __duplocale(loc);
1396               i = __strcoll_l(__one, __two, loc);
1397               j = __strcoll_l(__one, __two, loc_dup);
1398               return 0;
1399           }
1400           ],
1401           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1402           [enable_clocale_flag=generic])
1403           fi
1404
1405         # ... at some point put __strxfrm_l tests in as well.
1406         ;;
1407       darwin* | freebsd*)
1408         enable_clocale_flag=darwin
1409         ;;
1410       *)
1411         enable_clocale_flag=generic
1412         ;;
1413     esac
1414   fi
1415
1416   # Deal with gettext issues.  Default to not using it (=no) until we detect
1417   # support for it later.  Let the user turn it off via --e/d, but let that
1418   # default to on for easier handling.
1419   USE_NLS=no
1420   AC_ARG_ENABLE(nls,
1421     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1422     [],
1423     [enable_nls=yes])
1424
1425   # Set configure bits for specified locale package
1426   case ${enable_clocale_flag} in
1427     generic)
1428       AC_MSG_RESULT(generic)
1429
1430       CLOCALE_H=config/locale/generic/c_locale.h
1431       CLOCALE_CC=config/locale/generic/c_locale.cc
1432       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1433       CCOLLATE_CC=config/locale/generic/collate_members.cc
1434       CCTYPE_CC=config/locale/generic/ctype_members.cc
1435       CMESSAGES_H=config/locale/generic/messages_members.h
1436       CMESSAGES_CC=config/locale/generic/messages_members.cc
1437       CMONEY_CC=config/locale/generic/monetary_members.cc
1438       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1439       CTIME_H=config/locale/generic/time_members.h
1440       CTIME_CC=config/locale/generic/time_members.cc
1441       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1442       ;;
1443     darwin)
1444       AC_MSG_RESULT(darwin or freebsd)
1445
1446       CLOCALE_H=config/locale/generic/c_locale.h
1447       CLOCALE_CC=config/locale/generic/c_locale.cc
1448       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1449       CCOLLATE_CC=config/locale/generic/collate_members.cc
1450       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1451       CMESSAGES_H=config/locale/generic/messages_members.h
1452       CMESSAGES_CC=config/locale/generic/messages_members.cc
1453       CMONEY_CC=config/locale/generic/monetary_members.cc
1454       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1455       CTIME_H=config/locale/generic/time_members.h
1456       CTIME_CC=config/locale/generic/time_members.cc
1457       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1458       ;;
1459
1460     gnu)
1461       AC_MSG_RESULT(gnu)
1462
1463       # Declare intention to use gettext, and add support for specific
1464       # languages.
1465       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1466       ALL_LINGUAS="de fr"
1467
1468       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1469       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1470       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1471         USE_NLS=yes
1472       fi
1473       # Export the build objects.
1474       for ling in $ALL_LINGUAS; do \
1475         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1476         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1477       done
1478       AC_SUBST(glibcxx_MOFILES)
1479       AC_SUBST(glibcxx_POFILES)
1480
1481       CLOCALE_H=config/locale/gnu/c_locale.h
1482       CLOCALE_CC=config/locale/gnu/c_locale.cc
1483       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1484       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1485       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1486       CMESSAGES_H=config/locale/gnu/messages_members.h
1487       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1488       CMONEY_CC=config/locale/gnu/monetary_members.cc
1489       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1490       CTIME_H=config/locale/gnu/time_members.h
1491       CTIME_CC=config/locale/gnu/time_members.cc
1492       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1493       ;;
1494     ieee_1003.1-2001)
1495       AC_MSG_RESULT(IEEE 1003.1)
1496
1497       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1498       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1499       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1500       CCOLLATE_CC=config/locale/generic/collate_members.cc
1501       CCTYPE_CC=config/locale/generic/ctype_members.cc
1502       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1503       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1504       CMONEY_CC=config/locale/generic/monetary_members.cc
1505       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1506       CTIME_H=config/locale/generic/time_members.h
1507       CTIME_CC=config/locale/generic/time_members.cc
1508       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1509       ;;
1510   esac
1511
1512   # This is where the testsuite looks for locale catalogs, using the
1513   # -DLOCALEDIR define during testsuite compilation.
1514   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1515   AC_SUBST(glibcxx_localedir)
1516
1517   # A standalone libintl (e.g., GNU libintl) may be in use.
1518   if test $USE_NLS = yes; then
1519     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1520     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1521   fi
1522   if test $USE_NLS = yes; then
1523     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1524               [Define if NLS translations are to be used.])
1525   fi
1526
1527   AC_SUBST(USE_NLS)
1528   AC_SUBST(CLOCALE_H)
1529   AC_SUBST(CMESSAGES_H)
1530   AC_SUBST(CCODECVT_CC)
1531   AC_SUBST(CCOLLATE_CC)
1532   AC_SUBST(CCTYPE_CC)
1533   AC_SUBST(CMESSAGES_CC)
1534   AC_SUBST(CMONEY_CC)
1535   AC_SUBST(CNUMERIC_CC)
1536   AC_SUBST(CTIME_H)
1537   AC_SUBST(CTIME_CC)
1538   AC_SUBST(CLOCALE_CC)
1539   AC_SUBST(CLOCALE_INTERNAL_H)
1540 ])
1541
1542
1543 dnl
1544 dnl Check for which std::allocator base class to use.  The choice is
1545 dnl mapped from a subdirectory of include/ext.
1546 dnl
1547 dnl Default is new.
1548 dnl
1549 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1550   AC_MSG_CHECKING([for std::allocator base class])
1551   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1552     [use KIND for target std::allocator base],
1553     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1554
1555   # If they didn't use this option switch, or if they specified --enable
1556   # with no specific model, we'll have to look for one.  If they
1557   # specified --disable (???), do likewise.
1558   if test $enable_libstdcxx_allocator = no ||
1559      test $enable_libstdcxx_allocator = yes;
1560   then
1561      enable_libstdcxx_allocator=auto
1562   fi
1563
1564   # Either a known package, or "auto". Auto implies the default choice
1565   # for a particular platform.
1566   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1567
1568   # Probe for host-specific support if no specific model is specified.
1569   # Default to "new".
1570   if test $enable_libstdcxx_allocator_flag = auto; then
1571     case ${target_os} in
1572       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1573         enable_libstdcxx_allocator_flag=new
1574         ;;
1575       *)
1576         enable_libstdcxx_allocator_flag=new
1577         ;;
1578     esac
1579   fi
1580   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1581
1582
1583   # Set configure bits for specified locale package
1584   case ${enable_libstdcxx_allocator_flag} in
1585     bitmap)
1586       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1587       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1588       ;;
1589     malloc)
1590       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1591       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1592       ;;
1593     mt)
1594       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1595       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1596       ;;
1597     new)
1598       ALLOCATOR_H=config/allocator/new_allocator_base.h
1599       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1600       ;;
1601     pool)
1602       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1603       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1604       ;;
1605   esac
1606
1607   AC_SUBST(ALLOCATOR_H)
1608   AC_SUBST(ALLOCATOR_NAME)
1609 ])
1610
1611
1612 dnl
1613 dnl Check for whether the Boost-derived checks should be turned on.
1614 dnl
1615 dnl --enable-concept-checks turns them on.
1616 dnl --disable-concept-checks leaves them off.
1617 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1618 dnl       Where DEFAULT is either `yes' or `no'.
1619 dnl
1620 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1621   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1622   if test $enable_concept_checks = yes; then
1623     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1624               [Define to use concept checking code from the boost libraries.])
1625   fi
1626 ])
1627
1628
1629 dnl
1630 dnl Check for which I/O library to use:  stdio, or something specific.
1631 dnl
1632 dnl Default is stdio.
1633 dnl
1634 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1635   AC_MSG_CHECKING([for underlying I/O to use])
1636   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1637     [use target-specific I/O package], [permit stdio])
1638
1639   # Now that libio has been removed, you can have any color you want as long
1640   # as it's black.  This is one big no-op until other packages are added, but
1641   # showing the framework never hurts.
1642   case ${enable_cstdio} in
1643     stdio)
1644       CSTDIO_H=config/io/c_io_stdio.h
1645       BASIC_FILE_H=config/io/basic_file_stdio.h
1646       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1647       AC_MSG_RESULT(stdio)
1648       ;;
1649   esac
1650
1651   AC_SUBST(CSTDIO_H)
1652   AC_SUBST(BASIC_FILE_H)
1653   AC_SUBST(BASIC_FILE_CC)
1654 ])
1655
1656
1657 dnl
1658 dnl Check for "unusual" flags to pass to the compiler while building.
1659 dnl
1660 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1661 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1662 dnl --disable-cxx-flags passes nothing.
1663 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1664 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1665 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1666 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1667 dnl       If "default flags" is an empty string, the effect is the same
1668 dnl       as --disable or --enable=no.
1669 dnl
1670 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1671   AC_MSG_CHECKING([for extra compiler flags for building])
1672   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1673     [pass compiler FLAGS when building library],
1674     [case "x$enable_cxx_flags" in
1675       xno | x)   enable_cxx_flags= ;;
1676       x-*)       ;;
1677       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1678      esac])
1679
1680   # Run through flags (either default or command-line) and set anything
1681   # extra (e.g., #defines) that must accompany particular g++ options.
1682   if test -n "$enable_cxx_flags"; then
1683     for f in $enable_cxx_flags; do
1684       case "$f" in
1685         -fhonor-std)  ;;
1686         -*)  ;;
1687         *)   # and we're trying to pass /what/ exactly?
1688              AC_MSG_ERROR([compiler flags start with a -]) ;;
1689       esac
1690     done
1691   fi
1692
1693   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1694   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1695   AC_SUBST(EXTRA_CXX_FLAGS)
1696 ])
1697
1698
1699 dnl
1700 dnl Check to see if debugging libraries are to be built.
1701 dnl
1702 dnl --enable-libstdcxx-debug
1703 dnl builds a separate set of debugging libraries in addition to the
1704 dnl normal (shared, static) libstdc++ binaries.
1705 dnl
1706 dnl --disable-libstdcxx-debug
1707 dnl builds only one (non-debug) version of libstdc++.
1708 dnl
1709 dnl --enable-libstdcxx-debug-flags=FLAGS
1710 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1711 dnl
1712 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1713 dnl       Where DEFAULT is either `yes' or `no'.
1714 dnl
1715 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1716   AC_MSG_CHECKING([for additional debug build])
1717   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1718   AC_MSG_RESULT($enable_libstdcxx_debug)
1719   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1720 ])
1721
1722
1723 dnl
1724 dnl Check for explicit debug flags.
1725 dnl
1726 dnl --enable-libstdcxx-debug-flags='-O1'
1727 dnl is a general method for passing flags to be used when
1728 dnl building debug libraries with --enable-debug.
1729 dnl
1730 dnl --disable-libstdcxx-debug-flags does nothing.
1731 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1732 dnl       If "default flags" is an empty string, the effect is the same
1733 dnl       as --disable or --enable=no.
1734 dnl
1735 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1736   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1737     [pass compiler FLAGS when building debug library],
1738     [case "x$enable_libstdcxx_debug_flags" in
1739       xno | x)    enable_libstdcxx_debug_flags= ;;
1740       x-*)        ;;
1741       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1742      esac])
1743
1744   # Option parsed, now set things appropriately
1745   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1746   AC_SUBST(DEBUG_FLAGS)
1747
1748   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1749 ])
1750
1751
1752 dnl
1753 dnl Check if the user only wants a freestanding library implementation.
1754 dnl
1755 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1756 dnl installing only the headers required by [17.4.1.3] and the language
1757 dnl support library.  More than that will be built (to keep the Makefiles
1758 dnl conveniently clean), but not installed.
1759 dnl
1760 dnl Sets:
1761 dnl  is_hosted  (yes/no)
1762 dnl
1763 dnl Defines:
1764 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1765 dnl
1766 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1767   AC_ARG_ENABLE([hosted-libstdcxx],
1768     AC_HELP_STRING([--disable-hosted-libstdcxx],
1769                    [only build freestanding C++ runtime support]),,
1770     [case "$host" in
1771         arm*-*-symbianelf*)
1772             enable_hosted_libstdcxx=no
1773             ;;
1774         *)
1775             enable_hosted_libstdcxx=yes
1776             ;;
1777      esac])
1778   if test "$enable_hosted_libstdcxx" = no; then
1779     AC_MSG_NOTICE([Only freestanding libraries will be built])
1780     is_hosted=no
1781     hosted_define=0
1782     enable_abi_check=no
1783     enable_libstdcxx_pch=no
1784   else
1785     is_hosted=yes
1786     hosted_define=1
1787   fi
1788   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1789   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1790     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1791 ])
1792
1793
1794 dnl
1795 dnl Check for template specializations for the 'long long' type.
1796 dnl The result determines only whether 'long long' I/O is enabled; things
1797 dnl like numeric_limits<> specializations are always available.
1798 dnl
1799 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1800 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1801 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1802 dnl       Where DEFAULT is either `yes' or `no'.
1803 dnl
1804 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1805   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1806   if test $enable_long_long = yes; then
1807     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1808               [Define if code specialized for long long should be used.])
1809   fi
1810   AC_MSG_CHECKING([for enabled long long specializations])
1811   AC_MSG_RESULT([$enable_long_long])
1812 ])
1813
1814
1815 dnl
1816 dnl Check for template specializations for the 'wchar_t' type.
1817 dnl
1818 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1819 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1820 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1821 dnl       Where DEFAULT is either `yes' or `no'.
1822 dnl
1823 dnl Necessary support must also be present.
1824 dnl
1825 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1826   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1827
1828   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
1829   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
1830   AC_MSG_CHECKING([for mbstate_t])
1831   AC_TRY_COMPILE([#include <wchar.h>],
1832   [mbstate_t teststate;],
1833   have_mbstate_t=yes, have_mbstate_t=no)
1834   AC_MSG_RESULT($have_mbstate_t)
1835   if test x"$have_mbstate_t" = xyes; then
1836     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
1837   fi
1838
1839   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
1840   # ac_has_wchar_h.
1841   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
1842
1843   if test x"$enable_wchar_t" = x"yes"; then
1844
1845     AC_LANG_SAVE
1846     AC_LANG_CPLUSPLUS
1847
1848     if test x"$ac_has_wchar_h" = xyes &&
1849        test x"$ac_has_wctype_h" = xyes; then
1850       AC_TRY_COMPILE([#include <wchar.h>
1851                       #include <stddef.h>
1852                       wint_t i;
1853                       long l = WEOF;
1854                       long j = WCHAR_MIN;
1855                       long k = WCHAR_MAX;
1856                       namespace test
1857                       {
1858                         using ::btowc;
1859                         using ::fgetwc;
1860                         using ::fgetws;
1861                         using ::fputwc;
1862                         using ::fputws;
1863                         using ::fwide;
1864                         using ::fwprintf;
1865                         using ::fwscanf;
1866                         using ::getwc;
1867                         using ::getwchar;
1868                         using ::mbrlen;
1869                         using ::mbrtowc;
1870                         using ::mbsinit;
1871                         using ::mbsrtowcs;
1872                         using ::putwc;
1873                         using ::putwchar;
1874                         using ::swprintf;
1875                         using ::swscanf;
1876                         using ::ungetwc;
1877                         using ::vfwprintf;
1878                         using ::vswprintf;
1879                         using ::vwprintf;
1880                         using ::wcrtomb;
1881                         using ::wcscat;
1882                         using ::wcschr;
1883                         using ::wcscmp;
1884                         using ::wcscoll;
1885                         using ::wcscpy;
1886                         using ::wcscspn;
1887                         using ::wcsftime;
1888                         using ::wcslen;
1889                         using ::wcsncat;
1890                         using ::wcsncmp;
1891                         using ::wcsncpy;
1892                         using ::wcspbrk;
1893                         using ::wcsrchr;
1894                         using ::wcsrtombs;
1895                         using ::wcsspn;
1896                         using ::wcsstr;
1897                         using ::wcstod;
1898                         using ::wcstok;
1899                         using ::wcstol;
1900                         using ::wcstoul;
1901                         using ::wcsxfrm;
1902                         using ::wctob;
1903                         using ::wmemchr;
1904                         using ::wmemcmp;
1905                         using ::wmemcpy;
1906                         using ::wmemmove;
1907                         using ::wmemset;
1908                         using ::wprintf;
1909                         using ::wscanf;
1910                       }
1911                      ],[],[], [enable_wchar_t=no])
1912     else
1913       enable_wchar_t=no
1914     fi
1915
1916     AC_LANG_RESTORE
1917   fi
1918
1919   if test x"$enable_wchar_t" = x"yes"; then
1920     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
1921               [Define if code specialized for wchar_t should be used.])
1922   fi
1923
1924   AC_MSG_CHECKING([for enabled wchar_t specializations])
1925   AC_MSG_RESULT([$enable_wchar_t])
1926 ])
1927
1928
1929 dnl
1930 dnl Check to see if building and using a C++ precompiled header can be done.
1931 dnl
1932 dnl --enable-libstdcxx-pch=yes
1933 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1934 dnl may work, after some light-hearted attempts to puzzle out compiler
1935 dnl support, flip bits on in include/Makefile.am
1936 dnl
1937 dnl --disable-libstdcxx-pch
1938 dnl turns off attempts to use or build stdc++.h.gch.
1939 dnl
1940 dnl Substs:
1941 dnl  glibcxx_PCHFLAGS
1942 dnl
1943 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1944   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1945   if test $enable_libstdcxx_pch = yes; then
1946     AC_CACHE_CHECK([for compiler with PCH support],
1947       [glibcxx_cv_prog_CXX_pch],
1948       [ac_save_CXXFLAGS="$CXXFLAGS"
1949        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1950        AC_LANG_SAVE
1951        AC_LANG_CPLUSPLUS
1952        echo '#include <math.h>' > conftest.h
1953        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1954                           -o conftest.h.gch 1>&5 2>&1 &&
1955                 echo '#error "pch failed"' > conftest.h &&
1956           echo '#include "conftest.h"' > conftest.cc &&
1957                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1958        then
1959          glibcxx_cv_prog_CXX_pch=yes
1960        else
1961          glibcxx_cv_prog_CXX_pch=no
1962        fi
1963        rm -f conftest*
1964        CXXFLAGS=$ac_save_CXXFLAGS
1965        AC_LANG_RESTORE
1966       ])
1967     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1968   fi
1969
1970   AC_MSG_CHECKING([for enabled PCH])
1971   AC_MSG_RESULT([$enable_libstdcxx_pch])
1972
1973   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1974   if test $enable_libstdcxx_pch = yes; then
1975     glibcxx_PCHFLAGS="-include bits/stdtr1c++.h"
1976   else
1977     glibcxx_PCHFLAGS=""
1978   fi
1979   AC_SUBST(glibcxx_PCHFLAGS)
1980 ])
1981
1982
1983 dnl
1984 dnl Check for atomic builtins.
1985 dnl See:
1986 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
1987 dnl
1988 dnl This checks to see if the host supports the compiler-generated
1989 dnl builtins for atomic operations. Note, this is intended to be an
1990 dnl all-or-nothing switch, so all the atomic operations that are used
1991 dnl should be checked.
1992 dnl
1993 dnl Note:
1994 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
1995 dnl see: CHECK_SYNC_FETCH_AND_ADD
1996 dnl
1997 dnl Defines:
1998 dnl  _GLIBCXX_ATOMIC_BUILTINS if the compiler on this target supports atomics.
1999 dnl
2000 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2001   AC_MSG_CHECKING([for atomic builtins])
2002   AC_LANG_SAVE
2003   AC_LANG_CPLUSPLUS
2004
2005   # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2006     cat > conftest.$ac_ext << EOF
2007 [#]line __oline__ "configure"
2008 int main()
2009 {
2010   // NB: _Atomic_word not necessarily int.
2011   typedef int atomic_type;
2012   atomic_type c1;
2013   atomic_type c2;
2014   const atomic_type c3(0);
2015   if (__sync_fetch_and_add(&c1, c2) == c3)
2016     {
2017       // Do something.
2018     }
2019    return 0;
2020 }
2021 EOF
2022     old_CXXFLAGS="$CXXFLAGS"
2023     CXXFLAGS=-S
2024     if AC_TRY_EVAL(ac_compile); then
2025       if grep __sync_fetch_and_add conftest.s >/dev/null 2>&1 ; then
2026         enable_atomic_builtins=no
2027       else
2028       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2029         [Define if builtin atomic operations are supported on this host.])
2030         enable_atomic_builtins=yes
2031         atomicity_dir=cpu/generic/atomicity_builtins
2032       fi
2033     fi
2034     CXXFLAGS="$old_CXXFLAGS"
2035     rm -f conftest*
2036
2037    # Now, if still generic, set to mutex.
2038   if test $atomicity_dir = "cpu/generic" ; then
2039         atomicity_dir=cpu/generic/atomicity_mutex
2040   fi
2041  AC_LANG_RESTORE
2042  AC_MSG_RESULT($enable_atomic_builtins)
2043 ])
2044
2045
2046 dnl
2047 dnl Check for exception handling support.  If an explicit enable/disable
2048 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2049 dnl target may or may not support call frame exceptions.
2050 dnl
2051 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2052 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2053 dnl Neither one forces an attempt at detection.
2054 dnl
2055 dnl Defines:
2056 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2057 dnl
2058 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2059   AC_MSG_CHECKING([for exception model to use])
2060   AC_LANG_SAVE
2061   AC_LANG_CPLUSPLUS
2062   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2063     [force use of builtin_setjmp for exceptions],
2064     [permit yes|no|auto])
2065
2066   if test $enable_sjlj_exceptions = auto; then
2067     # Botheration.  Now we've got to detect the exception model.  Link tests
2068     # against libgcc.a are problematic since we've not been given proper -L
2069     # bits for single-tree newlib and libgloss.
2070     #
2071     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2072     cat > conftest.$ac_ext << EOF
2073 [#]line __oline__ "configure"
2074 struct S { ~S(); };
2075 void bar();
2076 void foo()
2077 {
2078   S s;
2079   bar();
2080 }
2081 EOF
2082     old_CXXFLAGS="$CXXFLAGS"
2083     CXXFLAGS=-S
2084     if AC_TRY_EVAL(ac_compile); then
2085       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2086         enable_sjlj_exceptions=yes
2087       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2088         enable_sjlj_exceptions=no
2089       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2090         enable_sjlj_exceptions=no
2091       fi
2092     fi
2093     CXXFLAGS="$old_CXXFLAGS"
2094     rm -f conftest*
2095   fi
2096
2097   # This is a tad weird, for hysterical raisins.  We have to map
2098   # enable/disable to two different models.
2099   case $enable_sjlj_exceptions in
2100     yes)
2101       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2102         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2103       ac_exception_model_name=sjlj
2104       ;;
2105     no)
2106       ac_exception_model_name="call frame"
2107       ;;
2108     *)
2109       AC_MSG_ERROR([unable to detect exception model])
2110       ;;
2111   esac
2112  AC_LANG_RESTORE
2113  AC_MSG_RESULT($ac_exception_model_name)
2114 ])
2115
2116
2117 dnl
2118 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2119 dnl
2120 dnl --enable-visibility enables attempt to use visibility attributes.
2121 dnl --disable-visibility turns off all use of visibility attributes.
2122 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2123 dnl       Where DEFAULT is 'yes'.
2124 dnl
2125 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2126 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2127
2128 if test x$enable_visibility = xyes ; then
2129   dnl all hail libgfortran
2130   dnl Check whether the target supports hidden visibility.
2131   AC_CACHE_CHECK([whether the target supports hidden visibility],
2132                  have_attribute_visibility, [
2133   save_CFLAGS="$CFLAGS"
2134   CFLAGS="$CFLAGS -Werror"
2135   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2136                  [], have_attribute_visibility=yes,
2137                  have_attribute_visibility=no)
2138   CFLAGS="$save_CFLAGS"])
2139   if test $have_attribute_visibility = no; then
2140     enable_visibility=no
2141   fi
2142 fi
2143
2144 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2145 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2146 ])
2147
2148
2149 dnl
2150 dnl Add version tags to symbols in shared library (or not), additionally
2151 dnl marking other symbols as private/local (or not).
2152 dnl
2153 dnl --enable-symvers=style adds a version script to the linker call when
2154 dnl       creating the shared library.  The choice of version script is
2155 dnl       controlled by 'style'.
2156 dnl --disable-symvers does not.
2157 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2158 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2159 dnl       choose a default style based on linker characteristics.  Passing
2160 dnl       'no' disables versioning.
2161 dnl
2162 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2163
2164 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2165   [enables symbol versioning of the shared library],
2166   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2167
2168 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2169 # don't know enough about $LD to do tricks...
2170 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2171
2172 # Turn a 'yes' into a suitable default.
2173 if test x$enable_symvers = xyes ; then
2174   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2175     enable_symvers=no
2176   else
2177     if test $with_gnu_ld = yes ; then
2178       enable_symvers=gnu
2179     else
2180       case ${target_os} in
2181         darwin*)
2182           enable_symvers=darwin ;;
2183         *)
2184           enable_symvers=no ;;
2185       esac
2186     fi
2187   fi
2188 fi
2189
2190 # Check to see if 'darwin' or 'darwin-export' can win.
2191 if test x$enable_symvers = xdarwin-export ; then
2192     enable_symvers=darwin
2193 fi
2194
2195 # Check to see if 'gnu' can win.
2196 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2197   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2198   AC_MSG_CHECKING([for shared libgcc])
2199   ac_save_CFLAGS="$CFLAGS"
2200   CFLAGS=' -lgcc_s'
2201   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2202   CFLAGS="$ac_save_CFLAGS"
2203   if test $glibcxx_shared_libgcc = no; then
2204     cat > conftest.c <<EOF
2205 int main (void) { return 0; }
2206 EOF
2207 changequote(,)dnl
2208     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2209                              -shared -shared-libgcc -o conftest.so \
2210                              conftest.c -v 2>&1 >/dev/null \
2211                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2212 changequote([,])dnl
2213     rm -f conftest.c conftest.so
2214     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2215       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2216       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2217       CFLAGS="$ac_save_CFLAGS"
2218     fi
2219   fi
2220   AC_MSG_RESULT($glibcxx_shared_libgcc)
2221
2222   # For GNU ld, we need at least this version.  The format is described in
2223   # GLIBCXX_CHECK_LINKER_FEATURES above.
2224   glibcxx_min_gnu_ld_version=21400
2225
2226   # If no shared libgcc, can't win.
2227   if test $glibcxx_shared_libgcc != yes; then
2228       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2229       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2230       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2231       enable_symvers=no
2232   elif test $with_gnu_ld != yes ; then
2233     # just fail for now
2234     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2235     AC_MSG_WARN([=== you are not using the GNU linker.])
2236     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2237     enable_symvers=no
2238   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2239     # The right tools, the right setup, but too old.  Fallbacks?
2240     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2241     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2242     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2243     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2244     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2245     enable_symvers=no
2246   fi
2247 fi
2248
2249 # Everything parsed; figure out what file to use.
2250 case $enable_symvers in
2251   no)
2252     SYMVER_FILE=config/abi/pre/none.ver
2253     ;;
2254   gnu)
2255     SYMVER_FILE=config/abi/pre/gnu.ver
2256     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2257               [Define to use GNU versioning in the shared library.])
2258     ;;
2259   gnu-versioned-namespace)
2260     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2261     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2262               [Define to use GNU namespace versioning in the shared library.])
2263     ;;
2264   darwin)
2265     SYMVER_FILE=config/abi/pre/gnu.ver
2266     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2267               [Define to use darwin versioning in the shared library.])
2268     ;;
2269 esac
2270
2271 if test x$enable_symvers != xno ; then
2272   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2273          [Define to use symbol versioning in the shared library.])
2274 fi
2275
2276 AC_SUBST(SYMVER_FILE)
2277 AC_SUBST(port_specific_symbol_files)
2278 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2279 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2280 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2281 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2282 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2283
2284 # Now, set up compatibility support, if any.
2285 # In addition, need this to deal with std::size_t mangling in
2286 # src/compatibility.cc.  In a perfect world, could use
2287 # typeid(std::size_t).name()[0] to do direct substitution.
2288 AC_MSG_CHECKING([for size_t as unsigned int])
2289 ac_save_CFLAGS="$CFLAGS"
2290 CFLAGS="-Werror"
2291 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2292                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2293 CFLAGS=$ac_save_CFLAGS
2294 if test "$glibcxx_size_t_is_i" = yes; then
2295   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2296 fi
2297 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2298
2299 AC_MSG_CHECKING([for ptrdiff_t as int])
2300 ac_save_CFLAGS="$CFLAGS"
2301 CFLAGS="-Werror"
2302 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2303                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2304 CFLAGS=$ac_save_CFLAGS
2305 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2306   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2307 fi
2308 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2309 ])
2310
2311
2312 dnl
2313 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2314 dnl We must stage the required headers so that they will be installed
2315 dnl with the library (unlike libgcc, the STL implementation is provided
2316 dnl solely within headers).  Since we must not inject random user-space
2317 dnl macro names into user-provided C++ code, we first stage into <file>-in
2318 dnl and process to <file> with an output command.  The reason for a two-
2319 dnl stage process here is to correctly handle $srcdir!=$objdir without
2320 dnl having to write complex code (the sed commands to clean the macro
2321 dnl namespace are complex and fragile enough as it is).  We must also
2322 dnl add a relative path so that -I- is supported properly.
2323 dnl
2324 dnl Substs:
2325 dnl  glibcxx_thread_h
2326 dnl
2327 dnl Defines:
2328 dnl  HAVE_GTHR_DEFAULT
2329 dnl
2330 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2331   AC_MSG_CHECKING([for thread model used by GCC])
2332   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2333   AC_MSG_RESULT([$target_thread_file])
2334
2335   if test $target_thread_file != single; then
2336     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2337               [Define if gthr-default.h exists
2338               (meaning that threading support is enabled).])
2339   fi
2340
2341   glibcxx_thread_h=gthr-$target_thread_file.h
2342
2343   dnl Check for __GTHREADS define.
2344   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2345   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2346     enable_thread=yes
2347   else
2348    enable_thread=no
2349   fi
2350
2351   AC_SUBST(glibcxx_thread_h)
2352 ])
2353
2354
2355 # Check whether LC_MESSAGES is available in <locale.h>.
2356 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2357 #
2358 # This file file be copied and used freely without restrictions.  It can
2359 # be used in projects which are not available under the GNU Public License
2360 # but which still want to provide support for the GNU gettext functionality.
2361 # Please note that the actual code is *not* freely available.
2362
2363 # serial 1
2364 AC_DEFUN([AC_LC_MESSAGES], [
2365   AC_CHECK_HEADER(locale.h, [
2366     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2367       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2368        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2369     if test $ac_cv_val_LC_MESSAGES = yes; then
2370       AC_DEFINE(HAVE_LC_MESSAGES, 1,
2371                 [Define if LC_MESSAGES is available in <locale.h>.])
2372     fi
2373   ])
2374 ])
2375
2376 # Macros from the top-level gcc directory.
2377 m4_include([../config/tls.m4])
2378