2 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
4 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
5 dnl end of configure. This lets tested variables be reassigned, and the
6 dnl conditional will depend on the final state of the variable. For a simple
7 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
9 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
10 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
11 m4_divert_text([glibcxx_diversion],dnl
12 AM_CONDITIONAL([$1],[$2])
15 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
19 dnl Check to see what architecture and operating system we are compiling
20 dnl for. Also, if architecture- or OS-specific flags are required for
21 dnl compilation, pick them up here.
23 AC_DEFUN([GLIBCXX_CHECK_HOST], [
24 . $glibcxx_srcdir/configure.host
25 AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
26 AC_MSG_NOTICE([OS config directory is $os_include_dir])
30 dnl Initialize the rest of the library configury. At this point we have
31 dnl variables like $host.
36 dnl glibcxx_builddir (absolute path)
37 dnl glibcxx_srcdir (absolute path)
38 dnl toplevel_builddir (absolute path)
39 dnl toplevel_srcdir (absolute path)
42 dnl with_target_subdir
44 dnl - the variables in GLIBCXX_CHECK_HOST / configure.host
45 dnl - default settings for all AM_CONFITIONAL test variables
46 dnl - lots of tools, like CC and CXX
48 AC_DEFUN([GLIBCXX_CONFIGURE], [
49 # Keep these sync'd with the list in Makefile.am. The first provides an
50 # expandable list at autoconf time; the second provides an expandable list
51 # (i.e., shell variable) at configure time.
52 m4_define([glibcxx_SUBDIRS],[include libsupc++ python src src/c++98 src/c++11 doc po testsuite])
53 SUBDIRS='glibcxx_SUBDIRS'
55 # These need to be absolute paths, yet at the same time need to
56 # canonicalize only relative paths, because then amd will not unmount
57 # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
58 glibcxx_builddir=`${PWDCMD-pwd}`
60 [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
61 *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
63 toplevel_builddir=${glibcxx_builddir}/..
64 toplevel_srcdir=${glibcxx_srcdir}/..
65 AC_SUBST(glibcxx_builddir)
66 AC_SUBST(glibcxx_srcdir)
67 AC_SUBST(toplevel_builddir)
68 AC_SUBST(toplevel_srcdir)
70 # We use these options to decide which functions to include. They are
71 # set from the top level.
72 AC_ARG_WITH([target-subdir],
73 AC_HELP_STRING([--with-target-subdir=SUBDIR],
74 [configuring in a subdirectory]))
76 AC_ARG_WITH([cross-host],
77 AC_HELP_STRING([--with-cross-host=HOST],
78 [configuring with a cross compiler]))
81 AC_HELP_STRING([--with-newlib],
82 [assume newlib as a system C library]))
84 # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
85 # available). Uncomment the next line to force a particular method.
91 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
95 # Set up safe default values for all subsequent AM_CONDITIONAL tests
96 # which are themselves conditionally expanded.
97 ## (Right now, this only matters for enable_wchar_t, but nothing prevents
98 ## other macros from doing the same. This should be automated.) -pme
100 # Check for C library flavor since GNU/Linux platforms use different
101 # configuration directories depending on the C library in use.
102 AC_EGREP_CPP([_using_uclibc], [
107 ], uclibc=yes, uclibc=no)
109 AC_EGREP_CPP([_using_bionic], [
114 ], bionic=yes, bionic=no)
116 # Find platform-specific directories containing configuration info.
117 # Also possibly modify flags used elsewhere, as needed by the platform.
123 dnl Tests for newer compiler features, or features that are present in newer
124 dnl compiler versions but not older compiler versions still in use, should
128 dnl WERROR='-Werror' if requested and possible; g++'s that lack the
129 dnl new inlining code or the new system_header pragma will die on -Werror.
130 dnl Leave it out by default and use maint-mode to use it.
131 dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if
132 dnl compiler supports it and the user has not requested debug mode.
134 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
135 # All these tests are for C++; save the language and the compiler flags.
136 # The CXXFLAGS thing is suspicious, but based on similar bits previously
137 # found in GLIBCXX_CONFIGURE.
140 ac_test_CXXFLAGS="${CXXFLAGS+set}"
141 ac_save_CXXFLAGS="$CXXFLAGS"
143 # Check for maintainer-mode bits.
144 if test x"$USE_MAINTAINER_MODE" = xno; then
150 # Check for -ffunction-sections -fdata-sections
151 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
152 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
153 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
154 if test "$ac_test_CXXFLAGS" = set; then
155 CXXFLAGS="$ac_save_CXXFLAGS"
157 # this is the suspicious part
160 if test x"$ac_fdsections" = x"yes"; then
161 SECTION_FLAGS='-ffunction-sections -fdata-sections'
163 AC_MSG_RESULT($ac_fdsections)
167 AC_SUBST(SECTION_FLAGS)
172 dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
173 dnl the native linker is in use, all variables will be defined to something
174 dnl safe (like an empty string).
177 dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
178 dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
179 dnl LD (as a side effect of testing)
182 dnl glibcxx_ld_is_gold (set to "no" or "yes")
183 dnl glibcxx_gnu_ld_version (possibly)
185 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
186 dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
188 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
189 # If we're not using GNU ld, then there's no point in even trying these
190 # tests. Check for that first. We should have already tested for gld
191 # by now (in libtool), but require it now just to be safe...
192 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
193 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
194 AC_REQUIRE([AC_PROG_LD])
195 AC_REQUIRE([AC_PROG_AWK])
197 # The name set by libtool depends on the version of libtool. Shame on us
198 # for depending on an impl detail, but c'est la vie. Older versions used
199 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
200 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
201 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
202 # set (hence we're using an older libtool), then set it.
203 if test x${with_gnu_ld+set} != xset; then
204 if test x${ac_cv_prog_gnu_ld+set} != xset; then
205 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
208 with_gnu_ld=$ac_cv_prog_gnu_ld
212 # Start by getting the version number. I think the libtool test already
213 # does some of this, but throws away the result.
214 glibcxx_ld_is_gold=no
215 if test x"$with_gnu_ld" = x"yes"; then
216 AC_MSG_CHECKING([for ld version])
218 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
219 glibcxx_ld_is_gold=yes
221 ldver=`$LD --version 2>/dev/null |
222 sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'`
224 glibcxx_gnu_ld_version=`echo $ldver | \
225 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
226 AC_MSG_RESULT($glibcxx_gnu_ld_version)
230 glibcxx_have_gc_sections=no
231 if test "$glibcxx_ld_is_gold" = "yes"; then
232 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
233 glibcxx_have_gc_sections=yes
236 glibcxx_gcsections_min_ld=21602
237 if test x"$with_gnu_ld" = x"yes" &&
238 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
239 glibcxx_have_gc_sections=yes
242 if test "$glibcxx_have_gc_sections" = "yes"; then
243 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
244 # NB: This flag only works reliably after 2.16.1. Configure tests
245 # for this are difficult, so hard wire a value that should work.
247 ac_test_CFLAGS="${CFLAGS+set}"
248 ac_save_CFLAGS="$CFLAGS"
249 CFLAGS='-Wl,--gc-sections'
251 # Check for -Wl,--gc-sections
252 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
253 AC_TRY_LINK([ int one(void) { return 1; }
254 int two(void) { return 2; }
255 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
256 if test "$ac_gcsections" = "yes"; then
259 if $CC -c conftest.c; then
260 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
261 grep "Warning: gc-sections option ignored" > /dev/null; then
265 rm -f conftest.c conftest.o conftest
267 if test "$ac_gcsections" = "yes"; then
268 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
270 AC_MSG_RESULT($ac_gcsections)
272 if test "$ac_test_CFLAGS" = set; then
273 CFLAGS="$ac_save_CFLAGS"
275 # this is the suspicious part
281 # Note this is only for shared objects.
283 if test x"$with_gnu_ld" = x"yes"; then
284 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
285 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
286 if test -n "$cxx_z_relo"; then
287 OPT_LDFLAGS="-Wl,-z,relro"
290 AC_MSG_RESULT($ac_ld_relro)
293 # Set linker optimization flags.
294 if test x"$with_gnu_ld" = x"yes"; then
295 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
298 AC_SUBST(SECTION_LDFLAGS)
299 AC_SUBST(OPT_LDFLAGS)
304 dnl Check for headers for, and arguments to, the setrlimit() function.
305 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
308 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
309 dnl various HAVE_LIMIT_* for individual limit names
311 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
312 AC_MSG_CHECKING([for RLIMIT_$1])
315 #include <sys/time.h>
316 #include <sys/resource.h>
318 [ int f = RLIMIT_$1 ; ],
319 [glibcxx_mresult=1], [glibcxx_mresult=0])
320 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
321 [Only used in build directory testsuite_hooks.h.])
322 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
326 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
327 setrlimit_have_headers=yes
328 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
330 [setrlimit_have_headers=no])
331 # If don't have the headers, then we can't run the tests now, and we
332 # won't be seeing any of these during testsuite compilation.
333 if test $setrlimit_have_headers = yes; then
334 # Can't do these in a loop, else the resulting syntax is wrong.
335 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
336 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
337 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
338 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
339 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
341 # Check for rlimit, setrlimit.
342 AC_CACHE_VAL(glibcxx_cv_setrlimit, [
345 #include <sys/time.h>
346 #include <sys/resource.h>
350 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
354 AC_MSG_CHECKING([for testsuite resource limits support])
355 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
357 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
358 [Define if using setrlimit to set resource limits during
363 AC_MSG_RESULT($ac_res_limits)
368 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
369 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
371 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
375 ac_save_CXXFLAGS="$CXXFLAGS"
376 CXXFLAGS="$CXXFLAGS -fno-exceptions"
378 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
379 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
380 GCC_TRY_COMPILE_OR_LINK(
381 [#include <sys/stat.h>],
384 S_ISREG(buffer.st_mode);],
385 [glibcxx_cv_S_ISREG=yes],
386 [glibcxx_cv_S_ISREG=no])
388 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
389 GCC_TRY_COMPILE_OR_LINK(
390 [#include <sys/stat.h>],
393 S_IFREG & buffer.st_mode;],
394 [glibcxx_cv_S_IFREG=yes],
395 [glibcxx_cv_S_IFREG=no])
398 if test $glibcxx_cv_S_ISREG = yes; then
399 AC_DEFINE(HAVE_S_ISREG, 1,
400 [Define if S_IFREG is available in <sys/stat.h>.])
402 elif test $glibcxx_cv_S_IFREG = yes; then
403 AC_DEFINE(HAVE_S_IFREG, 1,
404 [Define if S_IFREG is available in <sys/stat.h>.])
409 CXXFLAGS="$ac_save_CXXFLAGS"
415 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
417 AC_DEFUN([GLIBCXX_CHECK_POLL], [
421 ac_save_CXXFLAGS="$CXXFLAGS"
422 CXXFLAGS="$CXXFLAGS -fno-exceptions"
424 AC_MSG_CHECKING([for poll])
425 AC_CACHE_VAL(glibcxx_cv_POLL, [
426 GCC_TRY_COMPILE_OR_LINK(
428 [struct pollfd pfd[1];
429 pfd[0].events = POLLIN;
431 [glibcxx_cv_POLL=yes],
432 [glibcxx_cv_POLL=no])
434 if test $glibcxx_cv_POLL = yes; then
435 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
437 AC_MSG_RESULT($glibcxx_cv_POLL)
439 CXXFLAGS="$ac_save_CXXFLAGS"
445 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
447 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
451 ac_save_CXXFLAGS="$CXXFLAGS"
452 CXXFLAGS="$CXXFLAGS -fno-exceptions"
454 AC_MSG_CHECKING([for writev])
455 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
456 GCC_TRY_COMPILE_OR_LINK(
457 [#include <sys/uio.h>],
458 [struct iovec iov[2];
460 [glibcxx_cv_WRITEV=yes],
461 [glibcxx_cv_WRITEV=no])
463 if test $glibcxx_cv_WRITEV = yes; then
464 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
466 AC_MSG_RESULT($glibcxx_cv_WRITEV)
468 CXXFLAGS="$ac_save_CXXFLAGS"
474 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
475 dnl Also check whether int64_t is actually a typedef to long or long long.
477 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
482 AC_MSG_CHECKING([for int64_t])
483 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
485 [#include <stdint.h>],
487 [glibcxx_cv_INT64_T=yes],
488 [glibcxx_cv_INT64_T=no])
491 if test $glibcxx_cv_INT64_T = yes; then
492 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
493 AC_MSG_RESULT($glibcxx_cv_INT64_T)
495 AC_MSG_CHECKING([for int64_t as long])
496 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
499 template<typename, typename> struct same { enum { value = -1 }; };
500 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
501 int array[same<int64_t, long>::value];], [],
502 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
505 if test $glibcxx_cv_int64_t_long = yes; then
506 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
507 AC_MSG_RESULT($glibcxx_cv_int64_t_long)
510 AC_MSG_CHECKING([for int64_t as long long])
511 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
514 template<typename, typename> struct same { enum { value = -1 }; };
515 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
516 int array[same<int64_t, long long>::value];], [],
517 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
520 if test $glibcxx_cv_int64_t_long_long = yes; then
521 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
522 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
531 dnl Check whether LFS support is available.
533 AC_DEFUN([GLIBCXX_CHECK_LFS], [
536 ac_save_CXXFLAGS="$CXXFLAGS"
537 CXXFLAGS="$CXXFLAGS -fno-exceptions"
538 AC_MSG_CHECKING([for LFS support])
539 AC_CACHE_VAL(glibcxx_cv_LFS, [
540 GCC_TRY_COMPILE_OR_LINK(
543 #include <sys/stat.h>
547 fseeko64(fp, 0, SEEK_CUR);
549 lseek64(1, 0, SEEK_CUR);
552 [glibcxx_cv_LFS=yes],
555 if test $glibcxx_cv_LFS = yes; then
556 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
558 AC_MSG_RESULT($glibcxx_cv_LFS)
559 CXXFLAGS="$ac_save_CXXFLAGS"
565 dnl Check for whether a fully dynamic basic_string implementation should
566 dnl be turned on, that does not put empty objects in per-process static
567 dnl memory (mostly useful together with shared memory allocators, see PR
568 dnl libstdc++/16612 for details).
570 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
571 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
572 dnl otherwise undefined
573 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
574 dnl Where DEFAULT is either `yes' or `no'.
576 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
577 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
578 if test $enable_fully_dynamic_string = yes; then
579 enable_fully_dynamic_string_def=1
581 enable_fully_dynamic_string_def=0
583 AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
584 [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
589 dnl Does any necessary configuration of the testsuite directory. Generates
590 dnl the testsuite_hooks.h header.
592 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
596 dnl GLIBCXX_TEST_WCHAR_T
597 dnl GLIBCXX_TEST_THREAD
600 dnl baseline_subdir_switch
602 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
603 if $GLIBCXX_IS_NATIVE ; then
604 # Do checks for resource limit functions.
605 GLIBCXX_CHECK_SETRLIMIT
607 # Look for setenv, so that extended locale tests can be performed.
608 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
611 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
612 test $enable_symvers != no; then
615 enable_abi_check=no ;;
617 enable_abi_check=yes ;;
620 # Only build this as native, since automake does not understand
625 # Export file names for ABI checking.
626 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
627 AC_SUBST(baseline_dir)
628 baseline_subdir_switch="$abi_baseline_subdir_switch"
629 AC_SUBST(baseline_subdir_switch)
634 dnl Does any necessary configuration for docbook in the docs directory.
636 dnl XSLTPROC must be set before this
639 dnl glibcxx_stylesheets
643 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
645 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
646 glibcxx_stylesheets=no
647 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then
648 glibcxx_stylesheets=yes
650 AC_MSG_RESULT($glibcxx_stylesheets)
652 AC_MSG_CHECKING([for local stylesheet directory])
653 glibcxx_local_stylesheets=no
654 if test x"$glibcxx_stylesheets" = x"yes"; then
655 if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then
656 glibcxx_local_stylesheets=yes
657 XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets
659 if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then
660 glibcxx_local_stylesheets=yes
661 XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
664 AC_MSG_RESULT($glibcxx_local_stylesheets)
666 if test x"$glibcxx_local_stylesheets" = x"yes"; then
667 AC_SUBST(XSL_STYLE_DIR)
668 AC_MSG_NOTICE($XSL_STYLE_DIR)
670 glibcxx_stylesheets=no
673 # Check for epub3 dependencies.
674 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
675 glibcxx_epub_stylesheets=no
676 if test x"$glibcxx_local_stylesheets" = x"yes"; then
677 if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
678 glibcxx_epub_stylesheets=yes
681 AC_MSG_RESULT($glibcxx_epub_stylesheets)
682 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
688 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
692 dnl TOPLEVEL_INCLUDES
694 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
695 # Used for every C++ compile we perform.
697 -I$glibcxx_builddir/include/$host_alias \
698 -I$glibcxx_builddir/include \
699 -I$glibcxx_srcdir/libsupc++"
701 # For Canadian crosses, pick this up too.
702 if test $CANADIAN = yes; then
703 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
706 # Stuff in the actual top level. Currently only used by libsupc++ to
707 # get unwind* headers from the libgcc dir.
708 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
709 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
711 # Now, export this to all the little Makefiles....
712 AC_SUBST(GLIBCXX_INCLUDES)
713 AC_SUBST(TOPLEVEL_INCLUDES)
718 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
719 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
722 dnl OPTIMIZE_CXXFLAGS
725 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
726 # Optimization flags that are probably a good idea for thrill-seekers. Just
727 # uncomment the lines below and make, everything else is ready to go...
728 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
729 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
730 AC_SUBST(OPTIMIZE_CXXFLAGS)
732 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi'
738 dnl All installation directory information is determined here.
742 dnl glibcxx_prefixdir
743 dnl glibcxx_toolexecdir
744 dnl glibcxx_toolexeclibdir
746 dnl Assumes cross_compiling bits already done, and with_cross_host in
749 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
750 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
751 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
752 glibcxx_toolexecdir=no
753 glibcxx_toolexeclibdir=no
754 glibcxx_prefixdir=$prefix
756 AC_MSG_CHECKING([for gxx-include-dir])
757 AC_ARG_WITH([gxx-include-dir],
758 AC_HELP_STRING([--with-gxx-include-dir=DIR],
759 [installation directory for include files]),
761 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
762 no) gxx_include_dir=no ;;
763 *) gxx_include_dir=$withval ;;
765 [gxx_include_dir=no])
766 AC_MSG_RESULT($gxx_include_dir)
768 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
769 AC_ARG_ENABLE([version-specific-runtime-libs],
770 AC_HELP_STRING([--enable-version-specific-runtime-libs],
771 [Specify that runtime libraries should be installed in a compiler-specific directory]),
772 [case "$enableval" in
773 yes) version_specific_libs=yes ;;
774 no) version_specific_libs=no ;;
775 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
777 [version_specific_libs=no])
778 AC_MSG_RESULT($version_specific_libs)
780 # Default case for install directory for include files.
781 if test $version_specific_libs = no && test $gxx_include_dir = no; then
782 gxx_include_dir='include/c++/${gcc_version}'
783 if test -n "$with_cross_host" &&
784 test x"$with_cross_host" != x"no"; then
785 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
787 gxx_include_dir='${prefix}/'"$gxx_include_dir"
791 # Version-specific runtime libs processing.
792 if test $version_specific_libs = yes; then
793 # Need the gcc compiler version to know where to install libraries
794 # and header files if --enable-version-specific-runtime-libs option
795 # is selected. FIXME: these variables are misnamed, there are
796 # no executables installed in _toolexecdir or _toolexeclibdir.
797 if test x"$gxx_include_dir" = x"no"; then
798 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
800 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
801 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
804 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
805 # Install a library built with a cross compiler in tooldir, not libdir.
806 if test x"$glibcxx_toolexecdir" = x"no"; then
807 if test -n "$with_cross_host" &&
808 test x"$with_cross_host" != x"no"; then
809 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
810 glibcxx_toolexeclibdir='${toolexecdir}/lib'
812 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
813 glibcxx_toolexeclibdir='${libdir}'
815 multi_os_directory=`$CXX -print-multi-os-directory`
816 case $multi_os_directory in
817 .) ;; # Avoid trailing /.
818 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
822 AC_MSG_CHECKING([for install location])
823 AC_MSG_RESULT($gxx_include_dir)
825 AC_SUBST(glibcxx_prefixdir)
826 AC_SUBST(gxx_include_dir)
827 AC_SUBST(glibcxx_toolexecdir)
828 AC_SUBST(glibcxx_toolexeclibdir)
834 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
835 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
836 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
838 dnl See docs/html/17_intro/configury.html#enable for documentation.
840 m4_define([GLIBCXX_ENABLE],[dnl
841 m4_define([_g_switch],[--enable-$1])dnl
842 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
843 AC_ARG_ENABLE([$1],m4_dquote(_g_help),
848 m4_bpatsubst([$5],[permit ])) ;;
849 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
850 dnl Idea for future: generate a URL pointing to
851 dnl "onlinedocs/configopts.html#whatever"
858 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
862 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
863 m4_undefine([_g_switch])dnl
864 m4_undefine([_g_help])dnl
869 dnl Check for ISO/IEC 9899:1999 "C99" support.
871 dnl --enable-c99 defines _GLIBCXX_USE_C99
872 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
873 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
874 dnl Where DEFAULT is either `yes' or `no'.
875 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
877 AC_DEFUN([GLIBCXX_ENABLE_C99], [
878 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
880 if test x"$enable_c99" = x"yes"; then
885 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
886 # undefined and fake C99 facilities - like pre-standard snprintf - may be
887 # spuriously enabled.
888 # Long term, -std=c++0x could be even better, could manage to explicitely
889 # request C99 facilities to the underlying C headers.
890 ac_save_CXXFLAGS="$CXXFLAGS"
891 CXXFLAGS="$CXXFLAGS -std=c++98"
893 ac_save_gcc_no_link="$gcc_no_link"
895 if test x$gcc_no_link != xyes; then
896 # Use -fno-exceptions to that the C driver can link these tests without
897 # hitting undefined references to personality routines.
898 CXXFLAGS="$CXXFLAGS -fno-exceptions"
899 AC_CHECK_LIB(m, sin, [
902 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
907 # Check for the existence of <math.h> functions used if C99 is enabled.
908 AC_MSG_CHECKING([for ISO C99 support in <math.h>])
909 AC_CACHE_VAL(glibcxx_cv_c99_math, [
910 GCC_TRY_COMPILE_OR_LINK(
912 volatile double d1, d2;
920 i = isgreater(d1, d2);
921 i = isgreaterequal(d1, d2);
923 i = islessequal(d1, d2);
924 i = islessgreater(d1, d2);
925 i = islessgreater(d1, d2);
926 i = isunordered(d1, d2);
927 ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
929 AC_MSG_RESULT($glibcxx_cv_c99_math)
930 if test x"$glibcxx_cv_c99_math" = x"yes"; then
931 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
932 [Define if C99 functions or macros in <math.h> should be imported
933 in <cmath> in namespace std.])
936 # Check for the existence of <complex.h> complex math functions.
937 # This is necessary even though libstdc++ uses the builtin versions
938 # of these functions, because if the builtin cannot be used, a reference
939 # to the library function is emitted.
940 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
941 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
942 glibcxx_cv_c99_complex=no;
943 if test x"$ac_has_complex_h" = x"yes"; then
944 AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
945 GCC_TRY_COMPILE_OR_LINK(
946 [#include <complex.h>
947 typedef __complex__ float float_type;
948 typedef __complex__ double double_type;
949 typedef __complex__ long double ld_type;
950 volatile float_type tmpf;
951 volatile double_type tmpd;
952 volatile ld_type tmpld;
955 volatile long double ld;],
967 tmpf = cpowf(tmpf, tmpf);
980 tmpd = cpow(tmpd, tmpd);
984 tmpld = ccosl(tmpld);
985 tmpld = ccoshl(tmpld);
986 tmpld = cexpl(tmpld);
987 tmpld = clogl(tmpld);
988 tmpld = csinl(tmpld);
989 tmpld = csinhl(tmpld);
990 tmpld = csqrtl(tmpld);
991 tmpld = ctanl(tmpld);
992 tmpld = ctanhl(tmpld);
993 tmpld = cpowl(tmpld, tmpld);
994 tmpld = cprojl(tmpld);
995 ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
997 AC_MSG_RESULT($glibcxx_cv_c99_complex)
998 if test x"$glibcxx_cv_c99_complex" = x"yes"; then
999 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
1000 [Define if C99 functions in <complex.h> should be used in
1001 <complex>. Using compiler builtins for these functions requires
1002 corresponding C99 library functions to be present.])
1005 # Check for the existence in <stdio.h> of vscanf, et. al.
1006 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1007 AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
1008 GCC_TRY_COMPILE_OR_LINK(
1011 void foo(char* fmt, ...)
1013 va_list args; va_start(args, fmt);
1014 vfscanf(stderr, "%i", args);
1016 vsnprintf(fmt, 0, "%i", args);
1017 vsscanf(fmt, "%i", args);
1019 [snprintf("12", 0, "%i");],
1020 [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
1022 AC_MSG_RESULT($glibcxx_cv_c99_stdio)
1024 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1025 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1026 AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
1027 GCC_TRY_COMPILE_OR_LINK(
1028 [#include <stdlib.h>
1030 volatile long double ld;
1031 volatile unsigned long long ll;
1034 f = strtof("gnu", &tmp);
1035 ld = strtold("gnu", &tmp);
1036 ll = strtoll("gnu", &tmp, 10);
1037 ll = strtoull("gnu", &tmp, 10);
1039 mydivt = lldiv(10,1);
1044 ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
1046 AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
1048 # Check for the existence in <wchar.h> of wcstold, etc.
1049 glibcxx_cv_c99_wchar=no;
1050 if test x"$ac_has_wchar_h" = xyes &&
1051 test x"$ac_has_wctype_h" = xyes; then
1052 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1053 AC_TRY_COMPILE([#include <wchar.h>
1060 ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
1062 # Checks for wide character functions that may not be present.
1063 # Injection of these is wrapped with guard macros.
1064 # NB: only put functions here, instead of immediately above, if
1065 # absolutely necessary.
1066 AC_TRY_COMPILE([#include <wchar.h>
1067 namespace test { using ::vfwscanf; } ], [],
1068 [AC_DEFINE(HAVE_VFWSCANF,1,
1069 [Defined if vfwscanf exists.])],[])
1071 AC_TRY_COMPILE([#include <wchar.h>
1072 namespace test { using ::vswscanf; } ], [],
1073 [AC_DEFINE(HAVE_VSWSCANF,1,
1074 [Defined if vswscanf exists.])],[])
1076 AC_TRY_COMPILE([#include <wchar.h>
1077 namespace test { using ::vwscanf; } ], [],
1078 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1080 AC_TRY_COMPILE([#include <wchar.h>
1081 namespace test { using ::wcstof; } ], [],
1082 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1084 AC_TRY_COMPILE([#include <wctype.h>],
1085 [ wint_t t; int i = iswblank(t);],
1086 [AC_DEFINE(HAVE_ISWBLANK,1,
1087 [Defined if iswblank exists.])],[])
1089 AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1092 # Option parsed, now set things appropriately.
1093 if test x"$glibcxx_cv_c99_math" = x"no" ||
1094 test x"$glibcxx_cv_c99_complex" = x"no" ||
1095 test x"$glibcxx_cv_c99_stdio" = x"no" ||
1096 test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1097 test x"$glibcxx_cv_c99_wchar" = x"no"; then
1100 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1101 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1102 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1105 gcc_no_link="$ac_save_gcc_no_link"
1106 LIBS="$ac_save_LIBS"
1107 CXXFLAGS="$ac_save_CXXFLAGS"
1111 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1112 AC_MSG_RESULT($enable_c99)
1117 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1118 dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this]
1119 dnl in the current C++0x working draft.
1121 dnl --enable-libstdcxx-time
1122 dnl --enable-libstdcxx-time=yes
1123 dnl checks for the availability of monotonic and realtime clocks,
1124 dnl nanosleep and sched_yield in libc and libposix4 and, in case, links
1126 dnl --enable-libstdcxx-time=rt
1127 dnl also searches (and, in case, links) librt. Note that this is
1128 dnl not always desirable because, in glibc, for example, in turn it
1129 dnl triggers the linking of libpthread too, which activates locking,
1130 dnl a large overhead for single-thread programs.
1131 dnl --enable-libstdcxx-time=no
1132 dnl --disable-libstdcxx-time
1133 dnl disables the checks completely
1135 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1136 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1137 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1138 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1140 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1142 AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1143 GLIBCXX_ENABLE(libstdcxx-time,$1,[[[=KIND]]],
1144 [use KIND for check type],
1149 ac_save_CXXFLAGS="$CXXFLAGS"
1150 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1151 ac_save_LIBS="$LIBS"
1153 ac_has_clock_monotonic=no
1154 ac_has_clock_realtime=no
1155 AC_MSG_RESULT($enable_libstdcxx_time)
1157 if test x"$enable_libstdcxx_time" != x"no"; then
1159 if test x"$enable_libstdcxx_time" = x"rt"; then
1160 AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1161 AC_SEARCH_LIBS(nanosleep, [rt posix4])
1163 AC_SEARCH_LIBS(clock_gettime, [posix4])
1164 AC_SEARCH_LIBS(nanosleep, [posix4])
1167 case "$ac_cv_search_clock_gettime" in
1168 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1171 case "$ac_cv_search_nanosleep" in
1172 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1176 AC_SEARCH_LIBS(sched_yield, [rt posix4])
1178 case "$ac_cv_search_sched_yield" in
1180 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1181 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1182 [ Defined if sched_yield is available. ])
1185 if test x"$enable_libstdcxx_time" = x"rt"; then
1186 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1187 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1188 [ Defined if sched_yield is available. ])
1192 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1193 [ Defined if sched_yield is available. ])
1197 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1199 if test x"$ac_has_unistd_h" = x"yes"; then
1200 AC_MSG_CHECKING([for monotonic clock])
1202 [#include <unistd.h>
1205 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1208 clock_gettime(CLOCK_MONOTONIC, &tp);
1209 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1211 AC_MSG_RESULT($ac_has_clock_monotonic)
1213 AC_MSG_CHECKING([for realtime clock])
1215 [#include <unistd.h>
1218 [#if _POSIX_TIMERS > 0
1221 clock_gettime(CLOCK_REALTIME, &tp);
1222 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1224 AC_MSG_RESULT($ac_has_clock_realtime)
1226 AC_MSG_CHECKING([for nanosleep])
1228 [#include <unistd.h>
1231 [#if _POSIX_TIMERS > 0
1235 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1237 AC_MSG_RESULT($ac_has_nanosleep)
1241 if test x"$ac_has_clock_monotonic" = x"yes"; then
1242 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1243 [ Defined if clock_gettime has monotonic clock support. ])
1246 if test x"$ac_has_clock_realtime" = x"yes"; then
1247 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1248 [ Defined if clock_gettime has realtime clock support. ])
1251 if test x"$ac_has_nanosleep" = x"yes"; then
1252 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1253 [ Defined if nanosleep is available. ])
1256 AC_SUBST(GLIBCXX_LIBS)
1258 CXXFLAGS="$ac_save_CXXFLAGS"
1259 LIBS="$ac_save_LIBS"
1264 dnl Check for gettimeofday, used in the implementation of 20.8.5
1265 dnl [time.clock] in the current C++0x working draft.
1267 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1269 AC_MSG_CHECKING([for gettimeofday])
1273 ac_save_CXXFLAGS="$CXXFLAGS"
1274 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1276 ac_has_gettimeofday=no;
1277 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1278 if test x"$ac_has_sys_time_h" = x"yes"; then
1279 AC_MSG_CHECKING([for gettimeofday])
1280 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1281 [timeval tv; gettimeofday(&tv, 0);],
1282 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1284 AC_MSG_RESULT($ac_has_gettimeofday)
1287 if test x"$ac_has_gettimeofday" = x"yes"; then
1288 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1289 [ Defined if gettimeofday is available. ])
1292 CXXFLAGS="$ac_save_CXXFLAGS"
1297 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1298 dnl facilities in Chapter 8, "C compatibility".
1300 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1305 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1306 # undefined and fake C99 facilities may be spuriously enabled.
1307 ac_save_CXXFLAGS="$CXXFLAGS"
1308 CXXFLAGS="$CXXFLAGS -std=c++98"
1310 # Check for the existence of <complex.h> complex math functions used
1312 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1313 ac_c99_complex_tr1=no;
1314 if test x"$ac_has_complex_h" = x"yes"; then
1315 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1316 AC_TRY_COMPILE([#include <complex.h>],
1317 [typedef __complex__ float float_type; float_type tmpf;
1324 typedef __complex__ double double_type; double_type tmpd;
1331 typedef __complex__ long double ld_type; ld_type tmpld;
1338 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1340 AC_MSG_RESULT($ac_c99_complex_tr1)
1341 if test x"$ac_c99_complex_tr1" = x"yes"; then
1342 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1343 [Define if C99 functions in <complex.h> should be used in
1344 <tr1/complex>. Using compiler builtins for these functions
1345 requires corresponding C99 library functions to be present.])
1348 # Check for the existence of <ctype.h> functions.
1349 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1350 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1351 AC_TRY_COMPILE([#include <ctype.h>],
1355 ],[glibcxx_cv_c99_ctype_tr1=yes],
1356 [glibcxx_cv_c99_ctype_tr1=no])
1358 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1359 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1360 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1361 [Define if C99 functions in <ctype.h> should be imported in
1362 <tr1/cctype> in namespace std::tr1.])
1365 # Check for the existence of <fenv.h> functions.
1366 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1368 if test x"$ac_has_fenv_h" = x"yes"; then
1369 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1370 AC_TRY_COMPILE([#include <fenv.h>],
1375 ret = feclearexcept(except);
1376 ret = fegetexceptflag(pflag, except);
1377 ret = feraiseexcept(except);
1378 ret = fesetexceptflag(pflag, except);
1379 ret = fetestexcept(except);
1381 ret = fesetround(mode);
1382 ret = fegetenv(penv);
1383 ret = feholdexcept(penv);
1384 ret = fesetenv(penv);
1385 ret = feupdateenv(penv);
1386 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1388 AC_MSG_RESULT($ac_c99_fenv_tr1)
1389 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1390 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1391 [Define if C99 functions in <fenv.h> should be imported in
1392 <tr1/cfenv> in namespace std::tr1.])
1395 # Check for the existence of <stdint.h> types.
1396 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1397 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1398 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1399 #define __STDC_CONSTANT_MACROS
1400 #include <stdint.h>],
1401 [typedef int8_t my_int8_t;
1402 my_int8_t i8 = INT8_MIN;
1404 typedef int16_t my_int16_t;
1405 my_int16_t i16 = INT16_MIN;
1407 typedef int32_t my_int32_t;
1408 my_int32_t i32 = INT32_MIN;
1410 typedef int64_t my_int64_t;
1411 my_int64_t i64 = INT64_MIN;
1413 typedef int_fast8_t my_int_fast8_t;
1414 my_int_fast8_t if8 = INT_FAST8_MIN;
1415 if8 = INT_FAST8_MAX;
1416 typedef int_fast16_t my_int_fast16_t;
1417 my_int_fast16_t if16 = INT_FAST16_MIN;
1418 if16 = INT_FAST16_MAX;
1419 typedef int_fast32_t my_int_fast32_t;
1420 my_int_fast32_t if32 = INT_FAST32_MIN;
1421 if32 = INT_FAST32_MAX;
1422 typedef int_fast64_t my_int_fast64_t;
1423 my_int_fast64_t if64 = INT_FAST64_MIN;
1424 if64 = INT_FAST64_MAX;
1425 typedef int_least8_t my_int_least8_t;
1426 my_int_least8_t il8 = INT_LEAST8_MIN;
1427 il8 = INT_LEAST8_MAX;
1428 typedef int_least16_t my_int_least16_t;
1429 my_int_least16_t il16 = INT_LEAST16_MIN;
1430 il16 = INT_LEAST16_MAX;
1431 typedef int_least32_t my_int_least32_t;
1432 my_int_least32_t il32 = INT_LEAST32_MIN;
1433 il32 = INT_LEAST32_MAX;
1434 typedef int_least64_t my_int_least64_t;
1435 my_int_least64_t il64 = INT_LEAST64_MIN;
1436 il64 = INT_LEAST64_MAX;
1437 typedef intmax_t my_intmax_t;
1438 my_intmax_t im = INTMAX_MAX;
1440 typedef intptr_t my_intptr_t;
1441 my_intptr_t ip = INTPTR_MAX;
1443 typedef uint8_t my_uint8_t;
1444 my_uint8_t ui8 = UINT8_MAX;
1446 typedef uint16_t my_uint16_t;
1447 my_uint16_t ui16 = UINT16_MAX;
1449 typedef uint32_t my_uint32_t;
1450 my_uint32_t ui32 = UINT32_MAX;
1452 typedef uint64_t my_uint64_t;
1453 my_uint64_t ui64 = UINT64_MAX;
1455 typedef uint_fast8_t my_uint_fast8_t;
1456 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1457 uif8 = UINT_FAST8_MAX;
1458 typedef uint_fast16_t my_uint_fast16_t;
1459 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1460 uif16 = UINT_FAST16_MAX;
1461 typedef uint_fast32_t my_uint_fast32_t;
1462 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1463 uif32 = UINT_FAST32_MAX;
1464 typedef uint_fast64_t my_uint_fast64_t;
1465 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1466 uif64 = UINT_FAST64_MAX;
1467 typedef uint_least8_t my_uint_least8_t;
1468 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1469 uil8 = UINT_LEAST8_MAX;
1470 typedef uint_least16_t my_uint_least16_t;
1471 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1472 uil16 = UINT_LEAST16_MAX;
1473 typedef uint_least32_t my_uint_least32_t;
1474 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1475 uil32 = UINT_LEAST32_MAX;
1476 typedef uint_least64_t my_uint_least64_t;
1477 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1478 uil64 = UINT_LEAST64_MAX;
1479 typedef uintmax_t my_uintmax_t;
1480 my_uintmax_t uim = UINTMAX_MAX;
1482 typedef uintptr_t my_uintptr_t;
1483 my_uintptr_t uip = UINTPTR_MAX;
1485 ],[glibcxx_cv_c99_stdint_tr1=yes],
1486 [glibcxx_cv_c99_stdint_tr1=no])
1488 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1489 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1490 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1491 [Define if C99 types in <stdint.h> should be imported in
1492 <tr1/cstdint> in namespace std::tr1.])
1495 # Check for the existence of <math.h> functions.
1496 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1497 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1498 AC_TRY_COMPILE([#include <math.h>],
1499 [typedef double_t my_double_t;
1500 typedef float_t my_float_t;
1514 copysignf(0.0f, 0.0f);
1515 copysignl(0.0l, 0.0l);
1532 fmaf(0.0f, 0.0f, 0.0f);
1533 fmal(0.0l, 0.0l, 0.0l);
1576 nextafter(0.0, 0.0);
1577 nextafterf(0.0f, 0.0f);
1578 nextafterl(0.0l, 0.0l);
1579 nexttoward(0.0, 0.0);
1580 nexttowardf(0.0f, 0.0f);
1581 nexttowardl(0.0l, 0.0l);
1582 remainder(0.0, 0.0);
1583 remainderf(0.0f, 0.0f);
1584 remainderl(0.0l, 0.0l);
1585 remquo(0.0, 0.0, 0);
1586 remquof(0.0f, 0.0f, 0);
1587 remquol(0.0l, 0.0l, 0);
1606 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1608 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1609 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1610 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1611 [Define if C99 functions or macros in <math.h> should be imported
1612 in <tr1/cmath> in namespace std::tr1.])
1615 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1616 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1617 ac_c99_inttypes_tr1=no;
1618 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1619 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1620 AC_TRY_COMPILE([#include <inttypes.h>],
1621 [intmax_t i, numer, denom, base;
1624 intmax_t ret = imaxabs(i);
1625 imaxdiv_t dret = imaxdiv(numer, denom);
1626 ret = strtoimax(s, endptr, base);
1627 uintmax_t uret = strtoumax(s, endptr, base);
1628 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1630 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1631 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1632 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1633 [Define if C99 functions in <inttypes.h> should be imported in
1634 <tr1/cinttypes> in namespace std::tr1.])
1637 # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1638 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1639 ac_c99_inttypes_wchar_t_tr1=no;
1640 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1641 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1642 AC_TRY_COMPILE([#include <inttypes.h>],
1646 intmax_t ret = wcstoimax(s, endptr, base);
1647 uintmax_t uret = wcstoumax(s, endptr, base);
1648 ],[ac_c99_inttypes_wchar_t_tr1=yes],
1649 [ac_c99_inttypes_wchar_t_tr1=no])
1651 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1652 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1653 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1654 [Define if wchar_t C99 functions in <inttypes.h> should be
1655 imported in <tr1/cinttypes> in namespace std::tr1.])
1658 # Check for the existence of the <stdbool.h> header.
1659 AC_CHECK_HEADERS(stdbool.h)
1661 # Check for the existence of the <stdalign.h> header.
1662 AC_CHECK_HEADERS(stdalign.h)
1664 CXXFLAGS="$ac_save_CXXFLAGS"
1669 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1670 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1672 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1674 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1675 AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1676 if test -r /dev/random && test -r /dev/urandom; then
1677 glibcxx_cv_random_tr1=yes;
1679 glibcxx_cv_random_tr1=no;
1682 AC_MSG_RESULT($glibcxx_cv_random_tr1)
1684 if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1685 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1686 [Define if /dev/random and /dev/urandom are available for
1687 the random_device of TR1 (Chapter 5.1).])
1693 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
1695 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
1697 AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
1698 AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
1699 [#include <stdio.h>],
1700 [AC_MSG_ERROR([computing EOF failed])])
1702 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
1703 [Define to the value of the EOF integer constant.])
1705 AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
1706 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
1707 [#include <stdio.h>],
1708 [AC_MSG_ERROR([computing SEEK_CUR failed])])
1710 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
1711 [Define to the value of the SEEK_CUR integer constant.])
1713 AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
1714 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
1715 [#include <stdio.h>],
1716 [AC_MSG_ERROR([computing SEEK_END failed])])
1718 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
1719 [Define to the value of the SEEK_END integer constant.])
1723 dnl Check whether required C++ overloads are present in <math.h>.
1726 AC_DEFUN([GLIBCXX_CHECK_MATH_PROTO], [
1733 # Solaris 8 FCS only had an overload for double std::abs(double) in
1734 # <iso/math_iso.h>. Patches 111721-04 (SPARC) and 112757-01 (x86)
1735 # introduced the full set also found from Solaris 9 onwards.
1736 AC_MSG_CHECKING([for float std::abs(float) overload])
1737 AC_CACHE_VAL(glibcxx_cv_abs_float, [
1738 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1741 inline float abs(float __x)
1742 { return __builtin_fabsf(__x); }
1745 [glibcxx_cv_abs_float=no],
1746 [glibcxx_cv_abs_float=yes]
1749 # autoheader cannot handle indented templates.
1750 AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO1],
1751 [/* Define if all C++ overloads are available in <math.h>. */
1752 #if __cplusplus >= 199711L
1753 #undef __CORRECT_ISO_CPP_MATH_H_PROTO1
1755 AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO2],
1756 [/* Define if only double std::abs(double) is available in <math.h>. */
1757 #if __cplusplus >= 199711L
1758 #undef __CORRECT_ISO_CPP_MATH_H_PROTO2
1761 if test $glibcxx_cv_abs_float = yes; then
1762 AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO1)
1764 AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO2)
1766 AC_MSG_RESULT($glibcxx_cv_abs_float)
1774 dnl Check whether required C++ overloads are present in <stdlib.h>.
1777 AC_DEFUN([GLIBCXX_CHECK_STDLIB_PROTO], [
1784 # Solaris 8 FCS lacked the overloads for long std::abs(long) and
1785 # ldiv_t std::div(long, long) in <iso/stdlib_iso.h>. Patches 109607-02
1786 # (SPARC) and 109608-02 (x86) introduced them.
1787 AC_MSG_CHECKING([for long std::abs(long) overload])
1788 AC_CACHE_VAL(glibcxx_cv_abs_long, [
1789 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1790 [#include <stdlib.h>
1793 abs(long __i) { return labs(__i); }
1796 [glibcxx_cv_abs_long=no],
1797 [glibcxx_cv_abs_long=yes]
1800 # autoheader cannot handle indented templates.
1801 AH_VERBATIM([__CORRECT_ISO_CPP_STDLIB_H_PROTO],
1802 [/* Define if all C++ overloads are available in <stdlib.h>. */
1803 #if __cplusplus >= 199711L
1804 #undef __CORRECT_ISO_CPP_STDLIB_H_PROTO
1806 if test $glibcxx_cv_abs_long = yes; then
1807 AC_DEFINE(__CORRECT_ISO_CPP_STDLIB_H_PROTO, 1)
1809 AC_MSG_RESULT($glibcxx_cv_abs_long)
1817 dnl Check whether required C++ overloads are present in <stdio.h>.
1819 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
1824 AC_MSG_CHECKING([for gets declaration])
1825 AC_CACHE_VAL(glibcxx_cv_gets, [
1826 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1833 [glibcxx_cv_gets=yes],
1834 [glibcxx_cv_gets=no]
1837 if test $glibcxx_cv_gets = yes; then
1838 AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h>.])
1840 AC_MSG_RESULT($glibcxx_cv_gets)
1846 dnl Check whether macros, etc are present for <system_error>
1848 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1850 m4_pushdef([n_syserr], [1])dnl
1851 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1852 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1853 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
1854 ECHILD, ENOSPC, EPERM,
1855 ETIMEDOUT, EWOULDBLOCK],
1856 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1857 AC_MSG_CHECKING([for syserr])
1858 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1859 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1860 [int i = syserr;])],
1861 [glibcxx_cv_system_error[]n_syserr=yes],
1862 [glibcxx_cv_system_error[]n_syserr=no])
1864 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1865 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1866 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1868 m4_define([n_syserr], m4_incr(n_syserr))dnl
1869 m4_popdef([SYSERR])dnl
1871 m4_popdef([n_syserr])dnl
1875 dnl Check for what type of C headers to use.
1877 dnl --enable-cheaders= [does stuff].
1878 dnl --disable-cheaders [does not do anything, really].
1879 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1880 dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1882 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1883 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
1884 [construct "C" headers for g++], [permit c|c_std|c_global])
1885 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1887 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1889 # Allow overrides to configure.host here.
1890 if test $enable_cheaders = c_global; then
1894 AC_SUBST(C_INCLUDE_DIR)
1895 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1896 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1897 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1898 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1903 dnl Check for which locale library to use. The choice is mapped to
1904 dnl a subdirectory of config/locale.
1906 dnl Default is generic.
1908 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1909 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
1910 [use MODEL for target locale package],
1911 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
1913 # Deal with gettext issues. Default to not using it (=no) until we detect
1914 # support for it later. Let the user turn it off via --e/d, but let that
1915 # default to on for easier handling.
1918 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1922 # Either a known package, or "auto"
1923 if test $enable_clocale = no || test $enable_clocale = yes; then
1926 enable_clocale_flag=$enable_clocale
1928 # Probe for locale model to use if none specified.
1929 # Default to "generic".
1930 if test $enable_clocale_flag = auto; then
1931 case ${target_os} in
1932 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1933 enable_clocale_flag=gnu
1936 enable_clocale_flag=darwin
1939 if test x"$with_newlib" = x"yes"; then
1940 enable_clocale_flag=newlib
1942 enable_clocale_flag=generic
1948 # Sanity check model, and test for special functionality.
1949 if test $enable_clocale_flag = gnu; then
1950 AC_EGREP_CPP([_GLIBCXX_ok], [
1951 #include <features.h>
1952 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1955 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1957 # Set it to scream when it hurts.
1958 ac_save_CFLAGS="$CFLAGS"
1959 CFLAGS="-Wimplicit-function-declaration -Werror"
1961 # Use strxfrm_l if available.
1962 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1964 #include <locale.h>],
1965 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1966 AC_DEFINE(HAVE_STRXFRM_L, 1,
1967 [Define if strxfrm_l is available in <string.h>.]),)
1969 # Use strerror_l if available.
1970 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1972 #include <locale.h>],
1973 [__locale_t loc; strerror_l(5, loc);],
1974 AC_DEFINE(HAVE_STRERROR_L, 1,
1975 [Define if strerror_l is available in <string.h>.]),)
1977 CFLAGS="$ac_save_CFLAGS"
1980 # Perhaps use strerror_r if available, and strerror_l isn't.
1981 ac_save_CFLAGS="$CFLAGS"
1982 CFLAGS="-Wimplicit-function-declaration -Werror"
1983 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1985 #include <locale.h>],
1986 [char s[128]; strerror_r(5, s, 128);],
1987 AC_DEFINE(HAVE_STRERROR_R, 1,
1988 [Define if strerror_r is available in <string.h>.]),)
1989 CFLAGS="$ac_save_CFLAGS"
1991 # Set configure bits for specified locale package
1992 AC_MSG_CHECKING([for C locale to use])
1993 case ${enable_clocale_flag} in
1995 AC_MSG_RESULT(generic)
1997 CLOCALE_H=config/locale/generic/c_locale.h
1998 CLOCALE_CC=config/locale/generic/c_locale.cc
1999 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2000 CCOLLATE_CC=config/locale/generic/collate_members.cc
2001 CCTYPE_CC=config/locale/generic/ctype_members.cc
2002 CMESSAGES_H=config/locale/generic/messages_members.h
2003 CMESSAGES_CC=config/locale/generic/messages_members.cc
2004 CMONEY_CC=config/locale/generic/monetary_members.cc
2005 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2006 CTIME_H=config/locale/generic/time_members.h
2007 CTIME_CC=config/locale/generic/time_members.cc
2008 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2011 AC_MSG_RESULT(darwin or freebsd)
2013 CLOCALE_H=config/locale/generic/c_locale.h
2014 CLOCALE_CC=config/locale/generic/c_locale.cc
2015 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2016 CCOLLATE_CC=config/locale/generic/collate_members.cc
2017 CCTYPE_CC=config/locale/darwin/ctype_members.cc
2018 CMESSAGES_H=config/locale/generic/messages_members.h
2019 CMESSAGES_CC=config/locale/generic/messages_members.cc
2020 CMONEY_CC=config/locale/generic/monetary_members.cc
2021 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2022 CTIME_H=config/locale/generic/time_members.h
2023 CTIME_CC=config/locale/generic/time_members.cc
2024 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2030 # Declare intention to use gettext, and add support for specific
2032 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2035 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2036 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2037 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2040 # Export the build objects.
2041 for ling in $ALL_LINGUAS; do \
2042 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2043 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2045 AC_SUBST(glibcxx_MOFILES)
2046 AC_SUBST(glibcxx_POFILES)
2048 CLOCALE_H=config/locale/gnu/c_locale.h
2049 CLOCALE_CC=config/locale/gnu/c_locale.cc
2050 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2051 CCOLLATE_CC=config/locale/gnu/collate_members.cc
2052 CCTYPE_CC=config/locale/gnu/ctype_members.cc
2053 CMESSAGES_H=config/locale/gnu/messages_members.h
2054 CMESSAGES_CC=config/locale/gnu/messages_members.cc
2055 CMONEY_CC=config/locale/gnu/monetary_members.cc
2056 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2057 CTIME_H=config/locale/gnu/time_members.h
2058 CTIME_CC=config/locale/gnu/time_members.cc
2059 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2062 AC_MSG_RESULT(IEEE 1003.1)
2064 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2065 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2066 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2067 CCOLLATE_CC=config/locale/generic/collate_members.cc
2068 CCTYPE_CC=config/locale/generic/ctype_members.cc
2069 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2070 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2071 CMONEY_CC=config/locale/generic/monetary_members.cc
2072 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2073 CTIME_H=config/locale/generic/time_members.h
2074 CTIME_CC=config/locale/generic/time_members.cc
2075 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2078 AC_MSG_RESULT(newlib)
2080 CLOCALE_H=config/locale/generic/c_locale.h
2081 CLOCALE_CC=config/locale/generic/c_locale.cc
2082 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2083 CCOLLATE_CC=config/locale/generic/collate_members.cc
2084 CCTYPE_CC=config/locale/newlib/ctype_members.cc
2085 CMESSAGES_H=config/locale/generic/messages_members.h
2086 CMESSAGES_CC=config/locale/generic/messages_members.cc
2087 CMONEY_CC=config/locale/generic/monetary_members.cc
2088 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2089 CTIME_H=config/locale/generic/time_members.h
2090 CTIME_CC=config/locale/generic/time_members.cc
2091 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2095 # This is where the testsuite looks for locale catalogs, using the
2096 # -DLOCALEDIR define during testsuite compilation.
2097 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2098 AC_SUBST(glibcxx_localedir)
2100 # A standalone libintl (e.g., GNU libintl) may be in use.
2101 if test $USE_NLS = yes; then
2102 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2103 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2105 if test $USE_NLS = yes; then
2106 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2107 [Define if NLS translations are to be used.])
2112 AC_SUBST(CMESSAGES_H)
2113 AC_SUBST(CCODECVT_CC)
2114 AC_SUBST(CCOLLATE_CC)
2116 AC_SUBST(CMESSAGES_CC)
2118 AC_SUBST(CNUMERIC_CC)
2121 AC_SUBST(CLOCALE_CC)
2122 AC_SUBST(CLOCALE_INTERNAL_H)
2127 dnl Check for which std::allocator base class to use. The choice is
2128 dnl mapped from a subdirectory of include/ext.
2132 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2133 AC_MSG_CHECKING([for std::allocator base class])
2134 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2135 [use KIND for target std::allocator base],
2136 [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2138 # If they didn't use this option switch, or if they specified --enable
2139 # with no specific model, we'll have to look for one. If they
2140 # specified --disable (???), do likewise.
2141 if test $enable_libstdcxx_allocator = no ||
2142 test $enable_libstdcxx_allocator = yes;
2144 enable_libstdcxx_allocator=auto
2147 # Either a known package, or "auto". Auto implies the default choice
2148 # for a particular platform.
2149 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2151 # Probe for host-specific support if no specific model is specified.
2153 if test $enable_libstdcxx_allocator_flag = auto; then
2154 case ${target_os} in
2155 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2156 enable_libstdcxx_allocator_flag=new
2159 enable_libstdcxx_allocator_flag=new
2163 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2166 # Set configure bits for specified locale package
2167 case ${enable_libstdcxx_allocator_flag} in
2169 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2170 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2173 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2174 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2177 ALLOCATOR_H=config/allocator/mt_allocator_base.h
2178 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2181 ALLOCATOR_H=config/allocator/new_allocator_base.h
2182 ALLOCATOR_NAME=__gnu_cxx::new_allocator
2185 ALLOCATOR_H=config/allocator/pool_allocator_base.h
2186 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2190 AC_SUBST(ALLOCATOR_H)
2191 AC_SUBST(ALLOCATOR_NAME)
2196 dnl Check for whether the Boost-derived checks should be turned on.
2198 dnl --enable-concept-checks turns them on.
2199 dnl --disable-concept-checks leaves them off.
2200 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2201 dnl Where DEFAULT is either `yes' or `no'.
2203 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2204 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2205 if test $enable_concept_checks = yes; then
2206 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2207 [Define to use concept checking code from the boost libraries.])
2212 dnl Use extern templates.
2214 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2215 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2217 dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2218 dnl Where DEFAULT is `yes' or `no'.
2220 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2222 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2224 AC_MSG_CHECKING([for extern template support])
2225 AC_MSG_RESULT([$enable_extern_template])
2227 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2231 dnl Check for parallel mode pre-requisites, including OpenMP support.
2233 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
2235 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2239 # See if configured libgomp/omp.h exists. (libgomp may be in
2240 # noconfigdirs but not explicitly disabled.)
2241 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2242 enable_parallel=yes;
2244 AC_MSG_NOTICE([target-libgomp not built])
2247 AC_MSG_CHECKING([for parallel mode support])
2248 AC_MSG_RESULT([$enable_parallel])
2249 GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2254 dnl Check for which I/O library to use: stdio, or something specific.
2256 dnl Default is stdio.
2258 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2259 AC_MSG_CHECKING([for underlying I/O to use])
2260 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2261 [use target-specific I/O package], [permit stdio])
2263 # Now that libio has been removed, you can have any color you want as long
2264 # as it's black. This is one big no-op until other packages are added, but
2265 # showing the framework never hurts.
2266 case ${enable_cstdio} in
2268 CSTDIO_H=config/io/c_io_stdio.h
2269 BASIC_FILE_H=config/io/basic_file_stdio.h
2270 BASIC_FILE_CC=config/io/basic_file_stdio.cc
2271 AC_MSG_RESULT(stdio)
2276 AC_SUBST(BASIC_FILE_H)
2277 AC_SUBST(BASIC_FILE_CC)
2282 dnl Check for "unusual" flags to pass to the compiler while building.
2284 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2285 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2286 dnl --disable-cxx-flags passes nothing.
2287 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2288 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2289 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2290 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2291 dnl If "default flags" is an empty string, the effect is the same
2292 dnl as --disable or --enable=no.
2294 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2295 AC_MSG_CHECKING([for extra compiler flags for building])
2296 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2297 [pass compiler FLAGS when building library],
2298 [case "x$enable_cxx_flags" in
2299 xno | x) enable_cxx_flags= ;;
2301 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2304 # Run through flags (either default or command-line) and set anything
2305 # extra (e.g., #defines) that must accompany particular g++ options.
2306 if test -n "$enable_cxx_flags"; then
2307 for f in $enable_cxx_flags; do
2311 *) # and we're trying to pass /what/ exactly?
2312 AC_MSG_ERROR([compiler flags start with a -]) ;;
2317 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2318 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2319 AC_SUBST(EXTRA_CXX_FLAGS)
2324 dnl Check to see if debugging libraries are to be built.
2326 dnl --enable-libstdcxx-debug
2327 dnl builds a separate set of debugging libraries in addition to the
2328 dnl normal (shared, static) libstdc++ binaries.
2330 dnl --disable-libstdcxx-debug
2331 dnl builds only one (non-debug) version of libstdc++.
2333 dnl --enable-libstdcxx-debug-flags=FLAGS
2334 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2336 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2337 dnl Where DEFAULT is either `yes' or `no'.
2339 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2340 AC_MSG_CHECKING([for additional debug build])
2341 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2342 AC_MSG_RESULT($enable_libstdcxx_debug)
2343 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2348 dnl Check for explicit debug flags.
2350 dnl --enable-libstdcxx-debug-flags='-O1'
2351 dnl is a general method for passing flags to be used when
2352 dnl building debug libraries with --enable-debug.
2354 dnl --disable-libstdcxx-debug-flags does nothing.
2355 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2356 dnl If "default flags" is an empty string, the effect is the same
2357 dnl as --disable or --enable=no.
2359 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2360 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2361 [pass compiler FLAGS when building debug library],
2362 [case "x$enable_libstdcxx_debug_flags" in
2363 xno | x) enable_libstdcxx_debug_flags= ;;
2365 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2368 # Option parsed, now set things appropriately
2369 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2370 AC_SUBST(DEBUG_FLAGS)
2372 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2377 dnl Check if the user only wants a freestanding library implementation.
2379 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2380 dnl installing only the headers required by [17.4.1.3] and the language
2381 dnl support library. More than that will be built (to keep the Makefiles
2382 dnl conveniently clean), but not installed.
2385 dnl is_hosted (yes/no)
2388 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
2390 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2391 AC_ARG_ENABLE([hosted-libstdcxx],
2392 AC_HELP_STRING([--disable-hosted-libstdcxx],
2393 [only build freestanding C++ runtime support]),,
2396 enable_hosted_libstdcxx=no
2399 enable_hosted_libstdcxx=yes
2402 if test "$enable_hosted_libstdcxx" = no; then
2403 AC_MSG_NOTICE([Only freestanding libraries will be built])
2407 enable_libstdcxx_pch=no
2412 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2413 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2414 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2419 dnl Check for template specializations for the 'long long' type.
2420 dnl The result determines only whether 'long long' I/O is enabled; things
2421 dnl like numeric_limits<> specializations are always available.
2423 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2424 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2425 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2426 dnl Where DEFAULT is either `yes' or `no'.
2428 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2429 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2430 if test $enable_long_long = yes; then
2431 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2432 [Define if code specialized for long long should be used.])
2434 AC_MSG_CHECKING([for enabled long long specializations])
2435 AC_MSG_RESULT([$enable_long_long])
2440 dnl Check for decimal floating point.
2442 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2444 dnl This checks to see if the host supports decimal floating point types.
2447 dnl _GLIBCXX_USE_DECIMAL_FLOAT
2449 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2451 # Fake what AC_TRY_COMPILE does, without linking as this is
2452 # unnecessary for this test.
2454 cat > conftest.$ac_ext << EOF
2455 [#]line __oline__ "configure"
2465 AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2466 if AC_TRY_EVAL(ac_compile); then
2467 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2468 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2473 AC_MSG_RESULT($enable_dfp)
2478 dnl Check for GNU 128-bit integer and floating point types.
2480 dnl Note: also checks that the types aren't standard types.
2483 dnl _GLIBCXX_USE_INT128
2484 dnl _GLIBCXX_USE_FLOAT128
2486 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
2491 # Fake what AC_TRY_COMPILE does, without linking as this is
2492 # unnecessary for this test.
2494 cat > conftest.$ac_ext << EOF
2495 [#]line __oline__ "configure"
2496 template<typename T1, typename T2>
2498 { typedef T2 type; };
2500 template<typename T>
2505 typename same<long, __int128>::type i1;
2506 typename same<long long, __int128>::type i2;
2510 AC_MSG_CHECKING([for __int128])
2511 if AC_TRY_EVAL(ac_compile); then
2512 AC_DEFINE(_GLIBCXX_USE_INT128, 1,
2513 [Define if __int128 is supported on this host.])
2518 AC_MSG_RESULT($enable_int128)
2521 cat > conftest.$ac_ext << EOF
2522 [#]line __oline__ "configure"
2523 template<typename T1, typename T2>
2525 { typedef T2 type; };
2527 template<typename T>
2532 typename same<double, __float128>::type f1;
2533 typename same<long double, __float128>::type f2;
2537 AC_MSG_CHECKING([for __float128])
2538 if AC_TRY_EVAL(ac_compile); then
2539 AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
2540 [Define if __float128 is supported on this host.])
2545 AC_MSG_RESULT($enable_float128)
2552 dnl Check for template specializations for the 'wchar_t' type.
2554 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2555 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2556 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2557 dnl Where DEFAULT is either `yes' or `no'.
2559 dnl Necessary support must also be present.
2561 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2562 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2564 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2565 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2566 AC_MSG_CHECKING([for mbstate_t])
2567 AC_TRY_COMPILE([#include <wchar.h>],
2568 [mbstate_t teststate;],
2569 have_mbstate_t=yes, have_mbstate_t=no)
2570 AC_MSG_RESULT($have_mbstate_t)
2571 if test x"$have_mbstate_t" = xyes; then
2572 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2575 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2577 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2579 if test x"$enable_wchar_t" = x"yes"; then
2584 if test x"$ac_has_wchar_h" = xyes &&
2585 test x"$ac_has_wctype_h" = xyes; then
2586 AC_TRY_COMPILE([#include <wchar.h>
2647 ],[],[], [enable_wchar_t=no])
2655 if test x"$enable_wchar_t" = x"yes"; then
2656 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2657 [Define if code specialized for wchar_t should be used.])
2660 AC_MSG_CHECKING([for enabled wchar_t specializations])
2661 AC_MSG_RESULT([$enable_wchar_t])
2666 dnl Check to see if building and using a C++ precompiled header can be done.
2668 dnl --enable-libstdcxx-pch=yes
2669 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2670 dnl may work, after some light-hearted attempts to puzzle out compiler
2671 dnl support, flip bits on in include/Makefile.am
2673 dnl --disable-libstdcxx-pch
2674 dnl turns off attempts to use or build stdc++.h.gch.
2677 dnl glibcxx_PCHFLAGS
2679 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2680 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2681 if test $enable_libstdcxx_pch = yes; then
2682 AC_CACHE_CHECK([for compiler with PCH support],
2683 [glibcxx_cv_prog_CXX_pch],
2684 [ac_save_CXXFLAGS="$CXXFLAGS"
2685 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2688 echo '#include <math.h>' > conftest.h
2689 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2690 -o conftest.h.gch 1>&5 2>&1 &&
2691 echo '#error "pch failed"' > conftest.h &&
2692 echo '#include "conftest.h"' > conftest.cc &&
2693 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2695 glibcxx_cv_prog_CXX_pch=yes
2697 glibcxx_cv_prog_CXX_pch=no
2700 CXXFLAGS=$ac_save_CXXFLAGS
2703 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2706 AC_MSG_CHECKING([for enabled PCH])
2707 AC_MSG_RESULT([$enable_libstdcxx_pch])
2709 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2710 if test $enable_libstdcxx_pch = yes; then
2711 glibcxx_PCHFLAGS="-include bits/stdc++.h"
2715 AC_SUBST(glibcxx_PCHFLAGS)
2720 dnl Check for atomic builtins.
2722 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
2724 dnl This checks to see if the host supports the compiler-generated
2725 dnl builtins for atomic operations for various integral sizes. Note, this
2726 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2727 dnl that are used should be checked.
2730 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2732 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2735 old_CXXFLAGS="$CXXFLAGS"
2737 # Do link tests if possible, instead asm tests, limited to some platforms
2738 # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2739 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2740 atomic_builtins_link_tests=no
2741 if test x$gcc_no_link != xyes; then
2742 # Can do link tests. Limit to some tested platforms
2744 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2745 atomic_builtins_link_tests=yes
2750 if test x$atomic_builtins_link_tests = xyes; then
2754 CXXFLAGS="$CXXFLAGS -fno-exceptions"
2756 AC_MSG_CHECKING([for atomic builtins for bool])
2757 AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2760 [typedef bool atomic_type;
2764 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2765 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2767 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2768 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2770 [glibcxx_cv_atomic_bool=yes],
2771 [glibcxx_cv_atomic_bool=no])
2773 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2775 AC_MSG_CHECKING([for atomic builtins for short])
2776 AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2779 [typedef short atomic_type;
2783 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2784 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2786 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2787 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2789 [glibcxx_cv_atomic_short=yes],
2790 [glibcxx_cv_atomic_short=no])
2792 AC_MSG_RESULT($glibcxx_cv_atomic_short)
2794 AC_MSG_CHECKING([for atomic builtins for int])
2795 AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2798 [typedef int atomic_type;
2802 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2803 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2805 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2806 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2808 [glibcxx_cv_atomic_int=yes],
2809 [glibcxx_cv_atomic_int=no])
2811 AC_MSG_RESULT($glibcxx_cv_atomic_int)
2813 AC_MSG_CHECKING([for atomic builtins for long long])
2814 AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2817 [typedef long long atomic_type;
2821 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2822 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2824 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2825 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2827 [glibcxx_cv_atomic_long_long=yes],
2828 [glibcxx_cv_atomic_long_long=no])
2830 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2836 # Compile unoptimized.
2839 # Fake what AC_TRY_COMPILE does.
2841 cat > conftest.$ac_ext << EOF
2842 [#]line __oline__ "configure"
2845 typedef bool atomic_type;
2849 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2850 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2852 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2853 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2859 AC_MSG_CHECKING([for atomic builtins for bool])
2860 if AC_TRY_EVAL(ac_compile); then
2861 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2862 glibcxx_cv_atomic_bool=no
2864 glibcxx_cv_atomic_bool=yes
2867 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2870 cat > conftest.$ac_ext << EOF
2871 [#]line __oline__ "configure"
2874 typedef short atomic_type;
2878 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2879 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2881 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2882 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2888 AC_MSG_CHECKING([for atomic builtins for short])
2889 if AC_TRY_EVAL(ac_compile); then
2890 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2891 glibcxx_cv_atomic_short=no
2893 glibcxx_cv_atomic_short=yes
2896 AC_MSG_RESULT($glibcxx_cv_atomic_short)
2899 cat > conftest.$ac_ext << EOF
2900 [#]line __oline__ "configure"
2903 // NB: _Atomic_word not necessarily int.
2904 typedef int atomic_type;
2908 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2909 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2911 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2912 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2918 AC_MSG_CHECKING([for atomic builtins for int])
2919 if AC_TRY_EVAL(ac_compile); then
2920 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2921 glibcxx_cv_atomic_int=no
2923 glibcxx_cv_atomic_int=yes
2926 AC_MSG_RESULT($glibcxx_cv_atomic_int)
2929 cat > conftest.$ac_ext << EOF
2930 [#]line __oline__ "configure"
2933 typedef long long atomic_type;
2937 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2938 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2940 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2941 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2947 AC_MSG_CHECKING([for atomic builtins for long long])
2948 if AC_TRY_EVAL(ac_compile); then
2949 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2950 glibcxx_cv_atomic_long_long=no
2952 glibcxx_cv_atomic_long_long=yes
2955 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2960 CXXFLAGS="$old_CXXFLAGS"
2963 # Set atomicity_dir to builtins if all but the long long test above passes.
2964 if test $glibcxx_cv_atomic_bool = yes \
2965 && test $glibcxx_cv_atomic_short = yes \
2966 && test $glibcxx_cv_atomic_int = yes; then
2967 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2968 [Define if the compiler supports C++11 atomics.])
2969 atomicity_dir=cpu/generic/atomicity_builtins
2972 # If still generic, set to mutex.
2973 if test $atomicity_dir = "cpu/generic" ; then
2974 atomicity_dir=cpu/generic/atomicity_mutex
2975 AC_MSG_WARN([No native atomic operations are provided for this platform.])
2976 if test "x$target_thread_file" = xsingle; then
2977 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2978 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2980 AC_MSG_WARN([They will be faked using a mutex.])
2981 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2989 dnl Check for exception handling support. If an explicit enable/disable
2990 dnl sjlj exceptions is given, we don't have to detect. Otherwise the
2991 dnl target may or may not support call frame exceptions.
2993 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2994 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2995 dnl Neither one forces an attempt at detection.
2998 dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
3000 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
3001 AC_MSG_CHECKING([for exception model to use])
3004 GLIBCXX_ENABLE(sjlj-exceptions,auto,,
3005 [force use of builtin_setjmp for exceptions],
3006 [permit yes|no|auto])
3008 if test $enable_sjlj_exceptions = auto; then
3009 # Botheration. Now we've got to detect the exception model. Link tests
3010 # against libgcc.a are problematic since we've not been given proper -L
3011 # bits for single-tree newlib and libgloss.
3013 # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style.
3014 cat > conftest.$ac_ext << EOF
3015 [#]line __oline__ "configure"
3024 old_CXXFLAGS="$CXXFLAGS"
3026 if AC_TRY_EVAL(ac_compile); then
3027 if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
3028 enable_sjlj_exceptions=yes
3029 elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
3030 enable_sjlj_exceptions=no
3031 elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
3032 enable_sjlj_exceptions=no
3035 CXXFLAGS="$old_CXXFLAGS"
3039 # This is a tad weird, for hysterical raisins. We have to map
3040 # enable/disable to two different models.
3041 case $enable_sjlj_exceptions in
3043 AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
3044 [Define if the compiler is configured for setjmp/longjmp exceptions.])
3045 ac_exception_model_name=sjlj
3048 ac_exception_model_name="call frame"
3051 AC_MSG_ERROR([unable to detect exception model])
3055 AC_MSG_RESULT($ac_exception_model_name)
3060 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3062 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3063 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3064 dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3065 dnl Where DEFAULT is 'yes'.
3067 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3068 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3070 if test x$enable_libstdcxx_visibility = xyes ; then
3071 dnl all hail libgfortran
3072 dnl Check whether the target supports hidden visibility.
3073 AC_CACHE_CHECK([whether the target supports hidden visibility],
3074 glibcxx_cv_have_attribute_visibility, [
3075 save_CFLAGS="$CFLAGS"
3076 CFLAGS="$CFLAGS -Werror"
3077 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3078 [], glibcxx_cv_have_attribute_visibility=yes,
3079 glibcxx_cv_have_attribute_visibility=no)
3080 CFLAGS="$save_CFLAGS"])
3081 if test $glibcxx_cv_have_attribute_visibility = no; then
3082 enable_libstdcxx_visibility=no
3086 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3087 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3092 dnl Add version tags to symbols in shared library (or not), additionally
3093 dnl marking other symbols as private/local (or not).
3095 dnl Sets libtool_VERSION, and determines shared library SONAME.
3097 dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3099 dnl --enable-symvers=style adds a version script to the linker call when
3100 dnl creating the shared library. The choice of version script is
3101 dnl controlled by 'style'.
3102 dnl --disable-symvers does not.
3104 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3105 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
3106 dnl choose a default style based on linker characteristics. Passing
3107 dnl 'no' disables versioning.
3109 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3111 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3112 [enables symbol versioning of the shared library],
3113 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3115 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3116 # don't know enough about $LD to do tricks...
3117 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3118 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3119 # with extern "C++" in version scripts.
3120 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3122 # Turn a 'yes' into a suitable default.
3123 if test x$enable_symvers = xyes ; then
3124 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3127 if test $with_gnu_ld = yes ; then
3128 case ${target_os} in
3130 enable_symvers=no ;;
3132 enable_symvers=gnu ;;
3135 case ${target_os} in
3137 enable_symvers=darwin ;;
3138 # Sun symbol versioning exists since Solaris 2.5.
3139 solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3140 # make_sunver.pl needs GNU c++filt to support extern "C++" in
3141 # version scripts, so disable symbol versioning if none can be
3143 if test -z "$ac_cv_path_CXXFILT"; then
3144 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3145 AC_MSG_WARN([=== no GNU c++filt could be found.])
3146 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3153 enable_symvers=no ;;
3159 # Check to see if 'darwin' or 'darwin-export' can win.
3160 if test x$enable_symvers = xdarwin-export ; then
3161 enable_symvers=darwin
3164 # Check if 'sun' was requested on non-Solaris 2 platforms.
3165 if test x$enable_symvers = xsun ; then
3166 case ${target_os} in
3172 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3173 AC_MSG_WARN([=== you are not targetting Solaris 2.])
3174 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3180 # Check to see if 'gnu' can win.
3181 if test $enable_symvers = gnu ||
3182 test $enable_symvers = gnu-versioned-namespace ||
3183 test $enable_symvers = sun; then
3184 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3185 AC_MSG_CHECKING([for shared libgcc])
3186 ac_save_CFLAGS="$CFLAGS"
3188 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3189 CFLAGS="$ac_save_CFLAGS"
3190 if test $glibcxx_shared_libgcc = no; then
3191 cat > conftest.c <<EOF
3192 int main (void) { return 0; }
3195 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3196 -shared -shared-libgcc -o conftest.so \
3197 conftest.c -v 2>&1 >/dev/null \
3198 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3200 rm -f conftest.c conftest.so
3201 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3202 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3203 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3204 CFLAGS="$ac_save_CFLAGS"
3207 AC_MSG_RESULT($glibcxx_shared_libgcc)
3209 # For GNU ld, we need at least this version. The format is described in
3210 # GLIBCXX_CHECK_LINKER_FEATURES above.
3211 glibcxx_min_gnu_ld_version=21400
3213 # If no shared libgcc, can't win.
3214 if test $glibcxx_shared_libgcc != yes; then
3215 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3216 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3217 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3219 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3220 : All interesting versions of Sun ld support sun style symbol versioning.
3221 elif test $with_gnu_ld != yes ; then
3223 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3224 AC_MSG_WARN([=== you are not using the GNU linker.])
3225 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3227 elif test $glibcxx_ld_is_gold = yes ; then
3228 : All versions of gold support symbol versioning.
3229 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3230 # The right tools, the right setup, but too old. Fallbacks?
3231 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3232 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3233 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3234 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3235 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3240 # For libtool versioning info, format is CURRENT:REVISION:AGE
3241 libtool_VERSION=6:17:0
3243 # Everything parsed; figure out what files and settings to use.
3244 case $enable_symvers in
3246 SYMVER_FILE=config/abi/pre/none.ver
3249 SYMVER_FILE=config/abi/pre/gnu.ver
3250 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3251 [Define to use GNU versioning in the shared library.])
3253 gnu-versioned-namespace)
3254 libtool_VERSION=7:0:0
3255 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3256 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3257 [Define to use GNU namespace versioning in the shared library.])
3260 SYMVER_FILE=config/abi/pre/gnu.ver
3261 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3262 [Define to use darwin versioning in the shared library.])
3265 SYMVER_FILE=config/abi/pre/gnu.ver
3266 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3267 [Define to use Sun versioning in the shared library.])
3271 if test x$enable_symvers != xno ; then
3272 AC_DEFINE(_GLIBCXX_SYMVER, 1,
3273 [Define to use symbol versioning in the shared library.])
3276 AC_CACHE_CHECK([whether the target supports .symver directive],
3277 glibcxx_cv_have_as_symver_directive, [
3278 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3279 [], glibcxx_cv_have_as_symver_directive=yes,
3280 glibcxx_cv_have_as_symver_directive=no)])
3281 if test $glibcxx_cv_have_as_symver_directive = yes; then
3282 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3283 [Define to 1 if the target assembler supports .symver directive.])
3286 AC_SUBST(SYMVER_FILE)
3287 AC_SUBST(port_specific_symbol_files)
3288 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3289 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3290 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3291 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3292 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3293 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3295 if test $enable_symvers != no ; then
3296 case ${target_os} in
3297 # The Solaris 2 runtime linker doesn't support the GNU extension of
3298 # binding the same symbol to different versions
3301 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3303 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3304 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3309 # Now, set up compatibility support, if any.
3310 # In addition, need this to deal with std::size_t mangling in
3311 # src/compatibility.cc. In a perfect world, could use
3312 # typeid(std::size_t).name()[0] to do direct substitution.
3313 AC_MSG_CHECKING([for size_t as unsigned int])
3314 ac_save_CFLAGS="$CFLAGS"
3316 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3317 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3318 CFLAGS=$ac_save_CFLAGS
3319 if test "$glibcxx_size_t_is_i" = yes; then
3320 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3322 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3324 AC_MSG_CHECKING([for ptrdiff_t as int])
3325 ac_save_CFLAGS="$CFLAGS"
3327 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3328 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3329 CFLAGS=$ac_save_CFLAGS
3330 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3331 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3333 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3338 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3339 dnl We must stage the required headers so that they will be installed
3340 dnl with the library (unlike libgcc, the STL implementation is provided
3341 dnl solely within headers). Since we must not inject random user-space
3342 dnl macro names into user-provided C++ code, we first stage into <file>-in
3343 dnl and process to <file> with an output command. The reason for a two-
3344 dnl stage process here is to correctly handle $srcdir!=$objdir without
3345 dnl having to write complex code (the sed commands to clean the macro
3346 dnl namespace are complex and fragile enough as it is). We must also
3347 dnl add a relative path so that -I- is supported properly.
3349 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3350 AC_MSG_CHECKING([for thread model used by GCC])
3351 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3352 AC_MSG_RESULT([$target_thread_file])
3357 dnl Check if gthread implementation defines the types and functions
3358 dnl required by the c++0x thread library. Conforming gthread
3359 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3361 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3363 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3364 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3366 if test x$enable_libstdcxx_threads = xauto ||
3367 test x$enable_libstdcxx_threads = xyes; then
3372 ac_save_CXXFLAGS="$CXXFLAGS"
3373 CXXFLAGS="$CXXFLAGS -fno-exceptions \
3374 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3376 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3377 case $target_thread_file in
3379 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3382 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3384 AC_TRY_COMPILE([#include <unistd.h>],
3386 // In case of POSIX threads check _POSIX_TIMEOUTS.
3387 #if (defined(_PTHREADS) \
3388 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3391 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3393 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3394 [Define to 1 if mutex_timedlock is available.])
3396 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3397 else res_mutex_timedlock=no ; fi
3398 AC_MSG_RESULT([$res_mutex_timedlock])
3400 AC_MSG_CHECKING([for gthreads library])
3402 AC_TRY_COMPILE([#include "gthr.h"],
3404 #ifndef __GTHREADS_CXX0X
3407 ], [case $target_os in
3408 # gthreads support breaks symbol versioning on Solaris 8/9 (PR
3411 if test x$enable_symvers = xno; then
3413 elif test x$enable_libstdcxx_threads = xyes; then
3414 AC_MSG_WARN([You have requested C++11 threads support, but])
3415 AC_MSG_WARN([this breaks symbol versioning.])
3425 [ac_has_gthreads=no])
3430 AC_MSG_RESULT([$ac_has_gthreads])
3432 if test x"$ac_has_gthreads" = x"yes"; then
3433 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3434 [Define if gthreads library is available.])
3437 CXXFLAGS="$ac_save_CXXFLAGS"
3442 # Check whether LC_MESSAGES is available in <locale.h>.
3443 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3445 # This file file be copied and used freely without restrictions. It can
3446 # be used in projects which are not available under the GNU Public License
3447 # but which still want to provide support for the GNU gettext functionality.
3448 # Please note that the actual code is *not* freely available.
3449 AC_DEFUN([AC_LC_MESSAGES], [
3450 AC_CHECK_HEADER(locale.h, [
3451 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3452 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3453 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3454 if test $ac_cv_val_LC_MESSAGES = yes; then
3455 AC_DEFINE(HAVE_LC_MESSAGES, 1,
3456 [Define if LC_MESSAGES is available in <locale.h>.])
3462 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
3464 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
3468 ac_save_CXXFLAGS="$CXXFLAGS"
3469 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3471 AC_MSG_CHECKING([for get_nprocs])
3472 AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
3473 GCC_TRY_COMPILE_OR_LINK(
3474 [#include <sys/sysinfo.h>],
3475 [int n = get_nprocs();],
3476 [glibcxx_cv_GET_NPROCS=yes],
3477 [glibcxx_cv_GET_NPROCS=no])
3479 if test $glibcxx_cv_GET_NPROCS = yes; then
3480 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
3482 AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
3484 CXXFLAGS="$ac_save_CXXFLAGS"
3489 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
3491 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
3495 ac_save_CXXFLAGS="$CXXFLAGS"
3496 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3498 AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
3499 AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
3500 GCC_TRY_COMPILE_OR_LINK(
3501 [#include <unistd.h>],
3502 [int n = sysconf(_SC_NPROCESSORS_ONLN);],
3503 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
3504 [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
3506 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
3507 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.])
3509 AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
3511 CXXFLAGS="$ac_save_CXXFLAGS"
3516 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
3518 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
3522 ac_save_CXXFLAGS="$CXXFLAGS"
3523 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3525 AC_MSG_CHECKING([for _SC_NPROC_ONLN])
3526 AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [
3527 GCC_TRY_COMPILE_OR_LINK(
3528 [#include <unistd.h>],
3529 [int n = sysconf(_SC_NPROC_ONLN);],
3530 [glibcxx_cv_SC_NPROC_ONLN=yes],
3531 [glibcxx_cv_SC_NPROC_ONLN=no])
3533 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
3534 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.])
3536 AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN)
3538 CXXFLAGS="$ac_save_CXXFLAGS"
3543 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
3545 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
3549 ac_save_CXXFLAGS="$CXXFLAGS"
3550 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3552 AC_MSG_CHECKING([for pthreads_num_processors_np])
3553 AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
3554 GCC_TRY_COMPILE_OR_LINK(
3555 [#include <pthread.h>],
3556 [int n = pthread_num_processors_np();],
3557 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
3558 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
3560 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
3561 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
3563 AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP)
3565 CXXFLAGS="$ac_save_CXXFLAGS"
3570 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
3572 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
3576 ac_save_CXXFLAGS="$CXXFLAGS"
3577 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3579 AC_MSG_CHECKING([for hw.ncpu sysctl])
3580 AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [
3581 GCC_TRY_COMPILE_OR_LINK(
3584 #include <sys/sysctl.h>
3588 size_t size = sizeof(count);
3589 int mib[] = { CTL_HW, HW_NCPU };
3590 sysctl(mib, 2, &count, &size, NULL, 0);
3592 [glibcxx_cv_SYSCTL_HW_NCPU=yes],
3593 [glibcxx_cv_SYSCTL_HW_NCPU=no])
3595 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
3596 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
3598 AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU)
3600 CXXFLAGS="$ac_save_CXXFLAGS"
3605 dnl Check to see if python pretty printing can be activated.
3607 dnl --with-python-dir=dir
3608 dnl installs directory into $prefix/dir
3609 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
3611 AC_MSG_CHECKING([for custom python install directory])
3612 AC_ARG_WITH([python-dir],
3613 AS_HELP_STRING([--with-python-dir],
3614 [the location to install Python modules. This path is relative starting from the prefix.]),
3615 [with_python_dir=$withval], [with_python_dir="no"])
3616 AC_MSG_RESULT(${with_python_dir})
3618 # Needed for installing Python modules during make install.
3619 python_mod_dir="${with_python_dir}"
3620 AC_SUBST(python_mod_dir)
3621 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
3625 dnl Check to see if -Werror is disabled.
3627 dnl --enable-werror/--disable-werror
3628 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
3629 AC_MSG_CHECKING([for -Werror])
3630 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
3631 AC_MSG_RESULT($enable_werror)
3632 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
3636 # Macros from the top-level gcc directory.
3637 m4_include([../config/gc++filt.m4])
3638 m4_include([../config/tls.m4])