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                  [acosh(0.0);
1198                   acoshf(0.0f);
1199                   acoshl(0.0l);
1200                   asinh(0.0);
1201                   asinhf(0.0f);
1202                   asinhl(0.0l);
1203                   atanh(0.0);
1204                   atanhf(0.0f);
1205                   atanhl(0.0l);
1206                   cbrt(0.0);
1207                   cbrtf(0.0f);
1208                   cbrtl(0.0l);
1209                   copysign(0.0, 0.0);
1210                   copysignf(0.0f, 0.0f);
1211                   copysignl(0.0l, 0.0l);
1212                   erf(0.0);
1213                   erff(0.0f);
1214                   erfl(0.0l);
1215                   erfc(0.0);
1216                   erfcf(0.0f);
1217                   erfcl(0.0l);
1218                   exp2(0.0);
1219                   exp2f(0.0f);
1220                   exp2l(0.0l);
1221                   expm1(0.0);
1222                   expm1f(0.0f);
1223                   expm1l(0.0l);
1224                   fdim(0.0, 0.0);
1225                   fdimf(0.0f, 0.0f);
1226                   fdiml(0.0l, 0.0l);
1227                   fma(0.0, 0.0, 0.0);
1228                   fmaf(0.0f, 0.0f, 0.0f);
1229                   fmal(0.0l, 0.0l, 0.0l);
1230                   fmax(0.0, 0.0);
1231                   fmaxf(0.0f, 0.0f);
1232                   fmaxl(0.0l, 0.0l);
1233                   fmin(0.0, 0.0);
1234                   fminf(0.0f, 0.0f);
1235                   fminl(0.0l, 0.0l);
1236                   hypot(0.0, 0.0);
1237                   hypotf(0.0f, 0.0f);
1238                   hypotl(0.0l, 0.0l);
1239                   ilogb(0.0);
1240                   ilogbf(0.0f);
1241                   ilogbl(0.0l);
1242                   lgamma(0.0);
1243                   lgammaf(0.0f);
1244                   lgammal(0.0l);
1245                   llrint(0.0);
1246                   llrintf(0.0f);
1247                   llrintl(0.0l);
1248                   llround(0.0);
1249                   llroundf(0.0f);
1250                   llroundl(0.0l);
1251                   log1p(0.0);
1252                   log1pf(0.0f);
1253                   log1pl(0.0l);
1254                   log2(0.0);
1255                   log2f(0.0f);
1256                   log2l(0.0l);
1257                   logb(0.0);
1258                   logbf(0.0f);
1259                   logbl(0.0l);
1260                   lrint(0.0);
1261                   lrintf(0.0f);
1262                   lrintl(0.0l);
1263                   lround(0.0);
1264                   lroundf(0.0f);
1265                   lroundl(0.0l);
1266                   nan(0);
1267                   nanf(0);
1268                   nanl(0);
1269                   nearbyint(0.0);
1270                   nearbyintf(0.0f);
1271                   nearbyintl(0.0l);
1272                   nextafter(0.0, 0.0);
1273                   nextafterf(0.0f, 0.0f);
1274                   nextafterl(0.0l, 0.0l);
1275                   nexttoward(0.0, 0.0);
1276                   nexttowardf(0.0f, 0.0f);
1277                   nexttowardl(0.0l, 0.0l);
1278                   remainder(0.0, 0.0);
1279                   remainderf(0.0f, 0.0f);
1280                   remainderl(0.0l, 0.0l);
1281                   remquo(0.0, 0.0, 0);
1282                   remquo(0.0f, 0.0f, 0);
1283                   remquo(0.0l, 0.0l, 0);
1284                   rint(0.0);
1285                   rintf(0.0f);
1286                   rintl(0.0l);
1287                   round(0.0);
1288                   roundf(0.0f);
1289                   roundl(0.0l);
1290                   scalbln(0.0, 0l);
1291                   scalblnf(0.0f, 0l);
1292                   scalblnl(0.0l, 0l);
1293                   scalbn(0.0, 0);
1294                   scalbnf(0.0f, 0);
1295                   scalbnl(0.0l, 0);
1296                   tgamma(0.0);
1297                   tgammaf(0.0f);
1298                   tgammal(0.0l);
1299                   trunc(0.0);
1300                   truncf(0.0f);
1301                   truncl(0.0l);
1302                  ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
1303   ])
1304   AC_MSG_RESULT($ac_c99_math_tr1)
1305   if test x"$ac_c99_math_tr1" = x"yes"; then
1306     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1307               [Define if C99 functions or macros in <math.h> should be imported
1308               in <tr1/cmath> in namespace std::tr1.])
1309   fi
1310
1311   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1312   # sense if the previous check fails, per C99, 7.8/1).
1313   ac_c99_inttypes_tr1=no;
1314   if test x"$ac_c99_stdint_tr1" = x"yes"; then
1315     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1316     AC_TRY_COMPILE([#include <inttypes.h>],
1317                    [intmax_t i, numer, denom, base;
1318                     const char* s;
1319                     char** endptr;
1320                     intmax_t ret = imaxabs(i);
1321                     imaxdiv_t dret = imaxdiv(numer, denom);
1322                     ret = strtoimax(s, endptr, base);
1323                     uintmax_t uret = strtoumax(s, endptr, base);
1324                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1325   fi
1326   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1327   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1328     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1329               [Define if C99 functions in <inttypes.h> should be imported in
1330               <tr1/cinttypes> in namespace std::tr1.])
1331   fi
1332
1333   AC_LANG_RESTORE
1334 ])
1335
1336
1337 dnl
1338 dnl Check for what type of C headers to use.
1339 dnl
1340 dnl --enable-cheaders= [does stuff].
1341 dnl --disable-cheaders [does not do anything, really].
1342 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1343 dnl       Where DEFAULT is either `c' or `c_std'.
1344 dnl
1345 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1346   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1347     [construct "C" headers for g++], [permit c|c_std])
1348   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1349
1350   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1351
1352   AC_SUBST(C_INCLUDE_DIR)
1353   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1354   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1355   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1356 ])
1357
1358
1359 dnl
1360 dnl Check for which locale library to use.  The choice is mapped to
1361 dnl a subdirectory of config/locale.
1362 dnl
1363 dnl Default is generic.
1364 dnl
1365 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1366   AC_MSG_CHECKING([for C locale to use])
1367   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1368     [use MODEL for target locale package],
1369     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1370
1371   # If they didn't use this option switch, or if they specified --enable
1372   # with no specific model, we'll have to look for one.  If they
1373   # specified --disable (???), do likewise.
1374   if test $enable_clocale = no || test $enable_clocale = yes; then
1375      enable_clocale=auto
1376   fi
1377
1378   # Either a known package, or "auto"
1379   enable_clocale_flag=$enable_clocale
1380
1381   # Probe for locale support if no specific model is specified.
1382   # Default to "generic".
1383   if test $enable_clocale_flag = auto; then
1384     case ${target_os} in
1385       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1386         AC_EGREP_CPP([_GLIBCXX_ok], [
1387         #include <features.h>
1388         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1389           _GLIBCXX_ok
1390         #endif
1391         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1392
1393         # Test for bugs early in glibc-2.2.x series
1394           if test $enable_clocale_flag = gnu; then
1395           AC_TRY_RUN([
1396           #define _GNU_SOURCE 1
1397           #include <locale.h>
1398           #include <string.h>
1399           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1400           extern __typeof(newlocale) __newlocale;
1401           extern __typeof(duplocale) __duplocale;
1402           extern __typeof(strcoll_l) __strcoll_l;
1403           #endif
1404           int main()
1405           {
1406               const char __one[] = "Äuglein Augmen";
1407               const char __two[] = "Äuglein";
1408               int i;
1409               int j;
1410               __locale_t        loc;
1411                __locale_t        loc_dup;
1412               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1413               loc_dup = __duplocale(loc);
1414               i = __strcoll_l(__one, __two, loc);
1415               j = __strcoll_l(__one, __two, loc_dup);
1416               return 0;
1417           }
1418           ],
1419           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1420           [enable_clocale_flag=generic])
1421           fi
1422
1423         # ... at some point put __strxfrm_l tests in as well.
1424         ;;
1425       darwin* | freebsd*)
1426         enable_clocale_flag=darwin
1427         ;;
1428       *)
1429         enable_clocale_flag=generic
1430         ;;
1431     esac
1432   fi
1433
1434   # Deal with gettext issues.  Default to not using it (=no) until we detect
1435   # support for it later.  Let the user turn it off via --e/d, but let that
1436   # default to on for easier handling.
1437   USE_NLS=no
1438   AC_ARG_ENABLE(nls,
1439     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1440     [],
1441     [enable_nls=yes])
1442
1443   # Set configure bits for specified locale package
1444   case ${enable_clocale_flag} in
1445     generic)
1446       AC_MSG_RESULT(generic)
1447
1448       CLOCALE_H=config/locale/generic/c_locale.h
1449       CLOCALE_CC=config/locale/generic/c_locale.cc
1450       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1451       CCOLLATE_CC=config/locale/generic/collate_members.cc
1452       CCTYPE_CC=config/locale/generic/ctype_members.cc
1453       CMESSAGES_H=config/locale/generic/messages_members.h
1454       CMESSAGES_CC=config/locale/generic/messages_members.cc
1455       CMONEY_CC=config/locale/generic/monetary_members.cc
1456       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1457       CTIME_H=config/locale/generic/time_members.h
1458       CTIME_CC=config/locale/generic/time_members.cc
1459       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1460       ;;
1461     darwin)
1462       AC_MSG_RESULT(darwin or freebsd)
1463
1464       CLOCALE_H=config/locale/generic/c_locale.h
1465       CLOCALE_CC=config/locale/generic/c_locale.cc
1466       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1467       CCOLLATE_CC=config/locale/generic/collate_members.cc
1468       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1469       CMESSAGES_H=config/locale/generic/messages_members.h
1470       CMESSAGES_CC=config/locale/generic/messages_members.cc
1471       CMONEY_CC=config/locale/generic/monetary_members.cc
1472       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1473       CTIME_H=config/locale/generic/time_members.h
1474       CTIME_CC=config/locale/generic/time_members.cc
1475       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1476       ;;
1477
1478     gnu)
1479       AC_MSG_RESULT(gnu)
1480
1481       # Declare intention to use gettext, and add support for specific
1482       # languages.
1483       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1484       ALL_LINGUAS="de fr"
1485
1486       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1487       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1488       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1489         USE_NLS=yes
1490       fi
1491       # Export the build objects.
1492       for ling in $ALL_LINGUAS; do \
1493         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1494         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1495       done
1496       AC_SUBST(glibcxx_MOFILES)
1497       AC_SUBST(glibcxx_POFILES)
1498
1499       CLOCALE_H=config/locale/gnu/c_locale.h
1500       CLOCALE_CC=config/locale/gnu/c_locale.cc
1501       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1502       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1503       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1504       CMESSAGES_H=config/locale/gnu/messages_members.h
1505       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1506       CMONEY_CC=config/locale/gnu/monetary_members.cc
1507       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1508       CTIME_H=config/locale/gnu/time_members.h
1509       CTIME_CC=config/locale/gnu/time_members.cc
1510       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1511       ;;
1512     ieee_1003.1-2001)
1513       AC_MSG_RESULT(IEEE 1003.1)
1514
1515       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1516       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1517       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1518       CCOLLATE_CC=config/locale/generic/collate_members.cc
1519       CCTYPE_CC=config/locale/generic/ctype_members.cc
1520       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1521       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1522       CMONEY_CC=config/locale/generic/monetary_members.cc
1523       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1524       CTIME_H=config/locale/generic/time_members.h
1525       CTIME_CC=config/locale/generic/time_members.cc
1526       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1527       ;;
1528   esac
1529
1530   # This is where the testsuite looks for locale catalogs, using the
1531   # -DLOCALEDIR define during testsuite compilation.
1532   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1533   AC_SUBST(glibcxx_localedir)
1534
1535   # A standalone libintl (e.g., GNU libintl) may be in use.
1536   if test $USE_NLS = yes; then
1537     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1538     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1539   fi
1540   if test $USE_NLS = yes; then
1541     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1542               [Define if NLS translations are to be used.])
1543   fi
1544
1545   AC_SUBST(USE_NLS)
1546   AC_SUBST(CLOCALE_H)
1547   AC_SUBST(CMESSAGES_H)
1548   AC_SUBST(CCODECVT_CC)
1549   AC_SUBST(CCOLLATE_CC)
1550   AC_SUBST(CCTYPE_CC)
1551   AC_SUBST(CMESSAGES_CC)
1552   AC_SUBST(CMONEY_CC)
1553   AC_SUBST(CNUMERIC_CC)
1554   AC_SUBST(CTIME_H)
1555   AC_SUBST(CTIME_CC)
1556   AC_SUBST(CLOCALE_CC)
1557   AC_SUBST(CLOCALE_INTERNAL_H)
1558 ])
1559
1560
1561 dnl
1562 dnl Check for which std::allocator base class to use.  The choice is
1563 dnl mapped from a subdirectory of include/ext.
1564 dnl
1565 dnl Default is new.
1566 dnl
1567 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1568   AC_MSG_CHECKING([for std::allocator base class])
1569   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1570     [use KIND for target std::allocator base],
1571     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1572
1573   # If they didn't use this option switch, or if they specified --enable
1574   # with no specific model, we'll have to look for one.  If they
1575   # specified --disable (???), do likewise.
1576   if test $enable_libstdcxx_allocator = no ||
1577      test $enable_libstdcxx_allocator = yes;
1578   then
1579      enable_libstdcxx_allocator=auto
1580   fi
1581
1582   # Either a known package, or "auto". Auto implies the default choice
1583   # for a particular platform.
1584   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1585
1586   # Probe for host-specific support if no specific model is specified.
1587   # Default to "new".
1588   if test $enable_libstdcxx_allocator_flag = auto; then
1589     case ${target_os} in
1590       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1591         enable_libstdcxx_allocator_flag=new
1592         ;;
1593       *)
1594         enable_libstdcxx_allocator_flag=new
1595         ;;
1596     esac
1597   fi
1598   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1599
1600
1601   # Set configure bits for specified locale package
1602   case ${enable_libstdcxx_allocator_flag} in
1603     bitmap)
1604       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1605       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1606       ;;
1607     malloc)
1608       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1609       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1610       ;;
1611     mt)
1612       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1613       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1614       ;;
1615     new)
1616       ALLOCATOR_H=config/allocator/new_allocator_base.h
1617       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1618       ;;
1619     pool)
1620       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1621       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1622       ;;
1623   esac
1624
1625   AC_SUBST(ALLOCATOR_H)
1626   AC_SUBST(ALLOCATOR_NAME)
1627 ])
1628
1629
1630 dnl
1631 dnl Check for whether the Boost-derived checks should be turned on.
1632 dnl
1633 dnl --enable-concept-checks turns them on.
1634 dnl --disable-concept-checks leaves them off.
1635 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1636 dnl       Where DEFAULT is either `yes' or `no'.
1637 dnl
1638 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1639   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1640   if test $enable_concept_checks = yes; then
1641     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1642               [Define to use concept checking code from the boost libraries.])
1643   fi
1644 ])
1645
1646
1647 dnl
1648 dnl Check for which I/O library to use:  stdio, or something specific.
1649 dnl
1650 dnl Default is stdio.
1651 dnl
1652 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1653   AC_MSG_CHECKING([for underlying I/O to use])
1654   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1655     [use target-specific I/O package], [permit stdio])
1656
1657   # Now that libio has been removed, you can have any color you want as long
1658   # as it's black.  This is one big no-op until other packages are added, but
1659   # showing the framework never hurts.
1660   case ${enable_cstdio} in
1661     stdio)
1662       CSTDIO_H=config/io/c_io_stdio.h
1663       BASIC_FILE_H=config/io/basic_file_stdio.h
1664       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1665       AC_MSG_RESULT(stdio)
1666       ;;
1667   esac
1668
1669   AC_SUBST(CSTDIO_H)
1670   AC_SUBST(BASIC_FILE_H)
1671   AC_SUBST(BASIC_FILE_CC)
1672 ])
1673
1674
1675 dnl
1676 dnl Check for "unusual" flags to pass to the compiler while building.
1677 dnl
1678 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1679 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1680 dnl --disable-cxx-flags passes nothing.
1681 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1682 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1683 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1684 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1685 dnl       If "default flags" is an empty string, the effect is the same
1686 dnl       as --disable or --enable=no.
1687 dnl
1688 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1689   AC_MSG_CHECKING([for extra compiler flags for building])
1690   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1691     [pass compiler FLAGS when building library],
1692     [case "x$enable_cxx_flags" in
1693       xno | x)   enable_cxx_flags= ;;
1694       x-*)       ;;
1695       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1696      esac])
1697
1698   # Run through flags (either default or command-line) and set anything
1699   # extra (e.g., #defines) that must accompany particular g++ options.
1700   if test -n "$enable_cxx_flags"; then
1701     for f in $enable_cxx_flags; do
1702       case "$f" in
1703         -fhonor-std)  ;;
1704         -*)  ;;
1705         *)   # and we're trying to pass /what/ exactly?
1706              AC_MSG_ERROR([compiler flags start with a -]) ;;
1707       esac
1708     done
1709   fi
1710
1711   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1712   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1713   AC_SUBST(EXTRA_CXX_FLAGS)
1714 ])
1715
1716
1717 dnl
1718 dnl Check to see if debugging libraries are to be built.
1719 dnl
1720 dnl --enable-libstdcxx-debug
1721 dnl builds a separate set of debugging libraries in addition to the
1722 dnl normal (shared, static) libstdc++ binaries.
1723 dnl
1724 dnl --disable-libstdcxx-debug
1725 dnl builds only one (non-debug) version of libstdc++.
1726 dnl
1727 dnl --enable-libstdcxx-debug-flags=FLAGS
1728 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1729 dnl
1730 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1731 dnl       Where DEFAULT is either `yes' or `no'.
1732 dnl
1733 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1734   AC_MSG_CHECKING([for additional debug build])
1735   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1736   AC_MSG_RESULT($enable_libstdcxx_debug)
1737   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1738 ])
1739
1740
1741 dnl
1742 dnl Check for explicit debug flags.
1743 dnl
1744 dnl --enable-libstdcxx-debug-flags='-O1'
1745 dnl is a general method for passing flags to be used when
1746 dnl building debug libraries with --enable-debug.
1747 dnl
1748 dnl --disable-libstdcxx-debug-flags does nothing.
1749 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1750 dnl       If "default flags" is an empty string, the effect is the same
1751 dnl       as --disable or --enable=no.
1752 dnl
1753 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1754   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1755     [pass compiler FLAGS when building debug library],
1756     [case "x$enable_libstdcxx_debug_flags" in
1757       xno | x)    enable_libstdcxx_debug_flags= ;;
1758       x-*)        ;;
1759       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1760      esac])
1761
1762   # Option parsed, now set things appropriately
1763   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1764   AC_SUBST(DEBUG_FLAGS)
1765
1766   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1767 ])
1768
1769
1770 dnl
1771 dnl Check if the user only wants a freestanding library implementation.
1772 dnl
1773 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1774 dnl installing only the headers required by [17.4.1.3] and the language
1775 dnl support library.  More than that will be built (to keep the Makefiles
1776 dnl conveniently clean), but not installed.
1777 dnl
1778 dnl Sets:
1779 dnl  is_hosted  (yes/no)
1780 dnl
1781 dnl Defines:
1782 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1783 dnl
1784 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1785   AC_ARG_ENABLE([hosted-libstdcxx],
1786     AC_HELP_STRING([--disable-hosted-libstdcxx],
1787                    [only build freestanding C++ runtime support]),,
1788     [case "$host" in
1789         arm*-*-symbianelf*)
1790             enable_hosted_libstdcxx=no
1791             ;;
1792         *)
1793             enable_hosted_libstdcxx=yes
1794             ;;
1795      esac])
1796   if test "$enable_hosted_libstdcxx" = no; then
1797     AC_MSG_NOTICE([Only freestanding libraries will be built])
1798     is_hosted=no
1799     hosted_define=0
1800     enable_abi_check=no
1801     enable_libstdcxx_pch=no
1802   else
1803     is_hosted=yes
1804     hosted_define=1
1805   fi
1806   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1807   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1808     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1809 ])
1810
1811
1812 dnl
1813 dnl Check for template specializations for the 'long long' type.
1814 dnl The result determines only whether 'long long' I/O is enabled; things
1815 dnl like numeric_limits<> specializations are always available.
1816 dnl
1817 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1818 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1819 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1820 dnl       Where DEFAULT is either `yes' or `no'.
1821 dnl
1822 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1823   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1824   if test $enable_long_long = yes; then
1825     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1826               [Define if code specialized for long long should be used.])
1827   fi
1828   AC_MSG_CHECKING([for enabled long long specializations])
1829   AC_MSG_RESULT([$enable_long_long])
1830 ])
1831
1832
1833 dnl
1834 dnl Check for template specializations for the 'wchar_t' type.
1835 dnl
1836 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1837 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1838 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1839 dnl       Where DEFAULT is either `yes' or `no'.
1840 dnl
1841 dnl Necessary support (probed along with C99 support) must also be present.
1842 dnl
1843 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1844   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1845   if test x"$ac_c99_wchar" = x"yes" && test x"$enable_wchar_t" = x"yes"; then
1846     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
1847               [Define if code specialized for wchar_t should be used.])
1848   fi
1849   AC_MSG_CHECKING([for enabled wchar_t specializations])
1850   AC_MSG_RESULT([$enable_wchar_t])
1851 ])
1852
1853
1854 dnl
1855 dnl Check to see if building and using a C++ precompiled header can be done.
1856 dnl
1857 dnl --enable-libstdcxx-pch=yes
1858 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1859 dnl may work, after some light-hearted attempts to puzzle out compiler
1860 dnl support, flip bits on in include/Makefile.am
1861 dnl
1862 dnl --disable-libstdcxx-pch
1863 dnl turns off attempts to use or build stdc++.h.gch.
1864 dnl
1865 dnl Substs:
1866 dnl  glibcxx_PCHFLAGS
1867 dnl
1868 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1869   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1870   if test $enable_libstdcxx_pch = yes; then
1871     AC_CACHE_CHECK([for compiler with PCH support],
1872       [glibcxx_cv_prog_CXX_pch],
1873       [ac_save_CXXFLAGS="$CXXFLAGS"
1874        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1875        AC_LANG_SAVE
1876        AC_LANG_CPLUSPLUS
1877        echo '#include <math.h>' > conftest.h
1878        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1879                           -o conftest.h.gch 1>&5 2>&1 &&
1880                 echo '#error "pch failed"' > conftest.h &&
1881           echo '#include "conftest.h"' > conftest.cc &&
1882                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1883        then
1884          glibcxx_cv_prog_CXX_pch=yes
1885        else
1886          glibcxx_cv_prog_CXX_pch=no
1887        fi
1888        rm -f conftest*
1889        CXXFLAGS=$ac_save_CXXFLAGS
1890        AC_LANG_RESTORE
1891       ])
1892     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1893   fi
1894
1895   AC_MSG_CHECKING([for enabled PCH])
1896   AC_MSG_RESULT([$enable_libstdcxx_pch])
1897
1898   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1899   if test $enable_libstdcxx_pch = yes; then
1900     glibcxx_PCHFLAGS="-include bits/stdc++.h"
1901   else
1902     glibcxx_PCHFLAGS=""
1903   fi
1904   AC_SUBST(glibcxx_PCHFLAGS)
1905 ])
1906
1907
1908 dnl
1909 dnl Check for exception handling support.  If an explicit enable/disable
1910 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1911 dnl target may or may not support call frame exceptions.
1912 dnl
1913 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1914 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1915 dnl Neither one forces an attempt at detection.
1916 dnl
1917 dnl Defines:
1918 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
1919 dnl
1920 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
1921   AC_MSG_CHECKING([for exception model to use])
1922   AC_LANG_SAVE
1923   AC_LANG_CPLUSPLUS
1924   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
1925     [force use of builtin_setjmp for exceptions],
1926     [permit yes|no|auto])
1927
1928   if test $enable_sjlj_exceptions = auto; then
1929     # Botheration.  Now we've got to detect the exception model.  Link tests
1930     # against libgcc.a are problematic since we've not been given proper -L
1931     # bits for single-tree newlib and libgloss.
1932     #
1933     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
1934     cat > conftest.$ac_ext << EOF
1935 [#]line __oline__ "configure"
1936 struct S { ~S(); };
1937 void bar();
1938 void foo()
1939 {
1940   S s;
1941   bar();
1942 }
1943 EOF
1944     old_CXXFLAGS="$CXXFLAGS"
1945     CXXFLAGS=-S
1946     if AC_TRY_EVAL(ac_compile); then
1947       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1948         enable_sjlj_exceptions=yes
1949       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1950         enable_sjlj_exceptions=no
1951       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
1952         enable_sjlj_exceptions=no
1953       fi
1954     fi
1955     CXXFLAGS="$old_CXXFLAGS"
1956     rm -f conftest*
1957   fi
1958
1959   # This is a tad weird, for hysterical raisins.  We have to map
1960   # enable/disable to two different models.
1961   case $enable_sjlj_exceptions in
1962     yes)
1963       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
1964         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1965       ac_exception_model_name=sjlj
1966       ;;
1967     no)
1968       ac_exception_model_name="call frame"
1969       ;;
1970     *)
1971       AC_MSG_ERROR([unable to detect exception model])
1972       ;;
1973   esac
1974  AC_LANG_RESTORE
1975  AC_MSG_RESULT($ac_exception_model_name)
1976 ])
1977
1978
1979 dnl
1980 dnl Add version tags to symbols in shared library (or not), additionally
1981 dnl marking other symbols as private/local (or not).
1982 dnl
1983 dnl --enable-symvers=style adds a version script to the linker call when
1984 dnl       creating the shared library.  The choice of version script is
1985 dnl       controlled by 'style'.
1986 dnl --disable-symvers does not.
1987 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
1988 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
1989 dnl       choose a default style based on linker characteristics.  Passing
1990 dnl       'no' disables versioning.
1991 dnl
1992 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
1993
1994 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
1995   [enables symbol versioning of the shared library],
1996   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
1997
1998 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
1999 # don't know enough about $LD to do tricks...
2000 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2001
2002 # Turn a 'yes' into a suitable default.
2003 if test x$enable_symvers = xyes ; then
2004   if test $enable_shared = no || test "x$LD" = x ; then
2005     enable_symvers=no
2006   else
2007     if test $with_gnu_ld = yes ; then
2008       enable_symvers=gnu
2009     else
2010       case ${target_os} in
2011         darwin*)
2012           enable_symvers=darwin ;;
2013         *)
2014           enable_symvers=no ;;
2015       esac
2016     fi
2017   fi
2018 fi
2019
2020 # Check to see if 'darwin' or 'darwin-export' can win.
2021 if test x$enable_symvers = xdarwin-export ; then
2022     enable_symvers=darwin
2023 fi
2024
2025 # Check to see if 'gnu' can win.
2026 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2027   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2028   AC_MSG_CHECKING([for shared libgcc])
2029   ac_save_CFLAGS="$CFLAGS"
2030   CFLAGS=' -lgcc_s'
2031   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2032   CFLAGS="$ac_save_CFLAGS"
2033   if test $glibcxx_shared_libgcc = no; then
2034     cat > conftest.c <<EOF
2035 int main (void) { return 0; }
2036 EOF
2037 changequote(,)dnl
2038     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2039                              -shared -shared-libgcc -o conftest.so \
2040                              conftest.c -v 2>&1 >/dev/null \
2041                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2042 changequote([,])dnl
2043     rm -f conftest.c conftest.so
2044     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2045       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2046       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2047       CFLAGS="$ac_save_CFLAGS"
2048     fi
2049   fi
2050   AC_MSG_RESULT($glibcxx_shared_libgcc)
2051
2052   # For GNU ld, we need at least this version.  The format is described in
2053   # GLIBCXX_CHECK_LINKER_FEATURES above.
2054   glibcxx_min_gnu_ld_version=21400
2055
2056   # If no shared libgcc, can't win.
2057   if test $glibcxx_shared_libgcc != yes; then
2058       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2059       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2060       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2061       enable_symvers=no
2062   elif test $with_gnu_ld != yes ; then
2063     # just fail for now
2064     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2065     AC_MSG_WARN([=== you are not using the GNU linker.])
2066     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2067     enable_symvers=no
2068   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2069     # The right tools, the right setup, but too old.  Fallbacks?
2070     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2071     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2072     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2073     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2074     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2075     enable_symvers=no
2076   fi
2077 fi
2078
2079 # Everything parsed; figure out what file to use.
2080 case $enable_symvers in
2081   no)
2082     SYMVER_FILE=config/abi/pre/none.ver
2083     ;;
2084   gnu)
2085     SYMVER_FILE=config/abi/pre/gnu.ver
2086     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2087               [Define to use GNU versioning in the shared library.])
2088     ;;
2089   gnu-versioned-namespace)
2090     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2091     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2092               [Define to use GNU namespace versioning in the shared library.])
2093     ;;
2094   darwin)
2095     SYMVER_FILE=config/abi/pre/gnu.ver
2096     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2097               [Define to use darwin versioning in the shared library.])
2098     ;;
2099 esac
2100
2101 if test x$enable_symvers != xno ; then
2102   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2103          [Define to use symbol versioning in the shared library.])
2104 fi
2105
2106 AC_SUBST(SYMVER_FILE)
2107 AC_SUBST(port_specific_symbol_files)
2108 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2109 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2110 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2111 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2112 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2113
2114 # Now, set up compatibility support, if any.
2115 # In addition, need this to deal with std::size_t mangling in
2116 # src/compatibility.cc.  In a perfect world, could use
2117 # typeid(std::size_t).name()[0] to do direct substitution.
2118 AC_MSG_CHECKING([for size_t as unsigned int])
2119 ac_save_CFLAGS="$CFLAGS"
2120 CFLAGS="-Werror"
2121 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2122                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2123 CFLAGS=$ac_save_CFLAGS
2124 if test "$glibcxx_size_t_is_i" = yes; then
2125   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2126 fi
2127 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2128
2129 AC_MSG_CHECKING([for ptrdiff_t as int])
2130 ac_save_CFLAGS="$CFLAGS"
2131 CFLAGS="-Werror"
2132 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2133                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2134 CFLAGS=$ac_save_CFLAGS
2135 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2136   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2137 fi
2138 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2139 ])
2140
2141
2142 dnl
2143 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2144 dnl We must stage the required headers so that they will be installed
2145 dnl with the library (unlike libgcc, the STL implementation is provided
2146 dnl solely within headers).  Since we must not inject random user-space
2147 dnl macro names into user-provided C++ code, we first stage into <file>-in
2148 dnl and process to <file> with an output command.  The reason for a two-
2149 dnl stage process here is to correctly handle $srcdir!=$objdir without
2150 dnl having to write complex code (the sed commands to clean the macro
2151 dnl namespace are complex and fragile enough as it is).  We must also
2152 dnl add a relative path so that -I- is supported properly.
2153 dnl
2154 dnl Substs:
2155 dnl  glibcxx_thread_h
2156 dnl
2157 dnl Defines:
2158 dnl  HAVE_GTHR_DEFAULT
2159 dnl
2160 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2161   AC_MSG_CHECKING([for thread model used by GCC])
2162   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2163   AC_MSG_RESULT([$target_thread_file])
2164
2165   if test $target_thread_file != single; then
2166     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2167               [Define if gthr-default.h exists
2168               (meaning that threading support is enabled).])
2169   fi
2170
2171   glibcxx_thread_h=gthr-$target_thread_file.h
2172
2173   dnl Check for __GTHREADS define.
2174   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2175   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2176     enable_thread=yes
2177   else
2178    enable_thread=no
2179   fi
2180
2181   AC_SUBST(glibcxx_thread_h)
2182 ])
2183
2184
2185 # Check whether LC_MESSAGES is available in <locale.h>.
2186 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2187 #
2188 # This file file be copied and used freely without restrictions.  It can
2189 # be used in projects which are not available under the GNU Public License
2190 # but which still want to provide support for the GNU gettext functionality.
2191 # Please note that the actual code is *not* freely available.
2192
2193 # serial 1
2194 AC_DEFUN([AC_LC_MESSAGES], [
2195   AC_CHECK_HEADER(locale.h, [
2196     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2197       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2198        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2199     if test $ac_cv_val_LC_MESSAGES = yes; then
2200       AC_DEFINE(HAVE_LC_MESSAGES, 1,
2201                 [Define if LC_MESSAGES is available in <locale.h>.])
2202     fi
2203   ])
2204 ])
2205
2206 # Macros from the top-level gcc directory.
2207 m4_include([../config/tls.m4])
2208