l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.1.0/acinclude.m4

   1
   2 dnl
   3 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
   4 dnl
   5 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
   6 dnl end of configure.  This lets tested variables be reassigned, and the
   7 dnl conditional will depend on the final state of the variable.  For a simple
   8 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
   9 dnl
  10 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
  11 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
  12   m4_divert_text([glibcxx_diversion],dnl
  13    AM_CONDITIONAL([$1],[$2])
  14   )dnl
  15 ])dnl
  16 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
  17
  18
  19 dnl
  20 dnl Check to see what architecture and operating system we are compiling
  21 dnl for.  Also, if architecture- or OS-specific flags are required for
  22 dnl compilation, pick them up here.
  23 dnl
  24 AC_DEFUN([GLIBCXX_CHECK_HOST], [
  25   . $glibcxx_srcdir/configure.host
  26   AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
  27   AC_MSG_NOTICE([OS config directory is $os_include_dir])
  28 ])
  29
  30 dnl
  31 dnl Initialize the rest of the library configury.  At this point we have
  32 dnl variables like $host.
  33 dnl
  34 dnl Sets:
  35 dnl  SUBDIRS
  36 dnl Substs:
  37 dnl  glibcxx_builddir     (absolute path)
  38 dnl  glibcxx_srcdir       (absolute path)
  39 dnl  toplevel_srcdir      (absolute path)
  40 dnl  with_cross_host
  41 dnl  with_newlib
  42 dnl  with_target_subdir
  43 dnl plus
  44 dnl  - the variables in GLIBCXX_CHECK_HOST / configure.host
  45 dnl  - default settings for all AM_CONFITIONAL test variables
  46 dnl  - lots of tools, like CC and CXX
  47 dnl
  48 AC_DEFUN([GLIBCXX_CONFIGURE], [
  49   # Keep these sync'd with the list in Makefile.am.  The first provides an
  50   # expandable list at autoconf time; the second provides an expandable list
  51   # (i.e., shell variable) at configure time.
  52   m4_define([glibcxx_SUBDIRS],[include libmath libsupc++ src po testsuite])
  53   SUBDIRS='glibcxx_SUBDIRS'
  54
  55   # These need to be absolute paths, yet at the same time need to
  56   # canonicalize only relative paths, because then amd will not unmount
  57   # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
  58   glibcxx_builddir=`${PWDCMD-pwd}`
  59   case $srcdir in
  60     [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
  61     *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
  62   esac
  63   toplevel_srcdir=${glibcxx_srcdir}/..
  64   AC_SUBST(glibcxx_builddir)
  65   AC_SUBST(glibcxx_srcdir)
  66   AC_SUBST(toplevel_srcdir)
  67
  68   # We use these options to decide which functions to include.  They are
  69   # set from the top level.
  70   AC_ARG_WITH([target-subdir],
  71     AC_HELP_STRING([--with-target-subdir=SUBDIR],
  72                    [configuring in a subdirectory]))
  73
  74   AC_ARG_WITH([cross-host],
  75     AC_HELP_STRING([--with-cross-host=HOST],
  76                    [configuring with a cross compiler]))
  77
  78   AC_ARG_WITH([newlib],
  79     AC_HELP_STRING([--with-newlib],
  80                    [assume newlib as a system C library]))
  81
  82   # We're almost certainly being configured before anything else which uses
  83   # C++, so all of our AC_PROG_* discoveries will be cached.  It's vital that
  84   # we not cache the value of CXX that we "discover" here, because it's set
  85   # to something unique for us and libjava.  Other target libraries need to
  86   # find CXX for themselves.  We yank the rug out from under the normal AC_*
  87   # process by sneakily renaming the cache variable.  This also lets us debug
  88   # the value of "our" CXX in postmortems.
  89   #
  90   # We must also force CXX to /not/ be a precious variable, otherwise the
  91   # wrong (non-multilib-adjusted) value will be used in multilibs.  This
  92   # little trick also affects CPPFLAGS, CXXFLAGS, and LDFLAGS.  And as a side
  93   # effect, CXXFLAGS is no longer automagically subst'd, so we have to do
  94   # that ourselves.  Un-preciousing AC_PROG_CC also affects CC and CFLAGS.
  95   #
  96   # -fno-builtin must be present here so that a non-conflicting form of
  97   # std::exit can be guessed by AC_PROG_CXX, and used in later tests.
  98
  99   m4_define([ac_cv_prog_CXX],[glibcxx_cv_prog_CXX])
 100   m4_rename([_AC_ARG_VAR_PRECIOUS],[glibcxx_PRECIOUS])
 101   m4_define([_AC_ARG_VAR_PRECIOUS],[])
 102   save_CXXFLAGS="$CXXFLAGS"
 103   CXXFLAGS="$CXXFLAGS -fno-builtin"
 104   AC_PROG_CC
 105   AC_PROG_CXX
 106   CXXFLAGS="$save_CXXFLAGS"
 107   m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
 108   AC_SUBST(CFLAGS)
 109   AC_SUBST(CXXFLAGS)
 110
 111   # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
 112   # available).  Uncomment the next line to force a particular method.
 113   AC_PROG_LN_S
 114   #LN_S='cp -p'
 115
 116   AC_CHECK_TOOL(AS, as)
 117   AC_CHECK_TOOL(AR, ar)
 118   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
 119
 120   AM_MAINTAINER_MODE
 121
 122   # Set up safe default values for all subsequent AM_CONDITIONAL tests
 123   # which are themselves conditionally expanded.
 124   ## (Right now, this only matters for enable_wchar_t, but nothing prevents
 125   ## other macros from doing the same.  This should be automated.)  -pme
 126   need_libmath=no
 127
 128   # Find platform-specific directories containing configuration info.
 129   # Also possibly modify flags used elsewhere, as needed by the platform.
 130   GLIBCXX_CHECK_HOST
 131 ])
 132
 133
 134 dnl
 135 dnl Tests for newer compiler features, or features that are present in newer
 136 dnl compiler versions but not older compiler versions still in use, should
 137 dnl be placed here.
 138 dnl
 139 dnl Defines:
 140 dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
 141 dnl   new inlining code or the new system_header pragma will die on -Werror.
 142 dnl   Leave it out by default and use maint-mode to use it.
 143 dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 144 dnl   compiler supports it and the user has not requested debug mode.
 145 dnl
 146 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
 147   # All these tests are for C++; save the language and the compiler flags.
 148   # The CXXFLAGS thing is suspicious, but based on similar bits previously
 149   # found in GLIBCXX_CONFIGURE.
 150   AC_LANG_SAVE
 151   AC_LANG_CPLUSPLUS
 152   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 153   ac_save_CXXFLAGS="$CXXFLAGS"
 154
 155   # Check for maintainer-mode bits.
 156   if test x"$USE_MAINTAINER_MODE" = xno; then
 157     WERROR=''
 158   else
 159     WERROR='-Werror'
 160   fi
 161
 162   # Check for -ffunction-sections -fdata-sections
 163   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
 164   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
 165   AC_TRY_COMPILE(, [int foo;], [ac_fdsections=yes], [ac_fdsections=no])
 166   if test "$ac_test_CXXFLAGS" = set; then
 167     CXXFLAGS="$ac_save_CXXFLAGS"
 168   else
 169     # this is the suspicious part
 170     CXXFLAGS=''
 171   fi
 172   if test x"$ac_fdsections" = x"yes"; then
 173     SECTION_FLAGS='-ffunction-sections -fdata-sections'
 174   fi
 175   AC_MSG_RESULT($ac_fdsections)
 176
 177   AC_LANG_RESTORE
 178   AC_SUBST(WERROR)
 179   AC_SUBST(SECTION_FLAGS)
 180 ])
 181
 182
 183 dnl
 184 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
 185 dnl the native linker is in use, all variables will be defined to something
 186 dnl safe (like an empty string).
 187 dnl
 188 dnl Defines:
 189 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
 190 dnl  OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
 191 dnl  LD (as a side effect of testing)
 192 dnl Sets:
 193 dnl  with_gnu_ld
 194 dnl  glibcxx_gnu_ld_version (possibly)
 195 dnl
 196 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
 197 dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
 198 dnl
 199 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
 200   # If we're not using GNU ld, then there's no point in even trying these
 201   # tests.  Check for that first.  We should have already tested for gld
 202   # by now (in libtool), but require it now just to be safe...
 203   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
 204   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
 205   AC_REQUIRE([AC_PROG_LD])
 206   AC_REQUIRE([AC_PROG_AWK])
 207
 208   # The name set by libtool depends on the version of libtool.  Shame on us
 209   # for depending on an impl detail, but c'est la vie.  Older versions used
 210   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
 211   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
 212   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
 213   # set (hence we're using an older libtool), then set it.
 214   if test x${with_gnu_ld+set} != xset; then
 215     if test x${ac_cv_prog_gnu_ld+set} != xset; then
 216       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
 217       with_gnu_ld=no
 218     else
 219       with_gnu_ld=$ac_cv_prog_gnu_ld
 220     fi
 221   fi
 222
 223   # Start by getting the version number.  I think the libtool test already
 224   # does some of this, but throws away the result.
 225   changequote(,)
 226   ldver=`$LD --version 2>/dev/null | head -1 | \
 227          sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
 228   changequote([,])
 229   glibcxx_gnu_ld_version=`echo $ldver | \
 230          $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
 231
 232   # Set --gc-sections.
 233   if test "$with_gnu_ld" = "notbroken"; then
 234     # GNU ld it is!  Joy and bunny rabbits!
 235
 236     # All these tests are for C++; save the language and the compiler flags.
 237     # Need to do this so that g++ won't try to link in libstdc++
 238     ac_test_CFLAGS="${CFLAGS+set}"
 239     ac_save_CFLAGS="$CFLAGS"
 240     CFLAGS='-x c++  -Wl,--gc-sections'
 241
 242     # Check for -Wl,--gc-sections
 243     # XXX This test is broken at the moment, as symbols required for linking
 244     # are now in libsupc++ (not built yet).  In addition, this test has
 245     # cored on solaris in the past.  In addition, --gc-sections doesn't
 246     # really work at the moment (keeps on discarding used sections, first
 247     # .eh_frame and now some of the glibc sections for iconv).
 248     # Bzzzzt.  Thanks for playing, maybe next time.
 249     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
 250     AC_TRY_RUN([
 251      int main(void)
 252      {
 253        try { throw 1; }
 254        catch (...) { };
 255        return 0;
 256      }
 257     ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
 258     if test "$ac_test_CFLAGS" = set; then
 259       CFLAGS="$ac_save_CFLAGS"
 260     else
 261       # this is the suspicious part
 262       CFLAGS=''
 263     fi
 264     if test "$ac_sectionLDflags" = "yes"; then
 265       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
 266     fi
 267     AC_MSG_RESULT($ac_sectionLDflags)
 268   fi
 269
 270   # Set -z,relro.
 271   # Note this is only for shared objects
 272   ac_ld_relro=no
 273   if test x"$with_gnu_ld" = x"yes"; then
 274     AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
 275     cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
 276     if test -n "$cxx_z_relo"; then
 277       OPT_LDFLAGS="-Wl,-z,relro"
 278       ac_ld_relro=yes
 279     fi
 280     AC_MSG_RESULT($ac_ld_relro)
 281   fi
 282
 283   # Set linker optimization flags.
 284   if test x"$with_gnu_ld" = x"yes"; then
 285     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
 286   fi
 287
 288   AC_SUBST(SECTION_LDFLAGS)
 289   AC_SUBST(OPT_LDFLAGS)
 290 ])
 291
 292
 293 dnl
 294 dnl Check to see if this target can enable the iconv specializations.
 295 dnl If --disable-c-mbchar was given, no wchar_t specialization is enabled.
 296 dnl (This must have been previously checked, along with the rest of C99
 297 dnl support.) By default, iconv support is disabled.
 298 dnl
 299 dnl Defines:
 300 dnl  _GLIBCXX_USE_ICONV if all the bits are found.
 301 dnl Substs:
 302 dnl  LIBICONV to a -l string containing the iconv library, if needed.
 303 dnl
 304 AC_DEFUN([GLIBCXX_CHECK_ICONV_SUPPORT], [
 305
 306   enable_iconv=no
 307   # Only continue checking if the ISO C99 headers exist and support is on.
 308   if test x"$enable_wchar_t" = xyes; then
 309
 310     # Use iconv for wchar_t to char conversions. As such, check for
 311     # X/Open Portability Guide, version 2 features (XPG2).
 312     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
 313     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
 314
 315     # Check for existence of libiconv.a providing XPG2 wchar_t support.
 316     AC_CHECK_LIB(iconv, iconv, LIBICONV="-liconv")
 317     ac_save_LIBS="$LIBS"
 318     LIBS="$LIBS $LIBICONV"
 319     AC_SUBST(LIBICONV)
 320
 321     AC_CHECK_FUNCS([iconv_open iconv_close iconv nl_langinfo],
 322     [ac_XPG2funcs=yes], [ac_XPG2funcs=no])
 323
 324     LIBS="$ac_save_LIBS"
 325
 326     if test x"$ac_has_iconv_h" = xyes &&
 327        test x"$ac_has_langinfo_h" = xyes &&
 328        test x"$ac_XPG2funcs" = xyes;
 329     then
 330       AC_DEFINE([_GLIBCXX_USE_ICONV],1,
 331                 [Define if iconv and related functions exist and are usable.])
 332       enable_iconv=yes
 333     fi
 334   fi
 335   AC_MSG_CHECKING([for enabled iconv specializations])
 336   AC_MSG_RESULT($enable_iconv)
 337 ])
 338
 339
 340 dnl
 341 dnl Check for headers for, and arguments to, the setrlimit() function.
 342 dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
 343 dnl
 344 dnl Defines:
 345 dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits
 346 dnl  various HAVE_LIMIT_* for individual limit names
 347 dnl
 348 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
 349   AC_MSG_CHECKING([for RLIMIT_$1])
 350   AC_TRY_COMPILE(
 351     [#include <unistd.h>
 352      #include <sys/time.h>
 353      #include <sys/resource.h>
 354     ],
 355     [ int f = RLIMIT_$1 ; ],
 356     [glibcxx_mresult=1], [glibcxx_mresult=0])
 357   AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
 358                      [Only used in build directory testsuite_hooks.h.])
 359   if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
 360   AC_MSG_RESULT($res)
 361 ])
 362
 363 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
 364   setrlimit_have_headers=yes
 365   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
 366                    [],
 367                    [setrlimit_have_headers=no])
 368   # If don't have the headers, then we can't run the tests now, and we
 369   # won't be seeing any of these during testsuite compilation.
 370   if test $setrlimit_have_headers = yes; then
 371     # Can't do these in a loop, else the resulting syntax is wrong.
 372     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
 373     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
 374     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
 375     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
 376     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
 377
 378     # Check for rlimit, setrlimit.
 379     AC_CACHE_VAL(ac_setrlimit, [
 380       AC_TRY_COMPILE(
 381         [#include <unistd.h>
 382          #include <sys/time.h>
 383          #include <sys/resource.h>
 384         ],
 385         [struct rlimit r;
 386          setrlimit(0, &r);],
 387         [ac_setrlimit=yes], [ac_setrlimit=no])
 388     ])
 389   fi
 390
 391   AC_MSG_CHECKING([for testsuite resource limits support])
 392   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
 393     ac_res_limits=yes
 394     AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
 395               [Define if using setrlimit to set resource limits during
 396               "make check"])
 397   else
 398     ac_res_limits=no
 399   fi
 400   AC_MSG_RESULT($ac_res_limits)
 401 ])
 402
 403
 404 dnl
 405 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
 406 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
 407 dnl
 408 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
 409   AC_MSG_CHECKING([for S_ISREG or S_IFREG])
 410   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
 411     AC_TRY_LINK(
 412       [#include <sys/stat.h>],
 413       [struct stat buffer;
 414        fstat(0, &buffer);
 415        S_ISREG(buffer.st_mode);],
 416       [glibcxx_cv_S_ISREG=yes],
 417       [glibcxx_cv_S_ISREG=no])
 418   ])
 419   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
 420     AC_TRY_LINK(
 421       [#include <sys/stat.h>],
 422       [struct stat buffer;
 423        fstat(0, &buffer);
 424        S_IFREG & buffer.st_mode;],
 425       [glibcxx_cv_S_IFREG=yes],
 426       [glibcxx_cv_S_IFREG=no])
 427   ])
 428   res=no
 429   if test $glibcxx_cv_S_ISREG = yes; then
 430     AC_DEFINE(HAVE_S_ISREG, 1,
 431               [Define if S_IFREG is available in <sys/stat.h>.])
 432     res=S_ISREG
 433   elif test $glibcxx_cv_S_IFREG = yes; then
 434     AC_DEFINE(HAVE_S_IFREG, 1,
 435               [Define if S_IFREG is available in <sys/stat.h>.])
 436     res=S_IFREG
 437   fi
 438   AC_MSG_RESULT($res)
 439 ])
 440
 441
 442 dnl
 443 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
 444 dnl
 445 AC_DEFUN([GLIBCXX_CHECK_POLL], [
 446   AC_MSG_CHECKING([for poll])
 447   AC_CACHE_VAL(glibcxx_cv_POLL, [
 448     AC_TRY_LINK(
 449       [#include <poll.h>],
 450       [struct pollfd pfd[1];
 451        pfd[0].events = POLLIN;
 452        poll(pfd, 1, 0);],
 453       [glibcxx_cv_POLL=yes],
 454       [glibcxx_cv_POLL=no])
 455   ])
 456   if test $glibcxx_cv_POLL = yes; then
 457     AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
 458   fi
 459   AC_MSG_RESULT($glibcxx_cv_POLL)
 460 ])
 461
 462
 463 dnl
 464 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
 465 dnl
 466 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
 467   AC_MSG_CHECKING([for writev])
 468   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
 469     AC_TRY_LINK(
 470       [#include <sys/uio.h>],
 471       [struct iovec iov[2];
 472        writev(0, iov, 0);],
 473       [glibcxx_cv_WRITEV=yes],
 474       [glibcxx_cv_WRITEV=no])
 475   ])
 476   if test $glibcxx_cv_WRITEV = yes; then
 477     AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
 478   fi
 479   AC_MSG_RESULT($glibcxx_cv_WRITEV)
 480 ])
 481
 482
 483 dnl
 484 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
 485 dnl
 486 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
 487   AC_MSG_CHECKING([for int64_t])
 488   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
 489     AC_TRY_COMPILE(
 490       [#include <stdint.h>],
 491       [int64_t var;],
 492       [glibcxx_cv_INT64_T=yes],
 493       [glibcxx_cv_INT64_T=no])
 494   ])
 495   if test $glibcxx_cv_INT64_T = yes; then
 496     AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
 497   fi
 498   AC_MSG_RESULT($glibcxx_cv_INT64_T)
 499 ])
 500
 501
 502 dnl
 503 dnl Check whether LFS support is available.
 504 dnl
 505 AC_DEFUN([GLIBCXX_CHECK_LFS], [
 506   AC_LANG_SAVE
 507   AC_LANG_CPLUSPLUS
 508   ac_save_CXXFLAGS="$CXXFLAGS"
 509   CXXFLAGS="$CXXFLAGS -fno-exceptions"
 510   AC_MSG_CHECKING([for LFS support])
 511   AC_CACHE_VAL(glibcxx_cv_LFS, [
 512     AC_TRY_LINK(
 513       [#include <unistd.h>
 514        #include <stdio.h>
 515        #include <sys/stat.h>
 516       ],
 517       [FILE* fp;
 518        fopen64("t", "w");
 519        fseeko64(fp, 0, SEEK_CUR);
 520        ftello64(fp);
 521        lseek64(1, 0, SEEK_CUR);
 522        struct stat64 buf;
 523        fstat64(1, &buf);],
 524       [glibcxx_cv_LFS=yes],
 525       [glibcxx_cv_LFS=no])
 526   ])
 527   if test $glibcxx_cv_LFS = yes; then
 528     AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
 529   fi
 530   AC_MSG_RESULT($glibcxx_cv_LFS)
 531   CXXFLAGS="$ac_save_CXXFLAGS"
 532   AC_LANG_RESTORE
 533 ])
 534
 535
 536 dnl
 537 dnl Check for whether a fully dynamic basic_string implementation should
 538 dnl be turned on, that does not put empty objects in per-process static
 539 dnl memory (mostly useful together with shared memory allocators, see PR
 540 dnl libstdc++/16612 for details).
 541 dnl
 542 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
 543 dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
 544 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
 545 dnl       Where DEFAULT is either `yes' or `no'.
 546 dnl
 547 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
 548   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
 549   if test $enable_fully_dynamic_string = yes; then
 550     AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
 551               [Define if a fully dynamic basic_string is wanted.])
 552   fi
 553 ])
 554
 555
 556 dnl
 557 dnl Does any necessary configuration of the testsuite directory.  Generates
 558 dnl the testsuite_hooks.h header.
 559 dnl
 560 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
 561 dnl
 562 dnl Sets:
 563 dnl  enable_abi_check
 564 dnl  GLIBCXX_TEST_WCHAR_T
 565 dnl  GLIBCXX_TEST_THREAD
 566 dnl Substs:
 567 dnl  baseline_dir
 568 dnl
 569 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
 570   if $GLIBCXX_IS_NATIVE ; then
 571     # Do checks for resource limit functions.
 572     GLIBCXX_CHECK_SETRLIMIT
 573
 574     # Look for setenv, so that extended locale tests can be performed.
 575     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
 576   fi
 577
 578   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
 579      test $enable_symvers != no; then
 580     case "$host" in
 581       *-*-cygwin*)
 582         enable_abi_check=no ;;
 583       *)
 584         enable_abi_check=yes ;;
 585     esac
 586   else
 587     # Only build this as native, since automake does not understand
 588     # CXX_FOR_BUILD.
 589     enable_abi_check=no
 590   fi
 591
 592   # Export file names for ABI checking.
 593   baseline_dir="$glibcxx_srcdir/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
 594   AC_SUBST(baseline_dir)
 595 ])
 596
 597
 598 dnl
 599 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
 600 dnl
 601 dnl Substs:
 602 dnl  GLIBCXX_INCLUDES
 603 dnl  TOPLEVEL_INCLUDES
 604 dnl
 605 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
 606   # Used for every C++ compile we perform.
 607   GLIBCXX_INCLUDES="\
 608 -I$glibcxx_builddir/include/$host_alias \
 609 -I$glibcxx_builddir/include \
 610 -I$glibcxx_srcdir/libsupc++"
 611
 612   # For Canadian crosses, pick this up too.
 613   if test $CANADIAN = yes; then
 614     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
 615   fi
 616
 617   # Stuff in the actual top level.  Currently only used by libsupc++ to
 618   # get unwind* headers from the gcc dir.
 619   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
 620   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
 621
 622   # Now, export this to all the little Makefiles....
 623   AC_SUBST(GLIBCXX_INCLUDES)
 624   AC_SUBST(TOPLEVEL_INCLUDES)
 625 ])
 626
 627
 628 dnl
 629 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
 630 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
 631 dnl
 632 dnl Substs:
 633 dnl  OPTIMIZE_CXXFLAGS
 634 dnl  WARN_FLAGS
 635 dnl
 636 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
 637   # Optimization flags that are probably a good idea for thrill-seekers. Just
 638   # uncomment the lines below and make, everything else is ready to go...
 639   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
 640   OPTIMIZE_CXXFLAGS=
 641   AC_SUBST(OPTIMIZE_CXXFLAGS)
 642
 643   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
 644   AC_SUBST(WARN_FLAGS)
 645 ])
 646
 647
 648 dnl
 649 dnl All installation directory information is determined here.
 650 dnl
 651 dnl Substs:
 652 dnl  gxx_install_dir
 653 dnl  glibcxx_prefixdir
 654 dnl  glibcxx_toolexecdir
 655 dnl  glibcxx_toolexeclibdir
 656 dnl
 657 dnl Assumes cross_compiling bits already done, and with_cross_host in
 658 dnl particular.
 659 dnl
 660 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
 661   glibcxx_toolexecdir=no
 662   glibcxx_toolexeclibdir=no
 663   glibcxx_prefixdir=$prefix
 664
 665   AC_MSG_CHECKING([for gxx-include-dir])
 666   AC_ARG_WITH([gxx-include-dir],
 667     AC_HELP_STRING([--with-gxx-include-dir=DIR],
 668                    [installation directory for include files]),
 669     [case "$withval" in
 670       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
 671       no)  gxx_include_dir=no ;;
 672       *)   gxx_include_dir=$withval ;;
 673      esac],
 674     [gxx_include_dir=no])
 675   AC_MSG_RESULT($gxx_include_dir)
 676
 677   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
 678   AC_ARG_ENABLE([version-specific-runtime-libs],
 679     AC_HELP_STRING([--enable-version-specific-runtime-libs],
 680                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
 681     [case "$enableval" in
 682       yes) version_specific_libs=yes ;;
 683       no)  version_specific_libs=no ;;
 684       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
 685      esac],
 686     [version_specific_libs=no])
 687   AC_MSG_RESULT($version_specific_libs)
 688
 689   # Default case for install directory for include files.
 690   if test $version_specific_libs = no && test $gxx_include_dir = no; then
 691     gxx_include_dir='${prefix}/include/c++/${gcc_version}'
 692   fi
 693
 694   # Version-specific runtime libs processing.
 695   if test $version_specific_libs = yes; then
 696     # Need the gcc compiler version to know where to install libraries
 697     # and header files if --enable-version-specific-runtime-libs option
 698     # is selected.  FIXME: these variables are misnamed, there are
 699     # no executables installed in _toolexecdir or _toolexeclibdir.
 700     if test x"$gxx_include_dir" = x"no"; then
 701       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
 702     fi
 703     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 704     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
 705   fi
 706
 707   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
 708   # Install a library built with a cross compiler in tooldir, not libdir.
 709   if test x"$glibcxx_toolexecdir" = x"no"; then
 710     if test -n "$with_cross_host" &&
 711        test x"$with_cross_host" != x"no"; then
 712       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
 713       glibcxx_toolexeclibdir='${toolexecdir}/lib'
 714     else
 715       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
 716       glibcxx_toolexeclibdir='${libdir}'
 717     fi
 718     multi_os_directory=`$CXX -print-multi-os-directory`
 719     case $multi_os_directory in
 720       .) ;; # Avoid trailing /.
 721       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
 722     esac
 723   fi
 724
 725   AC_MSG_CHECKING([for install location])
 726   AC_MSG_RESULT($gxx_include_dir)
 727
 728   AC_SUBST(glibcxx_prefixdir)
 729   AC_SUBST(gxx_include_dir)
 730   AC_SUBST(glibcxx_toolexecdir)
 731   AC_SUBST(glibcxx_toolexeclibdir)
 732 ])
 733
 734
 735 dnl
 736 dnl GLIBCXX_ENABLE
 737 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
 738 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
 739 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
 740 dnl
 741 dnl See docs/html/17_intro/configury.html#enable for documentation.
 742 dnl
 743 m4_define([GLIBCXX_ENABLE],[dnl
 744 m4_define([_g_switch],[--enable-$1])dnl
 745 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
 746  AC_ARG_ENABLE($1,_g_help,
 747   m4_bmatch([$5],
 748    [^permit ],
 749      [[
 750       case "$enableval" in
 751        m4_bpatsubst([$5],[permit ])) ;;
 752        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
 753           dnl Idea for future:  generate a URL pointing to
 754           dnl "onlinedocs/configopts.html#whatever"
 755       esac
 756      ]],
 757    [^$],
 758      [[
 759       case "$enableval" in
 760        yes|no) ;;
 761        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
 762       esac
 763      ]],
 764    [[$5]]),
 765   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
 766 m4_undefine([_g_switch])dnl
 767 m4_undefine([_g_help])dnl
 768 ])
 769
 770
 771 dnl
 772 dnl Check for ISO/IEC 9899:1999 "C99" support.
 773 dnl
 774 dnl --enable-c99 defines _GLIBCXX_USE_C99
 775 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
 776 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
 777 dnl       Where DEFAULT is either `yes' or `no'.
 778 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
 779 dnl
 780 AC_DEFUN([GLIBCXX_ENABLE_C99], [
 781   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
 782
 783   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos
 784   # even if C99 support is turned off.
 785   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
 786   AC_MSG_CHECKING([for mbstate_t])
 787   AC_TRY_COMPILE([#include <wchar.h>],
 788   [mbstate_t teststate;],
 789   have_mbstate_t=yes, have_mbstate_t=no)
 790   AC_MSG_RESULT($have_mbstate_t)
 791   if test x"$have_mbstate_t" = xyes; then
 792     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
 793   fi
 794
 795   if test x"$enable_c99" = x"yes"; then
 796
 797   AC_LANG_SAVE
 798   AC_LANG_CPLUSPLUS
 799
 800   # Check for the existence of <math.h> functions used if C99 is enabled.
 801   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
 802   AC_CACHE_VAL(ac_c99_math, [
 803   AC_TRY_COMPILE([#include <math.h>],
 804                  [fpclassify(0.0);
 805                   isfinite(0.0);
 806                   isinf(0.0);
 807                   isnan(0.0);
 808                   isnormal(0.0);
 809                   signbit(0.0);
 810                   isgreater(0.0,0.0);
 811                   isgreaterequal(0.0,0.0);
 812                   isless(0.0,0.0);
 813                   islessequal(0.0,0.0);
 814                   islessgreater(0.0,0.0);
 815                   islessgreater(0.0,0.0);
 816                   isunordered(0.0,0.0);
 817                  ],[ac_c99_math=yes], [ac_c99_math=no])
 818   ])
 819   AC_MSG_RESULT($ac_c99_math)
 820   if test x"$ac_c99_math" = x"yes"; then
 821     AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
 822               [Define if C99 functions or macros in <math.h> should be imported
 823               in <cmath> in namespace std.])
 824   fi
 825
 826   # Check for the existence of <complex.h> complex math functions.
 827   # This is necessary even though libstdc++ uses the builtin versions
 828   # of these functions, because if the builtin cannot be used, a reference
 829   # to the library function is emitted.
 830   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
 831   ac_c99_complex=no;
 832   if test x"$ac_has_complex_h" = x"yes"; then
 833     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
 834     AC_TRY_COMPILE([#include <complex.h>],
 835                    [typedef __complex__ float float_type; float_type tmpf;
 836                     cabsf(tmpf);
 837                     cargf(tmpf);
 838                     ccosf(tmpf);
 839                     ccoshf(tmpf);
 840                     cexpf(tmpf);
 841                     clogf(tmpf);
 842                     csinf(tmpf);
 843                     csinhf(tmpf);
 844                     csqrtf(tmpf);
 845                     ctanf(tmpf);
 846                     ctanhf(tmpf);
 847                     cpowf(tmpf, tmpf);
 848                     typedef __complex__ double double_type; double_type tmpd;
 849                     cabs(tmpd);
 850                     carg(tmpd);
 851                     ccos(tmpd);
 852                     ccosh(tmpd);
 853                     cexp(tmpd);
 854                     clog(tmpd);
 855                     csin(tmpd);
 856                     csinh(tmpd);
 857                     csqrt(tmpd);
 858                     ctan(tmpd);
 859                     ctanh(tmpd);
 860                     cpow(tmpd, tmpd);
 861                     typedef __complex__ long double ld_type; ld_type tmpld;
 862                     cabsl(tmpld);
 863                     cargl(tmpld);
 864                     ccosl(tmpld);
 865                     ccoshl(tmpld);
 866                     cexpl(tmpld);
 867                     clogl(tmpld);
 868                     csinl(tmpld);
 869                     csinhl(tmpld);
 870                     csqrtl(tmpld);
 871                     ctanl(tmpld);
 872                     ctanhl(tmpld);
 873                     cpowl(tmpld, tmpld);
 874                    ],[ac_c99_complex=yes], [ac_c99_complex=no])
 875   fi
 876   AC_MSG_RESULT($ac_c99_complex)
 877   if test x"$ac_c99_complex" = x"yes"; then
 878     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
 879               [Define if C99 functions in <complex.h> should be used in
 880               <complex>. Using compiler builtins for these functions requires
 881               corresponding C99 library functions to be present.])
 882   fi
 883
 884   # Check for the existence in <stdio.h> of vscanf, et. al.
 885   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
 886   AC_CACHE_VAL(ac_c99_stdio, [
 887   AC_TRY_COMPILE([#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   AC_TRY_COMPILE([#include <stdlib.h>],
 906                  [char* tmp;
 907                   strtof("gnu", &tmp);
 908                   strtold("gnu", &tmp);
 909                   strtoll("gnu", &tmp, 10);
 910                   strtoull("gnu", &tmp, 10);
 911                   llabs(10);
 912                   lldiv(10,1);
 913                   atoll("10");
 914                   _Exit(0);
 915                   lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
 916   ])
 917   AC_MSG_RESULT($ac_c99_stdlib)
 918
 919   # Check for the existence in <wchar.h> of wcstoull, WEOF, etc.
 920   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
 921   ac_c99_wchar=no;
 922   if test x"$ac_has_wchar_h" = xyes &&
 923      test x"$ac_has_wctype_h" = xyes; then
 924     AC_TRY_COMPILE([#include <wchar.h>
 925                     #include <stddef.h>
 926                     wint_t i;
 927                     long l = WEOF;
 928                     long j = WCHAR_MIN;
 929                     long k = WCHAR_MAX;
 930                     namespace test
 931                     {
 932                       using ::btowc;
 933                       using ::fgetwc;
 934                       using ::fgetws;
 935                       using ::fputwc;
 936                       using ::fputws;
 937                       using ::fwide;
 938                       using ::fwprintf;
 939                       using ::fwscanf;
 940                       using ::getwc;
 941                       using ::getwchar;
 942                       using ::mbrlen;
 943                       using ::mbrtowc;
 944                       using ::mbsinit;
 945                       using ::mbsrtowcs;
 946                       using ::putwc;
 947                       using ::putwchar;
 948                       using ::swprintf;
 949                       using ::swscanf;
 950                       using ::ungetwc;
 951                       using ::vfwprintf;
 952                       using ::vswprintf;
 953                       using ::vwprintf;
 954                       using ::wcrtomb;
 955                       using ::wcscat;
 956                       using ::wcschr;
 957                       using ::wcscmp;
 958                       using ::wcscoll;
 959                       using ::wcscpy;
 960                       using ::wcscspn;
 961                       using ::wcsftime;
 962                       using ::wcslen;
 963                       using ::wcsncat;
 964                       using ::wcsncmp;
 965                       using ::wcsncpy;
 966                       using ::wcspbrk;
 967                       using ::wcsrchr;
 968                       using ::wcsrtombs;
 969                       using ::wcsspn;
 970                       using ::wcsstr;
 971                       using ::wcstod;
 972                       using ::wcstok;
 973                       using ::wcstol;
 974                       using ::wcstold;
 975                       using ::wcstoll;
 976                       using ::wcstoul;
 977                       using ::wcstoull;
 978                       using ::wcsxfrm;
 979                       using ::wctob;
 980                       using ::wmemchr;
 981                       using ::wmemcmp;
 982                       using ::wmemcpy;
 983                       using ::wmemmove;
 984                       using ::wmemset;
 985                       using ::wprintf;
 986                       using ::wscanf;
 987                     }
 988                    ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
 989
 990     # Checks for wide character functions that may not be present.
 991     # Injection of these is wrapped with guard macros.
 992     # NB: only put functions here, instead of immediately above, if
 993     # absolutely necessary.
 994     AC_TRY_COMPILE([#include <wchar.h>
 995                     namespace test { using ::vfwscanf; } ], [],
 996                    [AC_DEFINE(HAVE_VFWSCANF,1,
 997                         [Defined if vfwscanf exists.])],[])
 998
 999     AC_TRY_COMPILE([#include <wchar.h>
1000                     namespace test { using ::vswscanf; } ], [],
1001                    [AC_DEFINE(HAVE_VSWSCANF,1,
1002                         [Defined if vswscanf exists.])],[])
1003
1004     AC_TRY_COMPILE([#include <wchar.h>
1005                     namespace test { using ::vwscanf; } ], [],
1006                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1007
1008     AC_TRY_COMPILE([#include <wchar.h>
1009                     namespace test { using ::wcstof; } ], [],
1010                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1011
1012     AC_TRY_COMPILE([#include <wctype.h>],
1013                    [ wint_t t; int i = iswblank(t);],
1014                    [AC_DEFINE(HAVE_ISWBLANK,1,
1015                         [Defined if iswblank exists.])],[])
1016
1017     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1018     AC_MSG_RESULT($ac_c99_wchar)
1019   fi
1020
1021   # Option parsed, now set things appropriately.
1022   if test x"$ac_c99_math" = x"no" ||
1023      test x"$ac_c99_complex" = x"no" ||
1024      test x"$ac_c99_stdio" = x"no" ||
1025      test x"$ac_c99_stdlib" = x"no" ||
1026      test x"$ac_c99_wchar" = x"no"; then
1027     enable_c99=no;
1028   else
1029     AC_DEFINE(_GLIBCXX_USE_C99, 1,
1030     [Define if C99 functions or macros from <wchar.h>, <math.h>,
1031     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1032   fi
1033
1034   AC_LANG_RESTORE
1035   fi
1036
1037   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1038   AC_MSG_RESULT($enable_c99)
1039 ])
1040
1041
1042 dnl
1043 dnl Check for what type of C headers to use.
1044 dnl
1045 dnl --enable-cheaders= [does stuff].
1046 dnl --disable-cheaders [does not do anything, really].
1047 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1048 dnl       Where DEFAULT is either `c' or `c_std'.
1049 dnl
1050 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1051   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1052     [construct "C" headers for g++], [permit c|c_std])
1053   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1054
1055   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1056
1057   AC_SUBST(C_INCLUDE_DIR)
1058   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1059   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1060   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1061 ])
1062
1063
1064 dnl
1065 dnl Check for which locale library to use.  The choice is mapped to
1066 dnl a subdirectory of config/locale.
1067 dnl
1068 dnl Default is generic.
1069 dnl
1070 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1071   AC_MSG_CHECKING([for C locale to use])
1072   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1073     [use MODEL for target locale package],
1074     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1075
1076   # If they didn't use this option switch, or if they specified --enable
1077   # with no specific model, we'll have to look for one.  If they
1078   # specified --disable (???), do likewise.
1079   if test $enable_clocale = no || test $enable_clocale = yes; then
1080      enable_clocale=auto
1081   fi
1082
1083   # Either a known package, or "auto"
1084   enable_clocale_flag=$enable_clocale
1085
1086   # Probe for locale support if no specific model is specified.
1087   # Default to "generic".
1088   if test $enable_clocale_flag = auto; then
1089     case ${target_os} in
1090       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1091         AC_EGREP_CPP([_GLIBCXX_ok], [
1092         #include <features.h>
1093         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1094           _GLIBCXX_ok
1095         #endif
1096         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1097
1098         # Test for bugs early in glibc-2.2.x series
1099           if test $enable_clocale_flag = gnu; then
1100           AC_TRY_RUN([
1101           #define _GNU_SOURCE 1
1102           #include <locale.h>
1103           #include <string.h>
1104           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1105           extern __typeof(newlocale) __newlocale;
1106           extern __typeof(duplocale) __duplocale;
1107           extern __typeof(strcoll_l) __strcoll_l;
1108           #endif
1109           int main()
1110           {
1111               const char __one[] = "Äuglein Augmen";
1112               const char __two[] = "Äuglein";
1113               int i;
1114               int j;
1115               __locale_t        loc;
1116                __locale_t        loc_dup;
1117               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1118               loc_dup = __duplocale(loc);
1119               i = __strcoll_l(__one, __two, loc);
1120               j = __strcoll_l(__one, __two, loc_dup);
1121               return 0;
1122           }
1123           ],
1124           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1125           [enable_clocale_flag=generic])
1126           fi
1127
1128         # ... at some point put __strxfrm_l tests in as well.
1129         ;;
1130       darwin* | freebsd*)
1131         enable_clocale_flag=darwin
1132         ;;
1133       *)
1134         enable_clocale_flag=generic
1135         ;;
1136     esac
1137   fi
1138
1139   # Deal with gettext issues.  Default to not using it (=no) until we detect
1140   # support for it later.  Let the user turn it off via --e/d, but let that
1141   # default to on for easier handling.
1142   USE_NLS=no
1143   AC_ARG_ENABLE(nls,
1144     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1145     [],
1146     [enable_nls=yes])
1147
1148   # Set configure bits for specified locale package
1149   case ${enable_clocale_flag} in
1150     generic)
1151       AC_MSG_RESULT(generic)
1152
1153       CLOCALE_H=config/locale/generic/c_locale.h
1154       CLOCALE_CC=config/locale/generic/c_locale.cc
1155       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1156       CCOLLATE_CC=config/locale/generic/collate_members.cc
1157       CCTYPE_CC=config/locale/generic/ctype_members.cc
1158       CMESSAGES_H=config/locale/generic/messages_members.h
1159       CMESSAGES_CC=config/locale/generic/messages_members.cc
1160       CMONEY_CC=config/locale/generic/monetary_members.cc
1161       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1162       CTIME_H=config/locale/generic/time_members.h
1163       CTIME_CC=config/locale/generic/time_members.cc
1164       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1165       ;;
1166     darwin)
1167       AC_MSG_RESULT(darwin or freebsd)
1168
1169       CLOCALE_H=config/locale/generic/c_locale.h
1170       CLOCALE_CC=config/locale/generic/c_locale.cc
1171       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1172       CCOLLATE_CC=config/locale/generic/collate_members.cc
1173       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1174       CMESSAGES_H=config/locale/generic/messages_members.h
1175       CMESSAGES_CC=config/locale/generic/messages_members.cc
1176       CMONEY_CC=config/locale/generic/monetary_members.cc
1177       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1178       CTIME_H=config/locale/generic/time_members.h
1179       CTIME_CC=config/locale/generic/time_members.cc
1180       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1181       ;;
1182
1183     gnu)
1184       AC_MSG_RESULT(gnu)
1185
1186       # Declare intention to use gettext, and add support for specific
1187       # languages.
1188       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1189       ALL_LINGUAS="de fr"
1190
1191       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1192       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1193       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1194         USE_NLS=yes
1195       fi
1196       # Export the build objects.
1197       for ling in $ALL_LINGUAS; do \
1198         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1199         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1200       done
1201       AC_SUBST(glibcxx_MOFILES)
1202       AC_SUBST(glibcxx_POFILES)
1203
1204       CLOCALE_H=config/locale/gnu/c_locale.h
1205       CLOCALE_CC=config/locale/gnu/c_locale.cc
1206       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1207       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1208       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1209       CMESSAGES_H=config/locale/gnu/messages_members.h
1210       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1211       CMONEY_CC=config/locale/gnu/monetary_members.cc
1212       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1213       CTIME_H=config/locale/gnu/time_members.h
1214       CTIME_CC=config/locale/gnu/time_members.cc
1215       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1216       ;;
1217     ieee_1003.1-2001)
1218       AC_MSG_RESULT(IEEE 1003.1)
1219
1220       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1221       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1222       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1223       CCOLLATE_CC=config/locale/generic/collate_members.cc
1224       CCTYPE_CC=config/locale/generic/ctype_members.cc
1225       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1226       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1227       CMONEY_CC=config/locale/generic/monetary_members.cc
1228       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1229       CTIME_H=config/locale/generic/time_members.h
1230       CTIME_CC=config/locale/generic/time_members.cc
1231       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1232       ;;
1233   esac
1234
1235   # This is where the testsuite looks for locale catalogs, using the
1236   # -DLOCALEDIR define during testsuite compilation.
1237   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1238   AC_SUBST(glibcxx_localedir)
1239
1240   # A standalone libintl (e.g., GNU libintl) may be in use.
1241   if test $USE_NLS = yes; then
1242     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1243     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1244   fi
1245   if test $USE_NLS = yes; then
1246     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1247               [Define if NLS translations are to be used.])
1248   fi
1249
1250   AC_SUBST(USE_NLS)
1251   AC_SUBST(CLOCALE_H)
1252   AC_SUBST(CMESSAGES_H)
1253   AC_SUBST(CCODECVT_CC)
1254   AC_SUBST(CCOLLATE_CC)
1255   AC_SUBST(CCTYPE_CC)
1256   AC_SUBST(CMESSAGES_CC)
1257   AC_SUBST(CMONEY_CC)
1258   AC_SUBST(CNUMERIC_CC)
1259   AC_SUBST(CTIME_H)
1260   AC_SUBST(CTIME_CC)
1261   AC_SUBST(CLOCALE_CC)
1262   AC_SUBST(CLOCALE_INTERNAL_H)
1263 ])
1264
1265
1266 dnl
1267 dnl Check for which std::allocator base class to use.  The choice is
1268 dnl mapped from a subdirectory of include/ext.
1269 dnl
1270 dnl Default is new.
1271 dnl
1272 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1273   AC_MSG_CHECKING([for std::allocator base class])
1274   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1275     [use KIND for target std::allocator base],
1276     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1277
1278   # If they didn't use this option switch, or if they specified --enable
1279   # with no specific model, we'll have to look for one.  If they
1280   # specified --disable (???), do likewise.
1281   if test $enable_libstdcxx_allocator = no ||
1282      test $enable_libstdcxx_allocator = yes;
1283   then
1284      enable_libstdcxx_allocator=auto
1285   fi
1286
1287   # Either a known package, or "auto". Auto implies the default choice
1288   # for a particular platform.
1289   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1290
1291   # Probe for host-specific support if no specific model is specified.
1292   # Default to "new".
1293   if test $enable_libstdcxx_allocator_flag = auto; then
1294     case ${target_os} in
1295       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1296         enable_libstdcxx_allocator_flag=new
1297         ;;
1298       *)
1299         enable_libstdcxx_allocator_flag=new
1300         ;;
1301     esac
1302   fi
1303   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1304
1305
1306   # Set configure bits for specified locale package
1307   case ${enable_libstdcxx_allocator_flag} in
1308     bitmap)
1309       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1310       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1311       ;;
1312     malloc)
1313       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1314       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1315       ;;
1316     mt)
1317       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1318       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1319       ;;
1320     new)
1321       ALLOCATOR_H=config/allocator/new_allocator_base.h
1322       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1323       ;;
1324     pool)
1325       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1326       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1327       ;;
1328   esac
1329
1330   AC_SUBST(ALLOCATOR_H)
1331   AC_SUBST(ALLOCATOR_NAME)
1332 ])
1333
1334
1335 dnl
1336 dnl Check for whether the Boost-derived checks should be turned on.
1337 dnl
1338 dnl --enable-concept-checks turns them on.
1339 dnl --disable-concept-checks leaves them off.
1340 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1341 dnl       Where DEFAULT is either `yes' or `no'.
1342 dnl
1343 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1344   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1345   if test $enable_concept_checks = yes; then
1346     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1347               [Define to use concept checking code from the boost libraries.])
1348   fi
1349 ])
1350
1351
1352 dnl
1353 dnl Check for which I/O library to use:  stdio, or something specific.
1354 dnl
1355 dnl Default is stdio.
1356 dnl
1357 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1358   AC_MSG_CHECKING([for underlying I/O to use])
1359   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1360     [use target-specific I/O package], [permit stdio])
1361
1362   # Now that libio has been removed, you can have any color you want as long
1363   # as it's black.  This is one big no-op until other packages are added, but
1364   # showing the framework never hurts.
1365   case ${enable_cstdio} in
1366     stdio)
1367       CSTDIO_H=config/io/c_io_stdio.h
1368       BASIC_FILE_H=config/io/basic_file_stdio.h
1369       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1370       AC_MSG_RESULT(stdio)
1371       ;;
1372   esac
1373
1374   AC_SUBST(CSTDIO_H)
1375   AC_SUBST(BASIC_FILE_H)
1376   AC_SUBST(BASIC_FILE_CC)
1377 ])
1378
1379
1380 dnl
1381 dnl Check for "unusual" flags to pass to the compiler while building.
1382 dnl
1383 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1384 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1385 dnl --disable-cxx-flags passes nothing.
1386 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1387 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1388 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1389 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1390 dnl       If "default flags" is an empty string, the effect is the same
1391 dnl       as --disable or --enable=no.
1392 dnl
1393 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1394   AC_MSG_CHECKING([for extra compiler flags for building])
1395   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1396     [pass compiler FLAGS when building library],
1397     [case "x$enable_cxx_flags" in
1398       xno | x)   enable_cxx_flags= ;;
1399       x-*)       ;;
1400       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1401      esac])
1402
1403   # Run through flags (either default or command-line) and set anything
1404   # extra (e.g., #defines) that must accompany particular g++ options.
1405   if test -n "$enable_cxx_flags"; then
1406     for f in $enable_cxx_flags; do
1407       case "$f" in
1408         -fhonor-std)  ;;
1409         -*)  ;;
1410         *)   # and we're trying to pass /what/ exactly?
1411              AC_MSG_ERROR([compiler flags start with a -]) ;;
1412       esac
1413     done
1414   fi
1415
1416   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1417   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1418   AC_SUBST(EXTRA_CXX_FLAGS)
1419 ])
1420
1421
1422 dnl
1423 dnl Check to see if debugging libraries are to be built.
1424 dnl
1425 dnl --enable-libstdcxx-debug
1426 dnl builds a separate set of debugging libraries in addition to the
1427 dnl normal (shared, static) libstdc++ binaries.
1428 dnl
1429 dnl --disable-libstdcxx-debug
1430 dnl builds only one (non-debug) version of libstdc++.
1431 dnl
1432 dnl --enable-libstdcxx-debug-flags=FLAGS
1433 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1434 dnl
1435 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1436 dnl       Where DEFAULT is either `yes' or `no'.
1437 dnl
1438 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1439   AC_MSG_CHECKING([for additional debug build])
1440   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1441   AC_MSG_RESULT($enable_libstdcxx_debug)
1442   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1443 ])
1444
1445
1446 dnl
1447 dnl Check for explicit debug flags.
1448 dnl
1449 dnl --enable-libstdcxx-debug-flags='-O1'
1450 dnl is a general method for passing flags to be used when
1451 dnl building debug libraries with --enable-debug.
1452 dnl
1453 dnl --disable-libstdcxx-debug-flags does nothing.
1454 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1455 dnl       If "default flags" is an empty string, the effect is the same
1456 dnl       as --disable or --enable=no.
1457 dnl
1458 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1459   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1460     [pass compiler FLAGS when building debug library],
1461     [case "x$enable_libstdcxx_debug_flags" in
1462       xno | x)    enable_libstdcxx_debug_flags= ;;
1463       x-*)        ;;
1464       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1465      esac])
1466
1467   # Option parsed, now set things appropriately
1468   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1469   AC_SUBST(DEBUG_FLAGS)
1470
1471   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1472 ])
1473
1474
1475 dnl
1476 dnl Check if the user only wants a freestanding library implementation.
1477 dnl
1478 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1479 dnl installing only the headers required by [17.4.1.3] and the language
1480 dnl support library.  More than that will be built (to keep the Makefiles
1481 dnl conveniently clean), but not installed.
1482 dnl
1483 dnl Sets:
1484 dnl  is_hosted  (yes/no)
1485 dnl
1486 dnl Defines:
1487 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1488 dnl
1489 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1490   AC_ARG_ENABLE([hosted-libstdcxx],
1491     AC_HELP_STRING([--disable-hosted-libstdcxx],
1492                    [only build freestanding C++ runtime support]),,
1493     [case "$host" in
1494         arm*-*-symbianelf*)
1495             enable_hosted_libstdcxx=no
1496             ;;
1497         *)
1498             enable_hosted_libstdcxx=yes
1499             ;;
1500      esac])
1501   if test "$enable_hosted_libstdcxx" = no; then
1502     AC_MSG_NOTICE([Only freestanding libraries will be built])
1503     is_hosted=no
1504     hosted_define=0
1505     enable_abi_check=no
1506     enable_libstdcxx_pch=no
1507   else
1508     is_hosted=yes
1509     hosted_define=1
1510   fi
1511   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1512   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1513     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1514 ])
1515
1516
1517 dnl
1518 dnl Check for template specializations for the 'long long' type.
1519 dnl The result determines only whether 'long long' I/O is enabled; things
1520 dnl like numeric_limits<> specializations are always available.
1521 dnl
1522 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1523 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1524 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1525 dnl       Where DEFAULT is either `yes' or `no'.
1526 dnl
1527 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1528   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
1529   if test $enable_long_long = yes; then
1530     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
1531               [Define if code specialized for long long should be used.])
1532   fi
1533   AC_MSG_CHECKING([for enabled long long specializations])
1534   AC_MSG_RESULT([$enable_long_long])
1535 ])
1536
1537
1538 dnl
1539 dnl Check for template specializations for the 'wchar_t' type.
1540 dnl
1541 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
1542 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
1543 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
1544 dnl       Where DEFAULT is either `yes' or `no'.
1545 dnl
1546 dnl Necessary support (probed along with C99 support) must also be present.
1547 dnl
1548 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
1549   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
1550   if test x"$ac_c99_wchar" = x"yes" && test x"$enable_wchar_t" = x"yes"; then
1551     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
1552               [Define if code specialized for wchar_t should be used.])
1553   fi
1554   AC_MSG_CHECKING([for enabled wchar_t specializations])
1555   AC_MSG_RESULT([$enable_wchar_t])
1556 ])
1557
1558
1559 dnl
1560 dnl Check to see if building and using a C++ precompiled header can be done.
1561 dnl
1562 dnl --enable-libstdcxx-pch=yes
1563 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1564 dnl may work, after some light-hearted attempts to puzzle out compiler
1565 dnl support, flip bits on in include/Makefile.am
1566 dnl
1567 dnl --disable-libstdcxx-pch
1568 dnl turns off attempts to use or build stdc++.h.gch.
1569 dnl
1570 dnl Substs:
1571 dnl  glibcxx_PCHFLAGS
1572 dnl
1573 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1574   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1575   if test $enable_libstdcxx_pch = yes; then
1576     AC_CACHE_CHECK([for compiler with PCH support],
1577       [glibcxx_cv_prog_CXX_pch],
1578       [ac_save_CXXFLAGS="$CXXFLAGS"
1579        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1580        AC_LANG_SAVE
1581        AC_LANG_CPLUSPLUS
1582        echo '#include <math.h>' > conftest.h
1583        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1584                           -o conftest.h.gch 1>&5 2>&1 &&
1585                 echo '#error "pch failed"' > conftest.h &&
1586           echo '#include "conftest.h"' > conftest.cc &&
1587                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1588        then
1589          glibcxx_cv_prog_CXX_pch=yes
1590        else
1591          glibcxx_cv_prog_CXX_pch=no
1592        fi
1593        rm -f conftest*
1594        CXXFLAGS=$ac_save_CXXFLAGS
1595        AC_LANG_RESTORE
1596       ])
1597     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1598   fi
1599
1600   AC_MSG_CHECKING([for enabled PCH])
1601   AC_MSG_RESULT([$enable_libstdcxx_pch])
1602
1603   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1604   if test $enable_libstdcxx_pch = yes; then
1605     glibcxx_PCHFLAGS="-include bits/stdc++.h"
1606   else
1607     glibcxx_PCHFLAGS=""
1608   fi
1609   AC_SUBST(glibcxx_PCHFLAGS)
1610 ])
1611
1612
1613 dnl
1614 dnl Check for exception handling support.  If an explicit enable/disable
1615 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1616 dnl target may or may not support call frame exceptions.
1617 dnl
1618 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1619 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1620 dnl Neither one forces an attempt at detection.
1621 dnl
1622 dnl Defines:
1623 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
1624 dnl
1625 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
1626   AC_MSG_CHECKING([for exception model to use])
1627   AC_LANG_SAVE
1628   AC_LANG_CPLUSPLUS
1629   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
1630     [force use of builtin_setjmp for exceptions],
1631     [permit yes|no|auto])
1632
1633   if test $enable_sjlj_exceptions = auto; then
1634     # Botheration.  Now we've got to detect the exception model.  Link tests
1635     # against libgcc.a are problematic since we've not been given proper -L
1636     # bits for single-tree newlib and libgloss.
1637     #
1638     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
1639     cat > conftest.$ac_ext << EOF
1640 [#]line __oline__ "configure"
1641 struct S { ~S(); };
1642 void bar();
1643 void foo()
1644 {
1645   S s;
1646   bar();
1647 }
1648 EOF
1649     old_CXXFLAGS="$CXXFLAGS"
1650     CXXFLAGS=-S
1651     if AC_TRY_EVAL(ac_compile); then
1652       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1653         enable_sjlj_exceptions=yes
1654       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1655         enable_sjlj_exceptions=no
1656       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
1657         enable_sjlj_exceptions=no
1658       fi
1659     fi
1660     CXXFLAGS="$old_CXXFLAGS"
1661     rm -f conftest*
1662   fi
1663
1664   # This is a tad weird, for hysterical raisins.  We have to map
1665   # enable/disable to two different models.
1666   case $enable_sjlj_exceptions in
1667     yes)
1668       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
1669         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1670       ac_exception_model_name=sjlj
1671       ;;
1672     no)
1673       ac_exception_model_name="call frame"
1674       ;;
1675     *)
1676       AC_MSG_ERROR([unable to detect exception model])
1677       ;;
1678   esac
1679  AC_LANG_RESTORE
1680  AC_MSG_RESULT($ac_exception_model_name)
1681 ])
1682
1683
1684 dnl
1685 dnl Add version tags to symbols in shared library (or not), additionally
1686 dnl marking other symbols as private/local (or not).
1687 dnl
1688 dnl --enable-symvers=style adds a version script to the linker call when
1689 dnl       creating the shared library.  The choice of version script is
1690 dnl       controlled by 'style'.
1691 dnl --disable-symvers does not.
1692 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
1693 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
1694 dnl       choose a default style based on linker characteristics.  Passing
1695 dnl       'no' disables versioning.
1696 dnl
1697 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
1698
1699 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
1700   [enables symbol versioning of the shared library],
1701   [permit yes|no|gnu|darwin-export])
1702
1703 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
1704 # don't know enough about $LD to do tricks...
1705 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
1706
1707 # Turn a 'yes' into a suitable default.
1708 if test x$enable_symvers = xyes ; then
1709   if test $enable_shared = no ||
1710      test "x$LD" = x ; then
1711     enable_symvers=no
1712   elif test $with_gnu_ld = yes ; then
1713     enable_symvers=gnu
1714   else
1715     case ${target_os} in
1716       darwin*)
1717         enable_symvers=darwin-export ;;
1718       *)
1719       AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
1720       AC_MSG_WARN([=== you are not using a supported linker.])
1721       AC_MSG_WARN([=== Symbol versioning will be disabled.])
1722         enable_symvers=no ;;
1723     esac
1724   fi
1725 fi
1726
1727 # Check to see if 'gnu' can win.
1728 if test $enable_symvers = gnu; then
1729   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
1730   AC_MSG_CHECKING([for shared libgcc])
1731   ac_save_CFLAGS="$CFLAGS"
1732   CFLAGS=' -lgcc_s'
1733   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
1734   CFLAGS="$ac_save_CFLAGS"
1735   if test $glibcxx_shared_libgcc = no; then
1736     cat > conftest.c <<EOF
1737 int main (void) { return 0; }
1738 EOF
1739 changequote(,)dnl
1740     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
1741                              -shared -shared-libgcc -o conftest.so \
1742                              conftest.c -v 2>&1 >/dev/null \
1743                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
1744 changequote([,])dnl
1745     rm -f conftest.c conftest.so
1746     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
1747       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
1748       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
1749       CFLAGS="$ac_save_CFLAGS"
1750     fi
1751   fi
1752   AC_MSG_RESULT($glibcxx_shared_libgcc)
1753
1754   # For GNU ld, we need at least this version.  The format is described in
1755   # GLIBCXX_CHECK_LINKER_FEATURES above.
1756   glibcxx_min_gnu_ld_version=21400
1757
1758   # If no shared libgcc, can't win.
1759   if test $glibcxx_shared_libgcc != yes; then
1760       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
1761       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
1762       AC_MSG_WARN([=== Symbol versioning will be disabled.])
1763       enable_symvers=no
1764   elif test $with_gnu_ld != yes ; then
1765     # just fail for now
1766     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
1767     AC_MSG_WARN([=== you are not using the GNU linker.])
1768     AC_MSG_WARN([=== Symbol versioning will be disabled.])
1769     enable_symvers=no
1770   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
1771     # The right tools, the right setup, but too old.  Fallbacks?
1772     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
1773     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
1774     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
1775     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
1776     AC_MSG_WARN([=== Symbol versioning will be disabled.])
1777     enable_symvers=no
1778   fi
1779 fi
1780
1781 # Everything parsed; figure out what file to use.
1782 case $enable_symvers in
1783   no)
1784     SYMVER_MAP=config/linker-map.dummy
1785     ;;
1786   gnu)
1787     SYMVER_MAP=config/linker-map.gnu
1788     AC_DEFINE(_GLIBCXX_SYMVER, 1,
1789               [Define to use GNU symbol versioning in the shared library.])
1790     ;;
1791   darwin-export)
1792     SYMVER_MAP=config/linker-map.gnu
1793     ;;
1794 esac
1795
1796 # In addition, need this to deal with std::size_t mangling in
1797 # src/compatibility.cc.  In a perfect world, could use
1798 # typeid(std::size_t).name()[0] to do direct substitution.
1799 AC_MSG_CHECKING([for size_t as unsigned int])
1800 ac_save_CFLAGS="$CFLAGS"
1801 CFLAGS="-Werror"
1802 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
1803                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
1804 CFLAGS=$ac_save_CFLAGS
1805 if test "$glibcxx_size_t_is_i" = yes; then
1806   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
1807 fi
1808 AC_MSG_RESULT([$glibcxx_size_t_is_i])
1809
1810 AC_MSG_CHECKING([for ptrdiff_t as int])
1811 ac_save_CFLAGS="$CFLAGS"
1812 CFLAGS="-Werror"
1813 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
1814                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
1815 CFLAGS=$ac_save_CFLAGS
1816 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
1817   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
1818 fi
1819 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
1820
1821 AC_SUBST(SYMVER_MAP)
1822 AC_SUBST(port_specific_symbol_files)
1823 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
1824 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN_EXPORT, dnl
1825   test $enable_symvers = darwin-export)
1826 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
1827 ])
1828
1829
1830 dnl
1831 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1832 dnl We must stage the required headers so that they will be installed
1833 dnl with the library (unlike libgcc, the STL implementation is provided
1834 dnl solely within headers).  Since we must not inject random user-space
1835 dnl macro names into user-provided C++ code, we first stage into <file>-in
1836 dnl and process to <file> with an output command.  The reason for a two-
1837 dnl stage process here is to correctly handle $srcdir!=$objdir without
1838 dnl having to write complex code (the sed commands to clean the macro
1839 dnl namespace are complex and fragile enough as it is).  We must also
1840 dnl add a relative path so that -I- is supported properly.
1841 dnl
1842 dnl Substs:
1843 dnl  glibcxx_thread_h
1844 dnl
1845 dnl Defines:
1846 dnl  HAVE_GTHR_DEFAULT
1847 dnl
1848 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
1849   AC_MSG_CHECKING([for thread model used by GCC])
1850   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
1851   AC_MSG_RESULT([$target_thread_file])
1852
1853   if test $target_thread_file != single; then
1854     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
1855               [Define if gthr-default.h exists
1856               (meaning that threading support is enabled).])
1857   fi
1858
1859   glibcxx_thread_h=gthr-$target_thread_file.h
1860
1861   dnl Check for __GTHREADS define.
1862   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
1863   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
1864     enable_thread=yes
1865   else
1866    enable_thread=no
1867   fi
1868
1869   AC_SUBST(glibcxx_thread_h)
1870 ])
1871
1872
1873 # Check whether LC_MESSAGES is available in <locale.h>.
1874 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1875 #
1876 # This file file be copied and used freely without restrictions.  It can
1877 # be used in projects which are not available under the GNU Public License
1878 # but which still want to provide support for the GNU gettext functionality.
1879 # Please note that the actual code is *not* freely available.
1880
1881 # serial 1
1882 AC_DEFUN([AC_LC_MESSAGES], [
1883   AC_CHECK_HEADER(locale.h, [
1884     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1885       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1886        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1887     if test $ac_cv_val_LC_MESSAGES = yes; then
1888       AC_DEFINE(HAVE_LC_MESSAGES, 1,
1889                 [Define if LC_MESSAGES is available in <locale.h>.])
1890     fi
1891   ])
1892 ])
1893
1894 # Macros from the top-level gcc directory.
1895 m4_include([../config/tls.m4])
1896