libstdc++-v3/acinclude.m4

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