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/filesystem 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_gnu_ld_version (possibly)
177 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
178 dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
180 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
181 # If we're not using GNU ld, then there's no point in even trying these
182 # tests. Check for that first. We should have already tested for gld
183 # by now (in libtool), but require it now just to be safe...
184 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
185 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
186 AC_REQUIRE([AC_PROG_LD])
187 AC_REQUIRE([AC_PROG_AWK])
189 # The name set by libtool depends on the version of libtool. Shame on us
190 # for depending on an impl detail, but c'est la vie. Older versions used
191 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
192 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
193 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
194 # set (hence we're using an older libtool), then set it.
195 if test x${with_gnu_ld+set} != xset; then
196 if test x${ac_cv_prog_gnu_ld+set} != xset; then
197 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
200 with_gnu_ld=$ac_cv_prog_gnu_ld
204 # Start by getting the version number. I think the libtool test already
205 # does some of this, but throws away the result.
206 glibcxx_ld_is_gold=no
207 if test x"$with_gnu_ld" = x"yes"; then
208 AC_MSG_CHECKING([for ld version])
210 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
211 glibcxx_ld_is_gold=yes
213 ldver=`$LD --version 2>/dev/null |
214 sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'`
216 glibcxx_gnu_ld_version=`echo $ldver | \
217 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
218 AC_MSG_RESULT($glibcxx_gnu_ld_version)
222 glibcxx_have_gc_sections=no
223 if test "$glibcxx_ld_is_gold" = "yes"; then
224 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
225 glibcxx_have_gc_sections=yes
228 glibcxx_gcsections_min_ld=21602
229 if test x"$with_gnu_ld" = x"yes" &&
230 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
231 glibcxx_have_gc_sections=yes
234 if test "$glibcxx_have_gc_sections" = "yes"; then
235 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
236 # NB: This flag only works reliably after 2.16.1. Configure tests
237 # for this are difficult, so hard wire a value that should work.
239 ac_test_CFLAGS="${CFLAGS+set}"
240 ac_save_CFLAGS="$CFLAGS"
241 CFLAGS='-Wl,--gc-sections'
243 # Check for -Wl,--gc-sections
244 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
245 AC_TRY_LINK([ int one(void) { return 1; }
246 int two(void) { return 2; }
247 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
248 if test "$ac_gcsections" = "yes"; then
251 if $CC -c conftest.c; then
252 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
253 grep "Warning: gc-sections option ignored" > /dev/null; then
257 rm -f conftest.c conftest.o conftest
259 if test "$ac_gcsections" = "yes"; then
260 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
262 AC_MSG_RESULT($ac_gcsections)
264 if test "$ac_test_CFLAGS" = set; then
265 CFLAGS="$ac_save_CFLAGS"
267 # this is the suspicious part
273 # Note this is only for shared objects.
275 if test x"$with_gnu_ld" = x"yes"; then
276 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
277 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
278 if test -n "$cxx_z_relo"; then
279 OPT_LDFLAGS="-Wl,-z,relro"
282 AC_MSG_RESULT($ac_ld_relro)
285 # Set linker optimization flags.
286 if test x"$with_gnu_ld" = x"yes"; then
287 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
290 AC_SUBST(SECTION_LDFLAGS)
291 AC_SUBST(OPT_LDFLAGS)
296 dnl Check for headers for, and arguments to, the setrlimit() function.
297 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
300 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
301 dnl various HAVE_LIMIT_* for individual limit names
303 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
304 AC_MSG_CHECKING([for RLIMIT_$1])
307 #include <sys/time.h>
308 #include <sys/resource.h>
310 [ int f = RLIMIT_$1 ; ],
311 [glibcxx_mresult=1], [glibcxx_mresult=0])
312 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
313 [Only used in build directory testsuite_hooks.h.])
314 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
318 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
319 setrlimit_have_headers=yes
320 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
322 [setrlimit_have_headers=no])
323 # If don't have the headers, then we can't run the tests now, and we
324 # won't be seeing any of these during testsuite compilation.
325 if test $setrlimit_have_headers = yes; then
326 # Can't do these in a loop, else the resulting syntax is wrong.
327 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
328 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
329 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
330 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
331 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
333 # Check for rlimit, setrlimit.
334 AC_CACHE_VAL(glibcxx_cv_setrlimit, [
337 #include <sys/time.h>
338 #include <sys/resource.h>
342 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
346 AC_MSG_CHECKING([for testsuite resource limits support])
347 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
349 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
350 [Define if using setrlimit to set resource limits during
355 AC_MSG_RESULT($ac_res_limits)
360 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
361 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
363 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
367 ac_save_CXXFLAGS="$CXXFLAGS"
368 CXXFLAGS="$CXXFLAGS -fno-exceptions"
370 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
371 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
372 GCC_TRY_COMPILE_OR_LINK(
373 [#include <sys/stat.h>],
376 S_ISREG(buffer.st_mode);],
377 [glibcxx_cv_S_ISREG=yes],
378 [glibcxx_cv_S_ISREG=no])
380 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
381 GCC_TRY_COMPILE_OR_LINK(
382 [#include <sys/stat.h>],
385 S_IFREG & buffer.st_mode;],
386 [glibcxx_cv_S_IFREG=yes],
387 [glibcxx_cv_S_IFREG=no])
390 if test $glibcxx_cv_S_ISREG = yes; then
391 AC_DEFINE(HAVE_S_ISREG, 1,
392 [Define if S_ISREG is available in <sys/stat.h>.])
394 elif test $glibcxx_cv_S_IFREG = yes; then
395 AC_DEFINE(HAVE_S_IFREG, 1,
396 [Define if S_IFREG is available in <sys/stat.h>.])
401 CXXFLAGS="$ac_save_CXXFLAGS"
407 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
409 AC_DEFUN([GLIBCXX_CHECK_POLL], [
413 ac_save_CXXFLAGS="$CXXFLAGS"
414 CXXFLAGS="$CXXFLAGS -fno-exceptions"
416 AC_MSG_CHECKING([for poll])
417 AC_CACHE_VAL(glibcxx_cv_POLL, [
418 GCC_TRY_COMPILE_OR_LINK(
420 [struct pollfd pfd[1];
421 pfd[0].events = POLLIN;
423 [glibcxx_cv_POLL=yes],
424 [glibcxx_cv_POLL=no])
426 if test $glibcxx_cv_POLL = yes; then
427 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
429 AC_MSG_RESULT($glibcxx_cv_POLL)
431 CXXFLAGS="$ac_save_CXXFLAGS"
437 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
439 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
443 ac_save_CXXFLAGS="$CXXFLAGS"
444 CXXFLAGS="$CXXFLAGS -fno-exceptions"
446 AC_MSG_CHECKING([for writev])
447 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
448 GCC_TRY_COMPILE_OR_LINK(
449 [#include <sys/uio.h>],
450 [struct iovec iov[2];
452 [glibcxx_cv_WRITEV=yes],
453 [glibcxx_cv_WRITEV=no])
455 if test $glibcxx_cv_WRITEV = yes; then
456 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
458 AC_MSG_RESULT($glibcxx_cv_WRITEV)
460 CXXFLAGS="$ac_save_CXXFLAGS"
466 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
467 dnl Also check whether int64_t is actually a typedef to long or long long.
469 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
474 AC_MSG_CHECKING([for int64_t])
475 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
477 [#include <stdint.h>],
479 [glibcxx_cv_INT64_T=yes],
480 [glibcxx_cv_INT64_T=no])
483 if test $glibcxx_cv_INT64_T = yes; then
484 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
485 AC_MSG_RESULT($glibcxx_cv_INT64_T)
487 AC_MSG_CHECKING([for int64_t as long])
488 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
491 template<typename, typename> struct same { enum { value = -1 }; };
492 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
493 int array[same<int64_t, long>::value];], [],
494 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
497 if test $glibcxx_cv_int64_t_long = yes; then
498 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
499 AC_MSG_RESULT($glibcxx_cv_int64_t_long)
502 AC_MSG_CHECKING([for int64_t as long long])
503 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
506 template<typename, typename> struct same { enum { value = -1 }; };
507 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
508 int array[same<int64_t, long long>::value];], [],
509 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
512 if test $glibcxx_cv_int64_t_long_long = yes; then
513 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
514 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
523 dnl Check whether LFS support is available.
525 AC_DEFUN([GLIBCXX_CHECK_LFS], [
528 ac_save_CXXFLAGS="$CXXFLAGS"
529 CXXFLAGS="$CXXFLAGS -fno-exceptions"
530 AC_MSG_CHECKING([for LFS support])
531 AC_CACHE_VAL(glibcxx_cv_LFS, [
532 GCC_TRY_COMPILE_OR_LINK(
535 #include <sys/stat.h>
539 fseeko64(fp, 0, SEEK_CUR);
541 lseek64(1, 0, SEEK_CUR);
544 [glibcxx_cv_LFS=yes],
547 if test $glibcxx_cv_LFS = yes; then
548 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
550 AC_MSG_RESULT($glibcxx_cv_LFS)
551 CXXFLAGS="$ac_save_CXXFLAGS"
557 dnl Check for whether a fully dynamic basic_string implementation should
558 dnl be turned on, that does not put empty objects in per-process static
559 dnl memory (mostly useful together with shared memory allocators, see PR
560 dnl libstdc++/16612 for details).
562 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
563 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
564 dnl otherwise undefined
565 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
566 dnl Where DEFAULT is either `yes' or `no'.
568 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
569 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
570 if test $enable_fully_dynamic_string = yes; then
571 enable_fully_dynamic_string_def=1
573 enable_fully_dynamic_string_def=0
575 AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
576 [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
581 dnl Does any necessary configuration of the testsuite directory. Generates
582 dnl the testsuite_hooks.h header.
584 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
588 dnl GLIBCXX_TEST_WCHAR_T
589 dnl GLIBCXX_TEST_THREAD
592 dnl baseline_subdir_switch
594 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
595 # Do checks for resource limit functions.
596 GLIBCXX_CHECK_SETRLIMIT
598 if $GLIBCXX_IS_NATIVE ; then
599 # Look for setenv, so that extended locale tests can be performed.
600 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
603 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
604 test $enable_symvers != no; then
607 enable_abi_check=no ;;
609 enable_abi_check=yes ;;
612 # Only build this as native, since automake does not understand
617 # Export file names for ABI checking.
618 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
619 AC_SUBST(baseline_dir)
620 baseline_subdir_switch="$abi_baseline_subdir_switch"
621 AC_SUBST(baseline_subdir_switch)
626 dnl Does any necessary configuration for docbook in the docs directory.
628 dnl XSLTPROC must be set before this
631 dnl glibcxx_stylesheets
635 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
637 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
638 glibcxx_stylesheets=no
639 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then
640 glibcxx_stylesheets=yes
642 AC_MSG_RESULT($glibcxx_stylesheets)
644 AC_MSG_CHECKING([for local stylesheet directory])
645 glibcxx_local_stylesheets=no
646 if test x"$glibcxx_stylesheets" = x"yes"; then
647 if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then
648 glibcxx_local_stylesheets=yes
649 XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets
651 if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then
652 glibcxx_local_stylesheets=yes
653 XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
655 if test -d /usr/share/xml/docbook/stylesheet/nwalsh5/current; then
656 glibcxx_local_stylesheets=yes
657 XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/nwalsh5/current
660 AC_MSG_RESULT($glibcxx_local_stylesheets)
662 if test x"$glibcxx_local_stylesheets" = x"yes"; then
663 AC_SUBST(XSL_STYLE_DIR)
664 AC_MSG_NOTICE($XSL_STYLE_DIR)
666 glibcxx_stylesheets=no
669 # Check for epub3 dependencies.
670 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
671 glibcxx_epub_stylesheets=no
672 if test x"$glibcxx_local_stylesheets" = x"yes"; then
673 if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
674 glibcxx_epub_stylesheets=yes
677 AC_MSG_RESULT($glibcxx_epub_stylesheets)
678 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
684 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
688 dnl TOPLEVEL_INCLUDES
690 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
691 # Used for every C++ compile we perform.
693 -I$glibcxx_builddir/include/$host_alias \
694 -I$glibcxx_builddir/include \
695 -I$glibcxx_srcdir/libsupc++"
697 # For Canadian crosses, pick this up too.
698 if test $CANADIAN = yes; then
699 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
702 # Stuff in the actual top level. Currently only used by libsupc++ to
703 # get unwind* headers from the libgcc dir.
704 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
705 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
707 # Now, export this to all the little Makefiles....
708 AC_SUBST(GLIBCXX_INCLUDES)
709 AC_SUBST(TOPLEVEL_INCLUDES)
714 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
715 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
718 dnl OPTIMIZE_CXXFLAGS
721 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
722 # Optimization flags that are probably a good idea for thrill-seekers. Just
723 # uncomment the lines below and make, everything else is ready to go...
724 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
725 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
726 AC_SUBST(OPTIMIZE_CXXFLAGS)
728 WARN_FLAGS="-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi=2"
734 dnl All installation directory information is determined here.
738 dnl glibcxx_prefixdir
739 dnl glibcxx_toolexecdir
740 dnl glibcxx_toolexeclibdir
742 dnl Assumes cross_compiling bits already done, and with_cross_host in
745 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
746 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
747 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
748 glibcxx_toolexecdir=no
749 glibcxx_toolexeclibdir=no
750 glibcxx_prefixdir=$prefix
752 AC_MSG_CHECKING([for gxx-include-dir])
753 AC_ARG_WITH([gxx-include-dir],
754 AC_HELP_STRING([--with-gxx-include-dir=DIR],
755 [installation directory for include files]),
757 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
758 no) gxx_include_dir=no ;;
759 *) gxx_include_dir=$withval ;;
761 [gxx_include_dir=no])
762 AC_MSG_RESULT($gxx_include_dir)
764 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
765 AC_ARG_ENABLE([version-specific-runtime-libs],
766 AC_HELP_STRING([--enable-version-specific-runtime-libs],
767 [Specify that runtime libraries should be installed in a compiler-specific directory]),
768 [case "$enableval" in
769 yes) version_specific_libs=yes ;;
770 no) version_specific_libs=no ;;
771 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
773 [version_specific_libs=no])
774 AC_MSG_RESULT($version_specific_libs)
776 # Default case for install directory for include files.
777 if test $version_specific_libs = no && test $gxx_include_dir = no; then
778 gxx_include_dir='include/c++/${gcc_version}'
779 if test -n "$with_cross_host" &&
780 test x"$with_cross_host" != x"no"; then
781 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
783 gxx_include_dir='${prefix}/'"$gxx_include_dir"
787 # Version-specific runtime libs processing.
788 if test $version_specific_libs = yes; then
789 # Need the gcc compiler version to know where to install libraries
790 # and header files if --enable-version-specific-runtime-libs option
791 # is selected. FIXME: these variables are misnamed, there are
792 # no executables installed in _toolexecdir or _toolexeclibdir.
793 if test x"$gxx_include_dir" = x"no"; then
794 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
796 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
797 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
800 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
801 # Install a library built with a cross compiler in tooldir, not libdir.
802 if test x"$glibcxx_toolexecdir" = x"no"; then
803 if test -n "$with_cross_host" &&
804 test x"$with_cross_host" != x"no"; then
805 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
806 glibcxx_toolexeclibdir='${toolexecdir}/lib'
808 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
809 glibcxx_toolexeclibdir='${libdir}'
811 multi_os_directory=`$CXX -print-multi-os-directory`
812 case $multi_os_directory in
813 .) ;; # Avoid trailing /.
814 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
818 AC_MSG_CHECKING([for install location])
819 AC_MSG_RESULT($gxx_include_dir)
821 AC_SUBST(glibcxx_prefixdir)
822 AC_SUBST(gxx_include_dir)
823 AC_SUBST(glibcxx_toolexecdir)
824 AC_SUBST(glibcxx_toolexeclibdir)
830 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
831 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
832 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
834 dnl See manual/appendix_porting.html#appendix.porting.build_hacking for
837 m4_define([GLIBCXX_ENABLE],[dnl
838 m4_define([_g_switch],[--enable-$1])dnl
839 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
840 AC_ARG_ENABLE([$1],m4_dquote(_g_help),
845 m4_bpatsubst([$5],[permit ])) ;;
846 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
847 dnl Idea for future: generate a URL pointing to
848 dnl "onlinedocs/configopts.html#whatever"
855 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
859 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
860 m4_undefine([_g_switch])dnl
861 m4_undefine([_g_help])dnl
866 dnl Check for ISO/IEC 9899:1999 "C99" support.
868 dnl --enable-c99 defines _GLIBCXX_USE_C99
869 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
870 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
871 dnl Where DEFAULT is either `yes' or `no'.
872 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
874 AC_DEFUN([GLIBCXX_ENABLE_C99], [
875 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
877 if test x"$enable_c99" = x"yes"; then
881 # Use -std=c++98 (instead of -std=gnu++98) because leaving __STRICT_ANSI__
882 # undefined may cause fake C99 facilities, like pre-standard snprintf,
883 # to be spuriously enabled.
884 ac_save_CXXFLAGS="$CXXFLAGS"
885 CXXFLAGS="$CXXFLAGS -std=c++98"
887 ac_save_gcc_no_link="$gcc_no_link"
889 if test x$gcc_no_link != xyes; then
890 # Use -fno-exceptions to that the C driver can link these tests without
891 # hitting undefined references to personality routines.
892 CXXFLAGS="$CXXFLAGS -fno-exceptions"
893 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
894 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
899 # Check for the existence of <math.h> functions used if C99 is enabled.
900 AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++98])
901 AC_CACHE_VAL(glibcxx_cv_c99_math_cxx98, [
902 GCC_TRY_COMPILE_OR_LINK(
904 volatile double d1, d2;
912 i = isgreater(d1, d2);
913 i = isgreaterequal(d1, d2);
915 i = islessequal(d1, d2);
916 i = islessgreater(d1, d2);
917 i = islessgreater(d1, d2);
918 i = isunordered(d1, d2);
919 ], [glibcxx_cv_c99_math_cxx98=yes], [glibcxx_cv_c99_math_cxx98=no])
921 AC_MSG_RESULT($glibcxx_cv_c99_math_cxx98)
922 if test x"$glibcxx_cv_c99_math_cxx98" = x"yes"; then
923 AC_DEFINE(_GLIBCXX98_USE_C99_MATH, 1,
924 [Define if C99 functions or macros in <math.h> should be imported
925 in <cmath> in namespace std for C++98.])
928 # Check for the existence of <complex.h> complex math functions.
929 # This is necessary even though libstdc++ uses the builtin versions
930 # of these functions, because if the builtin cannot be used, a reference
931 # to the library function is emitted.
932 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
933 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
934 if test x"$ac_has_complex_h" = x"yes"; then
935 AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++98])
936 AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx98, [
937 GCC_TRY_COMPILE_OR_LINK(
938 [#include <complex.h>
939 typedef __complex__ float float_type;
940 typedef __complex__ double double_type;
941 typedef __complex__ long double ld_type;
942 volatile float_type tmpf;
943 volatile double_type tmpd;
944 volatile ld_type tmpld;
947 volatile long double ld;],
959 tmpf = cpowf(tmpf, tmpf);
972 tmpd = cpow(tmpd, tmpd);
976 tmpld = ccosl(tmpld);
977 tmpld = ccoshl(tmpld);
978 tmpld = cexpl(tmpld);
979 tmpld = clogl(tmpld);
980 tmpld = csinl(tmpld);
981 tmpld = csinhl(tmpld);
982 tmpld = csqrtl(tmpld);
983 tmpld = ctanl(tmpld);
984 tmpld = ctanhl(tmpld);
985 tmpld = cpowl(tmpld, tmpld);
986 tmpld = cprojl(tmpld);
987 ], [glibcxx_cv_c99_complex_cxx98=yes], [glibcxx_cv_c99_complex_cxx98=no])
990 AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx98)
991 if test x"$glibcxx_cv_c99_complex_cxx98" = x"yes"; then
992 AC_DEFINE(_GLIBCXX98_USE_C99_COMPLEX, 1,
993 [Define if C99 functions in <complex.h> should be used in
994 <complex> for C++98. Using compiler builtins for these functions
995 requires corresponding C99 library functions to be present.])
998 # Check for the existence in <stdio.h> of vscanf, et. al.
999 AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++98])
1000 AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx98, [
1001 GCC_TRY_COMPILE_OR_LINK(
1004 void foo(char* fmt, ...)
1006 va_list args; va_start(args, fmt);
1007 vfscanf(stderr, "%i", args);
1009 vsnprintf(fmt, 0, "%i", args);
1010 vsscanf(fmt, "%i", args);
1011 snprintf(fmt, 0, "%i");
1013 [glibcxx_cv_c99_stdio_cxx98=yes], [glibcxx_cv_c99_stdio_cxx98=no])
1015 AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx98)
1016 if test x"$glibcxx_cv_c99_stdio_cxx98" = x"yes"; then
1017 AC_DEFINE(_GLIBCXX98_USE_C99_STDIO, 1,
1018 [Define if C99 functions or macros in <stdio.h> should be imported
1019 in <cstdio> in namespace std for C++98.])
1022 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1023 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++98])
1024 AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx98, [
1025 GCC_TRY_COMPILE_OR_LINK(
1026 [#include <stdlib.h>
1028 volatile long double ld;
1029 volatile unsigned long long ll;
1032 f = strtof("gnu", &tmp);
1033 ld = strtold("gnu", &tmp);
1034 ll = strtoll("gnu", &tmp, 10);
1035 ll = strtoull("gnu", &tmp, 10);
1037 mydivt = lldiv(10,1);
1042 ], [glibcxx_cv_c99_stdlib_cxx98=yes], [glibcxx_cv_c99_stdlib_cxx98=no])
1044 AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx98)
1045 if test x"$glibcxx_cv_c99_stdlib_cxx98" = x"yes"; then
1046 AC_DEFINE(_GLIBCXX98_USE_C99_STDLIB, 1,
1047 [Define if C99 functions or macros in <stdlib.h> should be imported
1048 in <cstdlib> in namespace std for C++98.])
1051 # Check for the existence in <wchar.h> of wcstold, etc.
1052 if test x"$ac_has_wchar_h" = xyes &&
1053 test x"$ac_has_wctype_h" = xyes; then
1054 AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++98])
1055 AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx98, [
1056 AC_TRY_COMPILE([#include <wchar.h>
1063 ], [], [glibcxx_cv_c99_wchar_cxx98=yes], [glibcxx_cv_c99_wchar_cxx98=no])
1066 # Checks for wide character functions that may not be present.
1067 # Injection of these is wrapped with guard macros.
1068 # NB: only put functions here, instead of immediately above, if
1069 # absolutely necessary.
1070 AC_TRY_COMPILE([#include <wchar.h>
1071 namespace test { using ::vfwscanf; }], [],
1072 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1074 AC_TRY_COMPILE([#include <wchar.h>
1075 namespace test { using ::vswscanf; }], [],
1076 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1078 AC_TRY_COMPILE([#include <wchar.h>
1079 namespace test { using ::vwscanf; }], [],
1080 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1082 AC_TRY_COMPILE([#include <wchar.h>
1083 namespace test { using ::wcstof; }], [],
1084 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1086 AC_TRY_COMPILE([#include <wctype.h>],
1087 [wint_t t; int i = iswblank(t);],
1088 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1090 AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx98)
1091 if test x"$glibcxx_cv_c99_wchar_cxx98" = x"yes"; then
1092 AC_DEFINE(_GLIBCXX98_USE_C99_WCHAR, 1,
1093 [Define if C99 functions or macros in <wchar.h> should be imported
1094 in <cwchar> in namespace std for C++98.])
1098 # Option parsed, now set things appropriately.
1099 if test x"$glibcxx_cv_c99_math_cxx98" = x"no" ||
1100 test x"$glibcxx_cv_c99_complex_cxx98" = x"no" ||
1101 test x"$glibcxx_cv_c99_stdio_cxx98" = x"no" ||
1102 test x"$glibcxx_cv_c99_stdlib_cxx98" = x"no" ||
1103 test x"$glibcxx_cv_c99_wchar_cxx98" = x"no"; then
1106 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1107 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1108 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1111 gcc_no_link="$ac_save_gcc_no_link"
1112 LIBS="$ac_save_LIBS"
1113 CXXFLAGS="$ac_save_CXXFLAGS"
1119 # Use -std=c++11 and test again for C99 library feature in C++11 mode.
1120 # For the reasons given above we use -std=c++11 not -std=gnu++11.
1121 ac_save_CXXFLAGS="$CXXFLAGS"
1122 CXXFLAGS="$CXXFLAGS -std=c++11"
1123 ac_save_LIBS="$LIBS"
1124 ac_save_gcc_no_link="$gcc_no_link"
1126 if test x$gcc_no_link != xyes; then
1127 # Use -fno-exceptions to that the C driver can link these tests without
1128 # hitting undefined references to personality routines.
1129 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1130 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
1131 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
1136 # Check for the existence of <math.h> functions used if C99 is enabled.
1137 AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++11])
1138 AC_CACHE_VAL(glibcxx_cv_c99_math_cxx11, [
1139 GCC_TRY_COMPILE_OR_LINK(
1141 volatile double d1, d2;
1143 [i = fpclassify(d1);
1149 i = isgreater(d1, d2);
1150 i = isgreaterequal(d1, d2);
1152 i = islessequal(d1, d2);
1153 i = islessgreater(d1, d2);
1154 i = islessgreater(d1, d2);
1155 i = isunordered(d1, d2);
1156 ], [glibcxx_cv_c99_math_cxx11=yes], [glibcxx_cv_c99_math_cxx11=no])
1158 AC_MSG_RESULT($glibcxx_cv_c99_math_cxx11)
1159 if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
1160 AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
1161 [Define if C99 functions or macros in <math.h> should be imported
1162 in <cmath> in namespace std for C++11.])
1165 # Check for the existence of <complex.h> complex math functions.
1166 # This is necessary even though libstdc++ uses the builtin versions
1167 # of these functions, because if the builtin cannot be used, a reference
1168 # to the library function is emitted.
1169 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
1170 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1171 if test x"$ac_has_complex_h" = x"yes"; then
1172 AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++11])
1173 AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx11, [
1174 GCC_TRY_COMPILE_OR_LINK(
1175 [#include <complex.h>
1176 typedef __complex__ float float_type;
1177 typedef __complex__ double double_type;
1178 typedef __complex__ long double ld_type;
1179 volatile float_type tmpf;
1180 volatile double_type tmpd;
1181 volatile ld_type tmpld;
1184 volatile long double ld;],
1188 tmpf = ccoshf(tmpf);
1192 tmpf = csinhf(tmpf);
1193 tmpf = csqrtf(tmpf);
1195 tmpf = ctanhf(tmpf);
1196 tmpf = cpowf(tmpf, tmpf);
1197 tmpf = cprojf(tmpf);
1209 tmpd = cpow(tmpd, tmpd);
1213 tmpld = ccosl(tmpld);
1214 tmpld = ccoshl(tmpld);
1215 tmpld = cexpl(tmpld);
1216 tmpld = clogl(tmpld);
1217 tmpld = csinl(tmpld);
1218 tmpld = csinhl(tmpld);
1219 tmpld = csqrtl(tmpld);
1220 tmpld = ctanl(tmpld);
1221 tmpld = ctanhl(tmpld);
1222 tmpld = cpowl(tmpld, tmpld);
1223 tmpld = cprojl(tmpld);
1224 ], [glibcxx_cv_c99_complex_cxx11=yes], [glibcxx_cv_c99_complex_cxx11=no])
1227 AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx11)
1228 if test x"$glibcxx_cv_c99_complex_cxx11" = x"yes"; then
1229 AC_DEFINE(_GLIBCXX11_USE_C99_COMPLEX, 1,
1230 [Define if C99 functions in <complex.h> should be used in
1231 <complex> for C++11. Using compiler builtins for these functions
1232 requires corresponding C99 library functions to be present.])
1235 # Check for the existence in <stdio.h> of vscanf, et. al.
1236 AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++11])
1237 AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx11, [
1238 GCC_TRY_COMPILE_OR_LINK(
1241 void foo(char* fmt, ...)
1243 va_list args; va_start(args, fmt);
1244 vfscanf(stderr, "%i", args);
1246 vsnprintf(fmt, 0, "%i", args);
1247 vsscanf(fmt, "%i", args);
1248 snprintf(fmt, 0, "%i");
1250 [glibcxx_cv_c99_stdio_cxx11=yes], [glibcxx_cv_c99_stdio_cxx11=no])
1252 AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx11)
1253 if test x"$glibcxx_cv_c99_stdio_cxx11" = x"yes"; then
1254 AC_DEFINE(_GLIBCXX11_USE_C99_STDIO, 1,
1255 [Define if C99 functions or macros in <stdio.h> should be imported
1256 in <cstdio> in namespace std for C++11.])
1259 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1260 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++11])
1261 AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx11, [
1262 GCC_TRY_COMPILE_OR_LINK(
1263 [#include <stdlib.h>
1265 volatile long double ld;
1266 volatile unsigned long long ll;
1269 f = strtof("gnu", &tmp);
1270 ld = strtold("gnu", &tmp);
1271 ll = strtoll("gnu", &tmp, 10);
1272 ll = strtoull("gnu", &tmp, 10);
1274 mydivt = lldiv(10,1);
1279 ], [glibcxx_cv_c99_stdlib_cxx11=yes], [glibcxx_cv_c99_stdlib_cxx11=no])
1281 AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx11)
1282 if test x"$glibcxx_cv_c99_stdlib_cxx11" = x"yes"; then
1283 AC_DEFINE(_GLIBCXX11_USE_C99_STDLIB, 1,
1284 [Define if C99 functions or macros in <stdlib.h> should be imported
1285 in <cstdlib> in namespace std for C++11.])
1288 # Check for the existence in <wchar.h> of wcstold, etc.
1289 if test x"$ac_has_wchar_h" = xyes &&
1290 test x"$ac_has_wctype_h" = xyes; then
1291 AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++11])
1292 AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx11, [
1293 AC_TRY_COMPILE([#include <wchar.h>
1300 ], [], [glibcxx_cv_c99_wchar_cxx11=yes], [glibcxx_cv_c99_wchar_cxx11=no])
1303 # Checks for wide character functions that may not be present.
1304 # Injection of these is wrapped with guard macros.
1305 # NB: only put functions here, instead of immediately above, if
1306 # absolutely necessary.
1307 AC_TRY_COMPILE([#include <wchar.h>
1308 namespace test { using ::vfwscanf; }], [],
1309 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1311 AC_TRY_COMPILE([#include <wchar.h>
1312 namespace test { using ::vswscanf; }], [],
1313 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1315 AC_TRY_COMPILE([#include <wchar.h>
1316 namespace test { using ::vwscanf; }], [],
1317 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1319 AC_TRY_COMPILE([#include <wchar.h>
1320 namespace test { using ::wcstof; }], [],
1321 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1323 AC_TRY_COMPILE([#include <wctype.h>],
1324 [wint_t t; int i = iswblank(t);],
1325 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1327 AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx11)
1328 if test x"$glibcxx_cv_c99_wchar_cxx11" = x"yes"; then
1329 AC_DEFINE(_GLIBCXX11_USE_C99_WCHAR, 1,
1330 [Define if C99 functions or macros in <wchar.h> should be imported
1331 in <cwchar> in namespace std for C++11.])
1335 gcc_no_link="$ac_save_gcc_no_link"
1336 LIBS="$ac_save_LIBS"
1337 CXXFLAGS="$ac_save_CXXFLAGS"
1341 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1342 AC_MSG_RESULT($enable_c99)
1347 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1348 dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this]
1349 dnl in the C++11 standard.
1351 dnl --enable-libstdcxx-time
1352 dnl --enable-libstdcxx-time=yes
1353 dnl checks for the availability of monotonic and realtime clocks,
1354 dnl nanosleep and sched_yield in libc and libposix4 and, if needed,
1355 dnl links in the latter.
1356 dnl --enable-libstdcxx-time=rt
1357 dnl also searches (and, if needed, links) librt. Note that this is
1358 dnl not always desirable because, in glibc 2.16 and earlier, for
1359 dnl example, in turn it triggers the linking of libpthread too,
1360 dnl which activates locking,
1361 dnl a large overhead for single-thread programs.
1362 dnl --enable-libstdcxx-time=no
1363 dnl --disable-libstdcxx-time
1364 dnl disables the checks completely
1366 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1367 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1368 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1369 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1371 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1373 GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]],
1374 [use KIND for check type],
1379 ac_save_CXXFLAGS="$CXXFLAGS"
1380 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1381 ac_save_LIBS="$LIBS"
1383 ac_has_clock_monotonic=no
1384 ac_has_clock_realtime=no
1386 ac_has_sched_yield=no
1388 if test x"$enable_libstdcxx_time" = x"auto"; then
1390 case "${target_os}" in
1392 ac_has_nanosleep=yes
1395 ac_has_nanosleep=yes
1396 ac_has_sched_yield=yes
1398 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
1399 AC_MSG_CHECKING([for at least GNU libc 2.17])
1401 [#include <features.h>],
1403 #if ! __GLIBC_PREREQ(2, 17)
1407 [glibcxx_glibc217=yes], [glibcxx_glibc217=no])
1408 AC_MSG_RESULT($glibcxx_glibc217)
1410 if test x"$glibcxx_glibc217" = x"yes"; then
1411 ac_has_clock_monotonic=yes
1412 ac_has_clock_realtime=yes
1414 ac_has_nanosleep=yes
1415 ac_has_sched_yield=yes
1417 freebsd*|netbsd*|dragonfly*|rtems*)
1418 ac_has_clock_monotonic=yes
1419 ac_has_clock_realtime=yes
1420 ac_has_nanosleep=yes
1421 ac_has_sched_yield=yes
1424 ac_has_clock_monotonic=yes
1425 ac_has_clock_realtime=yes
1426 ac_has_nanosleep=yes
1429 GLIBCXX_LIBS="$GLIBCXX_LIBS -lrt"
1430 ac_has_clock_monotonic=yes
1431 ac_has_clock_realtime=yes
1432 ac_has_nanosleep=yes
1433 ac_has_sched_yield=yes
1437 elif test x"$enable_libstdcxx_time" != x"no"; then
1439 if test x"$enable_libstdcxx_time" = x"rt"; then
1440 AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1441 AC_SEARCH_LIBS(nanosleep, [rt posix4])
1443 AC_SEARCH_LIBS(clock_gettime, [posix4])
1444 AC_SEARCH_LIBS(nanosleep, [posix4])
1447 case "$ac_cv_search_clock_gettime" in
1448 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1451 case "$ac_cv_search_nanosleep" in
1452 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1456 AC_SEARCH_LIBS(sched_yield, [rt posix4])
1458 case "$ac_cv_search_sched_yield" in
1460 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1461 ac_has_sched_yield=yes
1464 if test x"$enable_libstdcxx_time" = x"rt"; then
1465 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1466 ac_has_sched_yield=yes
1470 ac_has_sched_yield=yes
1474 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1476 if test x"$ac_has_unistd_h" = x"yes"; then
1477 AC_MSG_CHECKING([for monotonic clock])
1479 [#include <unistd.h>
1482 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1485 clock_gettime(CLOCK_MONOTONIC, &tp);
1486 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1488 AC_MSG_RESULT($ac_has_clock_monotonic)
1490 AC_MSG_CHECKING([for realtime clock])
1492 [#include <unistd.h>
1495 [#if _POSIX_TIMERS > 0
1498 clock_gettime(CLOCK_REALTIME, &tp);
1499 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1501 AC_MSG_RESULT($ac_has_clock_realtime)
1503 AC_MSG_CHECKING([for nanosleep])
1505 [#include <unistd.h>
1508 [#if _POSIX_TIMERS > 0
1512 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1514 AC_MSG_RESULT($ac_has_nanosleep)
1518 if test x"$ac_has_clock_monotonic" != x"yes"; then
1519 case ${target_os} in
1521 AC_MSG_CHECKING([for clock_gettime syscall])
1523 [#include <unistd.h>
1525 #include <sys/syscall.h>
1527 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1530 syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp);
1531 syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp);
1532 ], [ac_has_clock_monotonic_syscall=yes], [ac_has_clock_monotonic_syscall=no])
1533 AC_MSG_RESULT($ac_has_clock_monotonic_syscall)
1534 if test x"$ac_has_clock_monotonic_syscall" = x"yes"; then
1535 AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1,
1536 [ Defined if clock_gettime syscall has monotonic and realtime clock support. ])
1537 ac_has_clock_monotonic=yes
1538 ac_has_clock_realtime=yes
1543 if test x"$ac_has_clock_monotonic" = x"yes"; then
1544 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1545 [ Defined if clock_gettime has monotonic clock support. ])
1548 if test x"$ac_has_clock_realtime" = x"yes"; then
1549 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1550 [ Defined if clock_gettime has realtime clock support. ])
1553 if test x"$ac_has_sched_yield" = x"yes"; then
1554 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1555 [ Defined if sched_yield is available. ])
1558 if test x"$ac_has_nanosleep" = x"yes"; then
1559 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1560 [ Defined if nanosleep is available. ])
1562 AC_MSG_CHECKING([for sleep])
1563 AC_TRY_COMPILE([#include <unistd.h>],
1565 [ac_has_sleep=yes],[ac_has_sleep=no])
1566 if test x"$ac_has_sleep" = x"yes"; then
1567 AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.])
1569 AC_MSG_RESULT($ac_has_sleep)
1570 AC_MSG_CHECKING([for usleep])
1571 AC_TRY_COMPILE([#include <unistd.h>],
1574 [ac_has_usleep=yes],[ac_has_usleep=no])
1575 if test x"$ac_has_usleep" = x"yes"; then
1576 AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.])
1578 AC_MSG_RESULT($ac_has_usleep)
1581 if test x"$ac_has_nanosleep$ac_has_sleep" = x"nono"; then
1582 AC_MSG_CHECKING([for Sleep])
1583 AC_TRY_COMPILE([#include <windows.h>],
1585 [ac_has_win32_sleep=yes],[ac_has_win32_sleep=no])
1586 if test x"$ac_has_win32_sleep" = x"yes"; then
1587 AC_DEFINE(HAVE_WIN32_SLEEP,1, [Defined if Sleep exists.])
1589 AC_MSG_RESULT($ac_has_win32_sleep)
1592 AC_SUBST(GLIBCXX_LIBS)
1594 CXXFLAGS="$ac_save_CXXFLAGS"
1595 LIBS="$ac_save_LIBS"
1600 dnl Check for gettimeofday, used in the implementation of 20.11.7
1601 dnl [time.clock] in the C++11 standard.
1603 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1605 AC_MSG_CHECKING([for gettimeofday])
1609 ac_save_CXXFLAGS="$CXXFLAGS"
1610 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1612 ac_has_gettimeofday=no;
1613 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1614 if test x"$ac_has_sys_time_h" = x"yes"; then
1615 AC_MSG_CHECKING([for gettimeofday])
1616 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1617 [timeval tv; gettimeofday(&tv, 0);],
1618 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1620 AC_MSG_RESULT($ac_has_gettimeofday)
1623 if test x"$ac_has_gettimeofday" = x"yes"; then
1624 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1625 [ Defined if gettimeofday is available. ])
1628 CXXFLAGS="$ac_save_CXXFLAGS"
1633 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1634 dnl facilities in Chapter 8, "C compatibility".
1636 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1641 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1642 # undefined and fake C99 facilities may be spuriously enabled.
1643 ac_save_CXXFLAGS="$CXXFLAGS"
1644 CXXFLAGS="$CXXFLAGS -std=c++98"
1646 # Check for the existence of <complex.h> complex math functions used
1648 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1649 ac_c99_complex_tr1=no;
1650 if test x"$ac_has_complex_h" = x"yes"; then
1651 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1652 AC_TRY_COMPILE([#include <complex.h>],
1653 [typedef __complex__ float float_type; float_type tmpf;
1660 typedef __complex__ double double_type; double_type tmpd;
1667 typedef __complex__ long double ld_type; ld_type tmpld;
1674 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1676 AC_MSG_RESULT($ac_c99_complex_tr1)
1677 if test x"$ac_c99_complex_tr1" = x"yes"; then
1678 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1679 [Define if C99 functions in <complex.h> should be used in
1680 <tr1/complex>. Using compiler builtins for these functions
1681 requires corresponding C99 library functions to be present.])
1684 # Check for the existence of <ctype.h> functions.
1685 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1686 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1687 AC_TRY_COMPILE([#include <ctype.h>],
1691 ],[glibcxx_cv_c99_ctype_tr1=yes],
1692 [glibcxx_cv_c99_ctype_tr1=no])
1694 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1695 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1696 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1697 [Define if C99 functions in <ctype.h> should be imported in
1698 <tr1/cctype> in namespace std::tr1.])
1701 # Check for the existence of <fenv.h> functions.
1702 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1704 if test x"$ac_has_fenv_h" = x"yes"; then
1705 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1706 AC_TRY_COMPILE([#include <fenv.h>],
1711 ret = feclearexcept(except);
1712 ret = fegetexceptflag(pflag, except);
1713 ret = feraiseexcept(except);
1714 ret = fesetexceptflag(pflag, except);
1715 ret = fetestexcept(except);
1717 ret = fesetround(mode);
1718 ret = fegetenv(penv);
1719 ret = feholdexcept(penv);
1720 ret = fesetenv(penv);
1721 ret = feupdateenv(penv);
1722 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1724 AC_MSG_RESULT($ac_c99_fenv_tr1)
1725 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1726 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1727 [Define if C99 functions in <fenv.h> should be imported in
1728 <tr1/cfenv> in namespace std::tr1.])
1731 # Check for the existence of <stdint.h> types.
1732 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1733 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1734 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1735 #define __STDC_CONSTANT_MACROS
1736 #include <stdint.h>],
1737 [typedef int8_t my_int8_t;
1738 my_int8_t i8 = INT8_MIN;
1740 typedef int16_t my_int16_t;
1741 my_int16_t i16 = INT16_MIN;
1743 typedef int32_t my_int32_t;
1744 my_int32_t i32 = INT32_MIN;
1746 typedef int64_t my_int64_t;
1747 my_int64_t i64 = INT64_MIN;
1749 typedef int_fast8_t my_int_fast8_t;
1750 my_int_fast8_t if8 = INT_FAST8_MIN;
1751 if8 = INT_FAST8_MAX;
1752 typedef int_fast16_t my_int_fast16_t;
1753 my_int_fast16_t if16 = INT_FAST16_MIN;
1754 if16 = INT_FAST16_MAX;
1755 typedef int_fast32_t my_int_fast32_t;
1756 my_int_fast32_t if32 = INT_FAST32_MIN;
1757 if32 = INT_FAST32_MAX;
1758 typedef int_fast64_t my_int_fast64_t;
1759 my_int_fast64_t if64 = INT_FAST64_MIN;
1760 if64 = INT_FAST64_MAX;
1761 typedef int_least8_t my_int_least8_t;
1762 my_int_least8_t il8 = INT_LEAST8_MIN;
1763 il8 = INT_LEAST8_MAX;
1764 typedef int_least16_t my_int_least16_t;
1765 my_int_least16_t il16 = INT_LEAST16_MIN;
1766 il16 = INT_LEAST16_MAX;
1767 typedef int_least32_t my_int_least32_t;
1768 my_int_least32_t il32 = INT_LEAST32_MIN;
1769 il32 = INT_LEAST32_MAX;
1770 typedef int_least64_t my_int_least64_t;
1771 my_int_least64_t il64 = INT_LEAST64_MIN;
1772 il64 = INT_LEAST64_MAX;
1773 typedef intmax_t my_intmax_t;
1774 my_intmax_t im = INTMAX_MAX;
1776 typedef intptr_t my_intptr_t;
1777 my_intptr_t ip = INTPTR_MAX;
1779 typedef uint8_t my_uint8_t;
1780 my_uint8_t ui8 = UINT8_MAX;
1782 typedef uint16_t my_uint16_t;
1783 my_uint16_t ui16 = UINT16_MAX;
1785 typedef uint32_t my_uint32_t;
1786 my_uint32_t ui32 = UINT32_MAX;
1788 typedef uint64_t my_uint64_t;
1789 my_uint64_t ui64 = UINT64_MAX;
1791 typedef uint_fast8_t my_uint_fast8_t;
1792 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1793 uif8 = UINT_FAST8_MAX;
1794 typedef uint_fast16_t my_uint_fast16_t;
1795 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1796 uif16 = UINT_FAST16_MAX;
1797 typedef uint_fast32_t my_uint_fast32_t;
1798 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1799 uif32 = UINT_FAST32_MAX;
1800 typedef uint_fast64_t my_uint_fast64_t;
1801 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1802 uif64 = UINT_FAST64_MAX;
1803 typedef uint_least8_t my_uint_least8_t;
1804 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1805 uil8 = UINT_LEAST8_MAX;
1806 typedef uint_least16_t my_uint_least16_t;
1807 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1808 uil16 = UINT_LEAST16_MAX;
1809 typedef uint_least32_t my_uint_least32_t;
1810 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1811 uil32 = UINT_LEAST32_MAX;
1812 typedef uint_least64_t my_uint_least64_t;
1813 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1814 uil64 = UINT_LEAST64_MAX;
1815 typedef uintmax_t my_uintmax_t;
1816 my_uintmax_t uim = UINTMAX_MAX;
1818 typedef uintptr_t my_uintptr_t;
1819 my_uintptr_t uip = UINTPTR_MAX;
1821 ],[glibcxx_cv_c99_stdint_tr1=yes],
1822 [glibcxx_cv_c99_stdint_tr1=no])
1824 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1825 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1826 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1827 [Define if C99 types in <stdint.h> should be imported in
1828 <tr1/cstdint> in namespace std::tr1.])
1831 # Check for the existence of <math.h> functions.
1832 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1833 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1834 AC_TRY_COMPILE([#include <math.h>],
1835 [typedef double_t my_double_t;
1836 typedef float_t my_float_t;
1850 copysignf(0.0f, 0.0f);
1851 copysignl(0.0l, 0.0l);
1868 fmaf(0.0f, 0.0f, 0.0f);
1869 fmal(0.0l, 0.0l, 0.0l);
1885 #ifndef __APPLE__ /* see below */
1914 nextafter(0.0, 0.0);
1915 nextafterf(0.0f, 0.0f);
1916 nextafterl(0.0l, 0.0l);
1917 nexttoward(0.0, 0.0);
1918 nexttowardf(0.0f, 0.0f);
1919 nexttowardl(0.0l, 0.0l);
1920 remainder(0.0, 0.0);
1921 remainderf(0.0f, 0.0f);
1922 remainderl(0.0l, 0.0l);
1923 remquo(0.0, 0.0, 0);
1924 remquof(0.0f, 0.0f, 0);
1925 remquol(0.0l, 0.0l, 0);
1944 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1946 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1947 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1948 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1949 [Define if C99 functions or macros in <math.h> should be imported
1950 in <tr1/cmath> in namespace std::tr1.])
1952 case "${target_os}" in
1954 AC_MSG_CHECKING([for ISO C99 rounding functions in <math.h>])
1955 AC_CACHE_VAL(glibcxx_cv_c99_math_llround, [
1956 AC_TRY_COMPILE([#include <math.h>],
1964 [glibcxx_cv_c99_math_llround=yes],
1965 [glibcxx_cv_c99_math_llround=no])
1967 AC_MSG_RESULT($glibcxx_cv_c99_math_llround)
1970 if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
1971 AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
1972 [Define if C99 llrint and llround functions are missing from <math.h>.])
1976 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1977 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1978 ac_c99_inttypes_tr1=no;
1979 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1980 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1981 AC_TRY_COMPILE([#include <inttypes.h>],
1982 [intmax_t i, numer, denom, base;
1985 intmax_t ret = imaxabs(i);
1986 imaxdiv_t dret = imaxdiv(numer, denom);
1987 ret = strtoimax(s, endptr, base);
1988 uintmax_t uret = strtoumax(s, endptr, base);
1989 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1991 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1992 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1993 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1994 [Define if C99 functions in <inttypes.h> should be imported in
1995 <tr1/cinttypes> in namespace std::tr1.])
1998 # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
1999 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
2000 ac_c99_inttypes_wchar_t_tr1=no;
2001 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2002 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
2003 AC_TRY_COMPILE([#include <inttypes.h>],
2007 intmax_t ret = wcstoimax(s, endptr, base);
2008 uintmax_t uret = wcstoumax(s, endptr, base);
2009 ],[ac_c99_inttypes_wchar_t_tr1=yes],
2010 [ac_c99_inttypes_wchar_t_tr1=no])
2012 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
2013 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
2014 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
2015 [Define if wchar_t C99 functions in <inttypes.h> should be
2016 imported in <tr1/cinttypes> in namespace std::tr1.])
2019 # Check for the existence of the <stdbool.h> header.
2020 AC_CHECK_HEADERS(stdbool.h)
2022 # Check for the existence of the <stdalign.h> header.
2023 AC_CHECK_HEADERS(stdalign.h)
2025 CXXFLAGS="$ac_save_CXXFLAGS"
2030 dnl Check for uchar.h and usability.
2032 AC_DEFUN([GLIBCXX_CHECK_UCHAR_H], [
2035 AC_CHECK_HEADERS(uchar.h, ac_has_uchar_h=yes, ac_has_uchar_h=no)
2039 ac_save_CXXFLAGS="$CXXFLAGS"
2040 CXXFLAGS="$CXXFLAGS -std=c++11"
2042 if test x"$ac_has_uchar_h" = x"yes"; then
2043 AC_MSG_CHECKING([for ISO C11 support for <uchar.h>])
2044 AC_TRY_COMPILE([#include <uchar.h>
2045 #ifdef __STDC_UTF_16__
2046 long i = __STDC_UTF_16__;
2048 #ifdef __STDC_UTF_32__
2049 long j = __STDC_UTF_32__;
2059 [], [ac_c11_uchar_cxx11=yes], [ac_c11_uchar_cxx11=no])
2061 ac_c11_uchar_cxx11=no
2063 AC_MSG_RESULT($ac_c11_uchar_cxx11)
2064 if test x"$ac_c11_uchar_cxx11" = x"yes"; then
2065 AC_DEFINE(_GLIBCXX_USE_C11_UCHAR_CXX11, 1,
2066 [Define if C11 functions in <uchar.h> should be imported into
2067 namespace std in <cuchar>.])
2070 CXXFLAGS="$ac_save_CXXFLAGS"
2076 dnl Check whether "/dev/random" and "/dev/urandom" are available for
2077 dnl class std::random_device from C++ 2011 [rand.device], and
2078 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
2080 AC_DEFUN([GLIBCXX_CHECK_DEV_RANDOM], [
2082 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for std::random_device])
2083 AC_CACHE_VAL(glibcxx_cv_dev_random, [
2084 if test -r /dev/random && test -r /dev/urandom; then
2085 ## For MSys environment the test above is detected as false-positive
2086 ## on mingw-targets. So disable it explicitly for them.
2087 case ${target_os} in
2088 *mingw*) glibcxx_cv_dev_random=no ;;
2089 *) glibcxx_cv_dev_random=yes ;;
2092 glibcxx_cv_dev_random=no;
2095 AC_MSG_RESULT($glibcxx_cv_dev_random)
2097 if test x"$glibcxx_cv_dev_random" = x"yes"; then
2098 AC_DEFINE(_GLIBCXX_USE_DEV_RANDOM, 1,
2099 [Define if /dev/random and /dev/urandom are available for
2100 std::random_device.])
2101 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
2102 [Define if /dev/random and /dev/urandom are available for
2103 the random_device of TR1 (Chapter 5.1).])
2109 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
2111 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
2113 AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
2114 AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
2115 [#include <stdio.h>],
2116 [AC_MSG_ERROR([computing EOF failed])])
2118 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
2119 [Define to the value of the EOF integer constant.])
2121 AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
2122 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
2123 [#include <stdio.h>],
2124 [AC_MSG_ERROR([computing SEEK_CUR failed])])
2126 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
2127 [Define to the value of the SEEK_CUR integer constant.])
2129 AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
2130 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
2131 [#include <stdio.h>],
2132 [AC_MSG_ERROR([computing SEEK_END failed])])
2134 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
2135 [Define to the value of the SEEK_END integer constant.])
2139 dnl Check whether required C++ overloads are present in <stdio.h>.
2141 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
2145 # Use C++11 because a conforming <stdio.h> won't define gets for C++14,
2146 # and we don't need a declaration for C++14 anyway.
2147 ac_save_CXXFLAGS="$CXXFLAGS"
2148 CXXFLAGS="$CXXFLAGS -std=gnu++11"
2150 AC_MSG_CHECKING([for gets declaration])
2151 AC_CACHE_VAL(glibcxx_cv_gets, [
2152 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2159 [glibcxx_cv_gets=yes],
2160 [glibcxx_cv_gets=no]
2163 if test $glibcxx_cv_gets = yes; then
2164 AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h> before C++14.])
2166 AC_MSG_RESULT($glibcxx_cv_gets)
2168 CXXFLAGS="$ac_save_CXXFLAGS"
2173 dnl Check whether required C++11 overloads for floating point and integral
2174 dnl types are present in <math.h>.
2176 AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
2180 ac_save_CXXFLAGS="$CXXFLAGS"
2181 CXXFLAGS="$CXXFLAGS -std=c++11"
2185 # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
2186 # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
2187 AC_MSG_CHECKING([for C++11 <math.h> floating point overloads])
2188 AC_CACHE_VAL(glibcxx_cv_math11_fp_overload, [
2189 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2193 inline bool isfinite(float __x)
2194 { return __builtin_isfinite(__x); }
2197 [glibcxx_cv_math11_fp_overload=no],
2198 [glibcxx_cv_math11_fp_overload=yes]
2201 # autoheader cannot handle indented templates.
2202 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP],
2203 [/* Define if all C++11 floating point overloads are available in <math.h>. */
2204 #if __cplusplus >= 201103L
2205 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2208 if test $glibcxx_cv_math11_fp_overload = yes; then
2209 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP)
2211 AC_MSG_RESULT([$glibcxx_cv_math11_fp_overload])
2213 # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
2214 # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
2215 AC_MSG_CHECKING([for C++11 <math.h> integral type overloads])
2216 AC_CACHE_VAL(glibcxx_cv_math11_int_overload, [
2217 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2220 template<typename _Tp>
2221 struct __is_integer;
2223 struct __is_integer<int>
2225 enum { __value = 1 };
2228 namespace __gnu_cxx {
2229 template<bool, typename>
2231 template<typename _Tp>
2232 struct __enable_if<true, _Tp>
2233 { typedef _Tp __type; };
2236 template<typename _Tp>
2237 constexpr typename __gnu_cxx::__enable_if
2238 <__is_integer<_Tp>::__value, double>::__type
2240 { return __builtin_log2(__x); }
2246 return std::log2(i);
2249 [glibcxx_cv_math11_int_overload=no],
2250 [glibcxx_cv_math11_int_overload=yes]
2253 # autoheader cannot handle indented templates.
2254 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT],
2255 [/* Define if all C++11 integral type overloads are available in <math.h>. */
2256 #if __cplusplus >= 201103L
2257 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2260 if test $glibcxx_cv_math11_int_overload = yes; then
2261 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT)
2263 AC_MSG_RESULT([$glibcxx_cv_math11_int_overload])
2266 # If <math.h> defines the obsolete isinf(double) and isnan(double)
2267 # functions (instead of or as well as the C99 generic macros) then we
2268 # can't define std::isinf(double) and std::isnan(double) in <cmath>
2269 # and must use the ones from <math.h> instead.
2270 AC_MSG_CHECKING([for obsolete isinf function in <math.h>])
2271 AC_CACHE_VAL(glibcxx_cv_obsolete_isinf, [
2272 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2273 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2279 bool isinf(long double);
2282 bool b = isinf(0.0);
2284 [glibcxx_cv_obsolete_isinf=yes],
2285 [glibcxx_cv_obsolete_isinf=no]
2287 AC_MSG_RESULT([$glibcxx_cv_obsolete_isinf])
2288 if test $glibcxx_cv_obsolete_isinf = yes; then
2289 AC_DEFINE(HAVE_OBSOLETE_ISINF, 1,
2290 [Define if <math.h> defines obsolete isinf function.])
2293 AC_MSG_CHECKING([for obsolete isnan function in <math.h>])
2294 AC_CACHE_VAL(glibcxx_cv_obsolete_isnan, [
2295 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2296 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2302 bool isnan(long double);
2305 bool b = isnan(0.0);
2307 [glibcxx_cv_obsolete_isnan=yes],
2308 [glibcxx_cv_obsolete_isnan=no]
2310 AC_MSG_RESULT([$glibcxx_cv_obsolete_isnan])
2311 if test $glibcxx_cv_obsolete_isnan = yes; then
2312 AC_DEFINE(HAVE_OBSOLETE_ISNAN, 1,
2313 [Define if <math.h> defines obsolete isnan function.])
2318 CXXFLAGS="$ac_save_CXXFLAGS"
2323 dnl Check whether macros, etc are present for <system_error>
2325 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
2327 m4_pushdef([n_syserr], [1])dnl
2328 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
2329 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
2330 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
2331 ECHILD, ENOSPC, EPERM,
2332 ETIMEDOUT, EWOULDBLOCK],
2333 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
2334 AC_MSG_CHECKING([for syserr])
2335 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
2336 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
2337 [int i = syserr;])],
2338 [glibcxx_cv_system_error[]n_syserr=yes],
2339 [glibcxx_cv_system_error[]n_syserr=no])
2341 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
2342 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
2343 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
2345 m4_define([n_syserr], m4_incr(n_syserr))dnl
2346 m4_popdef([SYSERR])dnl
2348 m4_popdef([n_syserr])dnl
2352 dnl Check for what type of C headers to use.
2354 dnl --enable-cheaders= [does stuff].
2355 dnl --disable-cheaders [does not do anything, really].
2356 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
2357 dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
2359 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
2360 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
2361 [construct "C" headers for g++], [permit c|c_std|c_global])
2362 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
2364 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
2366 # Allow overrides to configure.host here.
2367 if test $enable_cheaders = c_global; then
2371 AC_SUBST(C_INCLUDE_DIR)
2372 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
2373 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
2374 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
2375 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
2380 dnl Check for which locale library to use. The choice is mapped to
2381 dnl a subdirectory of config/locale.
2383 dnl Default is generic.
2385 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
2386 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
2387 [use MODEL for target locale package],
2388 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
2390 # Deal with gettext issues. Default to not using it (=no) until we detect
2391 # support for it later. Let the user turn it off via --e/d, but let that
2392 # default to on for easier handling.
2395 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
2399 # Either a known package, or "auto"
2400 if test $enable_clocale = no || test $enable_clocale = yes; then
2403 enable_clocale_flag=$enable_clocale
2405 # Probe for locale model to use if none specified.
2406 # Default to "generic".
2407 if test $enable_clocale_flag = auto; then
2408 case ${target_os} in
2409 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2410 enable_clocale_flag=gnu
2413 enable_clocale_flag=darwin
2415 dragonfly* | freebsd*)
2416 enable_clocale_flag=dragonfly
2419 enable_clocale_flag=newlib
2422 if test x"$with_newlib" = x"yes"; then
2423 enable_clocale_flag=newlib
2425 enable_clocale_flag=generic
2431 # Sanity check model, and test for special functionality.
2432 if test $enable_clocale_flag = gnu; then
2433 AC_EGREP_CPP([_GLIBCXX_ok], [
2434 #include <features.h>
2435 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
2438 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
2440 # Set it to scream when it hurts.
2441 ac_save_CFLAGS="$CFLAGS"
2442 CFLAGS="-Wimplicit-function-declaration -Werror"
2444 # Use strxfrm_l if available.
2445 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2447 #include <locale.h>],
2448 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
2449 AC_DEFINE(HAVE_STRXFRM_L, 1,
2450 [Define if strxfrm_l is available in <string.h>.]),)
2452 # Use strerror_l if available.
2453 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2455 #include <locale.h>],
2456 [__locale_t loc; strerror_l(5, loc);],
2457 AC_DEFINE(HAVE_STRERROR_L, 1,
2458 [Define if strerror_l is available in <string.h>.]),)
2460 CFLAGS="$ac_save_CFLAGS"
2463 # Perhaps use strerror_r if available, and strerror_l isn't.
2464 ac_save_CFLAGS="$CFLAGS"
2465 CFLAGS="-Wimplicit-function-declaration -Werror"
2466 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2468 #include <locale.h>],
2469 [char s[128]; strerror_r(5, s, 128);],
2470 AC_DEFINE(HAVE_STRERROR_R, 1,
2471 [Define if strerror_r is available in <string.h>.]),)
2472 CFLAGS="$ac_save_CFLAGS"
2474 # Set configure bits for specified locale package
2475 AC_MSG_CHECKING([for C locale to use])
2476 case ${enable_clocale_flag} in
2478 AC_MSG_RESULT(generic)
2480 CLOCALE_H=config/locale/generic/c_locale.h
2481 CLOCALE_CC=config/locale/generic/c_locale.cc
2482 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2483 CCOLLATE_CC=config/locale/generic/collate_members.cc
2484 CCTYPE_CC=config/locale/generic/ctype_members.cc
2485 CMESSAGES_H=config/locale/generic/messages_members.h
2486 CMESSAGES_CC=config/locale/generic/messages_members.cc
2487 CMONEY_CC=config/locale/generic/monetary_members.cc
2488 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2489 CTIME_H=config/locale/generic/time_members.h
2490 CTIME_CC=config/locale/generic/time_members.cc
2491 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2494 AC_MSG_RESULT(darwin)
2496 CLOCALE_H=config/locale/generic/c_locale.h
2497 CLOCALE_CC=config/locale/generic/c_locale.cc
2498 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2499 CCOLLATE_CC=config/locale/generic/collate_members.cc
2500 CCTYPE_CC=config/locale/darwin/ctype_members.cc
2501 CMESSAGES_H=config/locale/generic/messages_members.h
2502 CMESSAGES_CC=config/locale/generic/messages_members.cc
2503 CMONEY_CC=config/locale/generic/monetary_members.cc
2504 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2505 CTIME_H=config/locale/generic/time_members.h
2506 CTIME_CC=config/locale/generic/time_members.cc
2507 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2511 AC_MSG_RESULT(dragonfly or freebsd)
2513 CLOCALE_H=config/locale/dragonfly/c_locale.h
2514 CLOCALE_CC=config/locale/dragonfly/c_locale.cc
2515 CCODECVT_CC=config/locale/dragonfly/codecvt_members.cc
2516 CCOLLATE_CC=config/locale/dragonfly/collate_members.cc
2517 CCTYPE_CC=config/locale/dragonfly/ctype_members.cc
2518 CMESSAGES_H=config/locale/generic/messages_members.h
2519 CMESSAGES_CC=config/locale/generic/messages_members.cc
2520 CMONEY_CC=config/locale/dragonfly/monetary_members.cc
2521 CNUMERIC_CC=config/locale/dragonfly/numeric_members.cc
2522 CTIME_H=config/locale/dragonfly/time_members.h
2523 CTIME_CC=config/locale/dragonfly/time_members.cc
2524 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2530 # Declare intention to use gettext, and add support for specific
2532 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2535 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2536 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2537 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2540 # Export the build objects.
2541 for ling in $ALL_LINGUAS; do \
2542 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2543 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2545 AC_SUBST(glibcxx_MOFILES)
2546 AC_SUBST(glibcxx_POFILES)
2548 CLOCALE_H=config/locale/gnu/c_locale.h
2549 CLOCALE_CC=config/locale/gnu/c_locale.cc
2550 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2551 CCOLLATE_CC=config/locale/gnu/collate_members.cc
2552 CCTYPE_CC=config/locale/gnu/ctype_members.cc
2553 CMESSAGES_H=config/locale/gnu/messages_members.h
2554 CMESSAGES_CC=config/locale/gnu/messages_members.cc
2555 CMONEY_CC=config/locale/gnu/monetary_members.cc
2556 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2557 CTIME_H=config/locale/gnu/time_members.h
2558 CTIME_CC=config/locale/gnu/time_members.cc
2559 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2562 AC_MSG_RESULT(IEEE 1003.1)
2564 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2565 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2566 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2567 CCOLLATE_CC=config/locale/generic/collate_members.cc
2568 CCTYPE_CC=config/locale/generic/ctype_members.cc
2569 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2570 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2571 CMONEY_CC=config/locale/generic/monetary_members.cc
2572 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2573 CTIME_H=config/locale/generic/time_members.h
2574 CTIME_CC=config/locale/generic/time_members.cc
2575 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2578 AC_MSG_RESULT(newlib)
2580 CLOCALE_H=config/locale/generic/c_locale.h
2581 CLOCALE_CC=config/locale/generic/c_locale.cc
2582 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2583 CCOLLATE_CC=config/locale/generic/collate_members.cc
2584 CCTYPE_CC=config/locale/newlib/ctype_members.cc
2585 CMESSAGES_H=config/locale/generic/messages_members.h
2586 CMESSAGES_CC=config/locale/generic/messages_members.cc
2587 CMONEY_CC=config/locale/generic/monetary_members.cc
2588 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2589 CTIME_H=config/locale/generic/time_members.h
2590 CTIME_CC=config/locale/generic/time_members.cc
2591 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2595 # This is where the testsuite looks for locale catalogs, using the
2596 # -DLOCALEDIR define during testsuite compilation.
2597 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2598 AC_SUBST(glibcxx_localedir)
2600 # A standalone libintl (e.g., GNU libintl) may be in use.
2601 if test $USE_NLS = yes; then
2602 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2603 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2605 if test $USE_NLS = yes; then
2606 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2607 [Define if NLS translations are to be used.])
2612 AC_SUBST(CMESSAGES_H)
2613 AC_SUBST(CCODECVT_CC)
2614 AC_SUBST(CCOLLATE_CC)
2616 AC_SUBST(CMESSAGES_CC)
2618 AC_SUBST(CNUMERIC_CC)
2621 AC_SUBST(CLOCALE_CC)
2622 AC_SUBST(CLOCALE_INTERNAL_H)
2627 dnl Check for which std::allocator base class to use. The choice is
2628 dnl mapped from a subdirectory of include/ext.
2632 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2633 AC_MSG_CHECKING([for std::allocator base class])
2634 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2635 [use KIND for target std::allocator base],
2636 [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2638 # If they didn't use this option switch, or if they specified --enable
2639 # with no specific model, we'll have to look for one. If they
2640 # specified --disable (???), do likewise.
2641 if test $enable_libstdcxx_allocator = no ||
2642 test $enable_libstdcxx_allocator = yes;
2644 enable_libstdcxx_allocator=auto
2647 # Either a known package, or "auto". Auto implies the default choice
2648 # for a particular platform.
2649 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2651 # Probe for host-specific support if no specific model is specified.
2653 if test $enable_libstdcxx_allocator_flag = auto; then
2654 case ${target_os} in
2655 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2656 enable_libstdcxx_allocator_flag=new
2659 enable_libstdcxx_allocator_flag=new
2663 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2666 # Set configure bits for specified locale package
2667 case ${enable_libstdcxx_allocator_flag} in
2669 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2670 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2673 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2674 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2677 ALLOCATOR_H=config/allocator/mt_allocator_base.h
2678 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2681 ALLOCATOR_H=config/allocator/new_allocator_base.h
2682 ALLOCATOR_NAME=__gnu_cxx::new_allocator
2685 ALLOCATOR_H=config/allocator/pool_allocator_base.h
2686 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2690 GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
2691 test $enable_libstdcxx_allocator_flag = new)
2692 AC_SUBST(ALLOCATOR_H)
2693 AC_SUBST(ALLOCATOR_NAME)
2698 dnl Check for whether the Boost-derived checks should be turned on.
2700 dnl --enable-concept-checks turns them on.
2701 dnl --disable-concept-checks leaves them off.
2702 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2703 dnl Where DEFAULT is either `yes' or `no'.
2705 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2706 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2707 if test $enable_concept_checks = yes; then
2708 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2709 [Define to use concept checking code from the boost libraries.])
2714 dnl Use extern templates.
2716 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2717 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2719 dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2720 dnl Where DEFAULT is `yes' or `no'.
2722 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2724 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2726 AC_MSG_CHECKING([for extern template support])
2727 AC_MSG_RESULT([$enable_extern_template])
2729 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2733 dnl Use vtable verification.
2735 dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1
2736 dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0
2738 dnl + Usage: GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)]
2739 dnl Where DEFAULT is `yes' or `no'.
2741 AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [
2743 GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify])
2745 AC_MSG_CHECKING([for vtable verify support])
2746 AC_MSG_RESULT([$enable_vtable_verify])
2749 if test $enable_vtable_verify = yes; then
2750 case ${target_os} in
2752 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2753 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2757 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u,_vtable_map_vars_start -Wl,-u,_vtable_map_vars_end"
2758 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-rpath,${toplevel_builddir}/libvtv/.libs"
2761 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2762 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-R -Wl,${toplevel_builddir}/libvtv/.libs"
2765 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2766 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2769 VTV_PCH_CXXFLAGS="-fvtable-verify=std"
2776 AC_SUBST(VTV_CXXFLAGS)
2777 AC_SUBST(VTV_PCH_CXXFLAGS)
2778 AC_SUBST(VTV_CXXLINKFLAGS)
2779 AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes)
2780 GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes)
2784 dnl Check for parallel mode pre-requisites, including OpenMP support.
2786 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
2788 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2792 # See if configured libgomp/omp.h exists. (libgomp may be in
2793 # noconfigdirs but not explicitly disabled.)
2794 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2795 enable_parallel=yes;
2797 AC_MSG_NOTICE([target-libgomp not built])
2800 AC_MSG_CHECKING([for parallel mode support])
2801 AC_MSG_RESULT([$enable_parallel])
2806 dnl Check for which I/O library to use: stdio, or something specific.
2808 dnl Default is stdio.
2810 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2811 AC_MSG_CHECKING([for underlying I/O to use])
2812 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2813 [use target-specific I/O package], [permit stdio])
2815 # Now that libio has been removed, you can have any color you want as long
2816 # as it's black. This is one big no-op until other packages are added, but
2817 # showing the framework never hurts.
2818 case ${enable_cstdio} in
2820 CSTDIO_H=config/io/c_io_stdio.h
2821 BASIC_FILE_H=config/io/basic_file_stdio.h
2822 BASIC_FILE_CC=config/io/basic_file_stdio.cc
2823 AC_MSG_RESULT(stdio)
2828 AC_SUBST(BASIC_FILE_H)
2829 AC_SUBST(BASIC_FILE_CC)
2834 dnl Check for "unusual" flags to pass to the compiler while building.
2836 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2837 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2838 dnl --disable-cxx-flags passes nothing.
2839 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2840 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2841 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2842 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2843 dnl If "default flags" is an empty string, the effect is the same
2844 dnl as --disable or --enable=no.
2846 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2847 AC_MSG_CHECKING([for extra compiler flags for building])
2848 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2849 [pass compiler FLAGS when building library],
2850 [case "x$enable_cxx_flags" in
2851 xno | x) enable_cxx_flags= ;;
2853 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2856 # Run through flags (either default or command-line) and set anything
2857 # extra (e.g., #defines) that must accompany particular g++ options.
2858 if test -n "$enable_cxx_flags"; then
2859 for f in $enable_cxx_flags; do
2863 *) # and we're trying to pass /what/ exactly?
2864 AC_MSG_ERROR([compiler flags start with a -]) ;;
2869 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2870 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2871 AC_SUBST(EXTRA_CXX_FLAGS)
2876 dnl Check to see if debugging libraries are to be built.
2878 dnl --enable-libstdcxx-debug
2879 dnl builds a separate set of debugging libraries in addition to the
2880 dnl normal (shared, static) libstdc++ binaries.
2882 dnl --disable-libstdcxx-debug
2883 dnl builds only one (non-debug) version of libstdc++.
2885 dnl --enable-libstdcxx-debug-flags=FLAGS
2886 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2888 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2889 dnl Where DEFAULT is either `yes' or `no'.
2891 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2892 AC_MSG_CHECKING([for additional debug build])
2893 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2894 AC_MSG_RESULT($enable_libstdcxx_debug)
2895 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2900 dnl Check for explicit debug flags.
2902 dnl --enable-libstdcxx-debug-flags='-O1'
2903 dnl is a general method for passing flags to be used when
2904 dnl building debug libraries with --enable-libstdcxx-debug.
2906 dnl --disable-libstdcxx-debug-flags does nothing.
2907 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2908 dnl If "default flags" is an empty string, the effect is the same
2909 dnl as --disable or --enable=no.
2911 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2912 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2913 [pass compiler FLAGS when building debug library],
2914 [case "x$enable_libstdcxx_debug_flags" in
2915 xno | x) enable_libstdcxx_debug_flags= ;;
2917 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2920 # Option parsed, now set things appropriately
2921 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2922 AC_SUBST(DEBUG_FLAGS)
2924 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2929 dnl Check if the user only wants a freestanding library implementation.
2931 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2932 dnl installing only the headers required by [17.4.1.3] and the language
2933 dnl support library. More than that will be built (to keep the Makefiles
2934 dnl conveniently clean), but not installed.
2937 dnl is_hosted (yes/no)
2940 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
2942 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2943 AC_ARG_ENABLE([hosted-libstdcxx],
2944 AC_HELP_STRING([--disable-hosted-libstdcxx],
2945 [only build freestanding C++ runtime support]),,
2948 enable_hosted_libstdcxx=no
2951 enable_hosted_libstdcxx=yes
2954 if test "$enable_hosted_libstdcxx" = no; then
2955 AC_MSG_NOTICE([Only freestanding libraries will be built])
2959 enable_libstdcxx_pch=no
2964 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2965 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2966 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2971 dnl Check if the user wants a non-verbose library implementation.
2973 dnl --disable-libstdcxx-verbose will turn off descriptive messages to
2974 dnl standard error on termination.
2977 dnl _GLIBCXX_VERBOSE (always defined, either to 1 or 0)
2979 AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [
2980 AC_ARG_ENABLE([libstdcxx-verbose],
2981 AC_HELP_STRING([--disable-libstdcxx-verbose],
2982 [disable termination messages to standard error]),,
2983 [enable_libstdcxx_verbose=yes])
2984 if test x"$enable_libstdcxx_verbose" = xyes; then
2987 AC_MSG_NOTICE([verbose termination messages are disabled])
2990 AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define,
2991 [Define to 1 if a verbose library is built, or 0 otherwise.])
2996 dnl Check for template specializations for the 'long long' type.
2997 dnl The result determines only whether 'long long' I/O is enabled; things
2998 dnl like numeric_limits<> specializations are always available.
3000 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
3001 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
3002 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
3003 dnl Where DEFAULT is either `yes' or `no'.
3005 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
3006 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
3007 if test $enable_long_long = yes; then
3008 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
3009 [Define if code specialized for long long should be used.])
3011 AC_MSG_CHECKING([for enabled long long specializations])
3012 AC_MSG_RESULT([$enable_long_long])
3017 dnl Check for decimal floating point.
3019 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
3021 dnl This checks to see if the host supports decimal floating point types.
3024 dnl _GLIBCXX_USE_DECIMAL_FLOAT
3026 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
3028 # Fake what AC_TRY_COMPILE does, without linking as this is
3029 # unnecessary for this test.
3031 cat > conftest.$ac_ext << EOF
3032 [#]line __oline__ "configure"
3042 AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
3043 if AC_TRY_EVAL(ac_compile); then
3044 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
3045 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
3050 AC_MSG_RESULT($enable_dfp)
3055 dnl Check for GNU 128-bit integer and floating point types.
3057 dnl Note: also checks that the types aren't standard types.
3060 dnl _GLIBCXX_USE_INT128
3063 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
3068 # Fake what AC_TRY_COMPILE does, without linking as this is
3069 # unnecessary for this test.
3071 cat > conftest.$ac_ext << EOF
3072 [#]line __oline__ "configure"
3073 template<typename T1, typename T2>
3075 { typedef T2 type; };
3077 template<typename T>
3082 typename same<long, __int128>::type i1;
3083 typename same<long long, __int128>::type i2;
3087 AC_MSG_CHECKING([for __int128])
3088 if AC_TRY_EVAL(ac_compile); then
3089 AC_DEFINE(_GLIBCXX_USE_INT128, 1,
3090 [Define if __int128 is supported on this host.])
3095 AC_MSG_RESULT($enable_int128)
3098 cat > conftest.$ac_ext << EOF
3099 [#]line __oline__ "configure"
3100 template<typename T1, typename T2>
3102 { typedef T2 type; };
3104 template<typename T>
3109 typename same<double, __float128>::type f1;
3110 typename same<long double, __float128>::type f2;
3114 AC_MSG_CHECKING([for __float128])
3115 if AC_TRY_EVAL(ac_compile); then
3120 AC_MSG_RESULT($enable_float128)
3121 GLIBCXX_CONDITIONAL(ENABLE_FLOAT128, test $enable_float128 = yes)
3128 dnl Check for template specializations for the 'wchar_t' type.
3130 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
3131 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
3132 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
3133 dnl Where DEFAULT is either `yes' or `no'.
3135 dnl Necessary support must also be present.
3137 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
3138 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
3140 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
3141 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
3142 AC_MSG_CHECKING([for mbstate_t])
3143 AC_TRY_COMPILE([#include <wchar.h>],
3144 [mbstate_t teststate;],
3145 have_mbstate_t=yes, have_mbstate_t=no)
3146 AC_MSG_RESULT($have_mbstate_t)
3147 if test x"$have_mbstate_t" = xyes; then
3148 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
3151 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
3153 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
3155 if test x"$enable_wchar_t" = x"yes"; then
3160 if test x"$ac_has_wchar_h" = xyes &&
3161 test x"$ac_has_wctype_h" = xyes; then
3162 AC_TRY_COMPILE([#include <wchar.h>
3223 ],[],[], [enable_wchar_t=no])
3231 if test x"$enable_wchar_t" = x"yes"; then
3232 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
3233 [Define if code specialized for wchar_t should be used.])
3236 AC_MSG_CHECKING([for enabled wchar_t specializations])
3237 AC_MSG_RESULT([$enable_wchar_t])
3242 dnl Check to see if building and using a C++ precompiled header can be done.
3244 dnl --enable-libstdcxx-pch=yes
3245 dnl default, this shows intent to use stdc++.h.gch If it looks like it
3246 dnl may work, after some light-hearted attempts to puzzle out compiler
3247 dnl support, flip bits on in include/Makefile.am
3249 dnl --disable-libstdcxx-pch
3250 dnl turns off attempts to use or build stdc++.h.gch.
3253 dnl glibcxx_PCHFLAGS
3255 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
3256 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
3257 if test $enable_libstdcxx_pch = yes; then
3258 AC_CACHE_CHECK([for compiler with PCH support],
3259 [glibcxx_cv_prog_CXX_pch],
3260 [ac_save_CXXFLAGS="$CXXFLAGS"
3261 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
3264 echo '#include <math.h>' > conftest.h
3265 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
3266 -o conftest.h.gch 1>&5 2>&1 &&
3267 echo '#error "pch failed"' > conftest.h &&
3268 echo '#include "conftest.h"' > conftest.cc &&
3269 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
3271 glibcxx_cv_prog_CXX_pch=yes
3273 glibcxx_cv_prog_CXX_pch=no
3276 CXXFLAGS=$ac_save_CXXFLAGS
3279 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
3282 AC_MSG_CHECKING([for enabled PCH])
3283 AC_MSG_RESULT([$enable_libstdcxx_pch])
3285 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
3286 if test $enable_libstdcxx_pch = yes; then
3287 glibcxx_PCHFLAGS="-include bits/stdc++.h"
3291 AC_SUBST(glibcxx_PCHFLAGS)
3296 dnl Check for atomic builtins.
3298 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
3300 dnl This checks to see if the host supports the compiler-generated
3301 dnl builtins for atomic operations for various integral sizes. Note, this
3302 dnl is intended to be an all-or-nothing switch, so all the atomic operations
3303 dnl that are used should be checked.
3306 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
3308 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
3311 old_CXXFLAGS="$CXXFLAGS"
3313 # Do link tests if possible, instead asm tests, limited to some platforms
3314 # see discussion in PR target/40134, PR libstdc++/40133 and the thread
3315 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
3316 atomic_builtins_link_tests=no
3317 if test x$gcc_no_link != xyes; then
3318 # Can do link tests. Limit to some tested platforms
3320 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
3321 atomic_builtins_link_tests=yes
3326 if test x$atomic_builtins_link_tests = xyes; then
3330 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3332 AC_MSG_CHECKING([for atomic builtins for bool])
3333 AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
3336 [typedef bool atomic_type;
3340 // N.B. __atomic_fetch_add is not supported for bool.
3341 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3343 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3344 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3346 [glibcxx_cv_atomic_bool=yes],
3347 [glibcxx_cv_atomic_bool=no])
3349 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3351 AC_MSG_CHECKING([for atomic builtins for short])
3352 AC_CACHE_VAL(glibcxx_cv_atomic_short, [
3355 [typedef short atomic_type;
3359 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3360 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3362 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3363 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3365 [glibcxx_cv_atomic_short=yes],
3366 [glibcxx_cv_atomic_short=no])
3368 AC_MSG_RESULT($glibcxx_cv_atomic_short)
3370 AC_MSG_CHECKING([for atomic builtins for int])
3371 AC_CACHE_VAL(glibcxx_cv_atomic_int, [
3374 [typedef int atomic_type;
3378 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3379 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3381 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3382 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3384 [glibcxx_cv_atomic_int=yes],
3385 [glibcxx_cv_atomic_int=no])
3387 AC_MSG_RESULT($glibcxx_cv_atomic_int)
3389 AC_MSG_CHECKING([for atomic builtins for long long])
3390 AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
3393 [typedef long long atomic_type;
3397 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3398 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3400 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3401 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3403 [glibcxx_cv_atomic_long_long=yes],
3404 [glibcxx_cv_atomic_long_long=no])
3406 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3412 # Compile unoptimized.
3415 # Fake what AC_TRY_COMPILE does.
3417 cat > conftest.$ac_ext << EOF
3418 [#]line __oline__ "configure"
3421 typedef bool atomic_type;
3425 // N.B. __atomic_fetch_add is not supported for bool.
3426 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3428 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3429 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3435 AC_MSG_CHECKING([for atomic builtins for bool])
3436 if AC_TRY_EVAL(ac_compile); then
3437 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3438 glibcxx_cv_atomic_bool=no
3440 glibcxx_cv_atomic_bool=yes
3443 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3446 cat > conftest.$ac_ext << EOF
3447 [#]line __oline__ "configure"
3450 typedef short atomic_type;
3454 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3455 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3457 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3458 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3464 AC_MSG_CHECKING([for atomic builtins for short])
3465 if AC_TRY_EVAL(ac_compile); then
3466 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3467 glibcxx_cv_atomic_short=no
3469 glibcxx_cv_atomic_short=yes
3472 AC_MSG_RESULT($glibcxx_cv_atomic_short)
3475 cat > conftest.$ac_ext << EOF
3476 [#]line __oline__ "configure"
3479 // NB: _Atomic_word not necessarily int.
3480 typedef int atomic_type;
3484 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3485 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3487 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3488 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3494 AC_MSG_CHECKING([for atomic builtins for int])
3495 if AC_TRY_EVAL(ac_compile); then
3496 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3497 glibcxx_cv_atomic_int=no
3499 glibcxx_cv_atomic_int=yes
3502 AC_MSG_RESULT($glibcxx_cv_atomic_int)
3505 cat > conftest.$ac_ext << EOF
3506 [#]line __oline__ "configure"
3509 typedef long long atomic_type;
3513 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3514 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3516 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3517 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3523 AC_MSG_CHECKING([for atomic builtins for long long])
3524 if AC_TRY_EVAL(ac_compile); then
3525 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3526 glibcxx_cv_atomic_long_long=no
3528 glibcxx_cv_atomic_long_long=yes
3531 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3536 CXXFLAGS="$old_CXXFLAGS"
3539 # Set atomicity_dir to builtins if all but the long long test above passes,
3540 # or if the builtins were already chosen (e.g. by configure.host).
3541 if { test "$glibcxx_cv_atomic_bool" = yes \
3542 && test "$glibcxx_cv_atomic_short" = yes \
3543 && test "$glibcxx_cv_atomic_int" = yes; } \
3544 || test "$atomicity_dir" = "cpu/generic/atomicity_builtins"; then
3545 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
3546 [Define if the compiler supports C++11 atomics.])
3547 atomicity_dir=cpu/generic/atomicity_builtins
3550 # If still generic, set to mutex.
3551 if test $atomicity_dir = "cpu/generic" ; then
3552 atomicity_dir=cpu/generic/atomicity_mutex
3553 AC_MSG_WARN([No native atomic operations are provided for this platform.])
3554 if test "x$target_thread_file" = xsingle; then
3555 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
3556 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
3558 AC_MSG_WARN([They will be faked using a mutex.])
3559 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
3566 dnl Set default lock policy for synchronizing shared_ptr reference counting.
3568 dnl --with-libstdcxx-lock-policy=auto
3569 dnl Use atomic operations for shared_ptr reference counting only if
3570 dnl the default target supports atomic compare-and-swap.
3571 dnl --with-libstdcxx-lock-policy=atomic
3572 dnl Use atomic operations for shared_ptr reference counting.
3573 dnl --with-libstdcxx-lock-policy=mutex
3574 dnl Use a mutex to synchronize shared_ptr reference counting.
3576 dnl This controls the value of __gnu_cxx::__default_lock_policy, which
3577 dnl determines how shared_ptr reference counts are synchronized.
3578 dnl The option "atomic" means that atomic operations should be used,
3579 dnl "mutex" means that a mutex will be used. The default option, "auto",
3580 dnl will check if the target supports the compiler-generated builtins
3581 dnl for atomic compare-and-swap operations for 2-byte and 4-byte integers,
3582 dnl and will use "atomic" if supported, "mutex" otherwise.
3583 dnl This option is ignored if the thread model used by GCC is "single",
3584 dnl as no synchronization is used at all in that case.
3585 dnl This option affects the library ABI (except in the "single" thread model).
3587 dnl Defines _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY to 1 if atomics should be used.
3589 AC_DEFUN([GLIBCXX_ENABLE_LOCK_POLICY], [
3591 AC_ARG_WITH([libstdcxx-lock-policy],
3592 AC_HELP_STRING([--with-libstdcxx-lock-policy={atomic,mutex,auto}],
3593 [synchronization policy for shared_ptr reference counting [default=auto]]),
3594 [libstdcxx_atomic_lock_policy=$withval],
3595 [libstdcxx_atomic_lock_policy=auto])
3597 case "$libstdcxx_atomic_lock_policy" in
3598 atomic|mutex|auto) ;;
3599 *) AC_MSG_ERROR([Invalid argument for --with-libstdcxx-lock-policy]) ;;
3601 AC_MSG_CHECKING([for lock policy for shared_ptr reference counts])
3603 if test x"$libstdcxx_atomic_lock_policy" = x"auto"; then
3606 ac_save_CXXFLAGS="$CXXFLAGS"
3608 dnl Why do we care about 2-byte CAS on targets with 4-byte _Atomic_word?!
3610 #if ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
3611 # error "No 2-byte compare-and-swap"
3612 #elif ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
3613 # error "No 4-byte compare-and-swap"
3616 [libstdcxx_atomic_lock_policy=atomic],
3617 [libstdcxx_atomic_lock_policy=mutex])
3619 CXXFLAGS="$ac_save_CXXFLAGS"
3622 if test x"$libstdcxx_atomic_lock_policy" = x"atomic"; then
3623 AC_MSG_RESULT(atomic)
3624 AC_DEFINE(HAVE_ATOMIC_LOCK_POLICY,1,
3625 [Defined if shared_ptr reference counting should use atomic operations.])
3627 AC_MSG_RESULT(mutex)
3633 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3635 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3636 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3637 dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3638 dnl Where DEFAULT is 'yes'.
3640 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3641 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3643 if test x$enable_libstdcxx_visibility = xyes ; then
3644 dnl all hail libgfortran
3645 dnl Check whether the target supports hidden visibility.
3646 AC_CACHE_CHECK([whether the target supports hidden visibility],
3647 glibcxx_cv_have_attribute_visibility, [
3648 save_CFLAGS="$CFLAGS"
3649 CFLAGS="$CFLAGS -Werror"
3650 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3651 [], glibcxx_cv_have_attribute_visibility=yes,
3652 glibcxx_cv_have_attribute_visibility=no)
3653 CFLAGS="$save_CFLAGS"])
3654 if test $glibcxx_cv_have_attribute_visibility = no; then
3655 enable_libstdcxx_visibility=no
3659 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3660 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3665 dnl Add version tags to symbols in shared library (or not), additionally
3666 dnl marking other symbols as private/local (or not).
3668 dnl Sets libtool_VERSION, and determines shared library SONAME.
3670 dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3672 dnl --enable-symvers=style adds a version script to the linker call when
3673 dnl creating the shared library. The choice of version script is
3674 dnl controlled by 'style'.
3675 dnl --disable-symvers does not.
3677 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3678 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
3679 dnl choose a default style based on linker characteristics. Passing
3680 dnl 'no' disables versioning.
3682 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3684 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3685 [enables symbol versioning of the shared library],
3686 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3688 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3689 # don't know enough about $LD to do tricks...
3690 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3691 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3692 # with extern "C++" in version scripts.
3693 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3695 # Turn a 'yes' into a suitable default.
3696 if test x$enable_symvers = xyes ; then
3697 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3700 if test $with_gnu_ld = yes ; then
3701 case ${target_os} in
3703 enable_symvers=no ;;
3705 enable_symvers=gnu ;;
3708 case ${target_os} in
3710 enable_symvers=darwin ;;
3711 # Sun symbol versioning exists since Solaris 2.5.
3712 solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3713 # make_sunver.pl needs GNU c++filt to support extern "C++" in
3714 # version scripts, so disable symbol versioning if none can be
3716 if test -z "$ac_cv_path_CXXFILT"; then
3717 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3718 AC_MSG_WARN([=== no GNU c++filt could be found.])
3719 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3726 enable_symvers=no ;;
3732 # Check to see if 'darwin' or 'darwin-export' can win.
3733 if test x$enable_symvers = xdarwin-export ; then
3734 enable_symvers=darwin
3737 # Check if 'sun' was requested on non-Solaris 2 platforms.
3738 if test x$enable_symvers = xsun ; then
3739 case ${target_os} in
3745 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3746 AC_MSG_WARN([=== you are not targetting Solaris 2.])
3747 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3753 # Check to see if 'gnu' can win.
3754 if test $enable_symvers = gnu ||
3755 test $enable_symvers = gnu-versioned-namespace ||
3756 test $enable_symvers = sun; then
3757 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3758 AC_MSG_CHECKING([for shared libgcc])
3759 ac_save_CFLAGS="$CFLAGS"
3761 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3762 CFLAGS="$ac_save_CFLAGS"
3763 if test $glibcxx_shared_libgcc = no; then
3764 cat > conftest.c <<EOF
3765 int main (void) { return 0; }
3768 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3769 -shared -shared-libgcc -o conftest.so \
3770 conftest.c -v 2>&1 >/dev/null \
3771 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3773 rm -f conftest.c conftest.so
3774 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3775 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3776 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3777 CFLAGS="$ac_save_CFLAGS"
3780 AC_MSG_RESULT($glibcxx_shared_libgcc)
3782 # For GNU ld, we need at least this version. The format is described in
3783 # GLIBCXX_CHECK_LINKER_FEATURES above.
3784 glibcxx_min_gnu_ld_version=21400
3786 # If no shared libgcc, can't win.
3787 if test $glibcxx_shared_libgcc != yes; then
3788 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3789 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3790 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3792 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3793 : All interesting versions of Sun ld support sun style symbol versioning.
3794 elif test $with_gnu_ld != yes ; then
3796 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3797 AC_MSG_WARN([=== you are not using the GNU linker.])
3798 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3800 elif test $glibcxx_ld_is_gold = yes ; then
3801 : All versions of gold support symbol versioning.
3802 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3803 # The right tools, the right setup, but too old. Fallbacks?
3804 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3805 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3806 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3807 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3808 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3813 # For libtool versioning info, format is CURRENT:REVISION:AGE
3814 libtool_VERSION=6:26:0
3816 # Everything parsed; figure out what files and settings to use.
3817 case $enable_symvers in
3819 SYMVER_FILE=config/abi/pre/none.ver
3822 SYMVER_FILE=config/abi/pre/gnu.ver
3823 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3824 [Define to use GNU versioning in the shared library.])
3826 gnu-versioned-namespace)
3827 libtool_VERSION=8:0:0
3828 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3829 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3830 [Define to use GNU namespace versioning in the shared library.])
3833 SYMVER_FILE=config/abi/pre/gnu.ver
3834 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3835 [Define to use darwin versioning in the shared library.])
3838 SYMVER_FILE=config/abi/pre/gnu.ver
3839 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3840 [Define to use Sun versioning in the shared library.])
3844 if test x$enable_symvers != xno ; then
3845 AC_DEFINE(_GLIBCXX_SYMVER, 1,
3846 [Define to use symbol versioning in the shared library.])
3849 AC_CACHE_CHECK([whether the target supports .symver directive],
3850 glibcxx_cv_have_as_symver_directive, [
3851 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3852 [], glibcxx_cv_have_as_symver_directive=yes,
3853 glibcxx_cv_have_as_symver_directive=no)])
3854 if test $glibcxx_cv_have_as_symver_directive = yes; then
3855 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3856 [Define to 1 if the target assembler supports .symver directive.])
3859 AC_SUBST(SYMVER_FILE)
3860 AC_SUBST(port_specific_symbol_files)
3861 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3862 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3863 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3864 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3865 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3866 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3868 if test $enable_symvers != no ; then
3869 case ${target_os} in
3870 # The Solaris 2 runtime linker doesn't support the GNU extension of
3871 # binding the same symbol to different versions
3874 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3876 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3877 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3882 # Now, set up compatibility support, if any.
3883 # In addition, need this to deal with std::size_t mangling in
3884 # src/compatibility.cc. In a perfect world, could use
3885 # typeid(std::size_t).name()[0] to do direct substitution.
3886 AC_MSG_CHECKING([for size_t as unsigned int])
3887 ac_save_CFLAGS="$CFLAGS"
3889 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3890 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3891 CFLAGS=$ac_save_CFLAGS
3892 if test "$glibcxx_size_t_is_i" = yes; then
3893 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3895 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3897 AC_MSG_CHECKING([for ptrdiff_t as int])
3898 ac_save_CFLAGS="$CFLAGS"
3900 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3901 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3902 CFLAGS=$ac_save_CFLAGS
3903 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3904 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3906 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3911 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3912 dnl We must stage the required headers so that they will be installed
3913 dnl with the library (unlike libgcc, the STL implementation is provided
3914 dnl solely within headers). Since we must not inject random user-space
3915 dnl macro names into user-provided C++ code, we first stage into <file>-in
3916 dnl and process to <file> with an output command. The reason for a two-
3917 dnl stage process here is to correctly handle $srcdir!=$objdir without
3918 dnl having to write complex code (the sed commands to clean the macro
3919 dnl namespace are complex and fragile enough as it is). We must also
3920 dnl add a relative path so that -I- is supported properly.
3925 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3926 AC_MSG_CHECKING([for thread model used by GCC])
3927 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3928 AC_MSG_RESULT([$target_thread_file])
3929 GCC_AC_THREAD_HEADER([$target_thread_file])
3934 dnl Check if gthread implementation defines the types and functions
3935 dnl required by the c++0x thread library. Conforming gthread
3936 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3938 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3940 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3941 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3943 if test x$enable_libstdcxx_threads = xauto ||
3944 test x$enable_libstdcxx_threads = xyes; then
3949 ac_save_CXXFLAGS="$CXXFLAGS"
3950 CXXFLAGS="$CXXFLAGS -fno-exceptions \
3951 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3953 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3954 case $target_thread_file in
3956 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3959 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3961 AC_TRY_COMPILE([#include <unistd.h>],
3963 // In case of POSIX threads check _POSIX_TIMEOUTS.
3964 #if (defined(_PTHREADS) \
3965 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3968 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3970 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3971 [Define to 1 if mutex_timedlock is available.])
3973 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3974 else res_mutex_timedlock=no ; fi
3975 AC_MSG_RESULT([$res_mutex_timedlock])
3977 AC_MSG_CHECKING([for gthreads library])
3979 AC_TRY_COMPILE([#include "gthr.h"],
3981 #ifndef __GTHREADS_CXX0X
3984 ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
3989 AC_MSG_RESULT([$ac_has_gthreads])
3991 if test x"$ac_has_gthreads" = x"yes"; then
3992 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3993 [Define if gthreads library is available.])
3995 # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14
3996 AC_CHECK_TYPE([pthread_rwlock_t],
3997 [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1,
3998 [Define if POSIX read/write locks are available in <gthr.h>.])],
4000 [#include "gthr.h"])
4003 CXXFLAGS="$ac_save_CXXFLAGS"
4008 # Check whether LC_MESSAGES is available in <locale.h>.
4009 # Ulrich Drepper <drepper@cygnus.com>, 1995.
4011 # This file file be copied and used freely without restrictions. It can
4012 # be used in projects which are not available under the GNU Public License
4013 # but which still want to provide support for the GNU gettext functionality.
4014 # Please note that the actual code is *not* freely available.
4015 AC_DEFUN([AC_LC_MESSAGES], [
4016 AC_CHECK_HEADER(locale.h, [
4017 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
4018 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
4019 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
4020 if test $ac_cv_val_LC_MESSAGES = yes; then
4021 AC_DEFINE(HAVE_LC_MESSAGES, 1,
4022 [Define if LC_MESSAGES is available in <locale.h>.])
4028 dnl Check whether rdrand is supported in the assembler.
4029 AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [
4030 AC_MSG_CHECKING([for rdrand support in assembler])
4031 AC_CACHE_VAL(ac_cv_x86_rdrand, [
4036 AC_TRY_COMPILE(, [asm("rdrand %eax");],
4037 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no])
4040 if test $ac_cv_x86_rdrand = yes; then
4041 AC_DEFINE(_GLIBCXX_X86_RDRAND, 1,
4042 [ Defined if as can handle rdrand. ])
4044 AC_MSG_RESULT($ac_cv_x86_rdrand)
4048 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
4050 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
4054 ac_save_CXXFLAGS="$CXXFLAGS"
4055 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4057 AC_MSG_CHECKING([for get_nprocs])
4058 AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
4059 GCC_TRY_COMPILE_OR_LINK(
4060 [#include <sys/sysinfo.h>],
4061 [int n = get_nprocs();],
4062 [glibcxx_cv_GET_NPROCS=yes],
4063 [glibcxx_cv_GET_NPROCS=no])
4065 if test $glibcxx_cv_GET_NPROCS = yes; then
4066 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
4068 AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
4070 CXXFLAGS="$ac_save_CXXFLAGS"
4075 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
4077 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
4081 ac_save_CXXFLAGS="$CXXFLAGS"
4082 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4084 AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
4085 AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
4086 GCC_TRY_COMPILE_OR_LINK(
4087 [#include <unistd.h>],
4088 [int n = sysconf(_SC_NPROCESSORS_ONLN);],
4089 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
4090 [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
4092 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
4093 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.])
4095 AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
4097 CXXFLAGS="$ac_save_CXXFLAGS"
4102 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
4104 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
4108 ac_save_CXXFLAGS="$CXXFLAGS"
4109 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4111 AC_MSG_CHECKING([for _SC_NPROC_ONLN])
4112 AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [
4113 GCC_TRY_COMPILE_OR_LINK(
4114 [#include <unistd.h>],
4115 [int n = sysconf(_SC_NPROC_ONLN);],
4116 [glibcxx_cv_SC_NPROC_ONLN=yes],
4117 [glibcxx_cv_SC_NPROC_ONLN=no])
4119 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
4120 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.])
4122 AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN)
4124 CXXFLAGS="$ac_save_CXXFLAGS"
4129 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
4131 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
4135 ac_save_CXXFLAGS="$CXXFLAGS"
4136 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4138 AC_MSG_CHECKING([for pthreads_num_processors_np])
4139 AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
4140 GCC_TRY_COMPILE_OR_LINK(
4141 [#include <pthread.h>],
4142 [int n = pthread_num_processors_np();],
4143 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
4144 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
4146 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
4147 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
4149 AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP)
4151 CXXFLAGS="$ac_save_CXXFLAGS"
4156 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
4158 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
4162 ac_save_CXXFLAGS="$CXXFLAGS"
4163 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4165 AC_MSG_CHECKING([for hw.ncpu sysctl])
4166 AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [
4167 GCC_TRY_COMPILE_OR_LINK(
4170 #include <sys/sysctl.h>
4174 size_t size = sizeof(count);
4175 int mib[] = { CTL_HW, HW_NCPU };
4176 sysctl(mib, 2, &count, &size, NULL, 0);
4178 [glibcxx_cv_SYSCTL_HW_NCPU=yes],
4179 [glibcxx_cv_SYSCTL_HW_NCPU=no])
4181 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
4182 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
4184 AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU)
4186 CXXFLAGS="$ac_save_CXXFLAGS"
4191 dnl Check to see if python pretty printing can be activated.
4193 dnl --with-python-dir=dir
4194 dnl installs directory into $prefix/dir
4195 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
4197 AC_MSG_CHECKING([for custom python install directory])
4198 AC_ARG_WITH([python-dir],
4199 AS_HELP_STRING([--with-python-dir],
4200 [the location to install Python modules. This path is relative starting from the prefix.]),
4201 [with_python_dir=$withval], [with_python_dir="no"])
4202 AC_MSG_RESULT(${with_python_dir})
4204 # Needed for installing Python modules during make install.
4205 python_mod_dir="${with_python_dir}"
4206 AC_SUBST(python_mod_dir)
4207 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
4211 dnl Check to see if -Werror is disabled.
4213 dnl --enable-werror/--disable-werror
4214 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
4215 AC_MSG_CHECKING([for -Werror])
4216 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
4217 AC_MSG_RESULT($enable_werror)
4218 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
4222 dnl Check whether obsolescent tmpnam is available in <stdio.h>,
4223 dnl and define _GLIBCXX_USE_TMPNAM.
4225 AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl
4229 ac_save_CXXFLAGS="$CXXFLAGS"
4230 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4232 AC_MSG_CHECKING([for tmpnam])
4233 AC_CACHE_VAL(glibcxx_cv_TMPNAM, [dnl
4234 GCC_TRY_COMPILE_OR_LINK(
4235 [#include <stdio.h>],
4236 [char *tmp = tmpnam(NULL);],
4237 [glibcxx_cv_TMPNAM=yes],
4238 [glibcxx_cv_TMPNAM=no])
4240 if test $glibcxx_cv_TMPNAM = yes; then
4241 AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.])
4243 AC_MSG_RESULT($glibcxx_cv_TMPNAM)
4245 CXXFLAGS="$ac_save_CXXFLAGS"
4250 dnl Check to see if sys/sdt.h exists and that it is suitable for use.
4251 dnl Some versions of sdt.h were not compatible with C++11.
4253 AC_DEFUN([GLIBCXX_CHECK_SDT_H], [
4254 AC_MSG_CHECKING([for suitable sys/sdt.h])
4255 # Note that this test has to be run with the C language.
4256 # Otherwise, sdt.h will try to include some headers from
4260 AC_CACHE_VAL(glibcxx_cv_sys_sdt_h, [
4261 # Because we have to run the test in C, we use grep rather
4262 # than the compiler to check for the bug. The bug is that
4263 # were strings without trailing whitespace, causing g++
4264 # to look for operator"". The pattern searches for the fixed
4266 AC_EGREP_CPP([ \",\" ], [
4267 #include <sys/sdt.h>
4268 int f() { STAP_PROBE(hi, bob); }
4269 ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no])
4272 if test $glibcxx_cv_sys_sdt_h = yes; then
4273 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4274 [Define to 1 if you have a suitable <sys/sdt.h> header file])
4276 AC_MSG_RESULT($glibcxx_cv_sys_sdt_h)
4280 dnl Control whether the library should define symbols for old and new ABIs.
4281 dnl This affects definitions of strings, stringstreams and locale facets.
4283 dnl --disable-libstdcxx-dual-abi will use old ABI for all types.
4286 dnl _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0)
4288 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [
4289 GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string])
4290 if test x$enable_symvers = xgnu-versioned-namespace; then
4291 # gnu-versioned-namespace is incompatible with the dual ABI.
4292 enable_libstdcxx_dual_abi="no"
4294 if test x"$enable_libstdcxx_dual_abi" != xyes; then
4295 AC_MSG_NOTICE([dual ABI is disabled])
4296 default_libstdcxx_abi="gcc4-compatible"
4298 GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes)
4302 dnl Check to see which ABI should be enabled by default.
4304 dnl --with-default-libstdcxx-abi={gcc4-compatible,new}
4307 dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
4309 AC_DEFUN([GLIBCXX_DEFAULT_ABI], [
4310 if test x$enable_libstdcxx_dual_abi = xyes; then
4311 AC_MSG_CHECKING([for default std::string ABI to use])
4312 AC_ARG_WITH([default-libstdcxx-abi],
4313 AS_HELP_STRING([--with-default-libstdcxx-abi],
4314 [set the std::string ABI to use by default]),
4316 gcc4-compatible) default_libstdcxx_abi="gcc4-compatible" ;;
4317 new|cxx11) default_libstdcxx_abi="new" ;;
4318 c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;;
4319 *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
4322 [default_libstdcxx_abi="new"])
4323 AC_MSG_RESULT(${default_libstdcxx_abi})
4325 if test $default_libstdcxx_abi = "new"; then
4332 AC_SUBST(glibcxx_cxx98_abi)
4333 GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1)
4337 dnl Check to see whether to build libstdc++fs.a
4339 dnl --enable-libstdcxx-filesystem-ts
4341 AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [
4342 GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,,
4343 [turns on ISO/IEC TS 18822 support],
4344 [permit yes|no|auto])
4346 AC_MSG_CHECKING([whether to build Filesystem TS support])
4347 if test x"$ac_cv_header_dirent_h" != x"yes"; then
4348 enable_libstdcxx_filesystem_ts=no
4350 if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then
4351 case "${target_os}" in
4352 freebsd*|netbsd*|openbsd*|dragonfly*|darwin*)
4353 enable_libstdcxx_filesystem_ts=yes
4355 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
4356 enable_libstdcxx_filesystem_ts=yes
4359 enable_libstdcxx_filesystem_ts=yes
4362 enable_libstdcxx_filesystem_ts=yes
4365 enable_libstdcxx_filesystem_ts=no
4369 AC_MSG_RESULT($enable_libstdcxx_filesystem_ts)
4370 GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes)
4374 dnl Check whether the library calls required by the Filesystem TS are present.
4376 dnl HAVE_STRUCT_DIRENT_D_TYPE
4377 dnl _GLIBCXX_USE_REALPATH
4378 dnl _GLIBCXX_USE_UTIMENSAT
4379 dnl _GLIBCXX_USE_ST_MTIM
4380 dnl _GLIBCXX_USE_FCHMOD
4381 dnl _GLIBCXX_USE_FCHMODAT
4382 dnl _GLIBCXX_USE_SENDFILE
4387 AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
4389 if test $enable_libstdcxx_filesystem_ts = yes; then
4392 ac_save_CXXFLAGS="$CXXFLAGS"
4393 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4395 AC_MSG_CHECKING([for struct dirent.d_type])
4396 AC_CACHE_VAL(glibcxx_cv_dirent_d_type, [dnl
4397 GCC_TRY_COMPILE_OR_LINK(
4398 [#include <dirent.h>],
4401 if (sizeof d.d_type) return 0;
4403 [glibcxx_cv_dirent_d_type=yes],
4404 [glibcxx_cv_dirent_d_type=no])
4406 if test $glibcxx_cv_dirent_d_type = yes; then
4407 AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.])
4409 AC_MSG_RESULT($glibcxx_cv_dirent_d_type)
4411 AC_MSG_CHECKING([for realpath])
4412 AC_CACHE_VAL(glibcxx_cv_realpath, [dnl
4413 GCC_TRY_COMPILE_OR_LINK(
4420 #if _XOPEN_VERSION < 500
4422 #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX)
4423 char *tmp = realpath((const char*)NULL, (char*)NULL);
4428 [glibcxx_cv_realpath=yes],
4429 [glibcxx_cv_realpath=no])
4431 if test $glibcxx_cv_realpath = yes; then
4432 AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.])
4434 AC_MSG_RESULT($glibcxx_cv_realpath)
4436 AC_MSG_CHECKING([for utimensat])
4437 AC_CACHE_VAL(glibcxx_cv_utimensat, [dnl
4438 GCC_TRY_COMPILE_OR_LINK(
4441 #include <sys/stat.h>
4444 struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } };
4445 int i = utimensat(AT_FDCWD, "path", ts, 0);
4447 [glibcxx_cv_utimensat=yes],
4448 [glibcxx_cv_utimensat=no])
4450 if test $glibcxx_cv_utimensat = yes; then
4451 AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.])
4453 AC_MSG_RESULT($glibcxx_cv_utimensat)
4455 AC_MSG_CHECKING([for struct stat.st_mtim.tv_nsec])
4456 AC_CACHE_VAL(glibcxx_cv_st_mtim, [dnl
4457 GCC_TRY_COMPILE_OR_LINK(
4458 [ #include <sys/stat.h> ],
4461 return st.st_mtim.tv_nsec;
4463 [glibcxx_cv_st_mtim=yes],
4464 [glibcxx_cv_st_mtim=no])
4466 if test $glibcxx_cv_st_mtim = yes; then
4467 AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.])
4469 AC_MSG_RESULT($glibcxx_cv_st_mtim)
4471 AC_MSG_CHECKING([for fchmod])
4472 AC_CACHE_VAL(glibcxx_cv_fchmod, [dnl
4473 GCC_TRY_COMPILE_OR_LINK(
4474 [#include <sys/stat.h>],
4475 [fchmod(1, S_IWUSR);],
4476 [glibcxx_cv_fchmod=yes],
4477 [glibcxx_cv_fchmod=no])
4479 if test $glibcxx_cv_fchmod = yes; then
4480 AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.])
4482 AC_MSG_RESULT($glibcxx_cv_fchmod)
4484 AC_MSG_CHECKING([for fchmodat])
4485 AC_CACHE_VAL(glibcxx_cv_fchmodat, [dnl
4486 GCC_TRY_COMPILE_OR_LINK(
4489 #include <sys/stat.h>
4491 [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);],
4492 [glibcxx_cv_fchmodat=yes],
4493 [glibcxx_cv_fchmodat=no])
4495 if test $glibcxx_cv_fchmodat = yes; then
4496 AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.])
4498 AC_MSG_RESULT($glibcxx_cv_fchmodat)
4500 AC_MSG_CHECKING([for sendfile that can copy files])
4501 AC_CACHE_VAL(glibcxx_cv_sendfile, [dnl
4502 case "${target_os}" in
4503 gnu* | linux* | solaris*)
4504 GCC_TRY_COMPILE_OR_LINK(
4505 [#include <sys/sendfile.h>],
4506 [sendfile(1, 2, (off_t*)0, sizeof 1);],
4507 [glibcxx_cv_sendfile=yes],
4508 [glibcxx_cv_sendfile=no])
4511 glibcxx_cv_sendfile=no
4515 if test $glibcxx_cv_sendfile = yes; then
4516 AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.])
4518 AC_MSG_RESULT($glibcxx_cv_sendfile)
4520 AC_MSG_CHECKING([for link])
4521 AC_CACHE_VAL(glibcxx_cv_link, [dnl
4522 GCC_TRY_COMPILE_OR_LINK(
4523 [#include <unistd.h>],
4525 [glibcxx_cv_link=yes],
4526 [glibcxx_cv_link=no])
4528 if test $glibcxx_cv_link = yes; then
4529 AC_DEFINE(HAVE_LINK, 1, [Define if link is available in <unistd.h>.])
4531 AC_MSG_RESULT($glibcxx_cv_link)
4533 AC_MSG_CHECKING([for readlink])
4534 AC_CACHE_VAL(glibcxx_cv_readlink, [dnl
4535 GCC_TRY_COMPILE_OR_LINK(
4536 [#include <unistd.h>],
4537 [char buf[32]; readlink("", buf, sizeof(buf));],
4538 [glibcxx_cv_readlink=yes],
4539 [glibcxx_cv_readlink=no])
4541 if test $glibcxx_cv_readlink = yes; then
4542 AC_DEFINE(HAVE_READLINK, 1, [Define if readlink is available in <unistd.h>.])
4544 AC_MSG_RESULT($glibcxx_cv_readlink)
4546 AC_MSG_CHECKING([for symlink])
4547 AC_CACHE_VAL(glibcxx_cv_symlink, [dnl
4548 GCC_TRY_COMPILE_OR_LINK(
4549 [#include <unistd.h>],
4551 [glibcxx_cv_symlink=yes],
4552 [glibcxx_cv_symlink=no])
4554 if test $glibcxx_cv_symlink = yes; then
4555 AC_DEFINE(HAVE_SYMLINK, 1, [Define if symlink is available in <unistd.h>.])
4557 AC_MSG_RESULT($glibcxx_cv_symlink)
4559 CXXFLAGS="$ac_save_CXXFLAGS"
4565 dnl Check how size_t is mangled. Copied from libitm.
4567 AC_DEFUN([GLIBCXX_CHECK_SIZE_T_MANGLING], [
4568 AC_CACHE_CHECK([how size_t is mangled],
4569 glibcxx_cv_size_t_mangling, [
4570 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
4571 [glibcxx_cv_size_t_mangling=m], [
4572 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
4573 [glibcxx_cv_size_t_mangling=j], [
4575 [extern __SIZE_TYPE__ x; extern unsigned long long x;],
4576 [glibcxx_cv_size_t_mangling=y], [
4578 [extern __SIZE_TYPE__ x; extern unsigned short x;],
4579 [glibcxx_cv_size_t_mangling=t], [
4581 [extern __SIZE_TYPE__ x; extern __int20 unsigned x;],
4582 [glibcxx_cv_size_t_mangling=u6uint20],
4583 [glibcxx_cv_size_t_mangling=x])
4589 if test $glibcxx_cv_size_t_mangling = x; then
4590 AC_MSG_ERROR([Unknown underlying type for size_t])
4592 AC_DEFINE_UNQUOTED(_GLIBCXX_MANGLE_SIZE_T, [$glibcxx_cv_size_t_mangling],
4593 [Define to the letter to which size_t is mangled.])
4597 dnl Determine whether std::exception_ptr symbols should be exported with
4598 dnl the symbol versions from GCC 4.6.0 or GCC 7.1.0, depending on which
4599 dnl release first added support for std::exception_ptr. Originally it was
4600 dnl only supported for targets with always-lock-free atomics for int, but
4601 dnl since GCC 7.1 it is supported for all targets.
4603 AC_DEFUN([GLIBCXX_CHECK_EXCEPTION_PTR_SYMVER], [
4604 if test $enable_symvers != no; then
4605 AC_MSG_CHECKING([for first version to support std::exception_ptr])
4607 aarch64-*-* | alpha-*-* | hppa*-*-* | i?86-*-* | x86_64-*-* | \
4608 m68k-*-* | powerpc*-*-* | s390*-*-* | *-*-solaris* )
4609 ac_exception_ptr_since_gcc46=yes
4612 # If the value of this macro changes then we will need to hardcode
4613 # yes/no here for additional targets based on the original value.
4614 AC_TRY_COMPILE([], [
4615 #if __GCC_ATOMIC_INT_LOCK_FREE <= 1
4616 # error atomic int not always lock free
4619 [ac_exception_ptr_since_gcc46=yes],
4620 [ac_exception_ptr_since_gcc46=no])
4623 if test x"$ac_exception_ptr_since_gcc46" = x"yes" ; then
4624 AC_DEFINE(HAVE_EXCEPTION_PTR_SINCE_GCC46, 1,
4625 [Define to 1 if GCC 4.6 supported std::exception_ptr for the target])
4626 AC_MSG_RESULT([4.6.0])
4628 AC_MSG_RESULT([7.1.0])
4633 # Macros from the top-level gcc directory.
4634 m4_include([../config/gc++filt.m4])
4635 m4_include([../config/tls.m4])
4636 m4_include([../config/gthr.m4])
4637 m4_include([../config/cet.m4])