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