libstdc++-v3/acinclude.m4

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