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