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