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