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