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