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