3 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
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.
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])
16 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])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.
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])
32 dnl Initialize basic configure bits.
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(, ..)
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
48 # Looking in multi_basedir seems smarter, so actually execute that branch.
50 # this is for automake
53 # this is for autoconf
54 AC_CONFIG_AUX_DIRS(${multi_basedir})
63 dnl Initialize the rest of the library configury. At this point we have
64 dnl variables like $host.
67 dnl gcc_version (x.y.z format)
70 dnl glibcxx_builddir (absolute path)
71 dnl glibcxx_srcdir (absolute path)
72 dnl toplevel_srcdir (absolute path)
75 dnl with_target_subdir
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
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'
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}`
93 [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
94 *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
96 toplevel_srcdir=${glibcxx_srcdir}/..
97 AC_SUBST(glibcxx_builddir)
98 AC_SUBST(glibcxx_srcdir)
99 AC_SUBST(toplevel_srcdir)
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]))
107 AC_ARG_WITH([cross-host],
108 AC_HELP_STRING([--with-cross-host=HOST],
109 [configuring with a cross compiler]))
111 AC_ARG_WITH([newlib],
112 AC_HELP_STRING([--with-newlib],
113 [assume newlib as a system C library]))
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.
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.
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.
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"
139 CXXFLAGS="$save_CXXFLAGS"
140 m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
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)
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.
154 AC_CHECK_TOOL(AS, as)
155 AC_CHECK_TOOL(AR, ar)
156 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
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
166 #enable_libstdcxx_debug=no
167 #enable_libstdcxx_pch=no
172 #enable_hosted_libstdcxx=yes
174 # Find platform-specific directories containing configuration info.
175 # Also possibly modify flags used elsewhere, as needed by the platform.
180 m4_include([linkage.m4])
181 m4_include([../config/no-executables.m4])
185 dnl Tests for newer compiler features, or features that are present in newer
186 dnl compiler versions but not older compiler versions still in use, should
190 dnl WERROR='-Werror' if requested and possible; g++'s that lack the
191 dnl new inlining code or the new system_header pragma will die on -Werror.
192 dnl Leave it out by default and use maint-mode to use it.
193 dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if
194 dnl compiler supports it and the user has not requested debug mode.
196 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
197 # All these tests are for C++; save the language and the compiler flags.
198 # The CXXFLAGS thing is suspicious, but based on similar bits previously
199 # found in GLIBCXX_CONFIGURE.
202 ac_test_CXXFLAGS="${CXXFLAGS+set}"
203 ac_save_CXXFLAGS="$CXXFLAGS"
205 # Check for maintainer-mode bits.
206 if test x"$USE_MAINTAINER_MODE" = xno; then
212 # Check for -ffunction-sections -fdata-sections
213 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
214 CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
215 AC_TRY_COMPILE(, [int foo;], [ac_fdsections=yes], [ac_fdsections=no])
216 if test "$ac_test_CXXFLAGS" = set; then
217 CXXFLAGS="$ac_save_CXXFLAGS"
219 # this is the suspicious part
222 if test x"$ac_fdsections" = x"yes"; then
223 SECTION_FLAGS='-ffunction-sections -fdata-sections'
225 AC_MSG_RESULT($ac_fdsections)
229 AC_SUBST(SECTION_FLAGS)
234 dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
235 dnl the native linker is in use, all variables will be defined to something
236 dnl safe (like an empty string).
239 dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
240 dnl OPT_LDFLAGS='-Wl,-O1' if possible
241 dnl LD (as a side effect of testing)
244 dnl glibcxx_gnu_ld_version (possibly)
246 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
247 dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
249 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
250 # If we're not using GNU ld, then there's no point in even trying these
251 # tests. Check for that first. We should have already tested for gld
252 # by now (in libtool), but require it now just to be safe...
253 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
254 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
255 AC_REQUIRE([AC_PROG_LD])
256 AC_REQUIRE([AC_PROG_AWK])
258 # The name set by libtool depends on the version of libtool. Shame on us
259 # for depending on an impl detail, but c'est la vie. Older versions used
260 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
261 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
262 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
263 # set (hence we're using an older libtool), then set it.
264 if test x${with_gnu_ld+set} != xset; then
265 if test x${ac_cv_prog_gnu_ld+set} != xset; then
266 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
269 with_gnu_ld=$ac_cv_prog_gnu_ld
273 # Start by getting the version number. I think the libtool test already
274 # does some of this, but throws away the result.
276 ldver=`$LD --version 2>/dev/null | head -1 | \
277 sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
279 glibcxx_gnu_ld_version=`echo $ldver | \
280 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
283 if test "$with_gnu_ld" = "notbroken"; then
284 # GNU ld it is! Joy and bunny rabbits!
286 # All these tests are for C++; save the language and the compiler flags.
287 # Need to do this so that g++ won't try to link in libstdc++
288 ac_test_CFLAGS="${CFLAGS+set}"
289 ac_save_CFLAGS="$CFLAGS"
290 CFLAGS='-x c++ -Wl,--gc-sections'
292 # Check for -Wl,--gc-sections
293 # XXX This test is broken at the moment, as symbols required for linking
294 # are now in libsupc++ (not built yet). In addition, this test has
295 # cored on solaris in the past. In addition, --gc-sections doesn't
296 # really work at the moment (keeps on discarding used sections, first
297 # .eh_frame and now some of the glibc sections for iconv).
298 # Bzzzzt. Thanks for playing, maybe next time.
299 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
307 ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
308 if test "$ac_test_CFLAGS" = set; then
309 CFLAGS="$ac_save_CFLAGS"
311 # this is the suspicious part
314 if test "$ac_sectionLDflags" = "yes"; then
315 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
317 AC_MSG_RESULT($ac_sectionLDflags)
320 # Set linker optimization flags.
321 if test x"$with_gnu_ld" = x"yes"; then
322 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
325 AC_SUBST(SECTION_LDFLAGS)
326 AC_SUBST(OPT_LDFLAGS)
331 dnl Check to see if this target can enable the wchar_t parts.
332 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled. (This
333 dnl must have been previously checked.) By default, wide characters are
337 dnl HAVE_MBSTATE_T if mbstate_t is not in wchar.h
338 dnl _GLIBCXX_USE_WCHAR_T if all the bits are found.
340 dnl LIBICONV to a -l string containing the iconv library, if needed.
342 AC_DEFUN([GLIBCXX_CHECK_WCHAR_T_SUPPORT], [
343 # Test wchar.h for mbstate_t, which is needed for char_traits and
344 # others even if wchar_t support is not on.
345 AC_MSG_CHECKING([for mbstate_t])
346 AC_TRY_COMPILE([#include <wchar.h>],
347 [mbstate_t teststate;],
348 have_mbstate_t=yes, have_mbstate_t=no)
349 AC_MSG_RESULT($have_mbstate_t)
350 if test x"$have_mbstate_t" = xyes; then
351 AC_DEFINE(HAVE_MBSTATE_T)
354 # Sanity check for existence of ISO C99 headers for extended encoding.
355 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
356 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
358 # Only continue checking if the ISO C99 headers exist and support is on.
359 if test x"$ac_has_wchar_h" = xyes &&
360 test x"$ac_has_wctype_h" = xyes &&
361 test x"$enable_c_mbchar" != xno; then
363 # Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
364 # numeric_limits can instantiate type_traits<wchar_t>
365 AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
366 AC_TRY_COMPILE([#include <wchar.h>],
367 [int i = WCHAR_MIN; int j = WCHAR_MAX;],
368 has_wchar_minmax=yes, has_wchar_minmax=no)
369 AC_MSG_RESULT($has_wchar_minmax)
371 # Test wchar.h for WEOF, which is what we use to determine whether
372 # to specialize for char_traits<wchar_t> or not.
373 AC_MSG_CHECKING([for WEOF])
376 #include <stddef.h>],
378 has_weof=yes, has_weof=no)
379 AC_MSG_RESULT($has_weof)
381 # Tests for wide character functions used in char_traits<wchar_t>.
383 AC_CHECK_FUNCS([wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset],
386 # Checks for names injected into std:: by the c_std headers.
387 AC_CHECK_FUNCS([btowc wctob fgetwc fgetws fputwc fputws fwide \
388 fwprintf fwscanf swprintf swscanf vfwprintf vswprintf \
389 vwprintf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
390 mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstol \
391 wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
392 wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr],
395 # Checks for wide character functions that are not required
396 # for basic wchar_t support. Don't disable support if they are missing.
397 # Injection of these is wrapped with guard macros.
398 AC_CHECK_FUNCS([vfwscanf vswscanf vwscanf wcstof iswblank],[],[])
400 AC_MSG_CHECKING([for ISO C99 wchar_t support])
401 if test x"$has_weof" = xyes &&
402 test x"$has_wchar_minmax" = xyes &&
403 test x"$ac_wfuncs" = xyes;
405 ac_isoC99_wchar_t=yes
409 AC_MSG_RESULT($ac_isoC99_wchar_t)
411 # Use iconv for wchar_t to char conversions. As such, check for
412 # X/Open Portability Guide, version 2 features (XPG2).
413 AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
414 AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
416 # Check for existence of libiconv.a providing XPG2 wchar_t support.
417 AC_CHECK_LIB(iconv, iconv, LIBICONV="-liconv")
419 LIBS="$LIBS $LIBICONV"
422 AC_CHECK_FUNCS([iconv_open iconv_close iconv nl_langinfo],
423 [ac_XPG2funcs=yes], [ac_XPG2funcs=no])
427 AC_MSG_CHECKING([for XPG2 wchar_t support])
428 if test x"$ac_has_iconv_h" = xyes &&
429 test x"$ac_has_langinfo_h" = xyes &&
430 test x"$ac_XPG2funcs" = xyes;
436 AC_MSG_RESULT($ac_XPG2_wchar_t)
438 # At the moment, only enable wchar_t specializations if all the
439 # above support is present.
440 if test x"$ac_isoC99_wchar_t" = xyes &&
441 test x"$ac_XPG2_wchar_t" = xyes;
443 AC_DEFINE(_GLIBCXX_USE_WCHAR_T)
447 AC_MSG_CHECKING([for enabled wchar_t specializations])
448 AC_MSG_RESULT($enable_wchar_t)
453 dnl Check for headers for, and arguments to, the setrlimit() function.
454 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
457 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
458 dnl various HAVE_LIMIT_* for individual limit names
460 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
463 #include <sys/time.h>
464 #include <sys/resource.h>
466 [ int f = RLIMIT_$1 ; ],
467 [glibcxx_mresult=1], [glibcxx_mresult=0])
468 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
469 [Only used in build directory testsuite_hooks.h.])
472 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
473 setrlimit_have_headers=yes
474 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
476 [setrlimit_have_headers=no])
477 # If don't have the headers, then we can't run the tests now, and we
478 # won't be seeing any of these during testsuite compilation.
479 if test $setrlimit_have_headers = yes; then
480 # Can't do these in a loop, else the resulting syntax is wrong.
481 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
482 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
483 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
484 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
485 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
487 # Check for rlimit, setrlimit.
488 AC_CACHE_VAL(ac_setrlimit, [
491 #include <sys/time.h>
492 #include <sys/resource.h>
496 [ac_setrlimit=yes], [ac_setrlimit=no])
500 AC_MSG_CHECKING([for testsuite resource limits support])
501 if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
503 AC_DEFINE(_GLIBCXX_RES_LIMITS)
507 AC_MSG_RESULT($ac_res_limits)
512 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
513 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
515 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
516 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
518 [#include <sys/stat.h>],
521 S_ISREG(buffer.st_mode);],
522 [glibcxx_cv_S_ISREG=yes],
523 [glibcxx_cv_S_ISREG=no])
525 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
527 [#include <sys/stat.h>],
530 S_IFREG & buffer.st_mode;],
531 [glibcxx_cv_S_IFREG=yes],
532 [glibcxx_cv_S_IFREG=no])
534 if test $glibcxx_cv_S_ISREG = yes; then
535 AC_DEFINE(HAVE_S_ISREG)
536 elif test $glibcxx_cv_S_IFREG = yes; then
537 AC_DEFINE(HAVE_S_IFREG)
543 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
545 AC_DEFUN([GLIBCXX_CHECK_POLL], [
546 AC_CACHE_VAL(glibcxx_cv_POLL, [
549 [struct pollfd pfd[1];
550 pfd[0].events = POLLIN;
552 [glibcxx_cv_POLL=yes],
553 [glibcxx_cv_POLL=no])
555 if test $glibcxx_cv_POLL = yes; then
562 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
564 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
565 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
567 [#include <sys/uio.h>],
568 [struct iovec iov[2];
570 [glibcxx_cv_WRITEV=yes],
571 [glibcxx_cv_WRITEV=no])
573 if test $glibcxx_cv_WRITEV = yes; then
574 AC_DEFINE(HAVE_WRITEV)
580 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
582 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
583 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
585 [#include <stdint.h>],
587 [glibcxx_cv_INT64_T=yes],
588 [glibcxx_cv_INT64_T=no])
590 if test $glibcxx_cv_INT64_T = yes; then
591 AC_DEFINE(HAVE_INT64_T)
597 dnl Check whether LFS support is available.
599 AC_DEFUN([GLIBCXX_CHECK_LFS], [
602 ac_save_CXXFLAGS="$CXXFLAGS"
603 CXXFLAGS="$CXXFLAGS -fno-exceptions"
604 AC_CACHE_VAL(glibcxx_cv_LFS, [
611 fseeko64(fp, 0, SEEK_CUR);
613 lseek64(1, 0, SEEK_CUR);],
614 [glibcxx_cv_LFS=yes],
617 if test $glibcxx_cv_LFS = yes; then
618 AC_DEFINE(_GLIBCXX_USE_LFS)
620 CXXFLAGS="$ac_save_CXXFLAGS"
626 dnl Does any necessary configuration of the testsuite directory. Generates
627 dnl the testsuite_hooks.h header.
629 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
632 dnl enable_abi_check / GLIBCXX_TEST_ABI
636 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
637 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes; then
638 # Do checks for resource limit functions.
639 GLIBCXX_CHECK_SETRLIMIT
641 # Look for setenv, so that extended locale tests can be performed.
642 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
644 if test $enable_symvers = no; then
649 enable_abi_check=no ;;
651 enable_abi_check=yes ;;
655 # Only build this as native, since automake does not understand
660 # Export file names for ABI checking.
661 baseline_dir="$glibcxx_srcdir/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
662 AC_SUBST(baseline_dir)
664 GLIBCXX_CONDITIONAL(GLIBCXX_TEST_WCHAR_T, test $enable_wchar_t = yes)
665 GLIBCXX_CONDITIONAL(GLIBCXX_TEST_ABI, test $enable_abi_check = yes)
670 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
674 dnl TOPLEVEL_INCLUDES
676 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
677 # Used for every C++ compile we perform.
679 -I$glibcxx_builddir/include/$host_alias \
680 -I$glibcxx_builddir/include \
681 -I$glibcxx_srcdir/libsupc++"
683 # For Canadian crosses, pick this up too.
684 if test $CANADIAN = yes; then
685 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
688 # Stuff in the actual top level. Currently only used by libsupc++ to
689 # get unwind* headers from the gcc dir.
690 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
691 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
693 # Now, export this to all the little Makefiles....
694 AC_SUBST(GLIBCXX_INCLUDES)
695 AC_SUBST(TOPLEVEL_INCLUDES)
700 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
701 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
704 dnl OPTIMIZE_CXXFLAGS
707 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
708 # Optimization flags that are probably a good idea for thrill-seekers. Just
709 # uncomment the lines below and make, everything else is ready to go...
710 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
712 AC_SUBST(OPTIMIZE_CXXFLAGS)
714 WARN_FLAGS='-Wall -W -Wwrite-strings -Wcast-qual'
720 dnl All installation directory information is determined here.
724 dnl glibcxx_prefixdir
725 dnl glibcxx_toolexecdir
726 dnl glibcxx_toolexeclibdir
728 dnl Assumes cross_compiling bits already done, and with_cross_host in
731 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
732 glibcxx_toolexecdir=no
733 glibcxx_toolexeclibdir=no
734 glibcxx_prefixdir=$prefix
736 AC_MSG_CHECKING([for gxx-include-dir])
737 AC_ARG_WITH([gxx-include-dir],
738 AC_HELP_STRING([--with-gxx-include-dir=DIR],
739 [installation directory for include files]),
741 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
742 no) gxx_include_dir=no ;;
743 *) gxx_include_dir=$withval ;;
745 [gxx_include_dir=no])
746 AC_MSG_RESULT($gxx_include_dir)
748 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
749 AC_ARG_ENABLE([version-specific-runtime-libs],
750 AC_HELP_STRING([--enable-version-specific-runtime-libs],
751 [Specify that runtime libraries should be installed in a compiler-specific directory]),
752 [case "$enableval" in
753 yes) version_specific_libs=yes ;;
754 no) version_specific_libs=no ;;
755 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
757 [version_specific_libs=no])
758 AC_MSG_RESULT($version_specific_libs)
760 # Default case for install directory for include files.
761 if test $version_specific_libs = no && test $gxx_include_dir = no; then
762 gxx_include_dir='${prefix}'/include/c++/${gcc_version}
765 # Version-specific runtime libs processing.
766 if test $version_specific_libs = yes; then
767 # Need the gcc compiler version to know where to install libraries
768 # and header files if --enable-version-specific-runtime-libs option
769 # is selected. FIXME: these variables are misnamed, there are
770 # no executables installed in _toolexecdir or _toolexeclibdir.
771 if test x"$gxx_include_dir" = x"no"; then
772 gxx_include_dir='${libdir}/gcc/${host_alias}/'$gcc_version/include/c++
774 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
775 glibcxx_toolexeclibdir='${toolexecdir}/'$gcc_version'$(MULTISUBDIR)'
778 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
779 # Install a library built with a cross compiler in tooldir, not libdir.
780 if test x"$glibcxx_toolexecdir" = x"no"; then
781 if test -n "$with_cross_host" &&
782 test x"$with_cross_host" != x"no"; then
783 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
784 glibcxx_toolexeclibdir='${toolexecdir}/lib'
786 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
787 glibcxx_toolexeclibdir='${libdir}'
789 multi_os_directory=`$CXX -print-multi-os-directory`
790 case $multi_os_directory in
791 .) ;; # Avoid trailing /.
792 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
796 AC_MSG_CHECKING([for install location])
797 AC_MSG_RESULT($gxx_include_dir)
799 AC_SUBST(glibcxx_prefixdir)
800 AC_SUBST(gxx_include_dir)
801 AC_SUBST(glibcxx_toolexecdir)
802 AC_SUBST(glibcxx_toolexeclibdir)
808 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
809 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
810 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
812 dnl See docs/html/17_intro/configury.html#enable for documentation.
814 m4_define([GLIBCXX_ENABLE],[dnl
815 m4_define([_g_switch],[--enable-$1])dnl
816 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
817 AC_ARG_ENABLE($1,_g_help,
822 m4_bpatsubst([$5],[permit ])) ;;
823 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
824 dnl Idea for future: generate a URL pointing to
825 dnl "onlinedocs/configopts.html#whatever"
832 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
836 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
837 m4_undefine([_g_switch])dnl
838 m4_undefine([_g_help])dnl
843 dnl Check for ISO/IEC 9899:1999 "C99" support.
845 dnl --enable-c99 defines _GLIBCXX_USE_C99
846 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
847 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
848 dnl Where DEFAULT is either `yes' or `no'.
849 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
851 AC_DEFUN([GLIBCXX_ENABLE_C99], [
852 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
857 # Check for the existence of <math.h> functions used if C99 is enabled.
859 AC_MSG_CHECKING([for ISO C99 support in <math.h>])
860 AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
861 AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
862 AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
863 AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
864 AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
865 AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
866 AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
867 AC_TRY_COMPILE([#include <math.h>],
868 [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
869 AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
870 AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
871 AC_TRY_COMPILE([#include <math.h>],
872 [islessgreater(0.0,0.0);],, [ac_c99_math=no])
873 AC_TRY_COMPILE([#include <math.h>],
874 [isunordered(0.0,0.0);],, [ac_c99_math=no])
875 AC_MSG_RESULT($ac_c99_math)
877 if test x"$ac_c99_math" = x"yes"; then
878 AC_DEFINE(_GLIBCXX_USE_C99_MATH)
881 # Check for the existence in <stdio.h> of vscanf, et. al.
883 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
884 AC_TRY_COMPILE([#include <stdio.h>],
885 [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
886 AC_TRY_COMPILE([#include <stdio.h>
888 void foo(char* fmt, ...)
889 {va_list args; va_start(args, fmt);
890 vfscanf(stderr, "%i", args);}],
891 [],, [ac_c99_stdio=no])
892 AC_TRY_COMPILE([#include <stdio.h>
894 void foo(char* fmt, ...)
895 {va_list args; va_start(args, fmt);
896 vscanf("%i", args);}],
897 [],, [ac_c99_stdio=no])
898 AC_TRY_COMPILE([#include <stdio.h>
900 void foo(char* fmt, ...)
901 {va_list args; va_start(args, fmt);
902 vsnprintf(fmt, 0, "%i", args);}],
903 [],, [ac_c99_stdio=no])
904 AC_TRY_COMPILE([#include <stdio.h>
906 void foo(char* fmt, ...)
907 {va_list args; va_start(args, fmt);
908 vsscanf(fmt, "%i", args);}],
909 [],, [ac_c99_stdio=no])
910 AC_MSG_RESULT($ac_c99_stdio)
912 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
914 AC_MSG_CHECKING([for lldiv_t declaration])
915 AC_CACHE_VAL(ac_c99_lldiv_t, [
916 AC_TRY_COMPILE([#include <stdlib.h>],
918 [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
920 AC_MSG_RESULT($ac_c99_lldiv_t)
922 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
923 AC_TRY_COMPILE([#include <stdlib.h>],
924 [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
925 AC_TRY_COMPILE([#include <stdlib.h>],
926 [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
927 AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
928 AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
929 AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
930 AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
931 if test x"$ac_c99_lldiv_t" = x"no"; then
934 AC_MSG_RESULT($ac_c99_stdlib)
936 # Check for the existence of <wchar.h> functions used if C99 is enabled.
937 # XXX the wchar.h checks should be rolled into the general C99 bits.
939 AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
940 AC_TRY_COMPILE([#include <wchar.h>],
941 [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
942 AC_TRY_COMPILE([#include <wchar.h>],
943 [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
944 AC_TRY_COMPILE([#include <wchar.h>],
945 [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
946 AC_MSG_RESULT($ac_c99_wchar)
948 AC_MSG_CHECKING([for enabled ISO C99 support])
949 if test x"$ac_c99_math" = x"no" ||
950 test x"$ac_c99_stdio" = x"no" ||
951 test x"$ac_c99_stdlib" = x"no" ||
952 test x"$ac_c99_wchar" = x"no"; then
955 AC_MSG_RESULT($enable_c99)
957 if test x"$ac_99_math" = x"yes"; then
958 AC_DEFINE(_GLIBCXX_USE_C99_MATH)
961 # Option parsed, now set things appropriately
962 if test x"$enable_c99" = x"yes"; then
963 AC_DEFINE(_GLIBCXX_USE_C99)
971 dnl Check for what type of C headers to use.
973 dnl --enable-cheaders= [does stuff].
974 dnl --disable-cheaders [does not do anything, really].
975 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
976 dnl Where DEFAULT is either `c' or `c_std'.
978 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
979 GLIBCXX_ENABLE(cheaders,$1,[=KIND],
980 [construct "C" headers for g++], [permit c|c_std])
981 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
983 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
985 AC_SUBST(C_INCLUDE_DIR)
986 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
987 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
988 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
993 dnl Check for which locale library to use. The choice is mapped to
994 dnl a subdirectory of config/locale.
996 dnl Default is generic.
998 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
999 AC_MSG_CHECKING([for C locale to use])
1000 GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1001 [use MODEL for target locale package],
1002 [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1004 # If they didn't use this option switch, or if they specified --enable
1005 # with no specific model, we'll have to look for one. If they
1006 # specified --disable (???), do likewise.
1007 if test $enable_clocale = no || test $enable_clocale = yes; then
1011 # Either a known package, or "auto"
1012 enable_clocale_flag=$enable_clocale
1014 # Probe for locale support if no specific model is specified.
1015 # Default to "generic".
1016 if test $enable_clocale_flag = auto; then
1017 case x${target_os} in
1018 xlinux* | xgnu* | xkfreebsd*-gnu | xknetbsd*-gnu)
1019 AC_EGREP_CPP([_GLIBCXX_ok], [
1020 #include <features.h>
1021 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1024 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1026 # Test for bugs early in glibc-2.2.x series
1027 if test x$enable_clocale_flag = xgnu; then
1029 #define _GNU_SOURCE 1
1032 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1033 extern __typeof(newlocale) __newlocale;
1034 extern __typeof(duplocale) __duplocale;
1035 extern __typeof(strcoll_l) __strcoll_l;
1039 const char __one[] = "Äuglein Augmen";
1040 const char __two[] = "Äuglein";
1045 loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1046 loc_dup = __duplocale(loc);
1047 i = __strcoll_l(__one, __two, loc);
1048 j = __strcoll_l(__one, __two, loc_dup);
1052 [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1053 [enable_clocale_flag=generic])
1056 # ... at some point put __strxfrm_l tests in as well.
1059 enable_clocale_flag=generic
1064 # Deal with gettext issues. Default to not using it (=no) until we detect
1065 # support for it later. Let the user turn it off via --e/d, but let that
1066 # default to on for easier handling.
1069 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1073 # Set configure bits for specified locale package
1074 case ${enable_clocale_flag} in
1076 AC_MSG_RESULT(generic)
1078 CLOCALE_H=config/locale/generic/c_locale.h
1079 CLOCALE_CC=config/locale/generic/c_locale.cc
1080 CCODECVT_H=config/locale/generic/codecvt_specializations.h
1081 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1082 CCOLLATE_CC=config/locale/generic/collate_members.cc
1083 CCTYPE_CC=config/locale/generic/ctype_members.cc
1084 CMESSAGES_H=config/locale/generic/messages_members.h
1085 CMESSAGES_CC=config/locale/generic/messages_members.cc
1086 CMONEY_CC=config/locale/generic/monetary_members.cc
1087 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1088 CTIME_H=config/locale/generic/time_members.h
1089 CTIME_CC=config/locale/generic/time_members.cc
1090 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1095 # Declare intention to use gettext, and add support for specific
1097 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1100 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1101 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1102 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1105 # Export the build objects.
1106 for ling in $ALL_LINGUAS; do \
1107 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1108 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1110 AC_SUBST(glibcxx_MOFILES)
1111 AC_SUBST(glibcxx_POFILES)
1113 CLOCALE_H=config/locale/gnu/c_locale.h
1114 CLOCALE_CC=config/locale/gnu/c_locale.cc
1115 CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1116 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1117 CCOLLATE_CC=config/locale/gnu/collate_members.cc
1118 CCTYPE_CC=config/locale/gnu/ctype_members.cc
1119 CMESSAGES_H=config/locale/gnu/messages_members.h
1120 CMESSAGES_CC=config/locale/gnu/messages_members.cc
1121 CMONEY_CC=config/locale/gnu/monetary_members.cc
1122 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1123 CTIME_H=config/locale/gnu/time_members.h
1124 CTIME_CC=config/locale/gnu/time_members.cc
1125 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1128 AC_MSG_RESULT(IEEE 1003.1)
1130 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1131 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1132 CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1133 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1134 CCOLLATE_CC=config/locale/generic/collate_members.cc
1135 CCTYPE_CC=config/locale/generic/ctype_members.cc
1136 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1137 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1138 CMONEY_CC=config/locale/generic/monetary_members.cc
1139 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1140 CTIME_H=config/locale/generic/time_members.h
1141 CTIME_CC=config/locale/generic/time_members.cc
1142 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1146 # This is where the testsuite looks for locale catalogs, using the
1147 # -DLOCALEDIR define during testsuite compilation.
1148 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1149 AC_SUBST(glibcxx_localedir)
1151 # A standalone libintl (e.g., GNU libintl) may be in use.
1152 if test $USE_NLS = yes; then
1153 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1154 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1156 if test $USE_NLS = yes; then
1157 AC_DEFINE(_GLIBCXX_USE_NLS)
1162 AC_SUBST(CCODECVT_H)
1163 AC_SUBST(CMESSAGES_H)
1164 AC_SUBST(CCODECVT_CC)
1165 AC_SUBST(CCOLLATE_CC)
1167 AC_SUBST(CMESSAGES_CC)
1169 AC_SUBST(CNUMERIC_CC)
1172 AC_SUBST(CLOCALE_CC)
1173 AC_SUBST(CLOCALE_INTERNAL_H)
1178 dnl Check for which std::allocator base class to use. The choice is
1179 dnl mapped from a subdirectory of include/ext.
1183 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1184 AC_MSG_CHECKING([for std::allocator base class to use])
1185 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1186 [use KIND for target std::allocator base],
1187 [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1188 # If they didn't use this option switch, or if they specified --enable
1189 # with no specific model, we'll have to look for one. If they
1190 # specified --disable (???), do likewise.
1191 if test $enable_libstdcxx_allocator = no || test $enable_libstdcxx_allocator = yes; then
1192 enable_libstdcxx_allocator=auto
1195 # Either a known package, or "auto"
1196 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1198 # Probe for host-specific support if no specific model is specified.
1200 if test $enable_libstdcxx_allocator_flag = auto; then
1201 case ${target_os} in
1203 enable_libstdcxx_allocator_flag=new
1207 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1210 # Set configure bits for specified locale package
1211 case ${enable_libstdcxx_allocator_flag} in
1213 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1214 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1217 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1218 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1221 ALLOCATOR_H=config/allocator/mt_allocator_base.h
1222 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1225 ALLOCATOR_H=config/allocator/new_allocator_base.h
1226 ALLOCATOR_NAME=__gnu_cxx::new_allocator
1229 ALLOCATOR_H=config/allocator/pool_allocator_base.h
1230 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1234 AC_SUBST(ALLOCATOR_H)
1235 AC_SUBST(ALLOCATOR_NAME)
1240 dnl Check for whether the Boost-derived checks should be turned on.
1242 dnl --enable-concept-checks turns them on.
1243 dnl --disable-concept-checks leaves them off.
1244 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1245 dnl Where DEFAULT is either `yes' or `no'.
1247 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1248 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1249 if test $enable_concept_checks = yes; then
1250 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS)
1256 dnl Check for which I/O library to use: stdio, or something specific.
1258 dnl Default is stdio.
1260 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1261 AC_MSG_CHECKING([for underlying I/O to use])
1262 GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1263 [use target-specific I/O package], [permit stdio])
1265 # Now that libio has been removed, you can have any color you want as long
1266 # as it's black. This is one big no-op until other packages are added, but
1267 # showing the framework never hurts.
1268 case ${enable_cstdio} in
1270 CSTDIO_H=config/io/c_io_stdio.h
1271 BASIC_FILE_H=config/io/basic_file_stdio.h
1272 BASIC_FILE_CC=config/io/basic_file_stdio.cc
1273 AC_MSG_RESULT(stdio)
1278 AC_SUBST(BASIC_FILE_H)
1279 AC_SUBST(BASIC_FILE_CC)
1284 dnl Check for "unusual" flags to pass to the compiler while building.
1286 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1287 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1288 dnl --disable-cxx-flags passes nothing.
1289 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1290 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1291 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1292 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1293 dnl If "default flags" is an empty string, the effect is the same
1294 dnl as --disable or --enable=no.
1296 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1297 AC_MSG_CHECKING([for extra compiler flags for building])
1298 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1299 [pass compiler FLAGS when building library],
1300 [case "x$enable_cxx_flags" in
1301 xno | x) enable_cxx_flags= ;;
1303 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1306 # Run through flags (either default or command-line) and set anything
1307 # extra (e.g., #defines) that must accompany particular g++ options.
1308 if test -n "$enable_cxx_flags"; then
1309 for f in $enable_cxx_flags; do
1313 *) # and we're trying to pass /what/ exactly?
1314 AC_MSG_ERROR([compiler flags start with a -]) ;;
1319 EXTRA_CXX_FLAGS="$enable_cxx_flags"
1320 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1321 AC_SUBST(EXTRA_CXX_FLAGS)
1326 dnl Check for wide character support. Has the same effect as the option
1327 dnl in gcc's configure, but in a form that autoconf can mess with.
1329 dnl --enable-c-mbchar requests all the wchar_t stuff.
1330 dnl --disable-c-mbchar doesn't.
1331 dnl + Usage: GLIBCXX_ENABLE_C_MBCHAR[(DEFAULT)]
1332 dnl Where DEFAULT is either `yes' or `no'.
1334 AC_DEFUN([GLIBCXX_ENABLE_C_MBCHAR], [
1335 GLIBCXX_ENABLE(c-mbchar,$1,,[enable multibyte (wide) characters])
1336 # Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1341 dnl Check to see if debugging libraries are to be built.
1343 dnl --enable-libstdcxx-debug
1344 dnl builds a separate set of debugging libraries in addition to the
1345 dnl normal (shared, static) libstdc++ binaries.
1347 dnl --disable-libstdcxx-debug
1348 dnl builds only one (non-debug) version of libstdc++.
1350 dnl --enable-libstdcxx-debug-flags=FLAGS
1351 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1353 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1354 dnl Where DEFAULT is either `yes' or `no'.
1356 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1357 AC_MSG_CHECKING([for additional debug build])
1358 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1359 AC_MSG_RESULT($enable_libstdcxx_debug)
1360 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1365 dnl Check for explicit debug flags.
1367 dnl --enable-libstdcxx-debug-flags='-O1'
1368 dnl is a general method for passing flags to be used when
1369 dnl building debug libraries with --enable-debug.
1371 dnl --disable-libstdcxx-debug-flags does nothing.
1372 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1373 dnl If "default flags" is an empty string, the effect is the same
1374 dnl as --disable or --enable=no.
1376 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1377 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1378 [pass compiler FLAGS when building debug library],
1379 [case "x$enable_libstdcxx_debug_flags" in
1380 xno | x) enable_libstdcxx_debug_flags= ;;
1382 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1385 # Option parsed, now set things appropriately
1386 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1387 AC_SUBST(DEBUG_FLAGS)
1389 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1394 dnl Check if the user only wants a freestanding library implementation.
1396 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1397 dnl installing only the headers required by [17.4.1.3] and the language
1398 dnl support library. More than that will be built (to keep the Makefiles
1399 dnl conveniently clean), but not installed.
1402 dnl is_hosted (yes/no)
1405 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
1407 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1408 AC_ARG_ENABLE([hosted-libstdcxx],
1409 AC_HELP_STRING([--disable-hosted-libstdcxx],
1410 [only build freestanding C++ runtime support]),,
1411 [enable_hosted_libstdcxx=yes])
1412 if test "$enable_hosted_libstdcxx" = no; then
1413 AC_MSG_NOTICE([Only freestanding libraries will be built])
1417 enable_libstdcxx_pch=no
1422 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1423 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1424 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1429 dnl Check for template specializations for the 'long long' type extension.
1430 dnl The result determines only whether 'long long' I/O is enabled; things
1431 dnl like numeric_limits<> specializations are always available.
1433 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1434 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1435 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1436 dnl Where DEFAULT is either `yes' or `no'.
1437 dnl + If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1439 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1440 GLIBCXX_ENABLE(long-long,$1,,[enables I/O support for 'long long'])
1445 AC_MSG_CHECKING([for enabled long long I/O support])
1446 # iostreams require strtoll, strtoull to compile
1447 AC_TRY_COMPILE([#include <stdlib.h>],
1448 [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no])
1449 AC_TRY_COMPILE([#include <stdlib.h>],
1450 [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no])
1452 # Option parsed, now set things appropriately
1453 if test $enable_long_long = yes; then
1454 AC_DEFINE(_GLIBCXX_USE_LONG_LONG)
1456 AC_MSG_RESULT($enable_long_long)
1463 dnl Check to see if building and using a C++ precompiled header can be done.
1465 dnl --enable-libstdcxx-pch=yes
1466 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1467 dnl may work, after some light-hearted attempts to puzzle out compiler
1468 dnl support, flip bits on in include/Makefile.am
1470 dnl --disable-libstdcxx-pch
1471 dnl turns off attempts to use or build stdc++.h.gch.
1474 dnl glibcxx_PCHFLAGS
1476 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1477 AC_MSG_CHECKING([for enabled PCH])
1478 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1479 AC_MSG_RESULT([$enable_libstdcxx_pch])
1481 if test $enable_libstdcxx_pch = yes; then
1482 AC_CACHE_CHECK([for compiler with PCH support],
1483 [glibcxx_cv_prog_CXX_pch],
1484 [ac_save_CXXFLAGS="$CXXFLAGS"
1485 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1488 echo '#include <math.h>' > conftest.h
1489 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1490 -o conftest.h.gch 1>&5 2>&1 &&
1491 echo '#error "pch failed"' > conftest.h &&
1492 echo '#include "conftest.h"' > conftest.cc &&
1493 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1495 glibcxx_cv_prog_CXX_pch=yes
1497 glibcxx_cv_prog_CXX_pch=no
1500 CXXFLAGS=$ac_save_CXXFLAGS
1503 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1506 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1507 if test $enable_libstdcxx_pch = yes; then
1508 glibcxx_PCHFLAGS="-include bits/stdc++.h"
1512 AC_SUBST(glibcxx_PCHFLAGS)
1517 dnl Check for exception handling support. If an explicit enable/disable
1518 dnl sjlj exceptions is given, we don't have to detect. Otherwise the
1519 dnl target may or may not support call frame exceptions.
1521 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1522 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1523 dnl Neither one forces an attempt at detection.
1526 dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
1528 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
1529 AC_MSG_CHECKING([for exception model to use])
1532 GLIBCXX_ENABLE(sjlj-exceptions,auto,,
1533 [force use of builtin_setjmp for exceptions],
1534 [permit yes|no|auto])
1536 if test $enable_sjlj_exceptions = auto; then
1537 # Botheration. Now we've got to detect the exception model. Link tests
1538 # against libgcc.a are problematic since we've not been given proper -L
1539 # bits for single-tree newlib and libgloss.
1541 # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style.
1542 cat > conftest.$ac_ext << EOF
1543 [#]line __oline__ "configure"
1552 old_CXXFLAGS="$CXXFLAGS"
1554 if AC_TRY_EVAL(ac_compile); then
1555 if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1556 enable_sjlj_exceptions=yes
1557 elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1558 enable_sjlj_exceptions=no
1561 CXXFLAGS="$old_CXXFLAGS"
1565 # This is a tad weird, for hysterical raisins. We have to map enable/disable
1566 # to two different models.
1567 case $enable_sjlj_exceptions in
1569 AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
1570 [Define if the compiler is configured for setjmp/longjmp exceptions.])
1571 ac_exception_model_name=sjlj
1574 ac_exception_model_name="call frame"
1577 AC_MSG_ERROR([unable to detect exception model])
1581 AC_MSG_RESULT($ac_exception_model_name)
1586 dnl Add version tags to symbols in shared library (or not), additionally
1587 dnl marking other symbols as private/local (or not).
1589 dnl --enable-symvers=style adds a version script to the linker call when
1590 dnl creating the shared library. The choice of version script is
1591 dnl controlled by 'style'.
1592 dnl --disable-symvers does not.
1593 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
1594 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
1595 dnl choose a default style based on linker characteristics. Passing
1596 dnl 'no' disables versioning.
1598 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
1600 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
1601 [enables symbol versioning of the shared library],
1602 [permit yes|no|gnu])
1604 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
1605 # don't know enough about $LD to do tricks...
1606 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
1607 # FIXME The following test is too strict, in theory.
1608 if test $enable_shared = no ||
1610 test x$glibcxx_gnu_ld_version = x; then
1614 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
1615 if test $enable_symvers != no; then
1616 AC_MSG_CHECKING([for shared libgcc])
1617 ac_save_CFLAGS="$CFLAGS"
1619 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
1620 CFLAGS="$ac_save_CFLAGS"
1621 AC_MSG_RESULT($glibcxx_shared_libgcc)
1624 # For GNU ld, we need at least this version. The format is described in
1625 # GLIBCXX_CHECK_LINKER_FEATURES above.
1626 glibcxx_min_gnu_ld_version=21400
1627 # XXXXXXXXXXX glibcxx_gnu_ld_version=21390
1629 # Check to see if unspecified "yes" value can win, given results above.
1630 # Change "yes" into either "no" or a style name.
1631 if test $enable_symvers = yes; then
1632 if test $with_gnu_ld = yes &&
1633 test $glibcxx_shared_libgcc = yes;
1635 if test $glibcxx_gnu_ld_version -ge $glibcxx_min_gnu_ld_version ; then
1638 # The right tools, the right setup, but too old. Fallbacks?
1639 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
1640 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
1641 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
1642 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
1643 if test $glibcxx_gnu_ld_version -ge 21200 ; then
1644 # Globbing fix is present, proper block support is not.
1645 dnl AC_MSG_WARN([=== Dude, you are soooo close. Maybe we can fake it.])
1646 dnl enable_symvers=???
1647 AC_MSG_WARN([=== Symbol versioning will be disabled.])
1651 AC_MSG_WARN([=== Symbol versioning will be disabled.])
1657 AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
1658 AC_MSG_WARN([=== either you are not using a supported linker, or you are])
1659 AC_MSG_WARN([=== not building a shared libgcc_s (which is required).])
1660 AC_MSG_WARN([=== Symbol versioning will be disabled.])
1665 # Everything parsed; figure out what file to use.
1666 case $enable_symvers in
1668 SYMVER_MAP=config/linker-map.dummy
1671 SYMVER_MAP=config/linker-map.gnu
1672 AC_DEFINE(_GLIBCXX_SYMVER)
1676 AC_SUBST(SYMVER_MAP)
1677 AC_SUBST(port_specific_symbol_files)
1678 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
1679 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
1684 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1685 dnl We must stage the required headers so that they will be installed
1686 dnl with the library (unlike libgcc, the STL implementation is provided
1687 dnl solely within headers). Since we must not inject random user-space
1688 dnl macro names into user-provided C++ code, we first stage into <file>-in
1689 dnl and process to <file> with an output command. The reason for a two-
1690 dnl stage process here is to correctly handle $srcdir!=$objdir without
1691 dnl having to write complex code (the sed commands to clean the macro
1692 dnl namespace are complex and fragile enough as it is). We must also
1693 dnl add a relative path so that -I- is supported properly.
1696 dnl glibcxx_thread_h
1699 dnl HAVE_GTHR_DEFAULT
1701 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
1702 AC_MSG_CHECKING([for thread model used by GCC])
1703 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
1704 AC_MSG_RESULT([$target_thread_file])
1706 if test $target_thread_file != single; then
1707 AC_DEFINE(HAVE_GTHR_DEFAULT)
1710 glibcxx_thread_h=gthr-$target_thread_file.h
1711 AC_SUBST(glibcxx_thread_h)
1715 # Check whether LC_MESSAGES is available in <locale.h>.
1716 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1718 # This file file be copied and used freely without restrictions. It can
1719 # be used in projects which are not available under the GNU Public License
1720 # but which still want to provide support for the GNU gettext functionality.
1721 # Please note that the actual code is *not* freely available.
1724 AC_DEFUN([AC_LC_MESSAGES], [
1725 AC_CHECK_HEADER(locale.h, [
1726 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1727 [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1728 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1729 if test $ac_cv_val_LC_MESSAGES = yes; then
1730 AC_DEFINE(HAVE_LC_MESSAGES)
1736 sinclude([../libtool.m4])
1737 dnl The lines below arrange for aclocal not to bring an installed
1738 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
1739 dnl add a definition of LIBTOOL to Makefile.in.
1740 ifelse(,,,[AC_SUBST(LIBTOOL)
1741 AC_DEFUN([AM_PROG_LIBTOOL])
1742 AC_DEFUN([AC_LIBTOOL_DLOPEN])
1743 AC_DEFUN([AC_PROG_LD])
1746 dnl vim:et:ts=2:sw=2