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