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++ src src/c++98 src/c++11 src/c++17 src/c++20 src/filesystem src/libbacktrace src/experimental doc po testsuite python])
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 -ffunction-sections -fdata-sections
144 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
145 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
146 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
147 if test "$ac_test_CXXFLAGS" = set; then
148 CXXFLAGS="$ac_save_CXXFLAGS"
150 # this is the suspicious part
153 if test x"$ac_fdsections" = x"yes"; then
154 SECTION_FLAGS='-ffunction-sections -fdata-sections'
156 AC_MSG_RESULT($ac_fdsections)
159 AC_SUBST(SECTION_FLAGS)
164 dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
165 dnl the native linker is in use, all variables will be defined to something
166 dnl safe (like an empty string).
169 dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
170 dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
171 dnl LD (as a side effect of testing)
174 dnl glibcxx_ld_is_gold (set to "no" or "yes")
175 dnl glibcxx_ld_is_mold (set to "no" or "yes")
176 dnl glibcxx_gnu_ld_version (possibly)
178 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
179 dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
181 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
182 # If we're not using GNU ld, then there's no point in even trying these
183 # tests. Check for that first. We should have already tested for gld
184 # by now (in libtool), but require it now just to be safe...
185 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
186 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
187 AC_REQUIRE([AC_PROG_LD])
188 AC_REQUIRE([AC_PROG_AWK])
190 # The name set by libtool depends on the version of libtool. Shame on us
191 # for depending on an impl detail, but c'est la vie. Older versions used
192 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
193 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
194 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
195 # set (hence we're using an older libtool), then set it.
196 if test x${with_gnu_ld+set} != xset; then
197 if test x${ac_cv_prog_gnu_ld+set} != xset; then
198 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
201 with_gnu_ld=$ac_cv_prog_gnu_ld
205 # Start by getting the version number. I think the libtool test already
206 # does some of this, but throws away the result.
207 glibcxx_ld_is_gold=no
208 glibcxx_ld_is_mold=no
209 if test x"$with_gnu_ld" = x"yes"; then
210 AC_MSG_CHECKING([for ld version])
212 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
213 glibcxx_ld_is_gold=yes
214 elif $LD --version 2>/dev/null | grep 'mold' >/dev/null 2>&1; then
215 glibcxx_ld_is_mold=yes
217 ldver=`$LD --version 2>/dev/null |
218 sed -e 's/[. ][0-9]\{8\}$//;s/.* \([^ ]\{1,\}\)$/\1/; q'`
220 glibcxx_gnu_ld_version=`echo $ldver | \
221 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
222 AC_MSG_RESULT($glibcxx_gnu_ld_version)
226 glibcxx_have_gc_sections=no
227 if test "$glibcxx_ld_is_gold" = "yes" || test "$glibcxx_ld_is_mold" = "yes" ; then
228 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
229 glibcxx_have_gc_sections=yes
232 glibcxx_gcsections_min_ld=21602
233 if test x"$with_gnu_ld" = x"yes" &&
234 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
235 glibcxx_have_gc_sections=yes
238 if test "$glibcxx_have_gc_sections" = "yes"; then
239 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
240 # NB: This flag only works reliably after 2.16.1. Configure tests
241 # for this are difficult, so hard wire a value that should work.
243 ac_test_CFLAGS="${CFLAGS+set}"
244 ac_save_CFLAGS="$CFLAGS"
245 CFLAGS='-Wl,--gc-sections'
247 # Check for -Wl,--gc-sections
248 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
249 AC_TRY_LINK([ int one(void) { return 1; }
250 int two(void) { return 2; }
251 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
252 if test "$ac_gcsections" = "yes"; then
255 if $CC -c conftest.c; then
256 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
257 grep "Warning: gc-sections option ignored" > /dev/null; then
261 rm -f conftest.c conftest.o conftest
263 if test "$ac_gcsections" = "yes"; then
264 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
266 AC_MSG_RESULT($ac_gcsections)
268 if test "$ac_test_CFLAGS" = set; then
269 CFLAGS="$ac_save_CFLAGS"
271 # this is the suspicious part
277 # Note this is only for shared objects.
279 if test x"$with_gnu_ld" = x"yes"; then
280 # cygwin and mingw uses PE, which has no ELF relro support,
281 # multi target ld may confuse configure machinery
288 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
289 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
290 if test -n "$cxx_z_relo"; then
291 OPT_LDFLAGS="-Wl,-z,relro"
294 AC_MSG_RESULT($ac_ld_relro)
298 # Set linker optimization flags.
299 if test x"$with_gnu_ld" = x"yes"; then
300 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
303 AC_SUBST(SECTION_LDFLAGS)
304 AC_SUBST(OPT_LDFLAGS)
309 dnl Check for headers for, and arguments to, the setrlimit() function.
310 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
313 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
314 dnl various HAVE_LIMIT_* for individual limit names
316 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
317 AC_MSG_CHECKING([for RLIMIT_$1])
320 #include <sys/time.h>
321 #include <sys/resource.h>
323 [ int f = RLIMIT_$1 ; ],
324 [glibcxx_mresult=1], [glibcxx_mresult=0])
325 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
326 [Only used in build directory testsuite_hooks.h.])
327 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
331 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
334 setrlimit_have_headers=yes
335 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
337 [setrlimit_have_headers=no])
338 # If don't have the headers, then we can't run the tests now, and we
339 # won't be seeing any of these during testsuite compilation.
340 if test $setrlimit_have_headers = yes; then
341 # Can't do these in a loop, else the resulting syntax is wrong.
342 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
343 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
344 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
345 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
346 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
348 # Check for rlimit, setrlimit.
349 AC_CACHE_CHECK([for testsuite resource limits support],
350 glibcxx_cv_setrlimit, [
353 #include <sys/time.h>
354 #include <sys/resource.h>
358 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
361 if test $glibcxx_cv_setrlimit = yes; then
362 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
363 [Define if using setrlimit to set resource limits during
372 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
373 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
375 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
379 ac_save_CXXFLAGS="$CXXFLAGS"
380 CXXFLAGS="$CXXFLAGS -fno-exceptions"
382 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
383 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
384 GCC_TRY_COMPILE_OR_LINK(
385 [#include <sys/stat.h>],
388 S_ISREG(buffer.st_mode);],
389 [glibcxx_cv_S_ISREG=yes],
390 [glibcxx_cv_S_ISREG=no])
392 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
393 GCC_TRY_COMPILE_OR_LINK(
394 [#include <sys/stat.h>],
397 S_IFREG & buffer.st_mode;],
398 [glibcxx_cv_S_IFREG=yes],
399 [glibcxx_cv_S_IFREG=no])
402 if test $glibcxx_cv_S_ISREG = yes; then
403 AC_DEFINE(HAVE_S_ISREG, 1,
404 [Define if S_ISREG is available in <sys/stat.h>.])
406 elif test $glibcxx_cv_S_IFREG = yes; then
407 AC_DEFINE(HAVE_S_IFREG, 1,
408 [Define if S_IFREG is available in <sys/stat.h>.])
413 CXXFLAGS="$ac_save_CXXFLAGS"
419 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
421 AC_DEFUN([GLIBCXX_CHECK_POLL], [
425 ac_save_CXXFLAGS="$CXXFLAGS"
426 CXXFLAGS="$CXXFLAGS -fno-exceptions"
428 AC_CACHE_CHECK([for poll], glibcxx_cv_POLL, [
429 GCC_TRY_COMPILE_OR_LINK(
431 [struct pollfd pfd[1];
432 pfd[0].events = POLLIN;
434 [glibcxx_cv_POLL=yes],
435 [glibcxx_cv_POLL=no])
437 if test $glibcxx_cv_POLL = yes; then
438 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
441 CXXFLAGS="$ac_save_CXXFLAGS"
447 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
449 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
453 ac_save_CXXFLAGS="$CXXFLAGS"
454 CXXFLAGS="$CXXFLAGS -fno-exceptions"
456 AC_CACHE_CHECK([for writev], glibcxx_cv_WRITEV, [
457 GCC_TRY_COMPILE_OR_LINK(
458 [#include <sys/uio.h>],
459 [struct iovec iov[2];
461 [glibcxx_cv_WRITEV=yes],
462 [glibcxx_cv_WRITEV=no])
464 if test $glibcxx_cv_WRITEV = yes; then
465 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
468 CXXFLAGS="$ac_save_CXXFLAGS"
474 dnl Check whether LFS support is available.
476 AC_DEFUN([GLIBCXX_CHECK_LFS], [
479 ac_save_CXXFLAGS="$CXXFLAGS"
480 CXXFLAGS="$CXXFLAGS -fno-exceptions"
481 AC_CACHE_CHECK([for LFS support], glibcxx_cv_LFS, [
482 GCC_TRY_COMPILE_OR_LINK(
485 #include <sys/stat.h>
489 fseeko64(fp, 0, SEEK_CUR);
491 lseek64(1, 0, SEEK_CUR);
494 [glibcxx_cv_LFS=yes],
497 if test $glibcxx_cv_LFS = yes; then
498 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
500 CXXFLAGS="$ac_save_CXXFLAGS"
506 dnl Check whether the old Copy-On-Write basic_string should allocate a new
507 dnl empty representation for every default-constructed basic_string. Without
508 dnl this option, COW strings share a single empty rep in static storage,
509 dnl but this only works if the linker can guarantee the static storage has
510 dnl a unique definition in the process. It also doesn't work if basic_string
511 dnl objects are stored in shared memory (see PR libstdc++/16612).
512 dnl When fully dynamic strings are enabled, the static storage is not used
513 dnl and a new empty string with reference-count == 1 is allocated each time.
514 dnl Enabling this changes the libstdc++.so ABI.
516 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
517 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
518 dnl otherwise the macro is not defined.
519 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
520 dnl Where DEFAULT is either `yes' or `no'.
522 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
523 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory], [permit yes|no])
524 if test $enable_fully_dynamic_string = yes; then
525 enable_fully_dynamic_string_def=1
527 enable_fully_dynamic_string_def=0
529 AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
530 [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
535 dnl Does any necessary configuration of the testsuite directory. Generates
536 dnl the testsuite_hooks.h header.
538 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
542 dnl GLIBCXX_TEST_WCHAR_T
543 dnl GLIBCXX_TEST_THREAD
546 dnl baseline_subdir_switch
548 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
549 # Do checks for resource limit functions.
550 GLIBCXX_CHECK_SETRLIMIT
552 if $GLIBCXX_IS_NATIVE ; then
553 # Look for setenv, so that extended locale tests can be performed.
554 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
557 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
558 test $enable_symvers != no; then
561 enable_abi_check=no ;;
563 enable_abi_check=yes ;;
566 # Only build this as native, since automake does not understand
571 # Export file names for ABI checking.
572 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
573 AC_SUBST(baseline_dir)
574 baseline_subdir_switch="$abi_baseline_subdir_switch"
575 AC_SUBST(baseline_subdir_switch)
580 dnl Does any necessary configuration for docbook in the docs directory.
582 dnl XSLTPROC must be set before this
585 dnl glibcxx_stylesheets
589 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
591 glibcxx_docbook_url=http://docbook.sourceforge.net/release/xsl-ns/current/
593 AC_MSG_CHECKING([for local stylesheet directory])
594 glibcxx_local_stylesheets=no
595 if test x${XMLCATALOG} = xyes && xsl_style_dir=`xmlcatalog "" $glibcxx_docbook_url 2>/dev/null`
597 XSL_STYLE_DIR=`echo $xsl_style_dir | sed -n 's;^file://;;p'`
598 glibcxx_local_stylesheets=yes
601 /usr/share/sgml/docbook/xsl-ns-stylesheets \
602 /usr/share/xml/docbook/stylesheet/docbook-xsl-ns \
603 /usr/share/xml/docbook/stylesheet/nwalsh5/current \
604 /usr/share/xml/docbook/stylesheet/nwalsh/current
606 if test -d $dir; then
607 glibcxx_local_stylesheets=yes
613 AC_MSG_RESULT($glibcxx_local_stylesheets)
615 if test x"$glibcxx_local_stylesheets" = x"yes"; then
616 AC_SUBST(XSL_STYLE_DIR)
617 AC_MSG_NOTICE($XSL_STYLE_DIR)
619 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
620 glibcxx_stylesheets=no
621 if test x${XMLCATALOG} = xno || xmlcatalog "" $glibcxx_docbook_url/xhtml/docbook.xsl >/dev/null 2>&1; then
622 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude $glibcxx_docbook_url/xhtml/docbook.xsl - 2>/dev/null; then
623 glibcxx_stylesheets=yes
626 AC_MSG_RESULT($glibcxx_stylesheets)
629 glibcxx_stylesheets=no
632 # Check for epub3 dependencies.
633 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
634 glibcxx_epub_stylesheets=no
635 if test x"$glibcxx_local_stylesheets" = x"yes"; then
636 if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
637 glibcxx_epub_stylesheets=yes
640 AC_MSG_RESULT($glibcxx_epub_stylesheets)
641 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
647 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
651 dnl TOPLEVEL_INCLUDES
653 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
654 # Used for every C++ compile we perform.
656 -I$glibcxx_builddir/include/$host_alias \
657 -I$glibcxx_builddir/include \
658 -I$glibcxx_srcdir/libsupc++"
660 # For Canadian crosses, pick this up too.
661 if test $CANADIAN = yes; then
662 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
665 # Stuff in the actual top level. Currently only used by libsupc++ to
666 # get unwind* headers from the libgcc dir.
667 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
668 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
670 # Now, export this to all the little Makefiles....
671 AC_SUBST(GLIBCXX_INCLUDES)
672 AC_SUBST(TOPLEVEL_INCLUDES)
677 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
678 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
682 dnl OPTIMIZE_CXXFLAGS
685 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
688 # Optimization flags that are probably a good idea for thrill-seekers. Just
689 # uncomment the lines below and make, everything else is ready to go...
690 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
691 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
692 AC_SUBST(OPTIMIZE_CXXFLAGS)
694 WARN_FLAGS="-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi=2"
700 dnl All installation directory information is determined here.
704 dnl glibcxx_prefixdir
705 dnl glibcxx_toolexecdir
706 dnl glibcxx_toolexeclibdir
708 dnl Assumes cross_compiling bits already done, and with_cross_host in
711 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
712 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
713 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
714 glibcxx_toolexecdir=no
715 glibcxx_toolexeclibdir=no
716 glibcxx_prefixdir=$prefix
718 AC_MSG_CHECKING([for gxx-include-dir])
719 AC_ARG_WITH([gxx-include-dir],
720 AC_HELP_STRING([--with-gxx-include-dir=DIR],
721 [installation directory for include files]),
723 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
724 no) gxx_include_dir=no ;;
725 *) gxx_include_dir=$withval ;;
727 [gxx_include_dir=no])
728 AC_MSG_RESULT($gxx_include_dir)
730 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
731 AC_ARG_ENABLE([version-specific-runtime-libs],
732 AC_HELP_STRING([--enable-version-specific-runtime-libs],
733 [Specify that runtime libraries should be installed in a compiler-specific directory]),
734 [case "$enableval" in
735 yes) version_specific_libs=yes ;;
736 no) version_specific_libs=no ;;
737 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
739 [version_specific_libs=no])
740 AC_MSG_RESULT($version_specific_libs)
742 GCC_WITH_TOOLEXECLIBDIR
744 # Default case for install directory for include files.
745 if test $version_specific_libs = no && test $gxx_include_dir = no; then
746 gxx_include_dir='include/c++/${gcc_version}'
747 if test -n "$with_cross_host" &&
748 test x"$with_cross_host" != x"no"; then
749 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
751 gxx_include_dir='${prefix}/'"$gxx_include_dir"
755 # Version-specific runtime libs processing.
756 if test $version_specific_libs = yes; then
757 # Need the gcc compiler version to know where to install libraries
758 # and header files if --enable-version-specific-runtime-libs option
759 # is selected. FIXME: these variables are misnamed, there are
760 # no executables installed in _toolexecdir or _toolexeclibdir.
761 if test x"$gxx_include_dir" = x"no"; then
762 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
764 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
765 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
768 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
769 # Install a library built with a cross compiler in tooldir, not libdir.
770 if test x"$glibcxx_toolexecdir" = x"no"; then
771 if test -n "$with_cross_host" &&
772 test x"$with_cross_host" != x"no"; then
773 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
774 case ${with_toolexeclibdir} in
776 glibcxx_toolexeclibdir='${toolexecdir}/lib'
779 glibcxx_toolexeclibdir=${with_toolexeclibdir}
783 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
784 glibcxx_toolexeclibdir='${libdir}'
786 multi_os_directory=`$CXX -print-multi-os-directory`
787 case $multi_os_directory in
788 .) ;; # Avoid trailing /.
789 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
793 AC_MSG_CHECKING([for install location])
794 AC_MSG_RESULT($gxx_include_dir)
796 AC_SUBST(glibcxx_prefixdir)
797 AC_SUBST(gxx_include_dir)
798 AC_SUBST(glibcxx_toolexecdir)
799 AC_SUBST(glibcxx_toolexeclibdir)
805 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
806 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
807 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
809 dnl See manual/appendix_porting.html#appendix.porting.build_hacking for
812 m4_define([GLIBCXX_ENABLE],[dnl
813 m4_define([_g_switch],[--enable-$1])dnl
814 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
815 AC_ARG_ENABLE([$1],m4_dquote(_g_help),
820 m4_bpatsubst([$5],[permit ])) ;;
821 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
822 dnl Idea for future: generate a URL pointing to
823 dnl "onlinedocs/configopts.html#whatever"
830 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
834 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
835 m4_undefine([_g_switch])dnl
836 m4_undefine([_g_help])dnl
841 dnl Check for ISO/IEC 9899:1999 "C99" support.
843 dnl --enable-c99 defines _GLIBCXX_USE_C99
844 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
845 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
846 dnl Where DEFAULT is either `yes' or `no'.
847 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
849 AC_DEFUN([GLIBCXX_ENABLE_C99], [
850 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
852 if test x"$enable_c99" = x"yes"; then
856 # Use -std=c++98 (instead of -std=gnu++98) because leaving __STRICT_ANSI__
857 # undefined may cause fake C99 facilities, like pre-standard snprintf,
858 # to be spuriously enabled.
859 ac_save_CXXFLAGS="$CXXFLAGS"
860 CXXFLAGS="$CXXFLAGS -std=c++98"
862 ac_save_gcc_no_link="$gcc_no_link"
864 if test x$gcc_no_link != xyes; then
865 # Use -fno-exceptions to that the C driver can link these tests without
866 # hitting undefined references to personality routines.
867 CXXFLAGS="$CXXFLAGS -fno-exceptions"
868 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
869 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
874 # Check for the existence of <math.h> functions used if C99 is enabled.
875 AC_CACHE_CHECK([for ISO C99 support in <math.h> for C++98],
876 glibcxx_cv_c99_math_cxx98, [
877 GCC_TRY_COMPILE_OR_LINK(
879 volatile double d1, d2;
887 i = isgreater(d1, d2);
888 i = isgreaterequal(d1, d2);
890 i = islessequal(d1, d2);
891 i = islessgreater(d1, d2);
892 i = islessgreater(d1, d2);
893 i = isunordered(d1, d2);
894 ], [glibcxx_cv_c99_math_cxx98=yes], [glibcxx_cv_c99_math_cxx98=no])
896 if test x"$glibcxx_cv_c99_math_cxx98" = x"yes"; then
897 AC_DEFINE(_GLIBCXX98_USE_C99_MATH, 1,
898 [Define if C99 functions or macros in <math.h> should be imported
899 in <cmath> in namespace std for C++98.])
902 # Check for the existence of <complex.h> complex math functions.
903 # This is necessary even though libstdc++ uses the builtin versions
904 # of these functions, because if the builtin cannot be used, a reference
905 # to the library function is emitted.
906 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
907 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
908 if test x"$ac_has_complex_h" = x"yes"; then
909 AC_CACHE_CHECK([for ISO C99 support in <complex.h> for C++98],
910 glibcxx_cv_c99_complex_cxx98, [
911 GCC_TRY_COMPILE_OR_LINK(
912 [#include <complex.h>
913 typedef __complex__ float float_type;
914 typedef __complex__ double double_type;
915 typedef __complex__ long double ld_type;
916 volatile float_type tmpf;
917 volatile double_type tmpd;
918 volatile ld_type tmpld;
921 volatile long double ld;],
933 tmpf = cpowf(tmpf, tmpf);
946 tmpd = cpow(tmpd, tmpd);
950 tmpld = ccosl(tmpld);
951 tmpld = ccoshl(tmpld);
952 tmpld = cexpl(tmpld);
953 tmpld = clogl(tmpld);
954 tmpld = csinl(tmpld);
955 tmpld = csinhl(tmpld);
956 tmpld = csqrtl(tmpld);
957 tmpld = ctanl(tmpld);
958 tmpld = ctanhl(tmpld);
959 tmpld = cpowl(tmpld, tmpld);
960 tmpld = cprojl(tmpld);
961 ], [glibcxx_cv_c99_complex_cxx98=yes], [glibcxx_cv_c99_complex_cxx98=no])
964 if test x"$glibcxx_cv_c99_complex_cxx98" = x"yes"; then
965 AC_DEFINE(_GLIBCXX98_USE_C99_COMPLEX, 1,
966 [Define if C99 functions in <complex.h> should be used in
967 <complex> for C++98. Using compiler builtins for these functions
968 requires corresponding C99 library functions to be present.])
971 # Check for the existence in <stdio.h> of vscanf, et. al.
972 AC_CACHE_CHECK([for ISO C99 support in <stdio.h> for C++98],
973 glibcxx_cv_c99_stdio_cxx98, [
974 GCC_TRY_COMPILE_OR_LINK(
977 void foo(char* fmt, ...)
979 va_list args; va_start(args, fmt);
980 vfscanf(stderr, "%i", args);
982 vsnprintf(fmt, 0, "%i", args);
983 vsscanf(fmt, "%i", args);
984 snprintf(fmt, 0, "%i");
986 [glibcxx_cv_c99_stdio_cxx98=yes], [glibcxx_cv_c99_stdio_cxx98=no])
988 if test x"$glibcxx_cv_c99_stdio_cxx98" = x"yes"; then
989 AC_DEFINE(_GLIBCXX98_USE_C99_STDIO, 1,
990 [Define if C99 functions or macros in <stdio.h> should be imported
991 in <cstdio> in namespace std for C++98.])
994 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
995 AC_CACHE_CHECK([for ISO C99 support in <stdlib.h> for C++98],
996 glibcxx_cv_c99_stdlib_cxx98, [
997 GCC_TRY_COMPILE_OR_LINK(
1000 volatile long double ld;
1001 volatile unsigned long long ll;
1004 f = strtof("gnu", &tmp);
1005 ld = strtold("gnu", &tmp);
1006 ll = strtoll("gnu", &tmp, 10);
1007 ll = strtoull("gnu", &tmp, 10);
1009 mydivt = lldiv(10,1);
1014 ], [glibcxx_cv_c99_stdlib_cxx98=yes], [glibcxx_cv_c99_stdlib_cxx98=no])
1016 if test x"$glibcxx_cv_c99_stdlib_cxx98" = x"yes"; then
1017 AC_DEFINE(_GLIBCXX98_USE_C99_STDLIB, 1,
1018 [Define if C99 functions or macros in <stdlib.h> should be imported
1019 in <cstdlib> in namespace std for C++98.])
1022 # Check for the existence in <wchar.h> of wcstold, etc.
1023 if test x"$ac_has_wchar_h" = xyes &&
1024 test x"$ac_has_wctype_h" = xyes; then
1025 AC_CACHE_CHECK([for ISO C99 support in <wchar.h> for C++98],
1026 glibcxx_cv_c99_wchar_cxx98, [
1027 AC_TRY_COMPILE([#include <wchar.h>
1034 ], [], [glibcxx_cv_c99_wchar_cxx98=yes], [glibcxx_cv_c99_wchar_cxx98=no])
1037 # Checks for wide character functions that may not be present.
1038 # Injection of these is wrapped with guard macros.
1039 # NB: only put functions here, instead of immediately above, if
1040 # absolutely necessary.
1041 AC_TRY_COMPILE([#include <wchar.h>
1042 namespace test { using ::vfwscanf; }], [],
1043 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1045 AC_TRY_COMPILE([#include <wchar.h>
1046 namespace test { using ::vswscanf; }], [],
1047 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1049 AC_TRY_COMPILE([#include <wchar.h>
1050 namespace test { using ::vwscanf; }], [],
1051 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1053 AC_TRY_COMPILE([#include <wchar.h>
1054 namespace test { using ::wcstof; }], [],
1055 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1057 AC_TRY_COMPILE([#include <wctype.h>],
1058 [wint_t t; int i = iswblank(t);],
1059 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1061 if test x"$glibcxx_cv_c99_wchar_cxx98" = x"yes"; then
1062 AC_DEFINE(_GLIBCXX98_USE_C99_WCHAR, 1,
1063 [Define if C99 functions or macros in <wchar.h> should be imported
1064 in <cwchar> in namespace std for C++98.])
1068 # Option parsed, now set things appropriately.
1069 if test x"$glibcxx_cv_c99_math_cxx98" = x"no" ||
1070 test x"$glibcxx_cv_c99_complex_cxx98" = x"no" ||
1071 test x"$glibcxx_cv_c99_stdio_cxx98" = x"no" ||
1072 test x"$glibcxx_cv_c99_stdlib_cxx98" = x"no" ||
1073 test x"$glibcxx_cv_c99_wchar_cxx98" = x"no"; then
1076 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1077 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1078 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1081 gcc_no_link="$ac_save_gcc_no_link"
1082 LIBS="$ac_save_LIBS"
1083 CXXFLAGS="$ac_save_CXXFLAGS"
1089 # Use -std=c++11 and test again for C99 library feature in C++11 mode.
1090 # For the reasons given above we use -std=c++11 not -std=gnu++11.
1091 ac_save_CXXFLAGS="$CXXFLAGS"
1092 CXXFLAGS="$CXXFLAGS -std=c++11"
1093 ac_save_LIBS="$LIBS"
1094 ac_save_gcc_no_link="$gcc_no_link"
1096 if test x$gcc_no_link != xyes; then
1097 # Use -fno-exceptions to that the C driver can link these tests without
1098 # hitting undefined references to personality routines.
1099 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1100 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
1101 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
1106 # Check for the existence of <stdint.h> types.
1107 AC_CACHE_CHECK([for ISO C99 support in <stdint.h> for C++11],
1108 glibcxx_cv_c99_stdint, [
1109 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1110 #define __STDC_CONSTANT_MACROS
1111 #include <stdint.h>],
1112 [typedef int8_t my_int8_t;
1113 my_int8_t i8 = INT8_MIN;
1115 typedef int16_t my_int16_t;
1116 my_int16_t i16 = INT16_MIN;
1118 typedef int32_t my_int32_t;
1119 my_int32_t i32 = INT32_MIN;
1121 typedef int64_t my_int64_t;
1122 my_int64_t i64 = INT64_MIN;
1124 typedef int_fast8_t my_int_fast8_t;
1125 my_int_fast8_t if8 = INT_FAST8_MIN;
1126 if8 = INT_FAST8_MAX;
1127 typedef int_fast16_t my_int_fast16_t;
1128 my_int_fast16_t if16 = INT_FAST16_MIN;
1129 if16 = INT_FAST16_MAX;
1130 typedef int_fast32_t my_int_fast32_t;
1131 my_int_fast32_t if32 = INT_FAST32_MIN;
1132 if32 = INT_FAST32_MAX;
1133 typedef int_fast64_t my_int_fast64_t;
1134 my_int_fast64_t if64 = INT_FAST64_MIN;
1135 if64 = INT_FAST64_MAX;
1136 typedef int_least8_t my_int_least8_t;
1137 my_int_least8_t il8 = INT_LEAST8_MIN;
1138 il8 = INT_LEAST8_MAX;
1139 typedef int_least16_t my_int_least16_t;
1140 my_int_least16_t il16 = INT_LEAST16_MIN;
1141 il16 = INT_LEAST16_MAX;
1142 typedef int_least32_t my_int_least32_t;
1143 my_int_least32_t il32 = INT_LEAST32_MIN;
1144 il32 = INT_LEAST32_MAX;
1145 typedef int_least64_t my_int_least64_t;
1146 my_int_least64_t il64 = INT_LEAST64_MIN;
1147 il64 = INT_LEAST64_MAX;
1148 typedef intmax_t my_intmax_t;
1149 my_intmax_t im = INTMAX_MAX;
1151 typedef intptr_t my_intptr_t;
1152 my_intptr_t ip = INTPTR_MAX;
1154 typedef uint8_t my_uint8_t;
1155 my_uint8_t ui8 = UINT8_MAX;
1157 typedef uint16_t my_uint16_t;
1158 my_uint16_t ui16 = UINT16_MAX;
1160 typedef uint32_t my_uint32_t;
1161 my_uint32_t ui32 = UINT32_MAX;
1163 typedef uint64_t my_uint64_t;
1164 my_uint64_t ui64 = UINT64_MAX;
1166 typedef uint_fast8_t my_uint_fast8_t;
1167 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1168 uif8 = UINT_FAST8_MAX;
1169 typedef uint_fast16_t my_uint_fast16_t;
1170 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1171 uif16 = UINT_FAST16_MAX;
1172 typedef uint_fast32_t my_uint_fast32_t;
1173 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1174 uif32 = UINT_FAST32_MAX;
1175 typedef uint_fast64_t my_uint_fast64_t;
1176 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1177 uif64 = UINT_FAST64_MAX;
1178 typedef uint_least8_t my_uint_least8_t;
1179 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1180 uil8 = UINT_LEAST8_MAX;
1181 typedef uint_least16_t my_uint_least16_t;
1182 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1183 uil16 = UINT_LEAST16_MAX;
1184 typedef uint_least32_t my_uint_least32_t;
1185 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1186 uil32 = UINT_LEAST32_MAX;
1187 typedef uint_least64_t my_uint_least64_t;
1188 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1189 uil64 = UINT_LEAST64_MAX;
1190 typedef uintmax_t my_uintmax_t;
1191 my_uintmax_t uim = UINTMAX_MAX;
1193 typedef uintptr_t my_uintptr_t;
1194 my_uintptr_t uip = UINTPTR_MAX;
1196 ],[glibcxx_cv_c99_stdint=yes],
1197 [glibcxx_cv_c99_stdint=no])
1199 if test x"$glibcxx_cv_c99_stdint" = x"yes"; then
1200 AC_DEFINE(_GLIBCXX_USE_C99_STDINT, 1,
1201 [Define if C99 types in <stdint.h> should be imported in
1202 <cstdint> in namespace std for C++11.])
1205 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1206 # sense if the glibcxx_cv_c99_stdint check fails, per C99, 7.8/1).
1208 if test x"$glibcxx_cv_c99_stdint" = x"yes"; then
1209 AC_MSG_CHECKING([for ISO C99 support for C++11 in <inttypes.h>])
1210 AC_TRY_COMPILE([#include <inttypes.h>],
1211 [intmax_t i, numer, denom, base;
1214 intmax_t ret = imaxabs(i);
1215 imaxdiv_t dret = imaxdiv(numer, denom);
1216 ret = strtoimax(s, endptr, base);
1217 uintmax_t uret = strtoumax(s, endptr, base);
1218 ],[ac_c99_inttypes=yes], [ac_c99_inttypes=no])
1219 AC_MSG_RESULT($ac_c99_inttypes)
1221 if test x"$ac_c99_inttypes" = x"yes"; then
1222 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES, 1,
1223 [Define if C99 functions in <inttypes.h> should be imported in
1224 <cinttypes> in namespace std in C++11.])
1227 # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
1228 # make sense if the glibcxx_cv_c99_stdint check fails, per C99, 7.8/1).
1229 ac_c99_inttypes_wchar_t=no;
1230 if test x"$glibcxx_cv_c99_stdint" = x"yes"; then
1231 AC_MSG_CHECKING([for wchar_t ISO C99 support for C++11 in <inttypes.h>])
1232 AC_TRY_COMPILE([#include <inttypes.h>],
1236 intmax_t ret = wcstoimax(s, endptr, base);
1237 uintmax_t uret = wcstoumax(s, endptr, base);
1238 ],[ac_c99_inttypes_wchar_t=yes],
1239 [ac_c99_inttypes_wchar_t=no])
1240 AC_MSG_RESULT($ac_c99_inttypes_wchar_t)
1242 if test x"$ac_c99_inttypes_wchar_t" = x"yes"; then
1243 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T, 1,
1244 [Define if wchar_t C99 functions in <inttypes.h> should be
1245 imported in <cinttypes> in namespace std in C++11.])
1248 # Check for the existence of <math.h> functions used if C99 is enabled.
1249 AC_CACHE_CHECK([for ISO C99 support in <math.h> for C++11],
1250 glibcxx_cv_c99_math_cxx11, [
1251 GCC_TRY_COMPILE_OR_LINK(
1253 volatile double d1, d2;
1255 [i = fpclassify(d1);
1261 i = isgreater(d1, d2);
1262 i = isgreaterequal(d1, d2);
1264 i = islessequal(d1, d2);
1265 i = islessgreater(d1, d2);
1266 i = islessgreater(d1, d2);
1267 i = isunordered(d1, d2);
1268 ], [glibcxx_cv_c99_math_cxx11=yes], [glibcxx_cv_c99_math_cxx11=no])
1270 if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
1271 AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
1272 [Define if C99 functions or macros in <math.h> should be imported
1273 in <cmath> in namespace std for C++11.])
1276 # Check for the existence of <complex.h> complex math functions.
1277 # This is necessary even though libstdc++ uses the builtin versions
1278 # of these functions, because if the builtin cannot be used, a reference
1279 # to the library function is emitted.
1280 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
1281 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1282 if test x"$ac_has_complex_h" = x"yes"; then
1283 AC_CACHE_CHECK([for ISO C99 support in <complex.h> for C++11],
1284 glibcxx_cv_c99_complex_cxx11, [
1285 GCC_TRY_COMPILE_OR_LINK(
1286 [#include <complex.h>
1287 typedef __complex__ float float_type;
1288 typedef __complex__ double double_type;
1289 typedef __complex__ long double ld_type;
1290 volatile float_type tmpf;
1291 volatile double_type tmpd;
1292 volatile ld_type tmpld;
1295 volatile long double ld;],
1299 tmpf = ccoshf(tmpf);
1303 tmpf = csinhf(tmpf);
1304 tmpf = csqrtf(tmpf);
1306 tmpf = ctanhf(tmpf);
1307 tmpf = cpowf(tmpf, tmpf);
1308 tmpf = cprojf(tmpf);
1320 tmpd = cpow(tmpd, tmpd);
1324 tmpld = ccosl(tmpld);
1325 tmpld = ccoshl(tmpld);
1326 tmpld = cexpl(tmpld);
1327 tmpld = clogl(tmpld);
1328 tmpld = csinl(tmpld);
1329 tmpld = csinhl(tmpld);
1330 tmpld = csqrtl(tmpld);
1331 tmpld = ctanl(tmpld);
1332 tmpld = ctanhl(tmpld);
1333 tmpld = cpowl(tmpld, tmpld);
1334 tmpld = cprojl(tmpld);
1335 ], [glibcxx_cv_c99_complex_cxx11=yes], [glibcxx_cv_c99_complex_cxx11=no])
1338 if test x"$glibcxx_cv_c99_complex_cxx11" = x"yes"; then
1339 AC_DEFINE(_GLIBCXX11_USE_C99_COMPLEX, 1,
1340 [Define if C99 functions in <complex.h> should be used in
1341 <complex> for C++11. Using compiler builtins for these functions
1342 requires corresponding C99 library functions to be present.])
1345 # Check for the existence of <complex.h> complex inverse trigonometric
1346 # math functions used by <complex> for C++11 and later.
1347 ac_c99_complex_arc=no;
1348 if test x"$ac_has_complex_h" = x"yes"; then
1349 AC_MSG_CHECKING([for ISO C99 support for inverse trig functions in <complex.h>])
1350 AC_TRY_COMPILE([#include <complex.h>],
1351 [typedef __complex__ float float_type; float_type tmpf;
1358 typedef __complex__ double double_type; double_type tmpd;
1365 typedef __complex__ long double ld_type; ld_type tmpld;
1372 ],[ac_c99_complex_arc=yes], [ac_c99_complex_arc=no])
1374 AC_MSG_RESULT($ac_c99_complex_arc)
1375 if test x"$ac_c99_complex_arc" = x"yes"; then
1376 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_ARC, 1,
1377 [Define if C99 inverse trig functions in <complex.h> should be
1378 used in <complex>. Using compiler builtins for these functions
1379 requires corresponding C99 library functions to be present.])
1382 # Check for the existence in <stdio.h> of vscanf, et. al.
1383 AC_CACHE_CHECK([for ISO C99 support in <stdio.h> for C++11],
1384 glibcxx_cv_c99_stdio_cxx11, [
1385 GCC_TRY_COMPILE_OR_LINK(
1388 void foo(char* fmt, ...)
1390 va_list args; va_start(args, fmt);
1391 vfscanf(stderr, "%i", args);
1393 vsnprintf(fmt, 0, "%i", args);
1394 vsscanf(fmt, "%i", args);
1395 snprintf(fmt, 0, "%i");
1397 [glibcxx_cv_c99_stdio_cxx11=yes], [glibcxx_cv_c99_stdio_cxx11=no])
1399 if test x"$glibcxx_cv_c99_stdio_cxx11" = x"yes"; then
1400 AC_DEFINE(_GLIBCXX11_USE_C99_STDIO, 1,
1401 [Define if C99 functions or macros in <stdio.h> should be imported
1402 in <cstdio> in namespace std for C++11.])
1405 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1406 AC_CACHE_CHECK([for ISO C99 support in <stdlib.h> for C++11],
1407 glibcxx_cv_c99_stdlib_cxx11, [
1408 GCC_TRY_COMPILE_OR_LINK(
1409 [#include <stdlib.h>
1411 volatile long double ld;
1412 volatile unsigned long long ll;
1415 f = strtof("gnu", &tmp);
1416 ld = strtold("gnu", &tmp);
1417 ll = strtoll("gnu", &tmp, 10);
1418 ll = strtoull("gnu", &tmp, 10);
1420 mydivt = lldiv(10,1);
1425 ], [glibcxx_cv_c99_stdlib_cxx11=yes], [glibcxx_cv_c99_stdlib_cxx11=no])
1427 if test x"$glibcxx_cv_c99_stdlib_cxx11" = x"yes"; then
1428 AC_DEFINE(_GLIBCXX11_USE_C99_STDLIB, 1,
1429 [Define if C99 functions or macros in <stdlib.h> should be imported
1430 in <cstdlib> in namespace std for C++11.])
1433 # Check for the existence in <wchar.h> of wcstold, etc.
1434 if test x"$ac_has_wchar_h" = xyes &&
1435 test x"$ac_has_wctype_h" = xyes; then
1436 AC_CACHE_CHECK([for ISO C99 support in <wchar.h> for C++11],
1437 glibcxx_cv_c99_wchar_cxx11, [
1438 AC_TRY_COMPILE([#include <wchar.h>
1445 ], [], [glibcxx_cv_c99_wchar_cxx11=yes], [glibcxx_cv_c99_wchar_cxx11=no])
1448 # Checks for wide character functions that may not be present.
1449 # Injection of these is wrapped with guard macros.
1450 # NB: only put functions here, instead of immediately above, if
1451 # absolutely necessary.
1452 AC_TRY_COMPILE([#include <wchar.h>
1453 namespace test { using ::vfwscanf; }], [],
1454 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1456 AC_TRY_COMPILE([#include <wchar.h>
1457 namespace test { using ::vswscanf; }], [],
1458 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1460 AC_TRY_COMPILE([#include <wchar.h>
1461 namespace test { using ::vwscanf; }], [],
1462 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1464 AC_TRY_COMPILE([#include <wchar.h>
1465 namespace test { using ::wcstof; }], [],
1466 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1468 AC_TRY_COMPILE([#include <wctype.h>],
1469 [wint_t t; int i = iswblank(t);],
1470 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1472 if test x"$glibcxx_cv_c99_wchar_cxx11" = x"yes"; then
1473 AC_DEFINE(_GLIBCXX11_USE_C99_WCHAR, 1,
1474 [Define if C99 functions or macros in <wchar.h> should be imported
1475 in <cwchar> in namespace std for C++11.])
1479 # Check for the existence of <ctype.h> functions.
1480 AC_CACHE_CHECK([for ISO C99 support for C++11 in <ctype.h>],
1481 glibcxx_cv_c99_ctype, [
1482 AC_TRY_COMPILE([#include <ctype.h>],
1486 ],[glibcxx_cv_c99_ctype=yes],
1487 [glibcxx_cv_c99_ctype=no])
1489 if test x"$glibcxx_cv_c99_ctype" = x"yes"; then
1490 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE, 1,
1491 [Define if C99 functions in <ctype.h> should be imported in
1492 <cctype> in namespace std for C++11.])
1495 # Check for the existence of <fenv.h> functions.
1496 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1498 if test x"$ac_has_fenv_h" = x"yes"; then
1499 AC_MSG_CHECKING([for ISO C99 support for C++11 in <fenv.h>])
1500 AC_TRY_COMPILE([#include <fenv.h>],
1505 ret = feclearexcept(except);
1506 ret = fegetexceptflag(pflag, except);
1507 ret = feraiseexcept(except);
1508 ret = fesetexceptflag(pflag, except);
1509 ret = fetestexcept(except);
1511 ret = fesetround(mode);
1512 ret = fegetenv(penv);
1513 ret = feholdexcept(penv);
1514 ret = fesetenv(penv);
1515 ret = feupdateenv(penv);
1516 ],[ac_c99_fenv=yes], [ac_c99_fenv=no])
1517 AC_MSG_RESULT($ac_c99_fenv)
1519 if test x"$ac_c99_fenv" = x"yes"; then
1520 AC_DEFINE(_GLIBCXX_USE_C99_FENV, 1,
1521 [Define if C99 functions in <fenv.h> should be imported in
1522 <cfenv> in namespace std for C++11.])
1525 gcc_no_link="$ac_save_gcc_no_link"
1526 LIBS="$ac_save_LIBS"
1527 CXXFLAGS="$ac_save_CXXFLAGS"
1531 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1532 AC_MSG_RESULT($enable_c99)
1537 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1538 dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this]
1539 dnl in the C++11 standard.
1541 dnl --enable-libstdcxx-time
1542 dnl --enable-libstdcxx-time=yes
1543 dnl checks for the availability of monotonic and realtime clocks,
1544 dnl nanosleep and sched_yield in libc.
1545 dnl --enable-libstdcxx-time=rt
1546 dnl also searches (and, if needed, links) librt. Note that this is
1547 dnl not always desirable because, in glibc 2.16 and earlier, for
1548 dnl example, in turn it triggers the linking of libpthread too,
1549 dnl which activates locking,
1550 dnl a large overhead for single-thread programs.
1551 dnl --enable-libstdcxx-time=no
1552 dnl --disable-libstdcxx-time
1553 dnl disables the checks completely
1555 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1556 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1557 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1558 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1560 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1562 GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]],
1563 [use KIND for check type],
1568 ac_save_CXXFLAGS="$CXXFLAGS"
1569 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1570 ac_save_LIBS="$LIBS"
1572 ac_has_clock_monotonic=no
1573 ac_has_clock_realtime=no
1575 ac_has_sched_yield=no
1577 if test x"$enable_libstdcxx_time" = x"auto"; then
1579 case "${target_os}" in
1581 ac_has_nanosleep=yes
1584 ac_has_win32_sleep=yes
1585 ac_has_sched_yield=yes
1588 ac_has_nanosleep=yes
1589 ac_has_sched_yield=yes
1591 # VxWorks has nanosleep as soon as the kernel is configured with
1592 # INCLUDE_POSIX_TIMERS, which is normally/most-often the case.
1594 ac_has_nanosleep=yes
1596 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
1597 # Don't use link test for freestanding library, in case gcc_no_link=yes
1598 if test x"$is_hosted" = xyes; then
1599 # Versions of glibc before 2.17 needed -lrt for clock_gettime.
1600 AC_SEARCH_LIBS(clock_gettime, [rt])
1601 if test x"$ac_cv_search_clock_gettime" = x"none required"; then
1602 ac_has_clock_monotonic=yes
1603 ac_has_clock_realtime=yes
1606 ac_has_nanosleep=yes
1607 ac_has_sched_yield=yes
1609 freebsd*|netbsd*|dragonfly*|rtems*)
1610 ac_has_clock_monotonic=yes
1611 ac_has_clock_realtime=yes
1612 ac_has_nanosleep=yes
1613 ac_has_sched_yield=yes
1616 ac_has_clock_monotonic=yes
1617 ac_has_clock_realtime=yes
1618 ac_has_nanosleep=yes
1621 ac_has_clock_monotonic=yes
1622 ac_has_clock_realtime=yes
1623 ac_has_nanosleep=yes
1624 ac_has_sched_yield=yes
1627 ac_has_nanosleep=yes
1628 ac_has_sched_yield=yes
1631 elif test x"$enable_libstdcxx_time" != x"no"; then
1633 if test x"$enable_libstdcxx_time" = x"rt"; then
1634 AC_SEARCH_LIBS(clock_gettime, [rt])
1635 AC_SEARCH_LIBS(nanosleep, [rt])
1637 AC_CHECK_FUNC(clock_gettime)
1638 AC_CHECK_FUNC(nanosleep)
1641 case "$ac_cv_search_clock_gettime" in
1642 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1645 case "$ac_cv_search_nanosleep" in
1646 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1650 AC_SEARCH_LIBS(sched_yield, [rt])
1652 case "$ac_cv_search_sched_yield" in
1654 if test x"$enable_libstdcxx_time" = x"rt"; then
1655 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1656 ac_has_sched_yield=yes
1660 ac_has_sched_yield=yes
1664 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1666 if test x"$ac_has_unistd_h" = x"yes"; then
1667 AC_MSG_CHECKING([for monotonic clock])
1669 [#include <unistd.h>
1672 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1675 clock_gettime(CLOCK_MONOTONIC, &tp);
1676 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1678 AC_MSG_RESULT($ac_has_clock_monotonic)
1680 AC_MSG_CHECKING([for realtime clock])
1682 [#include <unistd.h>
1685 [#if _POSIX_TIMERS > 0
1688 clock_gettime(CLOCK_REALTIME, &tp);
1689 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1691 AC_MSG_RESULT($ac_has_clock_realtime)
1693 AC_MSG_CHECKING([for nanosleep])
1695 [#include <unistd.h>
1698 [#if _POSIX_TIMERS > 0
1702 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1704 AC_MSG_RESULT($ac_has_nanosleep)
1708 if test x"$ac_has_clock_monotonic" != x"yes"; then
1709 case ${target_os} in
1711 AC_MSG_CHECKING([for clock_gettime syscall])
1713 [#include <unistd.h>
1715 #include <sys/syscall.h>
1717 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1720 syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp);
1721 syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp);
1722 ], [ac_has_clock_gettime_syscall=yes], [ac_has_clock_gettime_syscall=no])
1723 AC_MSG_RESULT($ac_has_clock_gettime_syscall)
1724 if test x"$ac_has_clock_gettime_syscall" = x"yes"; then
1725 AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1,
1726 [Defined if clock_gettime syscall has monotonic and realtime clock support. ])
1727 ac_has_clock_monotonic=yes
1728 ac_has_clock_realtime=yes
1729 AC_MSG_CHECKING([for struct timespec that matches syscall])
1732 #include <sys/syscall.h>
1734 [#ifdef SYS_clock_gettime64
1735 #if SYS_clock_gettime64 != SYS_clock_gettime
1736 // We need to use SYS_clock_gettime and libc appears to
1737 // also know about the SYS_clock_gettime64 syscall.
1738 // Check that userspace doesn't use time64 version of timespec.
1739 static_assert(sizeof(timespec::tv_sec) == sizeof(long),
1740 "struct timespec must be compatible with SYS_clock_gettime");
1744 [ac_timespec_matches_syscall=yes],
1745 [ac_timespec_matches_syscall=no])
1746 AC_MSG_RESULT($ac_timespec_matches_syscall)
1747 if test x"$ac_timespec_matches_syscall" = no; then
1748 AC_MSG_ERROR([struct timespec is not compatible with SYS_clock_gettime, please report a bug to http://gcc.gnu.org/bugzilla])
1754 if test x"$ac_has_clock_monotonic" = x"yes"; then
1755 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1756 [ Defined if clock_gettime has monotonic clock support. ])
1759 if test x"$ac_has_clock_realtime" = x"yes"; then
1760 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1761 [ Defined if clock_gettime has realtime clock support. ])
1764 if test x"$ac_has_sched_yield" = x"yes"; then
1765 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1766 [ Defined if sched_yield is available. ])
1769 if test x"$ac_has_nanosleep" = x"yes"; then
1770 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1771 [ Defined if nanosleep is available. ])
1772 elif test x"$ac_has_win32_sleep" = x"yes"; then
1773 AC_DEFINE(_GLIBCXX_USE_WIN32_SLEEP, 1,
1774 [Defined if Sleep exists.])
1776 AC_MSG_CHECKING([for sleep])
1777 AC_TRY_COMPILE([#include <unistd.h>],
1779 [ac_has_sleep=yes],[ac_has_sleep=no])
1780 if test x"$ac_has_sleep" = x"yes"; then
1781 AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.])
1783 AC_MSG_RESULT($ac_has_sleep)
1784 AC_MSG_CHECKING([for usleep])
1785 AC_TRY_COMPILE([#include <unistd.h>],
1788 [ac_has_usleep=yes],[ac_has_usleep=no])
1789 if test x"$ac_has_usleep" = x"yes"; then
1790 AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.])
1792 AC_MSG_RESULT($ac_has_usleep)
1795 if test x"$ac_has_nanosleep$ac_has_win32_sleep$ac_has_sleep" = x"nonono"; then
1796 AC_DEFINE(_GLIBCXX_NO_SLEEP,1, [Defined if no way to sleep is available.])
1799 AC_SUBST(GLIBCXX_LIBS)
1801 CXXFLAGS="$ac_save_CXXFLAGS"
1802 LIBS="$ac_save_LIBS"
1807 dnl Check for gettimeofday, used in the implementation of 20.11.7
1808 dnl [time.clock] in the C++11 standard.
1810 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1812 AC_MSG_CHECKING([for gettimeofday])
1816 ac_save_CXXFLAGS="$CXXFLAGS"
1817 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1819 ac_has_gettimeofday=no;
1820 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1821 if test x"$ac_has_sys_time_h" = x"yes"; then
1822 AC_MSG_CHECKING([for gettimeofday])
1823 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1824 [timeval tv; gettimeofday(&tv, 0);],
1825 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1827 AC_MSG_RESULT($ac_has_gettimeofday)
1830 if test x"$ac_has_gettimeofday" = x"yes"; then
1831 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1832 [ Defined if gettimeofday is available. ])
1835 CXXFLAGS="$ac_save_CXXFLAGS"
1840 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1841 dnl facilities in Chapter 8, "C compatibility".
1843 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1848 # Use -std=c++98 because -std=gnu++98 leaves __STRICT_ANSI__
1849 # undefined and fake C99 facilities may be spuriously enabled.
1850 ac_save_CXXFLAGS="$CXXFLAGS"
1851 CXXFLAGS="$CXXFLAGS -std=c++98"
1853 # Check for the existence of <complex.h> complex math functions used
1855 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1856 ac_c99_complex_tr1=no;
1857 if test x"$ac_has_complex_h" = x"yes"; then
1858 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1859 AC_TRY_COMPILE([#include <complex.h>],
1860 [typedef __complex__ float float_type; float_type tmpf;
1867 typedef __complex__ double double_type; double_type tmpd;
1874 typedef __complex__ long double ld_type; ld_type tmpld;
1881 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1883 AC_MSG_RESULT($ac_c99_complex_tr1)
1884 if test x"$ac_c99_complex_tr1" = x"yes"; then
1885 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1886 [Define if C99 functions in <complex.h> should be used in
1887 <tr1/complex>. Using compiler builtins for these functions
1888 requires corresponding C99 library functions to be present.])
1891 # Check for the existence of <ctype.h> functions.
1892 AC_CACHE_CHECK([for ISO C99 support to TR1 in <ctype.h>],
1893 glibcxx_cv_c99_ctype_tr1, [
1894 AC_TRY_COMPILE([#include <ctype.h>],
1898 ],[glibcxx_cv_c99_ctype_tr1=yes],
1899 [glibcxx_cv_c99_ctype_tr1=no])
1901 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1902 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1903 [Define if C99 functions in <ctype.h> should be imported in
1904 <tr1/cctype> in namespace std::tr1.])
1907 # Check for the existence of <fenv.h> functions.
1908 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1910 if test x"$ac_has_fenv_h" = x"yes"; then
1911 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1912 AC_TRY_COMPILE([#include <fenv.h>],
1917 ret = feclearexcept(except);
1918 ret = fegetexceptflag(pflag, except);
1919 ret = feraiseexcept(except);
1920 ret = fesetexceptflag(pflag, except);
1921 ret = fetestexcept(except);
1923 ret = fesetround(mode);
1924 ret = fegetenv(penv);
1925 ret = feholdexcept(penv);
1926 ret = fesetenv(penv);
1927 ret = feupdateenv(penv);
1928 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1929 AC_MSG_RESULT($ac_c99_fenv_tr1)
1931 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1932 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1933 [Define if C99 functions in <fenv.h> should be imported in
1934 <tr1/cfenv> in namespace std::tr1.])
1937 # Check for the existence of <stdint.h> types.
1938 AC_CACHE_CHECK([for ISO C99 support to TR1 in <stdint.h>],
1939 glibcxx_cv_c99_stdint_tr1, [
1940 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1941 #define __STDC_CONSTANT_MACROS
1942 #include <stdint.h>],
1943 [typedef int8_t my_int8_t;
1944 my_int8_t i8 = INT8_MIN;
1946 typedef int16_t my_int16_t;
1947 my_int16_t i16 = INT16_MIN;
1949 typedef int32_t my_int32_t;
1950 my_int32_t i32 = INT32_MIN;
1952 typedef int64_t my_int64_t;
1953 my_int64_t i64 = INT64_MIN;
1955 typedef int_fast8_t my_int_fast8_t;
1956 my_int_fast8_t if8 = INT_FAST8_MIN;
1957 if8 = INT_FAST8_MAX;
1958 typedef int_fast16_t my_int_fast16_t;
1959 my_int_fast16_t if16 = INT_FAST16_MIN;
1960 if16 = INT_FAST16_MAX;
1961 typedef int_fast32_t my_int_fast32_t;
1962 my_int_fast32_t if32 = INT_FAST32_MIN;
1963 if32 = INT_FAST32_MAX;
1964 typedef int_fast64_t my_int_fast64_t;
1965 my_int_fast64_t if64 = INT_FAST64_MIN;
1966 if64 = INT_FAST64_MAX;
1967 typedef int_least8_t my_int_least8_t;
1968 my_int_least8_t il8 = INT_LEAST8_MIN;
1969 il8 = INT_LEAST8_MAX;
1970 typedef int_least16_t my_int_least16_t;
1971 my_int_least16_t il16 = INT_LEAST16_MIN;
1972 il16 = INT_LEAST16_MAX;
1973 typedef int_least32_t my_int_least32_t;
1974 my_int_least32_t il32 = INT_LEAST32_MIN;
1975 il32 = INT_LEAST32_MAX;
1976 typedef int_least64_t my_int_least64_t;
1977 my_int_least64_t il64 = INT_LEAST64_MIN;
1978 il64 = INT_LEAST64_MAX;
1979 typedef intmax_t my_intmax_t;
1980 my_intmax_t im = INTMAX_MAX;
1982 typedef intptr_t my_intptr_t;
1983 my_intptr_t ip = INTPTR_MAX;
1985 typedef uint8_t my_uint8_t;
1986 my_uint8_t ui8 = UINT8_MAX;
1988 typedef uint16_t my_uint16_t;
1989 my_uint16_t ui16 = UINT16_MAX;
1991 typedef uint32_t my_uint32_t;
1992 my_uint32_t ui32 = UINT32_MAX;
1994 typedef uint64_t my_uint64_t;
1995 my_uint64_t ui64 = UINT64_MAX;
1997 typedef uint_fast8_t my_uint_fast8_t;
1998 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1999 uif8 = UINT_FAST8_MAX;
2000 typedef uint_fast16_t my_uint_fast16_t;
2001 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
2002 uif16 = UINT_FAST16_MAX;
2003 typedef uint_fast32_t my_uint_fast32_t;
2004 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
2005 uif32 = UINT_FAST32_MAX;
2006 typedef uint_fast64_t my_uint_fast64_t;
2007 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
2008 uif64 = UINT_FAST64_MAX;
2009 typedef uint_least8_t my_uint_least8_t;
2010 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
2011 uil8 = UINT_LEAST8_MAX;
2012 typedef uint_least16_t my_uint_least16_t;
2013 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
2014 uil16 = UINT_LEAST16_MAX;
2015 typedef uint_least32_t my_uint_least32_t;
2016 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
2017 uil32 = UINT_LEAST32_MAX;
2018 typedef uint_least64_t my_uint_least64_t;
2019 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
2020 uil64 = UINT_LEAST64_MAX;
2021 typedef uintmax_t my_uintmax_t;
2022 my_uintmax_t uim = UINTMAX_MAX;
2024 typedef uintptr_t my_uintptr_t;
2025 my_uintptr_t uip = UINTPTR_MAX;
2027 ],[glibcxx_cv_c99_stdint_tr1=yes],
2028 [glibcxx_cv_c99_stdint_tr1=no])
2030 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2031 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
2032 [Define if C99 types in <stdint.h> should be imported in
2033 <tr1/cstdint> in namespace std::tr1.])
2036 # Check for the existence of <math.h> functions.
2037 AC_CACHE_CHECK([for ISO C99 support to TR1 in <math.h>],
2038 glibcxx_cv_c99_math_tr1, [
2039 AC_TRY_COMPILE([#include <math.h>],
2040 [typedef double_t my_double_t;
2041 typedef float_t my_float_t;
2055 copysignf(0.0f, 0.0f);
2056 copysignl(0.0l, 0.0l);
2073 fmaf(0.0f, 0.0f, 0.0f);
2074 fmal(0.0l, 0.0l, 0.0l);
2090 #ifndef __APPLE__ /* see below */
2119 nextafter(0.0, 0.0);
2120 nextafterf(0.0f, 0.0f);
2121 nextafterl(0.0l, 0.0l);
2122 nexttoward(0.0, 0.0);
2123 nexttowardf(0.0f, 0.0f);
2124 nexttowardl(0.0l, 0.0l);
2125 remainder(0.0, 0.0);
2126 remainderf(0.0f, 0.0f);
2127 remainderl(0.0l, 0.0l);
2128 remquo(0.0, 0.0, 0);
2129 remquof(0.0f, 0.0f, 0);
2130 remquol(0.0l, 0.0l, 0);
2149 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
2151 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
2152 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
2153 [Define if C99 functions or macros in <math.h> should be imported
2154 in <tr1/cmath> in namespace std::tr1.])
2156 case "${target_os}" in
2158 AC_CACHE_CHECK([for ISO C99 rounding functions in <math.h>],
2159 glibcxx_cv_c99_math_llround, [
2160 AC_TRY_COMPILE([#include <math.h>],
2168 [glibcxx_cv_c99_math_llround=yes],
2169 [glibcxx_cv_c99_math_llround=no])
2173 if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
2174 AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
2175 [Define if C99 llrint and llround functions are missing from <math.h>.])
2179 # Check for the existence of <inttypes.h> functions (NB: doesn't make
2180 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
2181 ac_c99_inttypes_tr1=no;
2182 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2183 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
2184 AC_TRY_COMPILE([#include <inttypes.h>],
2185 [intmax_t i, numer, denom, base;
2188 intmax_t ret = imaxabs(i);
2189 imaxdiv_t dret = imaxdiv(numer, denom);
2190 ret = strtoimax(s, endptr, base);
2191 uintmax_t uret = strtoumax(s, endptr, base);
2192 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
2193 AC_MSG_RESULT($ac_c99_inttypes_tr1)
2195 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
2196 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
2197 [Define if C99 functions in <inttypes.h> should be imported in
2198 <tr1/cinttypes> in namespace std::tr1.])
2201 # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
2202 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
2203 ac_c99_inttypes_wchar_t_tr1=no;
2204 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2205 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
2206 AC_TRY_COMPILE([#include <inttypes.h>],
2210 intmax_t ret = wcstoimax(s, endptr, base);
2211 uintmax_t uret = wcstoumax(s, endptr, base);
2212 ],[ac_c99_inttypes_wchar_t_tr1=yes],
2213 [ac_c99_inttypes_wchar_t_tr1=no])
2214 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
2216 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
2217 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
2218 [Define if wchar_t C99 functions in <inttypes.h> should be
2219 imported in <tr1/cinttypes> in namespace std::tr1.])
2222 # Check for the existence of the <stdbool.h> header.
2223 AC_CHECK_HEADERS(stdbool.h)
2225 # Check for the existence of the <stdalign.h> header.
2226 AC_CHECK_HEADERS(stdalign.h)
2228 CXXFLAGS="$ac_save_CXXFLAGS"
2233 dnl Check for uchar.h and usability.
2235 AC_DEFUN([GLIBCXX_CHECK_UCHAR_H], [
2238 AC_CHECK_HEADERS(uchar.h, ac_has_uchar_h=yes, ac_has_uchar_h=no)
2242 ac_save_CXXFLAGS="$CXXFLAGS"
2243 CXXFLAGS="$CXXFLAGS -std=c++11"
2245 if test x"$ac_has_uchar_h" = x"yes"; then
2246 AC_MSG_CHECKING([for ISO C11 support for <uchar.h>])
2247 AC_TRY_COMPILE([#include <uchar.h>
2248 #ifdef __STDC_UTF_16__
2249 long i = __STDC_UTF_16__;
2251 #ifdef __STDC_UTF_32__
2252 long j = __STDC_UTF_32__;
2262 [], [ac_c11_uchar_cxx11=yes], [ac_c11_uchar_cxx11=no])
2263 AC_MSG_RESULT($ac_c11_uchar_cxx11)
2265 ac_c11_uchar_cxx11=no
2267 if test x"$ac_c11_uchar_cxx11" = x"yes"; then
2268 AC_DEFINE(_GLIBCXX_USE_C11_UCHAR_CXX11, 1,
2269 [Define if C11 functions in <uchar.h> should be imported into
2270 namespace std in <cuchar>.])
2273 CXXFLAGS="$CXXFLAGS -fchar8_t"
2274 if test x"$ac_has_uchar_h" = x"yes"; then
2275 AC_MSG_CHECKING([for c8rtomb and mbrtoc8 in <uchar.h> with -fchar8_t])
2276 AC_TRY_COMPILE([#include <uchar.h>
2283 [], [ac_uchar_c8rtomb_mbrtoc8_fchar8_t=yes],
2284 [ac_uchar_c8rtomb_mbrtoc8_fchar8_t=no])
2285 AC_MSG_RESULT($ac_uchar_c8rtomb_mbrtoc8_fchar8_t)
2287 ac_uchar_c8rtomb_mbrtoc8_fchar8_t=no
2289 if test x"$ac_uchar_c8rtomb_mbrtoc8_fchar8_t" = x"yes"; then
2290 AC_DEFINE(_GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_FCHAR8_T, 1,
2291 [Define if c8rtomb and mbrtoc8 functions in <uchar.h> should be
2292 imported into namespace std in <cuchar> for -fchar8_t.])
2295 CXXFLAGS="$CXXFLAGS -std=c++20"
2296 if test x"$ac_has_uchar_h" = x"yes"; then
2297 AC_MSG_CHECKING([for c8rtomb and mbrtoc8 in <uchar.h> with -std=c++20])
2298 AC_TRY_COMPILE([#include <uchar.h>
2305 [], [ac_uchar_c8rtomb_mbrtoc8_cxx20=yes],
2306 [ac_uchar_c8rtomb_mbrtoc8_cxx20=no])
2307 AC_MSG_RESULT($ac_uchar_c8rtomb_mbrtoc8_cxx20)
2309 ac_uchar_c8rtomb_mbrtoc8_cxx20=no
2311 if test x"$ac_uchar_c8rtomb_mbrtoc8_cxx20" = x"yes"; then
2312 AC_DEFINE(_GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_CXX20, 1,
2313 [Define if c8rtomb and mbrtoc8 functions in <uchar.h> should be
2314 imported into namespace std in <cuchar> for C++20.])
2317 CXXFLAGS="$ac_save_CXXFLAGS"
2323 dnl Check whether "/dev/random" and "/dev/urandom" are available for
2324 dnl class std::random_device from C++ 2011 [rand.device], and
2325 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
2327 AC_DEFUN([GLIBCXX_CHECK_DEV_RANDOM], [
2329 AC_CACHE_CHECK([for "/dev/random" and "/dev/urandom" for std::random_device],
2330 glibcxx_cv_dev_random, [
2331 if test -r /dev/random && test -r /dev/urandom; then
2332 ## For MSys environment the test above is detected as false-positive
2333 ## on mingw-targets. So disable it explicitly for them.
2334 case ${target_os} in
2335 *mingw*) glibcxx_cv_dev_random=no ;;
2336 *) glibcxx_cv_dev_random=yes ;;
2339 glibcxx_cv_dev_random=no;
2343 if test x"$glibcxx_cv_dev_random" = x"yes"; then
2344 AC_DEFINE(_GLIBCXX_USE_DEV_RANDOM, 1,
2345 [Define if /dev/random and /dev/urandom are available for
2346 std::random_device.])
2347 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
2348 [Define if /dev/random and /dev/urandom are available for
2349 the random_device of TR1 (Chapter 5.1).])
2355 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
2357 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
2359 if test "$is_hosted" = yes; then
2360 AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
2361 AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
2362 [#include <stdio.h>],
2363 [AC_MSG_ERROR([computing EOF failed])])
2365 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
2366 [Define to the value of the EOF integer constant.])
2368 AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
2369 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
2370 [#include <stdio.h>],
2371 [AC_MSG_ERROR([computing SEEK_CUR failed])])
2373 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
2374 [Define to the value of the SEEK_CUR integer constant.])
2376 AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
2377 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
2378 [#include <stdio.h>],
2379 [AC_MSG_ERROR([computing SEEK_END failed])])
2381 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
2382 [Define to the value of the SEEK_END integer constant.])
2387 dnl Check whether required C++ overloads are present in <stdio.h>.
2389 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
2393 # Use C++11 because a conforming <stdio.h> won't define gets for C++14,
2394 # and we don't need a declaration for C++14 anyway.
2395 ac_save_CXXFLAGS="$CXXFLAGS"
2396 CXXFLAGS="$CXXFLAGS -std=gnu++11"
2398 AC_CACHE_CHECK([for gets declaration], glibcxx_cv_gets, [
2399 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2406 [glibcxx_cv_gets=yes],
2407 [glibcxx_cv_gets=no]
2410 if test $glibcxx_cv_gets = yes; then
2411 AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h> before C++14.])
2414 CXXFLAGS="$ac_save_CXXFLAGS"
2419 dnl Check whether required C++11 overloads for floating point and integral
2420 dnl types are present in <math.h>.
2422 AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
2426 ac_save_CXXFLAGS="$CXXFLAGS"
2427 CXXFLAGS="$CXXFLAGS -std=c++11"
2431 # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
2432 # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
2433 AC_CACHE_CHECK([for C++11 <math.h> floating point overloads],
2434 glibcxx_cv_math11_fp_overload, [
2435 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2439 inline bool isfinite(float __x)
2440 { return __builtin_isfinite(__x); }
2443 [glibcxx_cv_math11_fp_overload=no],
2444 [glibcxx_cv_math11_fp_overload=yes]
2447 # autoheader cannot handle indented templates.
2448 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP],
2449 [/* Define if all C++11 floating point overloads are available in <math.h>. */
2450 #if __cplusplus >= 201103L
2451 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2454 if test $glibcxx_cv_math11_fp_overload = yes; then
2455 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP)
2458 # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
2459 # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
2460 AC_CACHE_CHECK([for C++11 <math.h> integral type overloads],
2461 glibcxx_cv_math11_int_overload, [
2462 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2465 template<typename _Tp>
2466 struct __is_integer;
2468 struct __is_integer<int>
2470 enum { __value = 1 };
2473 namespace __gnu_cxx {
2474 template<bool, typename>
2476 template<typename _Tp>
2477 struct __enable_if<true, _Tp>
2478 { typedef _Tp __type; };
2481 template<typename _Tp>
2482 constexpr typename __gnu_cxx::__enable_if
2483 <__is_integer<_Tp>::__value, double>::__type
2485 { return __builtin_log2(__x); }
2491 return std::log2(i);
2494 [glibcxx_cv_math11_int_overload=no],
2495 [glibcxx_cv_math11_int_overload=yes]
2498 # autoheader cannot handle indented templates.
2499 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT],
2500 [/* Define if all C++11 integral type overloads are available in <math.h>. */
2501 #if __cplusplus >= 201103L
2502 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2505 if test $glibcxx_cv_math11_int_overload = yes; then
2506 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT)
2510 # If <math.h> defines the obsolete isinf(double) and isnan(double)
2511 # functions (instead of or as well as the C99 generic macros) then we
2512 # can't define std::isinf(double) and std::isnan(double) in <cmath>
2513 # and must use the ones from <math.h> instead.
2514 AC_CACHE_CHECK([for obsolete isinf function in <math.h>],
2515 glibcxx_cv_obsolete_isinf, [
2516 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2517 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2523 bool isinf(long double);
2526 bool b = isinf(0.0);
2528 [glibcxx_cv_obsolete_isinf=yes],
2529 [glibcxx_cv_obsolete_isinf=no]
2531 if test $glibcxx_cv_obsolete_isinf = yes; then
2532 AC_DEFINE(HAVE_OBSOLETE_ISINF, 1,
2533 [Define if <math.h> defines obsolete isinf function.])
2536 AC_CACHE_CHECK([for obsolete isnan function in <math.h>],
2537 glibcxx_cv_obsolete_isnan, [
2538 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2539 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2545 bool isnan(long double);
2548 bool b = isnan(0.0);
2550 [glibcxx_cv_obsolete_isnan=yes],
2551 [glibcxx_cv_obsolete_isnan=no]
2553 if test $glibcxx_cv_obsolete_isnan = yes; then
2554 AC_DEFINE(HAVE_OBSOLETE_ISNAN, 1,
2555 [Define if <math.h> defines obsolete isnan function.])
2560 CXXFLAGS="$ac_save_CXXFLAGS"
2565 dnl Check for what type of C headers to use.
2567 dnl --enable-cheaders= [does stuff].
2568 dnl --disable-cheaders [does not do anything, really].
2569 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
2570 dnl Where DEFAULT is either 'c' or 'c_global' or 'c_std'.
2572 dnl To use the obsolete 'c_std' headers use --enable-cheaders-obsolete as
2573 dnl well as --enable-cheaders=c_std, otherwise configure will fail.
2575 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
2576 GLIBCXX_ENABLE(cheaders-obsolete,no,,
2577 [allow use of obsolete "C" headers for g++])
2578 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
2579 [construct "C" headers for g++], [permit c|c_global|c_std])
2580 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
2581 if test $enable_cheaders = c_std ; then
2582 AC_MSG_WARN([the --enable-cheaders=c_std configuration is obsolete, c_global should be used instead])
2583 AC_MSG_WARN([if you are unable to use c_global please report a bug or inform libstdc++@gcc.gnu.org])
2584 if test $enable_cheaders_obsolete != yes ; then
2585 AC_MSG_ERROR(use --enable-cheaders-obsolete to use c_std "C" headers)
2589 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
2591 # Allow overrides to configure.host here.
2592 if test $enable_cheaders = c_global; then
2596 AC_SUBST(C_INCLUDE_DIR)
2597 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
2598 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
2599 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
2600 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
2605 dnl Check for which locale library to use. The choice is mapped to
2606 dnl a subdirectory of config/locale.
2608 dnl Default is generic.
2610 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
2611 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
2612 [use MODEL for target locale package],
2613 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
2615 # Deal with gettext issues. Default to not using it (=no) until we detect
2616 # support for it later. Let the user turn it off via --e/d, but let that
2617 # default to on for easier handling.
2620 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
2624 # Either a known package, or "auto"
2625 if test $enable_clocale = no || test $enable_clocale = yes; then
2628 enable_clocale_flag=$enable_clocale
2630 # Probe for locale model to use if none specified.
2631 # Default to "generic".
2632 if test $enable_clocale_flag = auto; then
2633 case ${target_os} in
2634 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2635 enable_clocale_flag=gnu
2638 enable_clocale_flag=darwin
2641 enable_clocale_flag=vxworks
2643 dragonfly* | freebsd*)
2644 enable_clocale_flag=dragonfly
2647 enable_clocale_flag=newlib
2650 if test x"$with_newlib" = x"yes"; then
2651 enable_clocale_flag=newlib
2653 enable_clocale_flag=generic
2659 # Sanity check model, and test for special functionality.
2660 if test $enable_clocale_flag = gnu; then
2661 AC_EGREP_CPP([_GLIBCXX_ok], [
2662 #include <features.h>
2663 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
2666 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
2668 # Set it to scream when it hurts.
2669 ac_save_CFLAGS="$CFLAGS"
2670 CFLAGS="-Wimplicit-function-declaration -Werror"
2672 # Use strxfrm_l if available.
2673 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2675 #include <locale.h>],
2676 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
2677 AC_DEFINE(HAVE_STRXFRM_L, 1,
2678 [Define if strxfrm_l is available in <string.h>.]),)
2680 # Use strerror_l if available.
2681 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2683 #include <locale.h>],
2684 [__locale_t loc; strerror_l(5, loc);],
2685 AC_DEFINE(HAVE_STRERROR_L, 1,
2686 [Define if strerror_l is available in <string.h>.]),)
2688 CFLAGS="$ac_save_CFLAGS"
2691 # Perhaps use strerror_r if available, and strerror_l isn't.
2692 ac_save_CFLAGS="$CFLAGS"
2693 CFLAGS="-Wimplicit-function-declaration -Werror"
2694 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2696 #include <locale.h>],
2697 [char s[128]; strerror_r(5, s, 128);],
2698 AC_DEFINE(HAVE_STRERROR_R, 1,
2699 [Define if strerror_r is available in <string.h>.]),)
2700 CFLAGS="$ac_save_CFLAGS"
2702 # Set configure bits for specified locale package
2703 AC_MSG_CHECKING([for C locale to use])
2704 case ${enable_clocale_flag} in
2706 AC_MSG_RESULT(generic)
2708 CLOCALE_H=config/locale/generic/c_locale.h
2709 CLOCALE_CC=config/locale/generic/c_locale.cc
2710 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2711 CCOLLATE_CC=config/locale/generic/collate_members.cc
2712 CCTYPE_CC=config/locale/generic/ctype_members.cc
2713 CMESSAGES_H=config/locale/generic/messages_members.h
2714 CMESSAGES_CC=config/locale/generic/messages_members.cc
2715 CMONEY_CC=config/locale/generic/monetary_members.cc
2716 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2717 CTIME_H=config/locale/generic/time_members.h
2718 CTIME_CC=config/locale/generic/time_members.cc
2719 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2722 AC_MSG_RESULT(darwin)
2724 CLOCALE_H=config/locale/generic/c_locale.h
2725 CLOCALE_CC=config/locale/generic/c_locale.cc
2726 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2727 CCOLLATE_CC=config/locale/generic/collate_members.cc
2728 CCTYPE_CC=config/locale/darwin/ctype_members.cc
2729 CMESSAGES_H=config/locale/generic/messages_members.h
2730 CMESSAGES_CC=config/locale/generic/messages_members.cc
2731 CMONEY_CC=config/locale/generic/monetary_members.cc
2732 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2733 CTIME_H=config/locale/generic/time_members.h
2734 CTIME_CC=config/locale/generic/time_members.cc
2735 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2738 AC_MSG_RESULT(vxworks)
2740 CLOCALE_H=config/locale/generic/c_locale.h
2741 CLOCALE_CC=config/locale/generic/c_locale.cc
2742 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2743 CCOLLATE_CC=config/locale/generic/collate_members.cc
2744 CCTYPE_CC=config/locale/vxworks/ctype_members.cc
2745 CMESSAGES_H=config/locale/generic/messages_members.h
2746 CMESSAGES_CC=config/locale/generic/messages_members.cc
2747 CMONEY_CC=config/locale/generic/monetary_members.cc
2748 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2749 CTIME_H=config/locale/generic/time_members.h
2750 CTIME_CC=config/locale/generic/time_members.cc
2751 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2754 AC_MSG_RESULT(dragonfly or freebsd)
2756 CLOCALE_H=config/locale/dragonfly/c_locale.h
2757 CLOCALE_CC=config/locale/dragonfly/c_locale.cc
2758 CCODECVT_CC=config/locale/dragonfly/codecvt_members.cc
2759 CCOLLATE_CC=config/locale/dragonfly/collate_members.cc
2760 CCTYPE_CC=config/locale/dragonfly/ctype_members.cc
2761 CMESSAGES_H=config/locale/generic/messages_members.h
2762 CMESSAGES_CC=config/locale/generic/messages_members.cc
2763 CMONEY_CC=config/locale/dragonfly/monetary_members.cc
2764 CNUMERIC_CC=config/locale/dragonfly/numeric_members.cc
2765 CTIME_H=config/locale/dragonfly/time_members.h
2766 CTIME_CC=config/locale/dragonfly/time_members.cc
2767 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2773 # Declare intention to use gettext, and add support for specific
2775 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2778 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2779 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2780 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2783 # Export the build objects.
2784 for ling in $ALL_LINGUAS; do \
2785 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2786 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2788 AC_SUBST(glibcxx_MOFILES)
2789 AC_SUBST(glibcxx_POFILES)
2791 CLOCALE_H=config/locale/gnu/c_locale.h
2792 CLOCALE_CC=config/locale/gnu/c_locale.cc
2793 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2794 CCOLLATE_CC=config/locale/gnu/collate_members.cc
2795 CCTYPE_CC=config/locale/gnu/ctype_members.cc
2796 CMESSAGES_H=config/locale/gnu/messages_members.h
2797 CMESSAGES_CC=config/locale/gnu/messages_members.cc
2798 CMONEY_CC=config/locale/gnu/monetary_members.cc
2799 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2800 CTIME_H=config/locale/gnu/time_members.h
2801 CTIME_CC=config/locale/gnu/time_members.cc
2802 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2805 AC_MSG_RESULT(IEEE 1003.1)
2807 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2808 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2809 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2810 CCOLLATE_CC=config/locale/generic/collate_members.cc
2811 CCTYPE_CC=config/locale/generic/ctype_members.cc
2812 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2813 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2814 CMONEY_CC=config/locale/generic/monetary_members.cc
2815 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2816 CTIME_H=config/locale/generic/time_members.h
2817 CTIME_CC=config/locale/generic/time_members.cc
2818 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2821 AC_MSG_RESULT(newlib)
2823 CLOCALE_H=config/locale/generic/c_locale.h
2824 CLOCALE_CC=config/locale/generic/c_locale.cc
2825 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2826 CCOLLATE_CC=config/locale/generic/collate_members.cc
2827 CCTYPE_CC=config/locale/newlib/ctype_members.cc
2828 CMESSAGES_H=config/locale/generic/messages_members.h
2829 CMESSAGES_CC=config/locale/generic/messages_members.cc
2830 CMONEY_CC=config/locale/generic/monetary_members.cc
2831 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2832 CTIME_H=config/locale/generic/time_members.h
2833 CTIME_CC=config/locale/generic/time_members.cc
2834 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2838 # This is where the testsuite looks for locale catalogs, using the
2839 # -DLOCALEDIR define during testsuite compilation.
2840 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2841 AC_SUBST(glibcxx_localedir)
2843 # A standalone libintl (e.g., GNU libintl) may be in use.
2844 if test $USE_NLS = yes; then
2845 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2846 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2848 if test $USE_NLS = yes; then
2849 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2850 [Define if NLS translations are to be used.])
2855 AC_SUBST(CMESSAGES_H)
2856 AC_SUBST(CCODECVT_CC)
2857 AC_SUBST(CCOLLATE_CC)
2859 AC_SUBST(CMESSAGES_CC)
2861 AC_SUBST(CNUMERIC_CC)
2864 AC_SUBST(CLOCALE_CC)
2865 AC_SUBST(CLOCALE_INTERNAL_H)
2870 dnl Check for which std::allocator base class to use. The choice is
2871 dnl mapped from a subdirectory of include/ext.
2875 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2876 AC_MSG_CHECKING([for std::allocator base class])
2877 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2878 [use KIND for target std::allocator base],
2879 [permit new|malloc|yes|no|auto])
2881 # If they didn't use this option switch, or if they specified --enable
2882 # with no specific model, we'll have to look for one. If they
2883 # specified --disable (???), do likewise.
2884 if test $enable_libstdcxx_allocator = no ||
2885 test $enable_libstdcxx_allocator = yes;
2887 enable_libstdcxx_allocator=auto
2890 # Either a known package, or "auto". Auto implies the default choice
2891 # for a particular platform.
2892 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2894 # Probe for host-specific support if no specific model is specified.
2896 if test $enable_libstdcxx_allocator_flag = auto; then
2897 case ${target_os} in
2898 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2899 enable_libstdcxx_allocator_flag=new
2902 enable_libstdcxx_allocator_flag=new
2906 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2909 # Set configure bits for specified locale package
2910 case ${enable_libstdcxx_allocator_flag} in
2912 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2913 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2916 ALLOCATOR_H=config/allocator/new_allocator_base.h
2917 ALLOCATOR_NAME=__gnu_cxx::new_allocator
2921 GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
2922 test $enable_libstdcxx_allocator_flag = new)
2923 AC_SUBST(ALLOCATOR_H)
2924 AC_SUBST(ALLOCATOR_NAME)
2929 dnl Check for whether the Boost-derived checks should be turned on.
2931 dnl --enable-concept-checks turns them on.
2932 dnl --disable-concept-checks leaves them off.
2933 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2934 dnl Where DEFAULT is either `yes' or `no'.
2936 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2937 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2938 if test $enable_concept_checks = yes; then
2939 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2940 [Define to use concept checking code from the boost libraries.])
2945 dnl Use extern templates.
2947 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2948 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2950 dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2951 dnl Where DEFAULT is `yes' or `no'.
2953 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2955 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2957 AC_MSG_CHECKING([for extern template support])
2958 AC_MSG_RESULT([$enable_extern_template])
2960 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2964 dnl Use vtable verification.
2966 dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1
2967 dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0
2969 dnl + Usage: GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)]
2970 dnl Where DEFAULT is `yes' or `no'.
2972 AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [
2974 GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify])
2976 AC_MSG_CHECKING([for vtable verify support])
2977 AC_MSG_RESULT([$enable_vtable_verify])
2980 if test $enable_vtable_verify = yes; then
2981 case ${target_os} in
2983 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2984 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2988 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u,_vtable_map_vars_start -Wl,-u,_vtable_map_vars_end"
2989 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-rpath,${toplevel_builddir}/libvtv/.libs"
2992 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2993 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-R -Wl,${toplevel_builddir}/libvtv/.libs"
2996 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2997 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
3000 VTV_PCH_CXXFLAGS="-fvtable-verify=std"
3007 AC_SUBST(VTV_CXXFLAGS)
3008 AC_SUBST(VTV_PCH_CXXFLAGS)
3009 AC_SUBST(VTV_CXXLINKFLAGS)
3010 AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes)
3011 GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes)
3015 dnl Check for parallel mode pre-requisites, including OpenMP support.
3017 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
3019 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
3023 # See if configured libgomp/omp.h exists. (libgomp may be in
3024 # noconfigdirs but not explicitly disabled.)
3025 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
3026 enable_parallel=yes;
3028 AC_MSG_NOTICE([target-libgomp not built])
3031 AC_MSG_CHECKING([for parallel mode support])
3032 AC_MSG_RESULT([$enable_parallel])
3037 dnl Check for which I/O library to use: stdio and POSIX, or pure stdio.
3039 dnl Default is stdio_posix.
3041 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
3042 AC_MSG_CHECKING([for underlying I/O to use])
3043 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
3044 [use target-specific I/O package], [permit stdio|stdio_posix|stdio_pure])
3046 # The only available I/O model is based on stdio, via basic_file_stdio.
3047 # The default "stdio" is actually "stdio + POSIX" because it uses fdopen(3)
3048 # to get a file descriptor and then uses read(3) and write(3) with it.
3049 # The "stdio_pure" model doesn't use fdopen and only uses FILE* for I/O.
3050 case ${enable_cstdio} in
3052 CSTDIO_H=config/io/c_io_stdio.h
3053 BASIC_FILE_H=config/io/basic_file_stdio.h
3054 BASIC_FILE_CC=config/io/basic_file_stdio.cc
3056 if test "x$enable_cstdio" = "xstdio_pure" ; then
3057 AC_MSG_RESULT([stdio (without POSIX read/write)])
3058 AC_DEFINE(_GLIBCXX_USE_STDIO_PURE, 1,
3059 [Define to restrict std::__basic_file<> to stdio APIs.])
3061 AC_MSG_RESULT([stdio (with POSIX read/write)])
3067 AC_SUBST(BASIC_FILE_H)
3068 AC_SUBST(BASIC_FILE_CC)
3073 dnl Check for "unusual" flags to pass to the compiler while building.
3075 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
3076 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
3077 dnl --disable-cxx-flags passes nothing.
3078 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
3079 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
3080 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
3081 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
3082 dnl If "default flags" is an empty string, the effect is the same
3083 dnl as --disable or --enable=no.
3085 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
3086 AC_MSG_CHECKING([for extra compiler flags for building])
3087 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
3088 [pass compiler FLAGS when building library],
3089 [case "x$enable_cxx_flags" in
3090 xno | x) enable_cxx_flags= ;;
3092 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
3095 # Run through flags (either default or command-line) and set anything
3096 # extra (e.g., #defines) that must accompany particular g++ options.
3097 if test -n "$enable_cxx_flags"; then
3098 for f in $enable_cxx_flags; do
3102 *) # and we're trying to pass /what/ exactly?
3103 AC_MSG_ERROR([compiler flags start with a -]) ;;
3108 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3109 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
3110 AC_SUBST(EXTRA_CXX_FLAGS)
3115 dnl Check to see if debugging libraries are to be built.
3117 dnl --enable-libstdcxx-debug
3118 dnl builds a separate set of debugging libraries in addition to the
3119 dnl normal (shared, static) libstdc++ binaries.
3121 dnl --disable-libstdcxx-debug
3122 dnl builds only one (non-debug) version of libstdc++.
3124 dnl --enable-libstdcxx-debug-flags=FLAGS
3125 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
3127 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
3128 dnl Where DEFAULT is either `yes' or `no'.
3130 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
3131 AC_MSG_CHECKING([for additional debug build])
3133 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
3134 if test x$enable_libstdcxx_debug = xyes; then
3135 if test -f $toplevel_builddir/../stage_final \
3136 && test -f $toplevel_builddir/../stage_current; then
3137 stage_final=`cat $toplevel_builddir/../stage_final`
3138 stage_current=`cat $toplevel_builddir/../stage_current`
3139 if test x$stage_current != x$stage_final ; then
3140 skip_debug_build=" (skipped for bootstrap stage $stage_current)"
3141 enable_libstdcxx_debug=no
3145 AC_MSG_RESULT($enable_libstdcxx_debug$skip_debug_build)
3146 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
3151 dnl Check for explicit debug flags.
3153 dnl --enable-libstdcxx-debug-flags='-O1'
3154 dnl is a general method for passing flags to be used when
3155 dnl building debug libraries with --enable-libstdcxx-debug.
3157 dnl --disable-libstdcxx-debug-flags does nothing.
3158 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
3159 dnl If "default flags" is an empty string, the effect is the same
3160 dnl as --disable or --enable=no.
3162 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
3163 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
3164 [pass compiler FLAGS when building debug library],
3165 [case "x$enable_libstdcxx_debug_flags" in
3166 xno | x) enable_libstdcxx_debug_flags= ;;
3168 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
3171 # Option parsed, now set things appropriately
3172 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
3173 AC_SUBST(DEBUG_FLAGS)
3175 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
3180 dnl Check if the user only wants a freestanding library implementation.
3182 dnl --disable-hosted-libstdcxx will turn off most of the library build,
3183 dnl installing only the headers required by [17.4.1.3] and the language
3184 dnl support library. More than that will be built (to keep the Makefiles
3185 dnl conveniently clean), but not installed.
3187 dnl Also define --disable-libstdcxx-hosted as an alias for
3188 dnl --disable-hosted-libstdcxx but fail if both are given
3189 dnl and their values do not agree.
3192 dnl is_hosted (yes/no)
3195 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
3197 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
3198 AC_ARG_ENABLE([hosted-libstdcxx],
3199 AC_HELP_STRING([--disable-hosted-libstdcxx],
3200 [only build freestanding C++ runtime support]),
3201 [enable_hosted_libstdcxx_was_given=yes],
3204 enable_hosted_libstdcxx=no
3207 case "${with_newlib}-${with_headers}" in
3208 no-no) enable_hosted_libstdcxx=no ;;
3209 *) enable_hosted_libstdcxx=yes ;;
3214 # Because most configure args are --enable-libstdcxx-foo add an alias
3215 # of that form for --enable-hosted-libstdcxx.
3216 AC_ARG_ENABLE([libstdcxx-hosted],
3217 AC_HELP_STRING([--disable-libstdcxx-hosted],
3218 [alias for --disable-hosted-libstdcxx]),
3219 [if test "$enable_hosted_libstdcxx_was_given" = yes; then
3220 if test "$enable_hosted_libstdcxx" != "$enableval"; then
3221 AC_MSG_ERROR([--enable-libstdcxx-hosted=$enableval conflicts with --enable-hosted-libstdcxx=$enable_hosted_libstdcxx])
3224 enable_hosted_libstdcxx=${enableval}
3229 if test "$enable_hosted_libstdcxx" = no; then
3230 AC_MSG_NOTICE([Only freestanding libraries will be built])
3234 enable_libstdcxx_pch=no
3235 if test "x$with_headers" = xno; then
3236 freestanding_flags="-ffreestanding"
3240 hosted_define=__STDC_HOSTED__
3242 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
3243 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
3244 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
3245 FREESTANDING_FLAGS="$freestanding_flags"
3246 AC_SUBST(FREESTANDING_FLAGS)
3251 dnl Check if the user wants a non-verbose library implementation.
3253 dnl --disable-libstdcxx-verbose will turn off descriptive messages to
3254 dnl standard error on termination.
3257 dnl _GLIBCXX_VERBOSE (always defined, either to 1 or 0)
3259 AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [
3260 AC_ARG_ENABLE([libstdcxx-verbose],
3261 AC_HELP_STRING([--disable-libstdcxx-verbose],
3262 [disable termination messages to standard error]),,
3263 [enable_libstdcxx_verbose=yes])
3264 if test x"$enable_libstdcxx_verbose" = xyes; then
3267 AC_MSG_NOTICE([verbose termination messages are disabled])
3270 AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define,
3271 [Define to 1 if a verbose library is built, or 0 otherwise.])
3276 dnl Check for template specializations for the 'long long' type.
3277 dnl The result determines only whether 'long long' I/O is enabled; things
3278 dnl like numeric_limits<> specializations are always available.
3280 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
3281 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
3282 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
3283 dnl Where DEFAULT is either `yes' or `no'.
3285 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
3286 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
3287 if test $enable_long_long = yes; then
3288 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
3289 [Define if code specialized for long long should be used.])
3291 AC_MSG_CHECKING([for enabled long long specializations])
3292 AC_MSG_RESULT([$enable_long_long])
3297 dnl Check for decimal floating point.
3299 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
3301 dnl This checks to see if the host supports decimal floating point types.
3304 dnl _GLIBCXX_USE_DECIMAL_FLOAT
3306 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
3308 # Fake what AC_TRY_COMPILE does, without linking as this is
3309 # unnecessary for this test.
3311 cat > conftest.$ac_ext << EOF
3312 [#]line __oline__ "configure"
3322 AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
3323 if AC_TRY_EVAL(ac_compile); then
3324 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
3325 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
3330 AC_MSG_RESULT($enable_dfp)
3335 dnl Check for GNU 128-bit floating point type.
3337 dnl Note: also checks that the type isn't a standard types.
3342 AC_DEFUN([GLIBCXX_ENABLE_FLOAT128], [
3347 # Fake what AC_TRY_COMPILE does, without linking as this is
3348 # unnecessary for this test.
3350 cat > conftest.$ac_ext << EOF
3351 [#]line __oline__ "configure"
3352 template<typename T1, typename T2>
3354 { typedef T2 type; };
3356 template<typename T>
3361 typename same<double, __float128>::type f1;
3362 typename same<long double, __float128>::type f2;
3366 AC_MSG_CHECKING([for __float128])
3367 if AC_TRY_EVAL(ac_compile); then
3372 AC_MSG_RESULT($enable_float128)
3373 GLIBCXX_CONDITIONAL(ENABLE_FLOAT128, test $enable_float128 = yes)
3380 dnl Check for template specializations for the 'wchar_t' type.
3382 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
3383 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
3384 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
3385 dnl Where DEFAULT is either `yes' or `no'.
3387 dnl Necessary support must also be present.
3389 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
3390 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
3392 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
3393 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
3394 AC_MSG_CHECKING([for mbstate_t])
3395 AC_TRY_COMPILE([#include <wchar.h>],
3396 [mbstate_t teststate;],
3397 have_mbstate_t=yes, have_mbstate_t=no)
3398 AC_MSG_RESULT($have_mbstate_t)
3399 if test x"$have_mbstate_t" = xyes; then
3400 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
3403 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
3405 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
3407 if test x"$enable_wchar_t" = x"yes"; then
3412 if test x"$ac_has_wchar_h" = xyes &&
3413 test x"$ac_has_wctype_h" = xyes; then
3414 AC_TRY_COMPILE([#include <wchar.h>
3475 ],[],[], [enable_wchar_t=no])
3483 if test x"$enable_wchar_t" = x"yes"; then
3484 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
3485 [Define if code specialized for wchar_t should be used.])
3488 AC_MSG_CHECKING([for enabled wchar_t specializations])
3489 AC_MSG_RESULT([$enable_wchar_t])
3494 dnl Check to see if building and using a C++ precompiled header can be done.
3496 dnl --enable-libstdcxx-pch=yes
3497 dnl default, this shows intent to use stdc++.h.gch If it looks like it
3498 dnl may work, after some light-hearted attempts to puzzle out compiler
3499 dnl support, flip bits on in include/Makefile.am
3501 dnl --disable-libstdcxx-pch
3502 dnl turns off attempts to use or build stdc++.h.gch.
3505 dnl glibcxx_PCHFLAGS
3507 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
3508 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
3509 if test $enable_libstdcxx_pch = yes; then
3510 AC_CACHE_CHECK([for compiler with PCH support],
3511 [glibcxx_cv_prog_CXX_pch],
3512 [ac_save_CXXFLAGS="$CXXFLAGS"
3513 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
3516 echo '#include <math.h>' > conftest.h
3517 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
3518 -o conftest.h.gch 1>&5 2>&1 &&
3519 echo '#error "pch failed"' > conftest.h &&
3520 echo '#include "conftest.h"' > conftest.cc &&
3521 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
3523 glibcxx_cv_prog_CXX_pch=yes
3525 glibcxx_cv_prog_CXX_pch=no
3528 CXXFLAGS=$ac_save_CXXFLAGS
3531 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
3534 AC_MSG_CHECKING([for enabled PCH])
3535 AC_MSG_RESULT([$enable_libstdcxx_pch])
3537 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
3538 if test $enable_libstdcxx_pch = yes; then
3539 glibcxx_PCHFLAGS="-include bits/stdc++.h"
3543 AC_SUBST(glibcxx_PCHFLAGS)
3548 dnl Check for atomic builtins.
3550 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
3552 dnl This checks to see if the host supports the compiler-generated
3553 dnl builtins for atomic operations for various integral sizes. Note, this
3554 dnl is intended to be an all-or-nothing switch, so all the atomic operations
3555 dnl that are used should be checked.
3558 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
3560 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
3563 old_CXXFLAGS="$CXXFLAGS"
3565 # Do link tests if possible, instead asm tests, limited to some platforms
3566 # see discussion in PR target/40134, PR libstdc++/40133 and the thread
3567 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
3568 atomic_builtins_link_tests=no
3569 if test x$gcc_no_link != xyes; then
3570 # Can do link tests. Limit to some tested platforms
3572 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
3573 atomic_builtins_link_tests=yes
3578 if test x$atomic_builtins_link_tests = xyes; then
3582 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3584 AC_CACHE_CHECK([for atomic builtins for bool],
3585 glibcxx_cv_atomic_bool, [
3588 [typedef bool atomic_type;
3592 // N.B. __atomic_fetch_add is not supported for bool.
3593 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3595 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3596 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3598 [glibcxx_cv_atomic_bool=yes],
3599 [glibcxx_cv_atomic_bool=no])
3602 AC_CACHE_CHECK([for atomic builtins for short],
3603 glibcxx_cv_atomic_short, [
3606 [typedef short atomic_type;
3610 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3611 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3613 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3614 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3616 [glibcxx_cv_atomic_short=yes],
3617 [glibcxx_cv_atomic_short=no])
3620 AC_CACHE_CHECK([for atomic builtins for int],
3621 glibcxx_cv_atomic_int, [
3624 [typedef int atomic_type;
3628 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3629 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3631 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3632 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3634 [glibcxx_cv_atomic_int=yes],
3635 [glibcxx_cv_atomic_int=no])
3638 AC_CACHE_CHECK([for atomic builtins for long long],
3639 glibcxx_cv_atomic_long_long, [
3642 [typedef long long atomic_type;
3646 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3647 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3649 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3650 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3652 [glibcxx_cv_atomic_long_long=yes],
3653 [glibcxx_cv_atomic_long_long=no])
3660 # Compile unoptimized.
3663 # Fake what AC_TRY_COMPILE does.
3665 cat > conftest.$ac_ext << EOF
3666 [#]line __oline__ "configure"
3669 typedef bool atomic_type;
3673 // N.B. __atomic_fetch_add is not supported for bool.
3674 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3676 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3677 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3683 AC_MSG_CHECKING([for atomic builtins for bool])
3684 if AC_TRY_EVAL(ac_compile); then
3685 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3686 glibcxx_cv_atomic_bool=no
3688 glibcxx_cv_atomic_bool=yes
3691 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3694 cat > conftest.$ac_ext << EOF
3695 [#]line __oline__ "configure"
3698 typedef short atomic_type;
3702 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3703 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3705 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3706 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3712 AC_MSG_CHECKING([for atomic builtins for short])
3713 if AC_TRY_EVAL(ac_compile); then
3714 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3715 glibcxx_cv_atomic_short=no
3717 glibcxx_cv_atomic_short=yes
3720 AC_MSG_RESULT($glibcxx_cv_atomic_short)
3723 cat > conftest.$ac_ext << EOF
3724 [#]line __oline__ "configure"
3727 // NB: _Atomic_word not necessarily int.
3728 typedef int atomic_type;
3732 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3733 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3735 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3736 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3742 AC_MSG_CHECKING([for atomic builtins for int])
3743 if AC_TRY_EVAL(ac_compile); then
3744 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3745 glibcxx_cv_atomic_int=no
3747 glibcxx_cv_atomic_int=yes
3750 AC_MSG_RESULT($glibcxx_cv_atomic_int)
3753 cat > conftest.$ac_ext << EOF
3754 [#]line __oline__ "configure"
3757 typedef long long atomic_type;
3761 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3762 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3764 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3765 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3771 AC_MSG_CHECKING([for atomic builtins for long long])
3772 if AC_TRY_EVAL(ac_compile); then
3773 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3774 glibcxx_cv_atomic_long_long=no
3776 glibcxx_cv_atomic_long_long=yes
3779 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3784 CXXFLAGS="$old_CXXFLAGS"
3787 # Set atomicity_dir to builtins if all but the long long test above passes,
3788 # or if the builtins were already chosen (e.g. by configure.host).
3789 if { test "$glibcxx_cv_atomic_bool" = yes \
3790 && test "$glibcxx_cv_atomic_short" = yes \
3791 && test "$glibcxx_cv_atomic_int" = yes; } \
3792 || test "$atomicity_dir" = "cpu/generic/atomicity_builtins"; then
3793 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
3794 [Define if the compiler supports C++11 atomics.])
3795 atomicity_dir=cpu/generic/atomicity_builtins
3798 # If still generic, set to mutex.
3799 if test $atomicity_dir = "cpu/generic" ; then
3800 atomicity_dir=cpu/generic/atomicity_mutex
3801 AC_MSG_WARN([No native atomic operations are provided for this platform.])
3802 if test "x$target_thread_file" = xsingle; then
3803 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
3804 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
3806 AC_MSG_WARN([They will be faked using a mutex.])
3807 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
3814 dnl Set default lock policy for synchronizing shared_ptr reference counting.
3816 dnl --with-libstdcxx-lock-policy=auto
3817 dnl Use atomic operations for shared_ptr reference counting only if
3818 dnl the default target supports atomic compare-and-swap.
3819 dnl --with-libstdcxx-lock-policy=atomic
3820 dnl Use atomic operations for shared_ptr reference counting.
3821 dnl --with-libstdcxx-lock-policy=mutex
3822 dnl Use a mutex to synchronize shared_ptr reference counting.
3824 dnl This controls the value of __gnu_cxx::__default_lock_policy, which
3825 dnl determines how shared_ptr reference counts are synchronized.
3826 dnl The option "atomic" means that atomic operations should be used,
3827 dnl "mutex" means that a mutex will be used. The default option, "auto",
3828 dnl will check if the target supports the compiler-generated builtins
3829 dnl for atomic compare-and-swap operations for 2-byte and 4-byte integers,
3830 dnl and will use "atomic" if supported, "mutex" otherwise.
3831 dnl This option is ignored if the thread model used by GCC is "single",
3832 dnl as no synchronization is used at all in that case.
3833 dnl This option affects the library ABI (except in the "single" thread model).
3835 dnl Defines _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY to 1 if atomics should be used.
3837 AC_DEFUN([GLIBCXX_ENABLE_LOCK_POLICY], [
3839 AC_ARG_WITH([libstdcxx-lock-policy],
3840 AC_HELP_STRING([--with-libstdcxx-lock-policy={atomic,mutex,auto}],
3841 [synchronization policy for shared_ptr reference counting [default=auto]]),
3842 [libstdcxx_atomic_lock_policy=$withval],
3843 [libstdcxx_atomic_lock_policy=auto])
3845 case "$libstdcxx_atomic_lock_policy" in
3846 atomic|mutex|auto) ;;
3847 *) AC_MSG_ERROR([Invalid argument for --with-libstdcxx-lock-policy]) ;;
3849 AC_MSG_CHECKING([for lock policy for shared_ptr reference counts])
3851 if test x"$libstdcxx_atomic_lock_policy" = x"auto"; then
3854 ac_save_CXXFLAGS="$CXXFLAGS"
3856 dnl Why do we care about 2-byte CAS on targets with 4-byte _Atomic_word?!
3857 dnl Why don't we check 8-byte CAS for sparc64, where _Atomic_word is long?!
3858 dnl New targets should only check for CAS for the _Atomic_word type.
3861 # error "Defaulting to mutex-based locks for ABI compatibility"
3863 #if ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
3864 # error "No 2-byte compare-and-swap"
3865 #elif ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
3866 # error "No 4-byte compare-and-swap"
3869 [libstdcxx_atomic_lock_policy=atomic],
3870 [libstdcxx_atomic_lock_policy=mutex])
3872 CXXFLAGS="$ac_save_CXXFLAGS"
3875 if test x"$libstdcxx_atomic_lock_policy" = x"atomic"; then
3876 AC_MSG_RESULT(atomic)
3877 AC_DEFINE(HAVE_ATOMIC_LOCK_POLICY,1,
3878 [Defined if shared_ptr reference counting should use atomic operations.])
3880 AC_MSG_RESULT(mutex)
3886 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3888 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3889 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3890 dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3891 dnl Where DEFAULT is 'yes'.
3893 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3894 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3896 if test x$enable_libstdcxx_visibility = xyes ; then
3897 dnl all hail libgfortran
3898 dnl Check whether the target supports hidden visibility.
3899 AC_CACHE_CHECK([whether the target supports hidden visibility],
3900 glibcxx_cv_have_attribute_visibility, [
3901 save_CFLAGS="$CFLAGS"
3902 CFLAGS="$CFLAGS -Werror"
3903 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3904 [], glibcxx_cv_have_attribute_visibility=yes,
3905 glibcxx_cv_have_attribute_visibility=no)
3906 CFLAGS="$save_CFLAGS"])
3907 if test $glibcxx_cv_have_attribute_visibility = no; then
3908 enable_libstdcxx_visibility=no
3912 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3913 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3918 dnl Add version tags to symbols in shared library (or not), additionally
3919 dnl marking other symbols as private/local (or not).
3921 dnl Sets libtool_VERSION, and determines shared library SONAME.
3923 dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3925 dnl --enable-symvers=style adds a version script to the linker call when
3926 dnl creating the shared library. The choice of version script is
3927 dnl controlled by 'style'.
3928 dnl --disable-symvers does not.
3930 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3931 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
3932 dnl choose a default style based on linker characteristics. Passing
3933 dnl 'no' disables versioning.
3935 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3937 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3938 [enables symbol versioning of the shared library],
3939 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3941 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3942 # don't know enough about $LD to do tricks...
3943 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3944 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3945 # with extern "C++" in version scripts.
3946 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3948 # Turn a 'yes' into a suitable default.
3949 if test x$enable_symvers = xyes ; then
3950 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3953 if test $with_gnu_ld = yes ; then
3954 case ${target_os} in
3956 enable_symvers=no ;;
3958 enable_symvers=gnu ;;
3961 case ${target_os} in
3963 enable_symvers=darwin ;;
3964 # Sun symbol versioning exists since Solaris 2.5.
3965 solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3966 # make_sunver.pl needs GNU c++filt to support extern "C++" in
3967 # version scripts, so disable symbol versioning if none can be
3969 if test -z "$ac_cv_path_CXXFILT"; then
3970 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3971 AC_MSG_WARN([=== no GNU c++filt could be found.])
3972 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3979 enable_symvers=no ;;
3985 # Check to see if 'darwin' or 'darwin-export' can win.
3986 if test x$enable_symvers = xdarwin-export ; then
3987 enable_symvers=darwin
3990 # Check if 'sun' was requested on non-Solaris 2 platforms.
3991 if test x$enable_symvers = xsun ; then
3992 case ${target_os} in
3998 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3999 AC_MSG_WARN([=== you are not targetting Solaris 2.])
4000 AC_MSG_WARN([=== Symbol versioning will be disabled.])
4006 # Check to see if 'gnu' can win.
4007 if test $enable_symvers = gnu ||
4008 test $enable_symvers = gnu-versioned-namespace ||
4009 test $enable_symvers = sun; then
4010 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
4011 AC_MSG_CHECKING([for shared libgcc])
4012 ac_save_CFLAGS="$CFLAGS"
4014 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
4015 CFLAGS="$ac_save_CFLAGS"
4016 if test $glibcxx_shared_libgcc = no; then
4017 cat > conftest.c <<EOF
4018 int main (void) { return 0; }
4021 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
4022 -shared -shared-libgcc -o conftest.so \
4023 conftest.c -v 2>&1 >/dev/null \
4024 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
4026 rm -f conftest.c conftest.so
4027 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
4028 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
4029 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
4030 CFLAGS="$ac_save_CFLAGS"
4033 AC_MSG_RESULT($glibcxx_shared_libgcc)
4035 # For GNU ld, we need at least this version. The format is described in
4036 # GLIBCXX_CHECK_LINKER_FEATURES above.
4037 glibcxx_min_gnu_ld_version=21400
4039 # If no shared libgcc, can't win.
4040 if test $glibcxx_shared_libgcc != yes; then
4041 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
4042 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
4043 AC_MSG_WARN([=== Symbol versioning will be disabled.])
4045 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
4046 : All interesting versions of Sun ld support sun style symbol versioning.
4047 elif test $with_gnu_ld != yes ; then
4049 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
4050 AC_MSG_WARN([=== you are not using the GNU linker.])
4051 AC_MSG_WARN([=== Symbol versioning will be disabled.])
4053 elif test $glibcxx_ld_is_gold = yes ; then
4054 : All versions of gold support symbol versioning.
4055 elif test $glibcxx_ld_is_mold = yes ; then
4056 : All versions of mold support symbol versioning.
4057 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
4058 # The right tools, the right setup, but too old. Fallbacks?
4059 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
4060 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
4061 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
4062 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
4063 AC_MSG_WARN([=== Symbol versioning will be disabled.])
4068 # For libtool versioning info, format is CURRENT:REVISION:AGE
4069 libtool_VERSION=6:32:0
4071 # Everything parsed; figure out what files and settings to use.
4072 case $enable_symvers in
4074 SYMVER_FILE=config/abi/pre/none.ver
4077 SYMVER_FILE=config/abi/pre/gnu.ver
4078 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
4079 [Define to use GNU versioning in the shared library.])
4081 gnu-versioned-namespace)
4082 libtool_VERSION=8:0:0
4083 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
4084 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
4085 [Define to use GNU namespace versioning in the shared library.])
4088 SYMVER_FILE=config/abi/pre/gnu.ver
4089 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
4090 [Define to use darwin versioning in the shared library.])
4093 SYMVER_FILE=config/abi/pre/gnu.ver
4094 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
4095 [Define to use Sun versioning in the shared library.])
4099 if test x$enable_symvers != xno ; then
4100 AC_DEFINE(_GLIBCXX_SYMVER, 1,
4101 [Define to use symbol versioning in the shared library.])
4104 AC_CACHE_CHECK([whether the target supports .symver directive],
4105 glibcxx_cv_have_as_symver_directive, [
4106 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
4107 [], glibcxx_cv_have_as_symver_directive=yes,
4108 glibcxx_cv_have_as_symver_directive=no)])
4109 if test $glibcxx_cv_have_as_symver_directive = yes; then
4110 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
4111 [Define to 1 if the target assembler supports .symver directive.])
4114 AC_SUBST(SYMVER_FILE)
4115 AC_SUBST(port_specific_symbol_files)
4116 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
4117 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
4118 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
4119 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
4120 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
4121 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
4123 if test $enable_symvers != no ; then
4124 case ${target_os} in
4125 # The Solaris 2 runtime linker doesn't support the GNU extension of
4126 # binding the same symbol to different versions
4129 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
4131 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
4132 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
4137 # Now, set up compatibility support, if any.
4138 # In addition, need this to deal with std::size_t mangling in
4139 # src/compatibility.cc. In a perfect world, could use
4140 # typeid(std::size_t).name()[0] to do direct substitution.
4141 AC_MSG_CHECKING([for size_t as unsigned int])
4142 ac_save_CFLAGS="$CFLAGS"
4144 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
4145 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
4146 CFLAGS=$ac_save_CFLAGS
4147 if test "$glibcxx_size_t_is_i" = yes; then
4148 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
4150 AC_MSG_RESULT([$glibcxx_size_t_is_i])
4152 AC_MSG_CHECKING([for ptrdiff_t as int])
4153 ac_save_CFLAGS="$CFLAGS"
4155 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
4156 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
4157 CFLAGS=$ac_save_CFLAGS
4158 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
4159 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
4161 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
4166 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
4167 dnl We must stage the required headers so that they will be installed
4168 dnl with the library (unlike libgcc, the STL implementation is provided
4169 dnl solely within headers). Since we must not inject random user-space
4170 dnl macro names into user-provided C++ code, we first stage into <file>-in
4171 dnl and process to <file> with an output command. The reason for a two-
4172 dnl stage process here is to correctly handle $srcdir!=$objdir without
4173 dnl having to write complex code (the sed commands to clean the macro
4174 dnl namespace are complex and fragile enough as it is). We must also
4175 dnl add a relative path so that -I- is supported properly.
4180 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
4181 AC_MSG_CHECKING([for thread model used by GCC])
4182 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
4183 AC_MSG_RESULT([$target_thread_file])
4184 GCC_AC_THREAD_HEADER([$target_thread_file])
4189 dnl Check if gthread implementation defines the types and functions
4190 dnl required by the c++0x thread library. Conforming gthread
4191 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
4193 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
4195 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
4196 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
4198 if test x$enable_libstdcxx_threads = xauto ||
4199 test x$enable_libstdcxx_threads = xyes; then
4204 ac_save_CXXFLAGS="$CXXFLAGS"
4205 CXXFLAGS="$CXXFLAGS -fno-exceptions \
4206 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
4208 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
4209 case $target_thread_file in
4211 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
4214 CXXFLAGS="$CXXFLAGS -D_WIN32_THREADS"
4215 # The support of condition variables is disabled by default in
4216 # the Win32 gthreads library, so enable it on explicit request.
4217 if test x$enable_libstdcxx_threads = xyes; then
4218 CXXFLAGS="$CXXFLAGS -D_WIN32_WINNT=0x0600"
4223 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
4225 AC_TRY_COMPILE([#include <unistd.h>],
4227 // In case of POSIX threads check _POSIX_TIMEOUTS.
4228 #if (defined(_PTHREADS) \
4229 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
4231 // In case of Win32 threads there is no support.
4232 #elif defined(_WIN32_THREADS)
4235 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
4237 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
4238 [Define to 1 if mutex_timedlock is available.])
4240 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
4241 else res_mutex_timedlock=no ; fi
4242 AC_MSG_RESULT([$res_mutex_timedlock])
4244 AC_MSG_CHECKING([for gthreads library])
4246 AC_TRY_COMPILE([#include "gthr.h"],
4248 #ifndef __GTHREADS_CXX0X
4251 ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
4256 AC_MSG_RESULT([$ac_has_gthreads])
4258 if test x"$ac_has_gthreads" = x"yes"; then
4259 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
4260 [Define if gthreads library is available.])
4262 # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14
4263 # but only do so if we're using pthread in the gthread library.
4264 # On VxWorks for example, pthread_rwlock_t is defined in sys/types.h
4265 # but the pthread library is not there by default and the gthread library
4267 AC_TRY_COMPILE([#include "gthr.h"],
4269 #if (!defined(_PTHREADS))
4272 ], [ac_gthread_use_pthreads=yes], [ac_gthread_use_pthreads=no])
4273 if test x"$ac_gthread_use_pthreads" = x"yes"; then
4274 AC_CHECK_TYPE([pthread_rwlock_t],
4275 [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1,
4276 [Define if POSIX read/write locks are available in <gthr.h>.])],
4278 [#include "gthr.h"])
4281 # See above for the rationale.
4282 if test $target_thread_file = win32; then
4283 CPPFLAGS="$CPPFLAGS -D_WIN32_WINNT=0x0600"
4287 AC_CHECK_HEADER(semaphore.h, [
4288 AC_MSG_CHECKING([for POSIX Semaphores and sem_timedwait])
4291 #include <semaphore.h>
4295 #if !defined _POSIX_TIMEOUTS || _POSIX_TIMEOUTS <= 0
4296 # error "POSIX Timeouts option not supported"
4297 #elif !defined _POSIX_SEMAPHORES || _POSIX_SEMAPHORES <= 0
4298 # error "POSIX Semaphores option not supported"
4300 #if defined SEM_VALUE_MAX
4301 constexpr int sem_value_max = SEM_VALUE_MAX;
4302 #elif defined _POSIX_SEM_VALUE_MAX
4303 constexpr int sem_value_max = _POSIX_SEM_VALUE_MAX;
4305 # error "SEM_VALUE_MAX not available"
4308 sem_init(&sem, 0, sem_value_max);
4309 struct timespec ts = { 0 };
4310 sem_timedwait(&sem, &ts);
4313 [ac_have_posix_semaphore=yes],
4314 [ac_have_posix_semaphore=no])],
4315 [ac_have_posix_semaphore=no])
4317 if test $ac_have_posix_semaphore = yes ; then
4318 AC_DEFINE(HAVE_POSIX_SEMAPHORE,
4320 [Define to 1 if POSIX Semaphores with sem_timedwait are available in <semaphore.h>.])
4322 AC_MSG_RESULT([$ac_have_posix_semaphore])
4324 CXXFLAGS="$ac_save_CXXFLAGS"
4329 # Check whether LC_MESSAGES is available in <locale.h>.
4330 # Ulrich Drepper <drepper@cygnus.com>, 1995.
4332 # This file file be copied and used freely without restrictions. It can
4333 # be used in projects which are not available under the GNU Public License
4334 # but which still want to provide support for the GNU gettext functionality.
4335 # Please note that the actual code is *not* freely available.
4336 AC_DEFUN([AC_LC_MESSAGES], [
4337 AC_CHECK_HEADER(locale.h, [
4338 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
4339 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
4340 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
4341 if test $ac_cv_val_LC_MESSAGES = yes; then
4342 AC_DEFINE(HAVE_LC_MESSAGES, 1,
4343 [Define if LC_MESSAGES is available in <locale.h>.])
4349 dnl Check whether rdrand is supported in the assembler.
4350 AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [
4351 AC_CACHE_CHECK([for rdrand support in assembler],
4357 AC_TRY_COMPILE(, [asm("rdrand %eax");],
4358 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no])
4361 if test $ac_cv_x86_rdrand = yes; then
4362 AC_DEFINE(_GLIBCXX_X86_RDRAND, 1,
4363 [ Defined if as can handle rdrand. ])
4368 dnl Check whether rdseed is supported in the assembler.
4369 AC_DEFUN([GLIBCXX_CHECK_X86_RDSEED], [
4370 AC_CACHE_CHECK([for rdseed support in assembler],
4376 AC_TRY_COMPILE(, [asm("rdseed %eax");],
4377 [ac_cv_x86_rdseed=yes], [ac_cv_x86_rdseed=no])
4380 if test $ac_cv_x86_rdseed = yes; then
4381 AC_DEFINE(_GLIBCXX_X86_RDSEED, 1,
4382 [ Defined if as can handle rdseed. ])
4387 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
4389 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
4393 ac_save_CXXFLAGS="$CXXFLAGS"
4394 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4396 AC_CACHE_CHECK([for get_nprocs],
4397 glibcxx_cv_GET_NPROCS, [
4398 GCC_TRY_COMPILE_OR_LINK(
4399 [#include <sys/sysinfo.h>],
4400 [int n = get_nprocs();],
4401 [glibcxx_cv_GET_NPROCS=yes],
4402 [glibcxx_cv_GET_NPROCS=no])
4404 if test $glibcxx_cv_GET_NPROCS = yes; then
4405 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
4408 CXXFLAGS="$ac_save_CXXFLAGS"
4413 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
4415 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
4419 ac_save_CXXFLAGS="$CXXFLAGS"
4420 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4422 AC_CACHE_CHECK([for _SC_NPROCESSORS_ONLN],
4423 glibcxx_cv_SC_NPROCESSORS_ONLN, [
4424 GCC_TRY_COMPILE_OR_LINK(
4425 [#include <unistd.h>],
4426 [int n = sysconf(_SC_NPROCESSORS_ONLN);],
4427 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
4428 [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
4430 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
4431 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.])
4434 CXXFLAGS="$ac_save_CXXFLAGS"
4439 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
4441 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
4445 ac_save_CXXFLAGS="$CXXFLAGS"
4446 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4448 AC_CACHE_CHECK([for _SC_NPROC_ONLN],
4449 glibcxx_cv_SC_NPROC_ONLN, [
4450 GCC_TRY_COMPILE_OR_LINK(
4451 [#include <unistd.h>],
4452 [int n = sysconf(_SC_NPROC_ONLN);],
4453 [glibcxx_cv_SC_NPROC_ONLN=yes],
4454 [glibcxx_cv_SC_NPROC_ONLN=no])
4456 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
4457 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.])
4460 CXXFLAGS="$ac_save_CXXFLAGS"
4465 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
4467 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
4471 ac_save_CXXFLAGS="$CXXFLAGS"
4472 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4474 AC_CACHE_CHECK([for pthreads_num_processors_np],
4475 glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
4476 GCC_TRY_COMPILE_OR_LINK(
4477 [#include <pthread.h>],
4478 [int n = pthread_num_processors_np();],
4479 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
4480 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
4482 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
4483 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
4486 CXXFLAGS="$ac_save_CXXFLAGS"
4491 dnl Check whether pthread_cond_clockwait is available in <pthread.h> for std::condition_variable to use,
4492 dnl and define _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT.
4494 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_COND_CLOCKWAIT], [
4498 ac_save_CXXFLAGS="$CXXFLAGS"
4499 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4500 ac_save_LIBS="$LIBS"
4501 LIBS="$LIBS -lpthread"
4503 AC_CACHE_CHECK([for pthread_cond_clockwait],
4504 glibcxx_cv_PTHREAD_COND_CLOCKWAIT, [
4505 GCC_TRY_COMPILE_OR_LINK(
4506 [#include <pthread.h>],
4507 [pthread_mutex_t mutex; pthread_cond_t cond; struct timespec ts; int n = pthread_cond_clockwait(&cond, &mutex, 0, &ts);],
4508 [glibcxx_cv_PTHREAD_COND_CLOCKWAIT=yes],
4509 [glibcxx_cv_PTHREAD_COND_CLOCKWAIT=no])
4511 if test $glibcxx_cv_PTHREAD_COND_CLOCKWAIT = yes; then
4512 AC_DEFINE(_GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT, 1, [Define if pthread_cond_clockwait is available in <pthread.h>.])
4515 CXXFLAGS="$ac_save_CXXFLAGS"
4516 LIBS="$ac_save_LIBS"
4521 dnl Check whether pthread_mutex_clocklock is available in <pthread.h> for std::timed_mutex to use,
4522 dnl and define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK.
4524 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_MUTEX_CLOCKLOCK], [
4528 ac_save_CXXFLAGS="$CXXFLAGS"
4529 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4530 ac_save_LIBS="$LIBS"
4531 LIBS="$LIBS -lpthread"
4533 AC_CACHE_CHECK([for pthread_mutex_clocklock],
4534 glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK, [
4535 GCC_TRY_COMPILE_OR_LINK(
4536 [#include <pthread.h>],
4537 [pthread_mutex_t mutex; struct timespec ts; int n = pthread_mutex_clocklock(&mutex, CLOCK_REALTIME, &ts);],
4538 [glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK=yes],
4539 [glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK=no])
4541 if test $glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK = yes; then
4542 AC_DEFINE(_GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK, (_GLIBCXX_TSAN==0), [Define if pthread_mutex_clocklock is available in <pthread.h>.])
4545 CXXFLAGS="$ac_save_CXXFLAGS"
4546 LIBS="$ac_save_LIBS"
4551 dnl Check whether pthread_mutex_clocklock is available in <pthread.h> for std::timed_mutex to use,
4552 dnl and define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK.
4554 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_RWLOCK_CLOCKLOCK], [
4558 ac_save_CXXFLAGS="$CXXFLAGS"
4559 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4560 ac_save_LIBS="$LIBS"
4561 LIBS="$LIBS -lpthread"
4563 AC_CACHE_CHECK([for pthread_rwlock_clockrdlock, pthread_wlock_clockwrlock],
4564 glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK, [
4565 GCC_TRY_COMPILE_OR_LINK(
4566 [#include <pthread.h>],
4567 [pthread_rwlock_t rwl; struct timespec ts;]
4568 [int n = pthread_rwlock_clockrdlock(&rwl, CLOCK_REALTIME, &ts);]
4569 [int m = pthread_rwlock_clockwrlock(&rwl, CLOCK_REALTIME, &ts);],
4570 [glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK=yes],
4571 [glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK=no])
4573 if test $glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK = yes; then
4574 AC_DEFINE(_GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK, 1, [Define if pthread_rwlock_clockrdlock and pthread_rwlock_clockwrlock are available in <pthread.h>.])
4577 CXXFLAGS="$ac_save_CXXFLAGS"
4578 LIBS="$ac_save_LIBS"
4583 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
4585 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
4589 ac_save_CXXFLAGS="$CXXFLAGS"
4590 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4592 AC_CACHE_CHECK([for hw.ncpu sysctl],
4593 glibcxx_cv_SYSCTL_HW_NCPU, [
4594 GCC_TRY_COMPILE_OR_LINK(
4597 #include <sys/sysctl.h>
4601 size_t size = sizeof(count);
4602 int mib[] = { CTL_HW, HW_NCPU };
4603 sysctl(mib, 2, &count, &size, NULL, 0);
4605 [glibcxx_cv_SYSCTL_HW_NCPU=yes],
4606 [glibcxx_cv_SYSCTL_HW_NCPU=no])
4608 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
4609 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
4612 CXXFLAGS="$ac_save_CXXFLAGS"
4617 dnl Check to see if python pretty printing can be activated.
4619 dnl --with-python-dir=dir
4620 dnl installs directory into $prefix/dir
4621 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
4623 AC_MSG_CHECKING([for custom python install directory])
4624 AC_ARG_WITH([python-dir],
4625 AS_HELP_STRING([--with-python-dir],
4626 [the location to install Python modules. This path is relative starting from the prefix.]),
4627 [with_python_dir=$withval], [with_python_dir="no"])
4628 AC_MSG_RESULT(${with_python_dir})
4630 # Needed for installing Python modules during make install.
4631 python_mod_dir="${with_python_dir}"
4632 AC_SUBST(python_mod_dir)
4633 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
4637 dnl Check to see if -Werror is disabled.
4639 dnl --enable-werror/--disable-werror
4640 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
4641 AC_MSG_CHECKING([for -Werror])
4642 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
4643 AC_MSG_RESULT($enable_werror)
4644 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
4648 dnl Check whether obsolescent tmpnam is available in <stdio.h>,
4649 dnl and define _GLIBCXX_USE_TMPNAM.
4651 AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl
4655 ac_save_CXXFLAGS="$CXXFLAGS"
4656 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4658 AC_CACHE_CHECK([for tmpnam], glibcxx_cv_TMPNAM, [dnl
4659 GCC_TRY_COMPILE_OR_LINK(
4660 [#include <stdio.h>],
4661 [char *tmp = tmpnam(NULL);],
4662 [glibcxx_cv_TMPNAM=yes],
4663 [glibcxx_cv_TMPNAM=no])
4665 if test $glibcxx_cv_TMPNAM = yes; then
4666 AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.])
4669 CXXFLAGS="$ac_save_CXXFLAGS"
4674 dnl Check to see if sys/sdt.h exists and that it is suitable for use.
4675 dnl Some versions of sdt.h were not compatible with C++11.
4677 AC_DEFUN([GLIBCXX_CHECK_SDT_H], [
4678 # Note that this test has to be run with the C language.
4679 # Otherwise, sdt.h will try to include some headers from
4683 AC_CACHE_CHECK([for suitable sys/sdt.h],
4684 glibcxx_cv_sys_sdt_h, [
4685 # Because we have to run the test in C, we use grep rather
4686 # than the compiler to check for the bug. The bug is that
4687 # were strings without trailing whitespace, causing g++
4688 # to look for operator"". The pattern searches for the fixed
4690 AC_EGREP_CPP([ \",\" ], [
4691 #include <sys/sdt.h>
4692 int f() { STAP_PROBE(hi, bob); }
4693 ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no])
4696 if test $glibcxx_cv_sys_sdt_h = yes; then
4697 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4698 [Define to 1 if you have a suitable <sys/sdt.h> header file])
4703 dnl Control whether the library should define symbols for old and new ABIs.
4704 dnl This affects definitions of strings, stringstreams and locale facets.
4706 dnl --disable-libstdcxx-dual-abi will use old ABI for all types.
4709 dnl _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0)
4711 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [
4712 GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string])
4713 if test x$enable_symvers = xgnu-versioned-namespace; then
4714 # gnu-versioned-namespace is incompatible with the dual ABI.
4715 enable_libstdcxx_dual_abi="no"
4717 if test x"$enable_libstdcxx_dual_abi" != xyes; then
4718 AC_MSG_NOTICE([dual ABI is disabled])
4719 default_libstdcxx_abi="gcc4-compatible"
4721 GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes)
4725 dnl Check to see which ABI should be enabled by default.
4727 dnl --with-default-libstdcxx-abi={gcc4-compatible,new}
4730 dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
4732 AC_DEFUN([GLIBCXX_DEFAULT_ABI], [
4733 if test x$enable_libstdcxx_dual_abi = xyes; then
4734 AC_MSG_CHECKING([for default std::string ABI to use])
4735 AC_ARG_WITH([default-libstdcxx-abi],
4736 AS_HELP_STRING([--with-default-libstdcxx-abi],
4737 [set the std::string ABI to use by default]),
4739 gcc4-compatible) default_libstdcxx_abi="gcc4-compatible" ;;
4740 new|cxx11) default_libstdcxx_abi="new" ;;
4741 c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;;
4742 *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
4745 [default_libstdcxx_abi="new"])
4746 AC_MSG_RESULT(${default_libstdcxx_abi})
4748 if test $default_libstdcxx_abi = "new"; then
4755 AC_SUBST(glibcxx_cxx98_abi)
4756 GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1)
4760 dnl Check to see whether to build libstdc++fs.a
4762 dnl --enable-libstdcxx-filesystem-ts
4764 AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [
4765 GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,,
4766 [turns on ISO/IEC TS 18822 support],
4767 [permit yes|no|auto])
4769 AC_MSG_CHECKING([whether to build Filesystem TS support])
4770 if test x"$ac_cv_header_dirent_h" != x"yes"; then
4771 enable_libstdcxx_filesystem_ts=no
4773 if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then
4774 case "${target_os}" in
4775 freebsd*|netbsd*|openbsd*|dragonfly*|darwin*)
4776 enable_libstdcxx_filesystem_ts=yes
4778 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu | uclinux*)
4779 enable_libstdcxx_filesystem_ts=yes
4782 enable_libstdcxx_filesystem_ts=yes
4785 enable_libstdcxx_filesystem_ts=yes
4788 enable_libstdcxx_filesystem_ts=yes
4791 enable_libstdcxx_filesystem_ts=no
4795 AC_MSG_RESULT($enable_libstdcxx_filesystem_ts)
4796 GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes)
4800 dnl Check whether the library calls required by the C++17 Filesystem library
4801 dnl and the Filesystem TS are present.
4803 dnl HAVE_STRUCT_DIRENT_D_TYPE
4804 dnl _GLIBCXX_USE_REALPATH
4805 dnl _GLIBCXX_USE_UTIMENSAT
4806 dnl _GLIBCXX_USE_ST_MTIM
4807 dnl _GLIBCXX_USE_FCHMOD
4808 dnl _GLIBCXX_USE_FCHMODAT
4809 dnl _GLIBCXX_USE_SENDFILE
4814 AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
4818 ac_save_CXXFLAGS="$CXXFLAGS"
4819 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4821 AC_CACHE_CHECK([for struct dirent.d_type], glibcxx_cv_dirent_d_type, [dnl
4822 GCC_TRY_COMPILE_OR_LINK(
4823 [#include <dirent.h>],
4826 if (sizeof d.d_type) return 0;
4828 [glibcxx_cv_dirent_d_type=yes],
4829 [glibcxx_cv_dirent_d_type=no])
4831 if test $glibcxx_cv_dirent_d_type = yes; then
4832 AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.])
4835 AC_CACHE_CHECK([for realpath], glibcxx_cv_realpath, [dnl
4836 GCC_TRY_COMPILE_OR_LINK(
4843 #if _XOPEN_VERSION < 500
4845 #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX)
4846 char *tmp = realpath((const char*)NULL, (char*)NULL);
4851 [glibcxx_cv_realpath=yes],
4852 [glibcxx_cv_realpath=no])
4854 if test $glibcxx_cv_realpath = yes; then
4855 AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.])
4858 AC_CACHE_CHECK([for utimensat], glibcxx_cv_utimensat, [dnl
4859 GCC_TRY_COMPILE_OR_LINK(
4862 #include <sys/stat.h>
4865 struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } };
4866 int i = utimensat(AT_FDCWD, "path", ts, 0);
4868 [glibcxx_cv_utimensat=yes],
4869 [glibcxx_cv_utimensat=no])
4871 if test $glibcxx_cv_utimensat = yes; then
4872 AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.])
4875 AC_CACHE_CHECK([for utime], glibcxx_cv_utime, [dnl
4876 GCC_TRY_COMPILE_OR_LINK(
4881 struct utimbuf t = { 1, 1 };
4882 int i = utime("path", &t);
4884 [glibcxx_cv_utime=yes],
4885 [glibcxx_cv_utime=no])
4887 if test $glibcxx_cv_utime = yes; then
4888 AC_DEFINE(_GLIBCXX_USE_UTIME, 1, [Define if utime is available in <utime.h>.])
4891 AC_CACHE_CHECK([for lstat], glibcxx_cv_lstat, [dnl
4892 GCC_TRY_COMPILE_OR_LINK(
4893 [ #include <sys/stat.h> ],
4896 int i = lstat("path", &st);
4898 [glibcxx_cv_lstat=yes],
4899 [glibcxx_cv_lstat=no])
4901 if test $glibcxx_cv_lstat = yes; then
4902 AC_DEFINE(_GLIBCXX_USE_LSTAT, 1, [Define if lstat is available in <sys/stat.h>.])
4905 AC_CACHE_CHECK([for struct stat.st_mtim.tv_nsec],
4906 glibcxx_cv_st_mtim, [dnl
4907 GCC_TRY_COMPILE_OR_LINK(
4908 [ #include <sys/stat.h> ],
4911 return st.st_mtim.tv_nsec;
4913 [glibcxx_cv_st_mtim=yes],
4914 [glibcxx_cv_st_mtim=no])
4916 if test $glibcxx_cv_st_mtim = yes; then
4917 AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.])
4920 AC_CACHE_CHECK([for fchmod],
4921 glibcxx_cv_fchmod, [dnl
4922 GCC_TRY_COMPILE_OR_LINK(
4923 [#include <sys/stat.h>],
4924 [fchmod(1, S_IWUSR);],
4925 [glibcxx_cv_fchmod=yes],
4926 [glibcxx_cv_fchmod=no])
4928 if test $glibcxx_cv_fchmod = yes; then
4929 AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.])
4932 AC_CACHE_CHECK([for fchmodat],
4933 glibcxx_cv_fchmodat, [dnl
4934 GCC_TRY_COMPILE_OR_LINK(
4937 #include <sys/stat.h>
4939 [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);],
4940 [glibcxx_cv_fchmodat=yes],
4941 [glibcxx_cv_fchmodat=no])
4943 if test $glibcxx_cv_fchmodat = yes; then
4944 AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.])
4947 AC_CACHE_CHECK([for sendfile that can copy files],
4948 glibcxx_cv_sendfile, [dnl
4949 case "${target_os}" in
4950 gnu* | linux* | solaris* | uclinux*)
4951 GCC_TRY_COMPILE_OR_LINK(
4952 [#include <sys/sendfile.h>],
4953 [sendfile(1, 2, (off_t*)0, sizeof 1);],
4954 [glibcxx_cv_sendfile=yes],
4955 [glibcxx_cv_sendfile=no])
4958 glibcxx_cv_sendfile=no
4962 if test $glibcxx_cv_sendfile = yes; then
4963 AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.])
4966 AC_CACHE_CHECK([for link],
4967 glibcxx_cv_link, [dnl
4968 GCC_TRY_COMPILE_OR_LINK(
4969 [#include <unistd.h>],
4971 [glibcxx_cv_link=yes],
4972 [glibcxx_cv_link=no])
4974 if test $glibcxx_cv_link = yes; then
4975 AC_DEFINE(HAVE_LINK, 1, [Define if link is available in <unistd.h>.])
4978 AC_CACHE_CHECK([for readlink],
4979 glibcxx_cv_readlink, [dnl
4980 GCC_TRY_COMPILE_OR_LINK(
4981 [#include <unistd.h>],
4982 [char buf[32]; readlink("", buf, sizeof(buf));],
4983 [glibcxx_cv_readlink=yes],
4984 [glibcxx_cv_readlink=no])
4986 if test $glibcxx_cv_readlink = yes; then
4987 AC_DEFINE(HAVE_READLINK, 1, [Define if readlink is available in <unistd.h>.])
4990 AC_CACHE_CHECK([for symlink],
4991 glibcxx_cv_symlink, [dnl
4992 GCC_TRY_COMPILE_OR_LINK(
4993 [#include <unistd.h>],
4995 [glibcxx_cv_symlink=yes],
4996 [glibcxx_cv_symlink=no])
4998 if test $glibcxx_cv_symlink = yes; then
4999 AC_DEFINE(HAVE_SYMLINK, 1, [Define if symlink is available in <unistd.h>.])
5002 AC_CACHE_CHECK([for truncate],
5003 glibcxx_cv_truncate, [dnl
5004 GCC_TRY_COMPILE_OR_LINK(
5005 [#include <unistd.h>],
5006 [truncate("", 99);],
5007 [glibcxx_cv_truncate=yes],
5008 [glibcxx_cv_truncate=no])
5010 if test $glibcxx_cv_truncate = yes; then
5011 AC_DEFINE(HAVE_TRUNCATE, 1, [Define if truncate is available in <unistd.h>.])
5014 AC_CACHE_CHECK([for fdopendir],
5015 glibcxx_cv_fdopendir, [dnl
5016 GCC_TRY_COMPILE_OR_LINK(
5017 [#include <dirent.h>],
5018 [::DIR* dir = ::fdopendir(1);],
5019 [glibcxx_cv_fdopendir=yes],
5020 [glibcxx_cv_fdopendir=no])
5022 if test $glibcxx_cv_fdopendir = yes; then
5023 AC_DEFINE(HAVE_FDOPENDIR, 1, [Define if fdopendir is available in <dirent.h>.])
5026 AC_CACHE_CHECK([for dirfd],
5027 glibcxx_cv_dirfd, [dnl
5028 GCC_TRY_COMPILE_OR_LINK(
5029 [#include <dirent.h>],
5030 [int fd = ::dirfd((::DIR*)0);],
5031 [glibcxx_cv_dirfd=yes],
5032 [glibcxx_cv_dirfd=no])
5034 if test $glibcxx_cv_dirfd = yes; then
5035 AC_DEFINE(HAVE_DIRFD, 1, [Define if dirfd is available in <dirent.h>.])
5038 AC_CACHE_CHECK([for openat],
5039 glibcxx_cv_openat, [dnl
5040 GCC_TRY_COMPILE_OR_LINK(
5041 [#include <fcntl.h>],
5042 [int fd = ::openat(AT_FDCWD, "", 0);],
5043 [glibcxx_cv_openat=yes],
5044 [glibcxx_cv_openat=no])
5046 if test $glibcxx_cv_openat = yes; then
5047 AC_DEFINE(HAVE_OPENAT, 1, [Define if openat is available in <fcntl.h>.])
5050 AC_CACHE_CHECK([for unlinkat],
5051 glibcxx_cv_unlinkat, [dnl
5052 GCC_TRY_COMPILE_OR_LINK(
5054 #include <unistd.h>],
5055 [::unlinkat(AT_FDCWD, "", AT_REMOVEDIR);],
5056 [glibcxx_cv_unlinkat=yes],
5057 [glibcxx_cv_unlinkat=no])
5059 if test $glibcxx_cv_unlinkat = yes; then
5060 AC_DEFINE(HAVE_UNLINKAT, 1, [Define if unlinkat is available in <fcntl.h>.])
5063 CXXFLAGS="$ac_save_CXXFLAGS"
5068 dnl Check how size_t is mangled. Copied from libitm.
5070 AC_DEFUN([GLIBCXX_CHECK_SIZE_T_MANGLING], [
5071 AC_CACHE_CHECK([how size_t is mangled],
5072 glibcxx_cv_size_t_mangling, [
5073 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
5074 [glibcxx_cv_size_t_mangling=m], [
5075 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
5076 [glibcxx_cv_size_t_mangling=j], [
5078 [extern __SIZE_TYPE__ x; extern unsigned long long x;],
5079 [glibcxx_cv_size_t_mangling=y], [
5081 [extern __SIZE_TYPE__ x; extern unsigned short x;],
5082 [glibcxx_cv_size_t_mangling=t], [
5084 [extern __SIZE_TYPE__ x; extern __int20 unsigned x;],
5085 [glibcxx_cv_size_t_mangling=u6uint20],
5086 [glibcxx_cv_size_t_mangling=x])
5092 if test $glibcxx_cv_size_t_mangling = x; then
5093 AC_MSG_ERROR([Unknown underlying type for size_t])
5095 AC_DEFINE_UNQUOTED(_GLIBCXX_MANGLE_SIZE_T, [$glibcxx_cv_size_t_mangling],
5096 [Define to the letter to which size_t is mangled.])
5100 dnl Determine whether std::exception_ptr symbols should be exported with
5101 dnl the symbol versions from GCC 4.6.0 or GCC 7.1.0, depending on which
5102 dnl release first added support for std::exception_ptr. Originally it was
5103 dnl only supported for targets with always-lock-free atomics for int, but
5104 dnl since GCC 7.1 it is supported for all targets.
5106 AC_DEFUN([GLIBCXX_CHECK_EXCEPTION_PTR_SYMVER], [
5107 if test $enable_symvers != no; then
5108 AC_MSG_CHECKING([for first version to support std::exception_ptr])
5110 aarch64-*-* | alpha-*-* | hppa*-*-* | i?86-*-* | x86_64-*-* | \
5111 m68k-*-* | powerpc*-*-* | s390*-*-* | *-*-solaris* )
5112 ac_exception_ptr_since_gcc46=yes
5115 # If the value of this macro changes then we will need to hardcode
5116 # yes/no here for additional targets based on the original value.
5117 AC_TRY_COMPILE([], [
5118 #if __GCC_ATOMIC_INT_LOCK_FREE <= 1
5119 # error atomic int not always lock free
5122 [ac_exception_ptr_since_gcc46=yes],
5123 [ac_exception_ptr_since_gcc46=no])
5126 if test x"$ac_exception_ptr_since_gcc46" = x"yes" ; then
5127 AC_DEFINE(HAVE_EXCEPTION_PTR_SINCE_GCC46, 1,
5128 [Define to 1 if GCC 4.6 supported std::exception_ptr for the target])
5129 AC_MSG_RESULT([4.6.0])
5131 AC_MSG_RESULT([7.1.0])
5137 dnl Check whether getentropy is present in <unistd.h>.
5139 AC_DEFUN([GLIBCXX_CHECK_GETENTROPY], [
5143 AC_CACHE_CHECK([for getentropy], glibcxx_cv_getentropy, [
5144 GCC_TRY_COMPILE_OR_LINK(
5145 [#include <unistd.h>],
5147 ::getentropy(&i, sizeof(i));],
5148 [glibcxx_cv_getentropy=yes], [glibcxx_cv_getentropy=no])
5151 if test $glibcxx_cv_getentropy = yes; then
5152 AC_DEFINE(HAVE_GETENTROPY, 1, [Define if getentropy is available in <unistd.h>.])
5158 dnl Check whether arc4random is present in <stdlib.h>.
5160 AC_DEFUN([GLIBCXX_CHECK_ARC4RANDOM], [
5164 AC_CACHE_CHECK([for arc4random], glibcxx_cv_arc4random, [
5165 GCC_TRY_COMPILE_OR_LINK(
5166 [#include <stdlib.h>],
5167 [unsigned i = ::arc4random();],
5168 [glibcxx_cv_arc4random=yes], [glibcxx_cv_arc4random=no])
5171 if test $glibcxx_cv_arc4random = yes; then
5172 AC_DEFINE(HAVE_ARC4RANDOM, 1, [Define if arc4random is available in <stdlib.h>.])
5178 dnl Check to see whether to build libstdc++_libbacktrace.a
5180 dnl --enable-libstdcxx-backtrace
5182 AC_DEFUN([GLIBCXX_ENABLE_BACKTRACE], [
5183 GLIBCXX_ENABLE(libstdcxx-backtrace,auto,,
5184 [turns on libbacktrace support],
5185 [permit yes|no|auto])
5187 # Most of this is adapted from libsanitizer/configure.ac
5191 # libbacktrace only needs atomics for int, which we've already tested
5192 if test "$glibcxx_cv_atomic_int" = "yes"; then
5193 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_ATOMIC_FUNCTIONS=1"
5196 # Test for __sync support.
5197 AC_CACHE_CHECK([__sync extensions],
5198 [glibcxx_cv_sys_sync],
5199 [GCC_TRY_COMPILE_OR_LINK(
5201 [__sync_bool_compare_and_swap (&i, i, i);
5202 __sync_lock_test_and_set (&i, 1);
5203 __sync_lock_release (&i);],
5204 [glibcxx_cv_sys_sync=yes],
5205 [glibcxx_cv_sys_sync=no])
5207 if test "$glibcxx_cv_sys_sync" = "yes"; then
5208 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_SYNC_FUNCTIONS=1"
5211 # Check for dl_iterate_phdr.
5212 AC_CHECK_HEADERS(link.h)
5213 if test "$ac_cv_header_link_h" = "no"; then
5214 have_dl_iterate_phdr=no
5216 # When built as a GCC target library, we can't do a link test.
5217 AC_EGREP_HEADER([dl_iterate_phdr], [link.h], [have_dl_iterate_phdr=yes],
5218 [have_dl_iterate_phdr=no])
5220 if test "$have_dl_iterate_phdr" = "yes"; then
5221 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_DL_ITERATE_PHDR=1"
5223 AC_CHECK_HEADERS(windows.h)
5225 # Check for the fcntl function.
5226 if test -n "${with_target_subdir}"; then
5228 *-*-mingw*) have_fcntl=no ;;
5229 *) have_fcntl=yes ;;
5232 AC_CHECK_FUNC(fcntl, [have_fcntl=yes], [have_fcntl=no])
5234 if test "$have_fcntl" = "yes"; then
5235 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_FCNTL=1"
5238 AC_CHECK_DECLS(strnlen)
5240 # Check for getexecname function.
5241 if test -n "${with_target_subdir}"; then
5243 *-*-solaris2*) have_getexecname=yes ;;
5244 *) have_getexecname=no ;;
5247 AC_CHECK_FUNC(getexecname, [have_getexecname=yes], [have_getexecname=no])
5249 if test "$have_getexecname" = "yes"; then
5250 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_GETEXECNAME=1"
5253 # The library needs to be able to read the executable itself. Compile
5254 # a file to determine the executable format. The awk script
5255 # filetype.awk prints out the file type.
5256 AC_CACHE_CHECK([output filetype],
5257 [glibcxx_cv_sys_filetype],
5260 [AC_LANG_PROGRAM([int i;], [int j;])],
5261 [filetype=`${AWK} -f $srcdir/../libbacktrace/filetype.awk conftest.$ac_objext`],
5262 [AC_MSG_FAILURE([compiler failed])])
5263 glibcxx_cv_sys_filetype=$filetype])
5265 # Match the file type to decide what files to compile.
5267 case "$glibcxx_cv_sys_filetype" in
5268 elf*) FORMAT_FILE="elf.lo" ;;
5269 pecoff*) FORMAT_FILE="pecoff.lo" ;;
5270 *) AC_MSG_WARN([could not determine output file type])
5271 FORMAT_FILE="unknown.lo"
5272 enable_libstdcxx_backtrace=no
5275 AC_SUBST(FORMAT_FILE)
5279 case "$glibcxx_cv_sys_filetype" in
5280 elf32) elfsize=32 ;;
5281 elf64) elfsize=64 ;;
5283 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DBACKTRACE_ELF_SIZE=$elfsize"
5285 AC_MSG_CHECKING([whether to build libbacktrace support])
5286 if test "$enable_libstdcxx_backtrace" = "auto"; then
5287 enable_libstdcxx_backtrace=no
5289 AC_MSG_RESULT($enable_libstdcxx_backtrace)
5290 if test "$enable_libstdcxx_backtrace" = "yes"; then
5291 BACKTRACE_SUPPORTED=1
5293 AC_CHECK_HEADERS(sys/mman.h)
5295 *-*-msdosdjgpp) # DJGPP has sys/man.h, but no mmap
5298 have_mmap="$ac_cv_header_sys_mman_h" ;;
5301 if test "$have_mmap" = "no"; then
5306 AC_PREPROC_IFELSE([AC_LANG_SOURCE([
5307 #include <sys/mman.h>
5308 #if !defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
5309 #error no MAP_ANONYMOUS
5311 ])], [ALLOC_FILE=mmap.lo], [ALLOC_FILE=alloc.lo])
5314 AC_SUBST(ALLOC_FILE)
5316 BACKTRACE_USES_MALLOC=0
5317 if test "$ALLOC_FILE" = "alloc.lo"; then
5318 BACKTRACE_USES_MALLOC=1
5321 if test "$ac_has_gthreads" = "yes"; then
5322 BACKTRACE_SUPPORTS_THREADS=1
5324 BACKTRACE_SUPPORTS_THREADS=0
5326 AC_SUBST(BACKTRACE_CPPFLAGS)
5327 AC_SUBST(BACKTRACE_SUPPORTED)
5328 AC_SUBST(BACKTRACE_USES_MALLOC)
5329 AC_SUBST(BACKTRACE_SUPPORTS_THREADS)
5330 AC_DEFINE(HAVE_STACKTRACE, 1, [Define if the <stacktrace> header is supported.])
5332 BACKTRACE_SUPPORTED=0
5333 BACKTRACE_USES_MALLOC=0
5334 BACKTRACE_SUPPORTS_THREADS=0
5336 GLIBCXX_CONDITIONAL(ENABLE_BACKTRACE, [test "$enable_libstdcxx_backtrace" = yes])
5340 dnl Allow the emergency EH pool to be configured.
5342 dnl --enable-libstdcxx-static-eh-pool will cause a fixed-size static buffer
5343 dnl to be used for allocating exceptions after malloc fails. The default is
5344 dnl to allocate a buffer using malloc
5346 dnl --with-libstdcxx-eh-pool-obj-count=N will set the default size for the
5347 dnl buffer. For a static buffer that size is fixed permanently. For a dynamic
5348 dnl buffer it's the default, but it can be overridden from the environment.
5350 dnl To set the default to approximately the same values as GCC 12,
5351 dnl use --with-libstdcxx-eh-pool-obj-count=94 for 32-bit targets,
5352 dnl and --with-libstdcxx-eh-pool-obj-count=252 for 64-bit targets.
5355 dnl _GLIBCXX_EH_POOL_STATIC if a fixed-size static buffer should be used
5356 dnl instead of allocating a buffer on startup.
5357 dnl _GLIBCXX_EH_POOL_NOBJS to override the default EMERGENCY_OBJ_COUNT value.
5359 AC_DEFUN([GLIBCXX_EMERGENCY_EH_ALLOC], [
5362 AC_ARG_ENABLE([libstdcxx-static-eh-pool],
5363 AC_HELP_STRING([--enable-libstdcxx-static-eh-pool],
5364 [use a fixed-size static buffer for allocating exceptions if malloc fails]),
5365 [if test "${enableval}" = yes; then
5366 eh_pool_static="-D_GLIBCXX_EH_POOL_STATIC"
5367 AC_MSG_NOTICE([EH pool using static buffer])
5370 AC_ARG_WITH([libstdcxx-eh-pool-obj-count],
5371 AC_HELP_STRING([--with-libstdcxx-eh-pool-obj-count],
5372 [the number of exceptions that can be allocated from the pool if malloc fails]),
5373 [if test "${withval}" -ge 0 2>/dev/null; then
5374 eh_pool_obj_count="-D_GLIBCXX_EH_POOL_NOBJS=${withval}"
5375 AC_MSG_NOTICE([EH pool object count: ${withval}])
5377 AC_MSG_ERROR([EH pool obj count must be a non-negative integer: $withval])
5380 EH_POOL_FLAGS="$eh_pool_static $eh_pool_obj_count"
5381 AC_SUBST(EH_POOL_FLAGS)
5385 dnl Allow the location of tzdata files to be configured.
5387 dnl --with-libstdcxx-zoneinfo=ARG where ARG can be:
5388 dnl DIR - use DIR/tzdata.zi and DIR/leapseconds files.
5389 dnl static - use static copy of tzdata.zi embedded in the library.
5390 dnl DIR,static - use DIR, but use embedded static copy as fallback.
5391 dnl yes - equivalent to DIR,static with a system-specific value for DIR.
5392 dnl no - disable most tzdb functionality.
5395 dnl _GLIBCXX_ZONEINFO_DIR if std::chrono::tzdb should use the specified
5396 dnl directory for the tzdata.zi and leapseconds files.
5397 dnl _GLIBCXX_STATIC_TZDATA if std::chrono::tzdb should use an embedded
5398 dnl static copy of the tzdata.zi file.
5400 AC_DEFUN([GLIBCXX_ZONEINFO_DIR], [
5401 AC_ARG_WITH([libstdcxx-zoneinfo],
5402 AC_HELP_STRING([--with-libstdcxx-zoneinfo],
5403 [the location to use for tzdata]),
5404 [],[with_libstdcxx_zoneinfo=yes])
5406 if test "x${with_libstdcxx_zoneinfo}" = xyes; then
5407 # Pick a default when no specific path is set.
5408 case "$target_os" in
5409 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
5410 # Not all distros ship tzdata.zi in this dir.
5411 zoneinfo_dir="/usr/share/zoneinfo"
5414 # Binary tzfile files are in /usr/share/lib/zoneinfo
5415 # but tzdata.zi is not present there.
5419 # Binary tzfile files are in /usr/share/lib/zoneinfo.default
5420 # but tzdata.zi is not present there.
5424 # Binary tzfile files are commonly found in /usr/share/zoneinfo
5425 # but tzdata.zi is not present there.
5430 avr-*-* | msp430-*-* ) embed_zoneinfo=no ;;
5432 # Also embed a copy of the tzdata.zi file as a static string.
5433 embed_zoneinfo=yes ;;
5435 elif test "x${with_libstdcxx_zoneinfo}" = xno; then
5436 # Disable tzdb support completely.
5440 case "${with_libstdcxx_zoneinfo}" in
5442 # Do not attempt to read from disk, always use embedded data.
5446 static,* | *,static)
5447 # Try to read from disk, use embedded data as fallback.
5448 zoneinfo_dir="${with_libstdcxx_zoneinfo#static,}"
5449 zoneinfo_dir="${with_libstdcxx_zoneinfo%,static}"
5453 zoneinfo_dir="${with_libstdcxx_zoneinfo}"
5458 AC_MSG_NOTICE([zoneinfo data directory: ${zoneinfo_dir}])
5459 if test "x${zoneinfo_dir}" != xnone; then
5460 AC_DEFINE_UNQUOTED(_GLIBCXX_ZONEINFO_DIR, "${zoneinfo_dir}",
5461 [Define if a directory should be searched for tzdata files.])
5462 if $GLIBCXX_IS_NATIVE && ! test -f "$zoneinfo_dir/tzdata.zi"; then
5463 AC_MSG_WARN("$zoneinfo_dir does not contain tzdata.zi file")
5466 GLIBCXX_CONDITIONAL(USE_STATIC_TZDATA, test "${embed_zoneinfo}" = yes)
5467 if test "x${embed_zoneinfo}" = xyes; then
5468 AC_MSG_NOTICE([static tzdata.zi file will be compiled into the library])
5469 AC_DEFINE_UNQUOTED(_GLIBCXX_STATIC_TZDATA, 1,
5470 [Define if static tzdata should be compiled into the library.])
5475 dnl Check whether lock tables can be aligned to avoid false sharing.
5478 dnl _GLIBCXX_CAN_ALIGNAS_DESTRUCTIVE_SIZE if objects with static storage
5479 dnl duration can be aligned to std::hardware_destructive_interference_size.
5481 AC_DEFUN([GLIBCXX_CHECK_ALIGNAS_CACHELINE], [
5485 AC_MSG_CHECKING([whether static objects can be aligned to the cacheline size])
5486 AC_TRY_COMPILE(, [struct alignas(__GCC_DESTRUCTIVE_SIZE) Aligned { };
5487 alignas(Aligned) static char buf[sizeof(Aligned) * 16];
5488 ], [ac_alignas_cacheline=yes], [ac_alignas_cacheline=no])
5489 if test "$ac_alignas_cacheline" = yes; then
5490 AC_DEFINE_UNQUOTED(_GLIBCXX_CAN_ALIGNAS_DESTRUCTIVE_SIZE, 1,
5491 [Define if global objects can be aligned to
5492 std::hardware_destructive_interference_size.])
5494 AC_MSG_RESULT($ac_alignas_cacheline)
5499 # Macros from the top-level gcc directory.
5500 m4_include([../config/gc++filt.m4])
5501 m4_include([../config/tls.m4])
5502 m4_include([../config/gthr.m4])
5503 m4_include([../config/cet.m4])