libstdc++-v3/acinclude.m4

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