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(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
 799   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 800   ac_c99_complex=no;
 801   if test x"$ac_has_complex_h" = x"yes"; then
 802     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
 803     AC_TRY_COMPILE([#include <complex.h>],
 804                    [typedef __complex__ float float_type; float_type tmpf;
 805                     cabsf(tmpf);
 806                     cargf(tmpf);
 807                     ccosf(tmpf);
 808                     ccoshf(tmpf);
 809                     cexpf(tmpf);
 810                     clogf(tmpf);
 811                     csinf(tmpf);
 812                     csinhf(tmpf);
 813                     csqrtf(tmpf);
 814                     ctanf(tmpf);
 815                     ctanhf(tmpf);
 816                     cpowf(tmpf, tmpf);
 817                     typedef __complex__ double double_type; double_type tmpd;
 818                     cabs(tmpd);
 819                     carg(tmpd);
 820                     ccos(tmpd);
 821                     ccosh(tmpd);
 822                     cexp(tmpd);
 823                     clog(tmpd);
 824                     csin(tmpd);
 825                     csinh(tmpd);
 826                     csqrt(tmpd);
 827                     ctan(tmpd);
 828                     ctanh(tmpd);
 829                     cpow(tmpd, tmpd);
 830                     typedef __complex__ long double ld_type; ld_type tmpld;
 831                     cabsl(tmpld);
 832                     cargl(tmpld);
 833                     ccosl(tmpld);
 834                     ccoshl(tmpld);
 835                     cexpl(tmpld);
 836                     clogl(tmpld);
 837                     csinl(tmpld);
 838                     csinhl(tmpld);
 839                     csqrtl(tmpld);
 840                     ctanl(tmpld);
 841                     ctanhl(tmpld);
 842                     cpowl(tmpld, tmpld);
 843                    ],[ac_c99_complex=yes], [ac_c99_complex=no])
 844   fi
 845   AC_MSG_RESULT($ac_c99_complex)
 846   if test x"$ac_c99_complex" = x"yes"; then
 847     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 848               [Define if C99 functions in <complex.h> should be used in
 849               <complex>. Using compiler builtins for these functions requires
 850               corresponding C99 library functions to be present.])
 851   fi
 852
 853   # Check for the existence in <stdio.h> of vscanf, et. al.
 854   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 855   AC_CACHE_VAL(ac_c99_stdio, [
 856   AC_TRY_COMPILE([#include <stdio.h>
 857                   #include <stdarg.h>
 858                   void foo(char* fmt, ...)
 859                   {
 860                     va_list args; va_start(args, fmt);
 861                     vfscanf(stderr, "%i", args);
 862                     vscanf("%i", args);
 863                     vsnprintf(fmt, 0, "%i", args);
 864                     vsscanf(fmt, "%i", args);
 865                   }],
 866                  [snprintf("12", 0, "%i");],
 867                  [ac_c99_stdio=yes], [ac_c99_stdio=no])
 868   ])
 869   AC_MSG_RESULT($ac_c99_stdio)
 870
 871   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
 872   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
 873   AC_CACHE_VAL(ac_c99_stdlib, [
 874   AC_TRY_COMPILE([#include <stdlib.h>],
 875                  [char* tmp;
 876                   strtof("gnu", &tmp);
 877                   strtold("gnu", &tmp);
 878                   strtoll("gnu", &tmp, 10);
 879                   strtoull("gnu", &tmp, 10);
 880                   llabs(10);
 881                   lldiv(10,1);
 882                   atoll("10");
 883                   _Exit(0);
 884                   lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
 885   ])
 886   AC_MSG_RESULT($ac_c99_stdlib)
 887
 888   # Check for the existence in <wchar.h> of wcstold, etc.
 889   ac_c99_wchar=no;
 890   if test x"$ac_has_wchar_h" = xyes &&
 891      test x"$ac_has_wctype_h" = xyes; then
 892     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
 893     AC_TRY_COMPILE([#include <wchar.h>
 894                     namespace test
 895                     {
 896                       using ::wcstold;
 897                       using ::wcstoll;
 898                       using ::wcstoull;
 899                     }
 900                    ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
 901
 902     # Checks for wide character functions that may not be present.
 903     # Injection of these is wrapped with guard macros.
 904     # NB: only put functions here, instead of immediately above, if
 905     # absolutely necessary.
 906     AC_TRY_COMPILE([#include <wchar.h>
 907                     namespace test { using ::vfwscanf; } ], [],
 908                    [AC_DEFINE(HAVE_VFWSCANF,1,
 909                         [Defined if vfwscanf exists.])],[])
 910
 911     AC_TRY_COMPILE([#include <wchar.h>
 912                     namespace test { using ::vswscanf; } ], [],
 913                    [AC_DEFINE(HAVE_VSWSCANF,1,
 914                         [Defined if vswscanf exists.])],[])
 915
 916     AC_TRY_COMPILE([#include <wchar.h>
 917                     namespace test { using ::vwscanf; } ], [],
 918                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
 919
 920     AC_TRY_COMPILE([#include <wchar.h>
 921                     namespace test { using ::wcstof; } ], [],
 922                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
 923
 924     AC_TRY_COMPILE([#include <wctype.h>],
 925                    [ wint_t t; int i = iswblank(t);],
 926                    [AC_DEFINE(HAVE_ISWBLANK,1,
 927                         [Defined if iswblank exists.])],[])
 928
 929     AC_MSG_RESULT($ac_c99_wchar)
 930   fi
 931
 932   # Option parsed, now set things appropriately.
 933   if test x"$ac_c99_math" = x"no" ||
 934      test x"$ac_c99_complex" = x"no" ||
 935      test x"$ac_c99_stdio" = x"no" ||
 936      test x"$ac_c99_stdlib" = x"no" ||
 937      test x"$ac_c99_wchar" = x"no"; then
 938     enable_c99=no;
 939   else
 940     AC_DEFINE(_GLIBCXX_USE_C99, 1,
 941     [Define if C99 functions or macros from <wchar.h>, <math.h>,
 942     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
 943   fi
 944
 945   AC_LANG_RESTORE
 946   fi
 947
 948   AC_MSG_CHECKING([for fully enabled ISO C99 support])
 949   AC_MSG_RESULT($enable_c99)
 950 ])
 951
 952
 953 dnl
 954 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
 955 dnl facilities in Chapter 8, "C compatibility".
 956 dnl
 957 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
 958
 959   AC_LANG_SAVE
 960   AC_LANG_CPLUSPLUS
 961
 962   # Check for the existence of <complex.h> complex math functions used
 963   # by tr1/complex.
 964   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 965   ac_c99_complex_tr1=no;
 966   if test x"$ac_has_complex_h" = x"yes"; then
 967     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
 968     AC_TRY_COMPILE([#include <complex.h>],
 969                    [typedef __complex__ float float_type; float_type tmpf;
 970                     cacosf(tmpf);
 971                     casinf(tmpf);
 972                     catanf(tmpf);
 973                     cacoshf(tmpf);
 974                     casinhf(tmpf);
 975                     catanhf(tmpf);
 976                     typedef __complex__ double double_type; double_type tmpd;
 977                     cacos(tmpd);
 978                     casin(tmpd);
 979                     catan(tmpd);
 980                     cacosh(tmpd);
 981                     casinh(tmpd);
 982                     catanh(tmpd);
 983                     typedef __complex__ long double ld_type; ld_type tmpld;
 984                     cacosl(tmpld);
 985                     casinl(tmpld);
 986                     catanl(tmpld);
 987                     cacoshl(tmpld);
 988                     casinhl(tmpld);
 989                     catanhl(tmpld);
 990                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
 991   fi
 992   AC_MSG_RESULT($ac_c99_complex_tr1)
 993   if test x"$ac_c99_complex_tr1" = x"yes"; then
 994     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
 995               [Define if C99 functions in <complex.h> should be used in
 996               <tr1/complex>. Using compiler builtins for these functions
 997               requires corresponding C99 library functions to be present.])
 998   fi
 999
1000   # Check for the existence of <ctype.h> functions.
1001   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1002   AC_CACHE_VAL(ac_c99_ctype_tr1, [
1003   AC_TRY_COMPILE([#include <ctype.h>],
1004                  [int ch;
1005                   int ret;
1006                   ret = isblank(ch);
1007                  ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no])
1008   ])
1009   AC_MSG_RESULT($ac_c99_ctype_tr1)
1010   if test x"$ac_c99_ctype_tr1" = x"yes"; then
1011     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1012               [Define if C99 functions in <ctype.h> should be imported in
1013               <tr1/cctype> in namespace std::tr1.])
1014   fi
1015
1016   # Check for the existence of <fenv.h> functions.
1017   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1018   ac_c99_fenv_tr1=no;
1019   if test x"$ac_has_fenv_h" = x"yes"; then
1020     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1021     AC_TRY_COMPILE([#include <fenv.h>],
1022                    [int except, mode;
1023                     fexcept_t* pflag;
1024                     fenv_t* penv;
1025                     int ret;
1026                     ret = feclearexcept(except);
1027                     ret = fegetexceptflag(pflag, except);
1028                     ret = feraiseexcept(except);
1029                     ret = fesetexceptflag(pflag, except);
1030                     ret = fetestexcept(except);
1031                     ret = fegetround();
1032                     ret = fesetround(mode);
1033                     ret = fegetenv(penv);
1034                     ret = feholdexcept(penv);
1035                     ret = fesetenv(penv);
1036                     ret = feupdateenv(penv);
1037                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1038   fi
1039   AC_MSG_RESULT($ac_c99_fenv_tr1)
1040   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1041     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1042               [Define if C99 functions in <fenv.h> should be imported in
1043               <tr1/cfenv> in namespace std::tr1.])
1044   fi
1045
1046   # Check for the existence of <stdint.h> types.
1047   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1048   AC_CACHE_VAL(ac_c99_stdint_tr1, [
1049   AC_TRY_COMPILE([#include <stdint.h>],
1050                  [typedef int8_t          my_int8_t;
1051                   typedef int16_t         my_int16_t;
1052                   typedef int32_t         my_int32_t;
1053                   typedef int64_t         my_int64_t;
1054                   typedef int_fast8_t     my_int_fast8_t;
1055                   typedef int_fast16_t    my_int_fast16_t;
1056                   typedef int_fast32_t    my_int_fast32_t;
1057                   typedef int_fast64_t    my_int_fast64_t;
1058                   typedef int_least8_t    my_int_least8_t;
1059                   typedef int_least16_t   my_int_least16_t;
1060                   typedef int_least32_t   my_int_least32_t;
1061                   typedef int_least64_t   my_int_least64_t;
1062                   typedef intmax_t        my_intmax_t;
1063                   typedef intptr_t        my_intptr_t;
1064                   typedef uint8_t         my_uint8_t;
1065                   typedef uint16_t        my_uint16_t;
1066                   typedef uint32_t        my_uint32_t;
1067                   typedef uint64_t        my_uint64_t;
1068                   typedef uint_fast8_t    my_uint_fast8_t;
1069                   typedef uint_fast16_t   my_uint_fast16_t;
1070                   typedef uint_fast32_t   my_uint_fast32_t;
1071                   typedef uint_fast64_t   my_uint_fast64_t;
1072                   typedef uint_least8_t   my_uint_least8_t;
1073                   typedef uint_least16_t  my_uint_least16_t;
1074                   typedef uint_least32_t  my_uint_least32_t;
1075                   typedef uint_least64_t  my_uint_least64_t;
1076                   typedef uintmax_t       my_uintmax_t;
1077                   typedef uintptr_t       my_uintptr_t;
1078                  ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no])
1079   ])
1080   AC_MSG_RESULT($ac_c99_stdint_tr1)
1081   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1082     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1083               [Define if C99 types in <stdint.h> should be imported in
1084               <tr1/cstdint> in namespace std::tr1.])
1085   fi
1086
1087   # Check for the existence of <math.h> functions.
1088   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1089   AC_CACHE_VAL(ac_c99_math_tr1, [
1090   AC_TRY_COMPILE([#include <math.h>],
1091                  [typedef double_t  my_double_t;
1092                   typedef float_t   my_float_t;
1093                   acosh(0.0);
1094                   acoshf(0.0f);
1095                   acoshl(0.0l);
1096                   asinh(0.0);
1097                   asinhf(0.0f);
1098                   asinhl(0.0l);
1099                   atanh(0.0);
1100                   atanhf(0.0f);
1101                   atanhl(0.0l);
1102                   cbrt(0.0);
1103                   cbrtf(0.0f);
1104                   cbrtl(0.0l);
1105                   copysign(0.0, 0.0);
1106                   copysignf(0.0f, 0.0f);
1107                   copysignl(0.0l, 0.0l);
1108                   erf(0.0);
1109                   erff(0.0f);
1110                   erfl(0.0l);
1111                   erfc(0.0);
1112                   erfcf(0.0f);
1113                   erfcl(0.0l);
1114                   exp2(0.0);
1115                   exp2f(0.0f);
1116                   exp2l(0.0l);
1117                   expm1(0.0);
1118                   expm1f(0.0f);
1119                   expm1l(0.0l);
1120                   fdim(0.0, 0.0);
1121                   fdimf(0.0f, 0.0f);
1122                   fdiml(0.0l, 0.0l);
1123                   fma(0.0, 0.0, 0.0);
1124                   fmaf(0.0f, 0.0f, 0.0f);
1125                   fmal(0.0l, 0.0l, 0.0l);
1126                   fmax(0.0, 0.0);
1127                   fmaxf(0.0f, 0.0f);
1128                   fmaxl(0.0l, 0.0l);
1129                   fmin(0.0, 0.0);
1130                   fminf(0.0f, 0.0f);
1131                   fminl(0.0l, 0.0l);
1132                   hypot(0.0, 0.0);
1133                   hypotf(0.0f, 0.0f);
1134                   hypotl(0.0l, 0.0l);
1135                   ilogb(0.0);
1136                   ilogbf(0.0f);
1137                   ilogbl(0.0l);
1138                   lgamma(0.0);
1139                   lgammaf(0.0f);
1140                   lgammal(0.0l);
1141                   llrint(0.0);
1142                   llrintf(0.0f);
1143                   llrintl(0.0l);
1144                   llround(0.0);
1145                   llroundf(0.0f);
1146                   llroundl(0.0l);
1147                   log1p(0.0);
1148                   log1pf(0.0f);
1149                   log1pl(0.0l);
1150                   log2(0.0);
1151                   log2f(0.0f);
1152                   log2l(0.0l);
1153                   logb(0.0);
1154                   logbf(0.0f);
1155                   logbl(0.0l);
1156                   lrint(0.0);
1157                   lrintf(0.0f);
1158                   lrintl(0.0l);
1159                   lround(0.0);
1160                   lroundf(0.0f);
1161                   lroundl(0.0l);
1162                   nan(0);
1163                   nanf(0);
1164                   nanl(0);
1165                   nearbyint(0.0);
1166                   nearbyintf(0.0f);
1167                   nearbyintl(0.0l);
1168                   nextafter(0.0, 0.0);
1169                   nextafterf(0.0f, 0.0f);
1170                   nextafterl(0.0l, 0.0l);
1171                   nexttoward(0.0, 0.0);
1172                   nexttowardf(0.0f, 0.0f);
1173                   nexttowardl(0.0l, 0.0l);
1174                   remainder(0.0, 0.0);
1175                   remainderf(0.0f, 0.0f);
1176                   remainderl(0.0l, 0.0l);
1177                   remquo(0.0, 0.0, 0);
1178                   remquo(0.0f, 0.0f, 0);
1179                   remquo(0.0l, 0.0l, 0);
1180                   rint(0.0);
1181                   rintf(0.0f);
1182                   rintl(0.0l);
1183                   round(0.0);
1184                   roundf(0.0f);
1185                   roundl(0.0l);
1186                   scalbln(0.0, 0l);
1187                   scalblnf(0.0f, 0l);
1188                   scalblnl(0.0l, 0l);
1189                   scalbn(0.0, 0);
1190                   scalbnf(0.0f, 0);
1191                   scalbnl(0.0l, 0);
1192                   tgamma(0.0);
1193                   tgammaf(0.0f);
1194                   tgammal(0.0l);
1195                   trunc(0.0);
1196                   truncf(0.0f);
1197                   truncl(0.0l);
1198                  ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
1199   ])
1200   AC_MSG_RESULT($ac_c99_math_tr1)
1201   if test x"$ac_c99_math_tr1" = x"yes"; then
1202     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1203               [Define if C99 functions or macros in <math.h> should be imported
1204               in <tr1/cmath> in namespace std::tr1.])
1205   fi
1206
1207   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1208   # sense if the previous check fails, per C99, 7.8/1).
1209   ac_c99_inttypes_tr1=no;
1210   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1211     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1212     AC_TRY_COMPILE([#include <inttypes.h>],
1213                    [intmax_t i, numer, denom, base;
1214                     const char* s;
1215                     char** endptr;
1216                     intmax_t ret = imaxabs(i);
1217                     imaxdiv_t dret = imaxdiv(numer, denom);
1218                     ret = strtoimax(s, endptr, base);
1219                     uintmax_t uret = strtoumax(s, endptr, base);
1220                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1221   fi
1222   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1223   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1224     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1225               [Define if C99 functions in <inttypes.h> should be imported in
1226               <tr1/cinttypes> in namespace std::tr1.])
1227   fi
1228
1229   # Check for the existence of the <stdbool.h> header.
1230   AC_CHECK_HEADERS(stdbool.h)
1231
1232   AC_LANG_RESTORE
1233 ])
1234
1235 dnl
1236 dnl Check whether "dev/random" and "dev/urandom" are available for the
1237 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1238 dnl
1239 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1240
1241   AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1242   AC_CACHE_VAL(ac_random_tr1, [
1243   AC_TRY_RUN([#include <stdio.h>
1244               int main()
1245               {
1246                 return !(fopen("/dev/random", "r")
1247                          && fopen("/dev/urandom", "r"));
1248               }
1249              ],
1250              [ac_random_tr1=yes], [ac_random_tr1=no],
1251              [ac_random_tr1=no])
1252   ])
1253   AC_MSG_RESULT($ac_random_tr1)
1254   if test x"$ac_random_tr1" = x"yes"; then
1255     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1256               [Define if dev/random and dev/urandom are available for
1257                the random_device of TR1 (Chapter 5.1).])
1258   fi
1259
1260 ])
1261
1262 dnl
1263 dnl Check for what type of C headers to use.
1264 dnl
1265 dnl --enable-cheaders= [does stuff].
1266 dnl --disable-cheaders [does not do anything, really].
1267 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1268 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1269 dnl
1270 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1271   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1272     [construct "C" headers for g++], [permit c|c_std|c_global])
1273   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1274
1275   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1276
1277   # Allow overrides to configure.host here.
1278   if test $enable_cheaders = c_global; then
1279      c_compatibility=yes
1280   fi
1281
1282   if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1283      c_extra=yes
1284   fi
1285
1286   AC_SUBST(C_INCLUDE_DIR)
1287   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1288   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1289   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1290   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1291   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1292 ])
1293
1294
1295 dnl
1296 dnl Check for which locale library to use.  The choice is mapped to
1297 dnl a subdirectory of config/locale.
1298 dnl
1299 dnl Default is generic.
1300 dnl
1301 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1302   AC_MSG_CHECKING([for C locale to use])
1303   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1304     [use MODEL for target locale package],
1305     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1306
1307   # If they didn't use this option switch, or if they specified --enable
1308   # with no specific model, we'll have to look for one.  If they
1309   # specified --disable (???), do likewise.
1310   if test $enable_clocale = no || test $enable_clocale = yes; then
1311      enable_clocale=auto
1312   fi
1313
1314   # Either a known package, or "auto"
1315   enable_clocale_flag=$enable_clocale
1316
1317   # Probe for locale support if no specific model is specified.
1318   # Default to "generic".
1319   if test $enable_clocale_flag = auto; then
1320     case ${target_os} in
1321       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1322         AC_EGREP_CPP([_GLIBCXX_ok], [
1323         #include <features.h>
1324         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1325           _GLIBCXX_ok
1326         #endif
1327         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1328
1329         # Test for bugs early in glibc-2.2.x series
1330           if test $enable_clocale_flag = gnu; then
1331           AC_TRY_RUN([
1332           #define _GNU_SOURCE 1
1333           #include <locale.h>
1334           #include <string.h>
1335           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1336           extern __typeof(newlocale) __newlocale;
1337           extern __typeof(duplocale) __duplocale;
1338           extern __typeof(strcoll_l) __strcoll_l;
1339           #endif
1340           int main()
1341           {
1342               const char __one[] = "Äuglein Augmen";
1343               const char __two[] = "Äuglein";
1344               int i;
1345               int j;
1346               __locale_t        loc;
1347                __locale_t        loc_dup;
1348               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1349               loc_dup = __duplocale(loc);
1350               i = __strcoll_l(__one, __two, loc);
1351               j = __strcoll_l(__one, __two, loc_dup);
1352               return 0;
1353           }
1354           ],
1355           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1356           [enable_clocale_flag=generic])
1357           fi
1358
1359         # ... at some point put __strxfrm_l tests in as well.
1360         ;;
1361       darwin* | freebsd*)
1362         enable_clocale_flag=darwin
1363         ;;
1364       *)
1365         enable_clocale_flag=generic
1366         ;;
1367     esac
1368   fi
1369
1370   # Deal with gettext issues.  Default to not using it (=no) until we detect
1371   # support for it later.  Let the user turn it off via --e/d, but let that
1372   # default to on for easier handling.
1373   USE_NLS=no
1374   AC_ARG_ENABLE(nls,
1375     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1376     [],
1377     [enable_nls=yes])
1378
1379   # Set configure bits for specified locale package
1380   case ${enable_clocale_flag} in
1381     generic)
1382       AC_MSG_RESULT(generic)
1383
1384       CLOCALE_H=config/locale/generic/c_locale.h
1385       CLOCALE_CC=config/locale/generic/c_locale.cc
1386       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1387       CCOLLATE_CC=config/locale/generic/collate_members.cc
1388       CCTYPE_CC=config/locale/generic/ctype_members.cc
1389       CMESSAGES_H=config/locale/generic/messages_members.h
1390       CMESSAGES_CC=config/locale/generic/messages_members.cc
1391       CMONEY_CC=config/locale/generic/monetary_members.cc
1392       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1393       CTIME_H=config/locale/generic/time_members.h
1394       CTIME_CC=config/locale/generic/time_members.cc
1395       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1396       ;;
1397     darwin)
1398       AC_MSG_RESULT(darwin or freebsd)
1399
1400       CLOCALE_H=config/locale/generic/c_locale.h
1401       CLOCALE_CC=config/locale/generic/c_locale.cc
1402       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1403       CCOLLATE_CC=config/locale/generic/collate_members.cc
1404       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1405       CMESSAGES_H=config/locale/generic/messages_members.h
1406       CMESSAGES_CC=config/locale/generic/messages_members.cc
1407       CMONEY_CC=config/locale/generic/monetary_members.cc
1408       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1409       CTIME_H=config/locale/generic/time_members.h
1410       CTIME_CC=config/locale/generic/time_members.cc
1411       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1412       ;;
1413
1414     gnu)
1415       AC_MSG_RESULT(gnu)
1416
1417       # Declare intention to use gettext, and add support for specific
1418       # languages.
1419       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1420       ALL_LINGUAS="de fr"
1421
1422       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1423       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1424       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1425         USE_NLS=yes
1426       fi
1427       # Export the build objects.
1428       for ling in $ALL_LINGUAS; do \
1429         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1430         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1431       done
1432       AC_SUBST(glibcxx_MOFILES)
1433       AC_SUBST(glibcxx_POFILES)
1434
1435       CLOCALE_H=config/locale/gnu/c_locale.h
1436       CLOCALE_CC=config/locale/gnu/c_locale.cc
1437       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1438       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1439       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1440       CMESSAGES_H=config/locale/gnu/messages_members.h
1441       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1442       CMONEY_CC=config/locale/gnu/monetary_members.cc
1443       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1444       CTIME_H=config/locale/gnu/time_members.h
1445       CTIME_CC=config/locale/gnu/time_members.cc
1446       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1447       ;;
1448     ieee_1003.1-2001)
1449       AC_MSG_RESULT(IEEE 1003.1)
1450
1451       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1452       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1453       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1454       CCOLLATE_CC=config/locale/generic/collate_members.cc
1455       CCTYPE_CC=config/locale/generic/ctype_members.cc
1456       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1457       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1458       CMONEY_CC=config/locale/generic/monetary_members.cc
1459       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1460       CTIME_H=config/locale/generic/time_members.h
1461       CTIME_CC=config/locale/generic/time_members.cc
1462       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1463       ;;
1464   esac
1465
1466   # This is where the testsuite looks for locale catalogs, using the
1467   # -DLOCALEDIR define during testsuite compilation.
1468   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1469   AC_SUBST(glibcxx_localedir)
1470
1471   # A standalone libintl (e.g., GNU libintl) may be in use.
1472   if test $USE_NLS = yes; then
1473     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1474     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1475   fi
1476   if test $USE_NLS = yes; then
1477     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1478               [Define if NLS translations are to be used.])
1479   fi
1480
1481   AC_SUBST(USE_NLS)
1482   AC_SUBST(CLOCALE_H)
1483   AC_SUBST(CMESSAGES_H)
1484   AC_SUBST(CCODECVT_CC)
1485   AC_SUBST(CCOLLATE_CC)
1486   AC_SUBST(CCTYPE_CC)
1487   AC_SUBST(CMESSAGES_CC)
1488   AC_SUBST(CMONEY_CC)
1489   AC_SUBST(CNUMERIC_CC)
1490   AC_SUBST(CTIME_H)
1491   AC_SUBST(CTIME_CC)
1492   AC_SUBST(CLOCALE_CC)
1493   AC_SUBST(CLOCALE_INTERNAL_H)
1494 ])
1495
1496
1497 dnl
1498 dnl Check for which std::allocator base class to use.  The choice is
1499 dnl mapped from a subdirectory of include/ext.
1500 dnl
1501 dnl Default is new.
1502 dnl
1503 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1504   AC_MSG_CHECKING([for std::allocator base class])
1505   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1506     [use KIND for target std::allocator base],
1507     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1508
1509   # If they didn't use this option switch, or if they specified --enable
1510   # with no specific model, we'll have to look for one.  If they
1511   # specified --disable (???), do likewise.
1512   if test $enable_libstdcxx_allocator = no ||
1513      test $enable_libstdcxx_allocator = yes;
1514   then
1515      enable_libstdcxx_allocator=auto
1516   fi
1517
1518   # Either a known package, or "auto". Auto implies the default choice
1519   # for a particular platform.
1520   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1521
1522   # Probe for host-specific support if no specific model is specified.
1523   # Default to "new".
1524   if test $enable_libstdcxx_allocator_flag = auto; then
1525     case ${target_os} in
1526       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1527         enable_libstdcxx_allocator_flag=new
1528         ;;
1529       *)
1530         enable_libstdcxx_allocator_flag=new
1531         ;;
1532     esac
1533   fi
1534   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1535
1536
1537   # Set configure bits for specified locale package
1538   case ${enable_libstdcxx_allocator_flag} in
1539     bitmap)
1540       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1541       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1542       ;;
1543     malloc)
1544       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1545       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1546       ;;
1547     mt)
1548       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1549       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1550       ;;
1551     new)
1552       ALLOCATOR_H=config/allocator/new_allocator_base.h
1553       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1554       ;;
1555     pool)
1556       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1557       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1558       ;;
1559   esac
1560
1561   AC_SUBST(ALLOCATOR_H)
1562   AC_SUBST(ALLOCATOR_NAME)
1563 ])
1564
1565
1566 dnl
1567 dnl Check for whether the Boost-derived checks should be turned on.
1568 dnl
1569 dnl --enable-concept-checks turns them on.
1570 dnl --disable-concept-checks leaves them off.
1571 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1572 dnl       Where DEFAULT is either `yes' or `no'.
1573 dnl
1574 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1575   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1576   if test $enable_concept_checks = yes; then
1577     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1578               [Define to use concept checking code from the boost libraries.])
1579   fi
1580 ])
1581
1582
1583 dnl
1584 dnl Check for which I/O library to use:  stdio, or something specific.
1585 dnl
1586 dnl Default is stdio.
1587 dnl
1588 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1589   AC_MSG_CHECKING([for underlying I/O to use])
1590   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1591     [use target-specific I/O package], [permit stdio])
1592
1593   # Now that libio has been removed, you can have any color you want as long
1594   # as it's black.  This is one big no-op until other packages are added, but
1595   # showing the framework never hurts.
1596   case ${enable_cstdio} in
1597     stdio)
1598       CSTDIO_H=config/io/c_io_stdio.h
1599       BASIC_FILE_H=config/io/basic_file_stdio.h
1600       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1601       AC_MSG_RESULT(stdio)
1602       ;;
1603   esac
1604
1605   AC_SUBST(CSTDIO_H)
1606   AC_SUBST(BASIC_FILE_H)
1607   AC_SUBST(BASIC_FILE_CC)
1608 ])
1609
1610
1611 dnl
1612 dnl Check for "unusual" flags to pass to the compiler while building.
1613 dnl
1614 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1615 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1616 dnl --disable-cxx-flags passes nothing.
1617 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1618 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1619 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1620 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1621 dnl       If "default flags" is an empty string, the effect is the same
1622 dnl       as --disable or --enable=no.
1623 dnl
1624 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1625   AC_MSG_CHECKING([for extra compiler flags for building])
1626   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1627     [pass compiler FLAGS when building library],
1628     [case "x$enable_cxx_flags" in
1629       xno | x)   enable_cxx_flags= ;;
1630       x-*)       ;;
1631       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1632      esac])
1633
1634   # Run through flags (either default or command-line) and set anything
1635   # extra (e.g., #defines) that must accompany particular g++ options.
1636   if test -n "$enable_cxx_flags"; then
1637     for f in $enable_cxx_flags; do
1638       case "$f" in
1639         -fhonor-std)  ;;
1640         -*)  ;;
1641         *)   # and we're trying to pass /what/ exactly?
1642              AC_MSG_ERROR([compiler flags start with a -]) ;;
1643       esac
1644     done
1645   fi
1646
1647   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1648   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1649   AC_SUBST(EXTRA_CXX_FLAGS)
1650 ])
1651
1652
1653 dnl
1654 dnl Check to see if debugging libraries are to be built.
1655 dnl
1656 dnl --enable-libstdcxx-debug
1657 dnl builds a separate set of debugging libraries in addition to the
1658 dnl normal (shared, static) libstdc++ binaries.
1659 dnl
1660 dnl --disable-libstdcxx-debug
1661 dnl builds only one (non-debug) version of libstdc++.
1662 dnl
1663 dnl --enable-libstdcxx-debug-flags=FLAGS
1664 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1665 dnl
1666 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1667 dnl       Where DEFAULT is either `yes' or `no'.
1668 dnl
1669 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1670   AC_MSG_CHECKING([for additional debug build])
1671   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1672   AC_MSG_RESULT($enable_libstdcxx_debug)
1673   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1674 ])
1675
1676
1677 dnl
1678 dnl Check for explicit debug flags.
1679 dnl
1680 dnl --enable-libstdcxx-debug-flags='-O1'
1681 dnl is a general method for passing flags to be used when
1682 dnl building debug libraries with --enable-debug.
1683 dnl
1684 dnl --disable-libstdcxx-debug-flags does nothing.
1685 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1686 dnl       If "default flags" is an empty string, the effect is the same
1687 dnl       as --disable or --enable=no.
1688 dnl
1689 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1690   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1691     [pass compiler FLAGS when building debug library],
1692     [case "x$enable_libstdcxx_debug_flags" in
1693       xno | x)    enable_libstdcxx_debug_flags= ;;
1694       x-*)        ;;
1695       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1696      esac])
1697
1698   # Option parsed, now set things appropriately
1699   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1700   AC_SUBST(DEBUG_FLAGS)
1701
1702   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1703 ])
1704
1705
1706 dnl
1707 dnl Check if the user only wants a freestanding library implementation.
1708 dnl
1709 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1710 dnl installing only the headers required by [17.4.1.3] and the language
1711 dnl support library.  More than that will be built (to keep the Makefiles
1712 dnl conveniently clean), but not installed.
1713 dnl
1714 dnl Sets:
1715 dnl  is_hosted  (yes/no)
1716 dnl
1717 dnl Defines:
1718 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1719 dnl
1720 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1721   AC_ARG_ENABLE([hosted-libstdcxx],
1722     AC_HELP_STRING([--disable-hosted-libstdcxx],
1723                    [only build freestanding C++ runtime support]),,
1724     [case "$host" in
1725         arm*-*-symbianelf*)
1726             enable_hosted_libstdcxx=no
1727             ;;
1728         *)
1729             enable_hosted_libstdcxx=yes
1730             ;;
1731      esac])
1732   if test "$enable_hosted_libstdcxx" = no; then
1733     AC_MSG_NOTICE([Only freestanding libraries will be built])
1734     is_hosted=no
1735     hosted_define=0
1736     enable_abi_check=no
1737     enable_libstdcxx_pch=no
1738   else
1739     is_hosted=yes
1740     hosted_define=1
1741   fi
1742   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1743   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1744     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1745 ])
1746
1747
1748 dnl
1749 dnl Check for template specializations for the 'long long' type.
1750 dnl The result determines only whether 'long long' I/O is enabled; things
1751 dnl like numeric_limits<> specializations are always available.
1752 dnl
1753 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1754 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1755 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1756 dnl       Where DEFAULT is either `yes' or `no'.
1757 dnl
1758 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1759   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1760   if test $enable_long_long = yes; then
1761     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1762               [Define if code specialized for long long should be used.])
1763   fi
1764   AC_MSG_CHECKING([for enabled long long specializations])
1765   AC_MSG_RESULT([$enable_long_long])
1766 ])
1767
1768
1769 dnl
1770 dnl Check for template specializations for the 'wchar_t' type.
1771 dnl
1772 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1773 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1774 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1775 dnl       Where DEFAULT is either `yes' or `no'.
1776 dnl
1777 dnl Necessary support must also be present.
1778 dnl
1779 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1780   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1781
1782   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
1783   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
1784   AC_MSG_CHECKING([for mbstate_t])
1785   AC_TRY_COMPILE([#include <wchar.h>],
1786   [mbstate_t teststate;],
1787   have_mbstate_t=yes, have_mbstate_t=no)
1788   AC_MSG_RESULT($have_mbstate_t)
1789   if test x"$have_mbstate_t" = xyes; then
1790     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
1791   fi
1792
1793   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
1794   # ac_has_wchar_h.
1795   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
1796
1797   if test x"$enable_wchar_t" = x"yes"; then
1798
1799     AC_LANG_SAVE
1800     AC_LANG_CPLUSPLUS
1801
1802     if test x"$ac_has_wchar_h" = xyes &&
1803        test x"$ac_has_wctype_h" = xyes; then
1804       AC_TRY_COMPILE([#include <wchar.h>
1805                       #include <stddef.h>
1806                       wint_t i;
1807                       long l = WEOF;
1808                       long j = WCHAR_MIN;
1809                       long k = WCHAR_MAX;
1810                       namespace test
1811                       {
1812                         using ::btowc;
1813                         using ::fgetwc;
1814                         using ::fgetws;
1815                         using ::fputwc;
1816                         using ::fputws;
1817                         using ::fwide;
1818                         using ::fwprintf;
1819                         using ::fwscanf;
1820                         using ::getwc;
1821                         using ::getwchar;
1822                         using ::mbrlen;
1823                         using ::mbrtowc;
1824                         using ::mbsinit;
1825                         using ::mbsrtowcs;
1826                         using ::putwc;
1827                         using ::putwchar;
1828                         using ::swprintf;
1829                         using ::swscanf;
1830                         using ::ungetwc;
1831                         using ::vfwprintf;
1832                         using ::vswprintf;
1833                         using ::vwprintf;
1834                         using ::wcrtomb;
1835                         using ::wcscat;
1836                         using ::wcschr;
1837                         using ::wcscmp;
1838                         using ::wcscoll;
1839                         using ::wcscpy;
1840                         using ::wcscspn;
1841                         using ::wcsftime;
1842                         using ::wcslen;
1843                         using ::wcsncat;
1844                         using ::wcsncmp;
1845                         using ::wcsncpy;
1846                         using ::wcspbrk;
1847                         using ::wcsrchr;
1848                         using ::wcsrtombs;
1849                         using ::wcsspn;
1850                         using ::wcsstr;
1851                         using ::wcstod;
1852                         using ::wcstok;
1853                         using ::wcstol;
1854                         using ::wcstoul;
1855                         using ::wcsxfrm;
1856                         using ::wctob;
1857                         using ::wmemchr;
1858                         using ::wmemcmp;
1859                         using ::wmemcpy;
1860                         using ::wmemmove;
1861                         using ::wmemset;
1862                         using ::wprintf;
1863                         using ::wscanf;
1864                       }
1865                      ],[],[], [enable_wchar_t=no])
1866     else
1867       enable_wchar_t=no
1868     fi
1869
1870     AC_LANG_RESTORE
1871   fi
1872
1873   if test x"$enable_wchar_t" = x"yes"; then
1874     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
1875               [Define if code specialized for wchar_t should be used.])
1876   fi
1877
1878   AC_MSG_CHECKING([for enabled wchar_t specializations])
1879   AC_MSG_RESULT([$enable_wchar_t])
1880 ])
1881
1882
1883 dnl
1884 dnl Check to see if building and using a C++ precompiled header can be done.
1885 dnl
1886 dnl --enable-libstdcxx-pch=yes
1887 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1888 dnl may work, after some light-hearted attempts to puzzle out compiler
1889 dnl support, flip bits on in include/Makefile.am
1890 dnl
1891 dnl --disable-libstdcxx-pch
1892 dnl turns off attempts to use or build stdc++.h.gch.
1893 dnl
1894 dnl Substs:
1895 dnl  glibcxx_PCHFLAGS
1896 dnl
1897 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1898   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1899   if test $enable_libstdcxx_pch = yes; then
1900     AC_CACHE_CHECK([for compiler with PCH support],
1901       [glibcxx_cv_prog_CXX_pch],
1902       [ac_save_CXXFLAGS="$CXXFLAGS"
1903        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1904        AC_LANG_SAVE
1905        AC_LANG_CPLUSPLUS
1906        echo '#include <math.h>' > conftest.h
1907        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1908                           -o conftest.h.gch 1>&5 2>&1 &&
1909                 echo '#error "pch failed"' > conftest.h &&
1910           echo '#include "conftest.h"' > conftest.cc &&
1911                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1912        then
1913          glibcxx_cv_prog_CXX_pch=yes
1914        else
1915          glibcxx_cv_prog_CXX_pch=no
1916        fi
1917        rm -f conftest*
1918        CXXFLAGS=$ac_save_CXXFLAGS
1919        AC_LANG_RESTORE
1920       ])
1921     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1922   fi
1923
1924   AC_MSG_CHECKING([for enabled PCH])
1925   AC_MSG_RESULT([$enable_libstdcxx_pch])
1926
1927   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1928   if test $enable_libstdcxx_pch = yes; then
1929     glibcxx_PCHFLAGS="-include bits/stdtr1c++.h"
1930   else
1931     glibcxx_PCHFLAGS=""
1932   fi
1933   AC_SUBST(glibcxx_PCHFLAGS)
1934 ])
1935
1936
1937 dnl
1938 dnl Check for atomic builtins.
1939 dnl See:
1940 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
1941 dnl
1942 dnl This checks to see if the host supports the compiler-generated
1943 dnl builtins for atomic operations. Note, this is intended to be an
1944 dnl all-or-nothing switch, so all the atomic operations that are used
1945 dnl should be checked.
1946 dnl
1947 dnl Note:
1948 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
1949 dnl see: CHECK_SYNC_FETCH_AND_ADD
1950 dnl
1951 dnl Defines:
1952 dnl  _GLIBCXX_ATOMIC_BUILTINS if the compiler on this target supports atomics.
1953 dnl
1954 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
1955   AC_MSG_CHECKING([for atomic builtins])
1956   AC_LANG_SAVE
1957   AC_LANG_CPLUSPLUS
1958
1959   # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
1960     cat > conftest.$ac_ext << EOF
1961 [#]line __oline__ "configure"
1962 int main()
1963 {
1964   // NB: _Atomic_word not necessarily int.
1965   typedef int atomic_type;
1966   atomic_type c1;
1967   atomic_type c2;
1968   const atomic_type c3(0);
1969   if (__sync_fetch_and_add(&c1, c2) == c3)
1970     {
1971       // Do something.
1972     }
1973    return 0;
1974 }
1975 EOF
1976     old_CXXFLAGS="$CXXFLAGS"
1977     CXXFLAGS=-S
1978     if AC_TRY_EVAL(ac_compile); then
1979       if grep __sync_fetch_and_add conftest.s >/dev/null 2>&1 ; then
1980         enable_atomic_builtins=no
1981       else
1982       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
1983         [Define if builtin atomic operations are supported on this host.])
1984         enable_atomic_builtins=yes
1985         atomicity_dir=cpu/generic/atomicity_builtins
1986       fi
1987     fi
1988     CXXFLAGS="$old_CXXFLAGS"
1989     rm -f conftest*
1990
1991    # Now, if still generic, set to mutex.
1992   if test $atomicity_dir = "cpu/generic" ; then
1993         atomicity_dir=cpu/generic/atomicity_mutex
1994   fi
1995  AC_LANG_RESTORE
1996  AC_MSG_RESULT($enable_atomic_builtins)
1997 ])
1998
1999
2000 dnl
2001 dnl Check for exception handling support.  If an explicit enable/disable
2002 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2003 dnl target may or may not support call frame exceptions.
2004 dnl
2005 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2006 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2007 dnl Neither one forces an attempt at detection.
2008 dnl
2009 dnl Defines:
2010 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2011 dnl
2012 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2013   AC_MSG_CHECKING([for exception model to use])
2014   AC_LANG_SAVE
2015   AC_LANG_CPLUSPLUS
2016   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2017     [force use of builtin_setjmp for exceptions],
2018     [permit yes|no|auto])
2019
2020   if test $enable_sjlj_exceptions = auto; then
2021     # Botheration.  Now we've got to detect the exception model.  Link tests
2022     # against libgcc.a are problematic since we've not been given proper -L
2023     # bits for single-tree newlib and libgloss.
2024     #
2025     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2026     cat > conftest.$ac_ext << EOF
2027 [#]line __oline__ "configure"
2028 struct S { ~S(); };
2029 void bar();
2030 void foo()
2031 {
2032   S s;
2033   bar();
2034 }
2035 EOF
2036     old_CXXFLAGS="$CXXFLAGS"
2037     CXXFLAGS=-S
2038     if AC_TRY_EVAL(ac_compile); then
2039       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2040         enable_sjlj_exceptions=yes
2041       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2042         enable_sjlj_exceptions=no
2043       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2044         enable_sjlj_exceptions=no
2045       fi
2046     fi
2047     CXXFLAGS="$old_CXXFLAGS"
2048     rm -f conftest*
2049   fi
2050
2051   # This is a tad weird, for hysterical raisins.  We have to map
2052   # enable/disable to two different models.
2053   case $enable_sjlj_exceptions in
2054     yes)
2055       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2056         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2057       ac_exception_model_name=sjlj
2058       ;;
2059     no)
2060       ac_exception_model_name="call frame"
2061       ;;
2062     *)
2063       AC_MSG_ERROR([unable to detect exception model])
2064       ;;
2065   esac
2066  AC_LANG_RESTORE
2067  AC_MSG_RESULT($ac_exception_model_name)
2068 ])
2069
2070
2071 dnl
2072 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2073 dnl
2074 dnl --enable-visibility enables attempt to use visibility attributes.
2075 dnl --disable-visibility turns off all use of visibility attributes.
2076 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2077 dnl       Where DEFAULT is 'yes'.
2078 dnl
2079 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2080 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2081
2082 if test x$enable_visibility = xyes ; then
2083   dnl all hail libgfortran
2084   dnl Check whether the target supports hidden visibility.
2085   AC_CACHE_CHECK([whether the target supports hidden visibility],
2086                  have_attribute_visibility, [
2087   save_CFLAGS="$CFLAGS"
2088   CFLAGS="$CFLAGS -Werror"
2089   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2090                  [], have_attribute_visibility=yes,
2091                  have_attribute_visibility=no)
2092   CFLAGS="$save_CFLAGS"])
2093   if test $have_attribute_visibility = no; then
2094     enable_visibility=no
2095   fi
2096 fi
2097
2098 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2099 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2100 ])
2101
2102
2103 dnl
2104 dnl Add version tags to symbols in shared library (or not), additionally
2105 dnl marking other symbols as private/local (or not).
2106 dnl
2107 dnl --enable-symvers=style adds a version script to the linker call when
2108 dnl       creating the shared library.  The choice of version script is
2109 dnl       controlled by 'style'.
2110 dnl --disable-symvers does not.
2111 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2112 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2113 dnl       choose a default style based on linker characteristics.  Passing
2114 dnl       'no' disables versioning.
2115 dnl
2116 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2117
2118 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2119   [enables symbol versioning of the shared library],
2120   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2121
2122 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2123 # don't know enough about $LD to do tricks...
2124 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2125
2126 # Turn a 'yes' into a suitable default.
2127 if test x$enable_symvers = xyes ; then
2128   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2129     enable_symvers=no
2130   else
2131     if test $with_gnu_ld = yes ; then
2132       enable_symvers=gnu
2133     else
2134       case ${target_os} in
2135         darwin*)
2136           enable_symvers=darwin ;;
2137         *)
2138           enable_symvers=no ;;
2139       esac
2140     fi
2141   fi
2142 fi
2143
2144 # Check to see if 'darwin' or 'darwin-export' can win.
2145 if test x$enable_symvers = xdarwin-export ; then
2146     enable_symvers=darwin
2147 fi
2148
2149 # Check to see if 'gnu' can win.
2150 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2151   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2152   AC_MSG_CHECKING([for shared libgcc])
2153   ac_save_CFLAGS="$CFLAGS"
2154   CFLAGS=' -lgcc_s'
2155   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2156   CFLAGS="$ac_save_CFLAGS"
2157   if test $glibcxx_shared_libgcc = no; then
2158     cat > conftest.c <<EOF
2159 int main (void) { return 0; }
2160 EOF
2161 changequote(,)dnl
2162     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2163                              -shared -shared-libgcc -o conftest.so \
2164                              conftest.c -v 2>&1 >/dev/null \
2165                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2166 changequote([,])dnl
2167     rm -f conftest.c conftest.so
2168     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2169       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2170       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2171       CFLAGS="$ac_save_CFLAGS"
2172     fi
2173   fi
2174   AC_MSG_RESULT($glibcxx_shared_libgcc)
2175
2176   # For GNU ld, we need at least this version.  The format is described in
2177   # GLIBCXX_CHECK_LINKER_FEATURES above.
2178   glibcxx_min_gnu_ld_version=21400
2179
2180   # If no shared libgcc, can't win.
2181   if test $glibcxx_shared_libgcc != yes; then
2182       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2183       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2184       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2185       enable_symvers=no
2186   elif test $with_gnu_ld != yes ; then
2187     # just fail for now
2188     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2189     AC_MSG_WARN([=== you are not using the GNU linker.])
2190     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2191     enable_symvers=no
2192   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2193     # The right tools, the right setup, but too old.  Fallbacks?
2194     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2195     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2196     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2197     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2198     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2199     enable_symvers=no
2200   fi
2201 fi
2202
2203 # Everything parsed; figure out what file to use.
2204 case $enable_symvers in
2205   no)
2206     SYMVER_FILE=config/abi/pre/none.ver
2207     ;;
2208   gnu)
2209     SYMVER_FILE=config/abi/pre/gnu.ver
2210     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2211               [Define to use GNU versioning in the shared library.])
2212     ;;
2213   gnu-versioned-namespace)
2214     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2215     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2216               [Define to use GNU namespace versioning in the shared library.])
2217     ;;
2218   darwin)
2219     SYMVER_FILE=config/abi/pre/gnu.ver
2220     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2221               [Define to use darwin versioning in the shared library.])
2222     ;;
2223 esac
2224
2225 if test x$enable_symvers != xno ; then
2226   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2227          [Define to use symbol versioning in the shared library.])
2228 fi
2229
2230 AC_SUBST(SYMVER_FILE)
2231 AC_SUBST(port_specific_symbol_files)
2232 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2233 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2234 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2235 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2236 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2237
2238 # Now, set up compatibility support, if any.
2239 # In addition, need this to deal with std::size_t mangling in
2240 # src/compatibility.cc.  In a perfect world, could use
2241 # typeid(std::size_t).name()[0] to do direct substitution.
2242 AC_MSG_CHECKING([for size_t as unsigned int])
2243 ac_save_CFLAGS="$CFLAGS"
2244 CFLAGS="-Werror"
2245 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2246                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2247 CFLAGS=$ac_save_CFLAGS
2248 if test "$glibcxx_size_t_is_i" = yes; then
2249   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2250 fi
2251 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2252
2253 AC_MSG_CHECKING([for ptrdiff_t as int])
2254 ac_save_CFLAGS="$CFLAGS"
2255 CFLAGS="-Werror"
2256 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2257                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2258 CFLAGS=$ac_save_CFLAGS
2259 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2260   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2261 fi
2262 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2263 ])
2264
2265
2266 dnl
2267 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2268 dnl We must stage the required headers so that they will be installed
2269 dnl with the library (unlike libgcc, the STL implementation is provided
2270 dnl solely within headers).  Since we must not inject random user-space
2271 dnl macro names into user-provided C++ code, we first stage into <file>-in
2272 dnl and process to <file> with an output command.  The reason for a two-
2273 dnl stage process here is to correctly handle $srcdir!=$objdir without
2274 dnl having to write complex code (the sed commands to clean the macro
2275 dnl namespace are complex and fragile enough as it is).  We must also
2276 dnl add a relative path so that -I- is supported properly.
2277 dnl
2278 dnl Substs:
2279 dnl  glibcxx_thread_h
2280 dnl
2281 dnl Defines:
2282 dnl  HAVE_GTHR_DEFAULT
2283 dnl
2284 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2285   AC_MSG_CHECKING([for thread model used by GCC])
2286   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2287   AC_MSG_RESULT([$target_thread_file])
2288
2289   if test $target_thread_file != single; then
2290     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2291               [Define if gthr-default.h exists
2292               (meaning that threading support is enabled).])
2293   fi
2294
2295   glibcxx_thread_h=gthr-$target_thread_file.h
2296
2297   dnl Check for __GTHREADS define.
2298   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2299   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2300     enable_thread=yes
2301   else
2302    enable_thread=no
2303   fi
2304
2305   AC_SUBST(glibcxx_thread_h)
2306 ])
2307
2308
2309 # Check whether LC_MESSAGES is available in <locale.h>.
2310 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2311 #
2312 # This file file be copied and used freely without restrictions.  It can
2313 # be used in projects which are not available under the GNU Public License
2314 # but which still want to provide support for the GNU gettext functionality.
2315 # Please note that the actual code is *not* freely available.
2316
2317 # serial 1
2318 AC_DEFUN([AC_LC_MESSAGES], [
2319   AC_CHECK_HEADER(locale.h, [
2320     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2321       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2322        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2323     if test $ac_cv_val_LC_MESSAGES = yes; then
2324       AC_DEFINE(HAVE_LC_MESSAGES, 1,
2325                 [Define if LC_MESSAGES is available in <locale.h>.])
2326     fi
2327   ])
2328 ])
2329
2330 # Macros from the top-level gcc directory.
2331 m4_include([../config/tls.m4])
2332