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/[. ][0-9]\{8\}$//;s/.* \([^ ]\{1,\}\)$/\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], [
321 setrlimit_have_headers=yes
322 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
324 [setrlimit_have_headers=no])
325 # If don't have the headers, then we can't run the tests now, and we
326 # won't be seeing any of these during testsuite compilation.
327 if test $setrlimit_have_headers = yes; then
328 # Can't do these in a loop, else the resulting syntax is wrong.
329 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
330 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
331 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
332 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
333 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
335 # Check for rlimit, setrlimit.
336 AC_CACHE_VAL(glibcxx_cv_setrlimit, [
339 #include <sys/time.h>
340 #include <sys/resource.h>
344 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
348 AC_MSG_CHECKING([for testsuite resource limits support])
349 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
351 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
352 [Define if using setrlimit to set resource limits during
358 AC_MSG_RESULT($ac_res_limits)
363 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
364 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
366 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
370 ac_save_CXXFLAGS="$CXXFLAGS"
371 CXXFLAGS="$CXXFLAGS -fno-exceptions"
373 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
374 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
375 GCC_TRY_COMPILE_OR_LINK(
376 [#include <sys/stat.h>],
379 S_ISREG(buffer.st_mode);],
380 [glibcxx_cv_S_ISREG=yes],
381 [glibcxx_cv_S_ISREG=no])
383 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
384 GCC_TRY_COMPILE_OR_LINK(
385 [#include <sys/stat.h>],
388 S_IFREG & buffer.st_mode;],
389 [glibcxx_cv_S_IFREG=yes],
390 [glibcxx_cv_S_IFREG=no])
393 if test $glibcxx_cv_S_ISREG = yes; then
394 AC_DEFINE(HAVE_S_ISREG, 1,
395 [Define if S_ISREG is available in <sys/stat.h>.])
397 elif test $glibcxx_cv_S_IFREG = yes; then
398 AC_DEFINE(HAVE_S_IFREG, 1,
399 [Define if S_IFREG is available in <sys/stat.h>.])
404 CXXFLAGS="$ac_save_CXXFLAGS"
410 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
412 AC_DEFUN([GLIBCXX_CHECK_POLL], [
416 ac_save_CXXFLAGS="$CXXFLAGS"
417 CXXFLAGS="$CXXFLAGS -fno-exceptions"
419 AC_MSG_CHECKING([for poll])
420 AC_CACHE_VAL(glibcxx_cv_POLL, [
421 GCC_TRY_COMPILE_OR_LINK(
423 [struct pollfd pfd[1];
424 pfd[0].events = POLLIN;
426 [glibcxx_cv_POLL=yes],
427 [glibcxx_cv_POLL=no])
429 if test $glibcxx_cv_POLL = yes; then
430 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
432 AC_MSG_RESULT($glibcxx_cv_POLL)
434 CXXFLAGS="$ac_save_CXXFLAGS"
440 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
442 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
446 ac_save_CXXFLAGS="$CXXFLAGS"
447 CXXFLAGS="$CXXFLAGS -fno-exceptions"
449 AC_MSG_CHECKING([for writev])
450 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
451 GCC_TRY_COMPILE_OR_LINK(
452 [#include <sys/uio.h>],
453 [struct iovec iov[2];
455 [glibcxx_cv_WRITEV=yes],
456 [glibcxx_cv_WRITEV=no])
458 if test $glibcxx_cv_WRITEV = yes; then
459 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
461 AC_MSG_RESULT($glibcxx_cv_WRITEV)
463 CXXFLAGS="$ac_save_CXXFLAGS"
469 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
470 dnl Also check whether int64_t is actually a typedef to long or long long.
472 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
477 AC_MSG_CHECKING([for int64_t])
478 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
480 [#include <stdint.h>],
482 [glibcxx_cv_INT64_T=yes],
483 [glibcxx_cv_INT64_T=no])
486 if test $glibcxx_cv_INT64_T = yes; then
487 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
488 AC_MSG_RESULT($glibcxx_cv_INT64_T)
490 AC_MSG_CHECKING([for int64_t as long])
491 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
494 template<typename, typename> struct same { enum { value = -1 }; };
495 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
496 int array[same<int64_t, long>::value];], [],
497 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
500 if test $glibcxx_cv_int64_t_long = yes; then
501 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
502 AC_MSG_RESULT($glibcxx_cv_int64_t_long)
505 AC_MSG_CHECKING([for int64_t as long long])
506 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
509 template<typename, typename> struct same { enum { value = -1 }; };
510 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
511 int array[same<int64_t, long long>::value];], [],
512 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
515 if test $glibcxx_cv_int64_t_long_long = yes; then
516 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
517 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
526 dnl Check whether LFS support is available.
528 AC_DEFUN([GLIBCXX_CHECK_LFS], [
531 ac_save_CXXFLAGS="$CXXFLAGS"
532 CXXFLAGS="$CXXFLAGS -fno-exceptions"
533 AC_MSG_CHECKING([for LFS support])
534 AC_CACHE_VAL(glibcxx_cv_LFS, [
535 GCC_TRY_COMPILE_OR_LINK(
538 #include <sys/stat.h>
542 fseeko64(fp, 0, SEEK_CUR);
544 lseek64(1, 0, SEEK_CUR);
547 [glibcxx_cv_LFS=yes],
550 if test $glibcxx_cv_LFS = yes; then
551 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
553 AC_MSG_RESULT($glibcxx_cv_LFS)
554 CXXFLAGS="$ac_save_CXXFLAGS"
560 dnl Check for whether a fully dynamic basic_string implementation should
561 dnl be turned on, that does not put empty objects in per-process static
562 dnl memory (mostly useful together with shared memory allocators, see PR
563 dnl libstdc++/16612 for details).
565 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
566 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
567 dnl otherwise undefined
568 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
569 dnl Where DEFAULT is either `yes' or `no'.
571 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
572 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
573 if test $enable_fully_dynamic_string = yes; then
574 enable_fully_dynamic_string_def=1
576 enable_fully_dynamic_string_def=0
578 AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
579 [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
584 dnl Does any necessary configuration of the testsuite directory. Generates
585 dnl the testsuite_hooks.h header.
587 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
591 dnl GLIBCXX_TEST_WCHAR_T
592 dnl GLIBCXX_TEST_THREAD
595 dnl baseline_subdir_switch
597 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
598 # Do checks for resource limit functions.
599 GLIBCXX_CHECK_SETRLIMIT
601 if $GLIBCXX_IS_NATIVE ; then
602 # Look for setenv, so that extended locale tests can be performed.
603 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
606 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
607 test $enable_symvers != no; then
610 enable_abi_check=no ;;
612 enable_abi_check=yes ;;
615 # Only build this as native, since automake does not understand
620 # Export file names for ABI checking.
621 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
622 AC_SUBST(baseline_dir)
623 baseline_subdir_switch="$abi_baseline_subdir_switch"
624 AC_SUBST(baseline_subdir_switch)
629 dnl Does any necessary configuration for docbook in the docs directory.
631 dnl XSLTPROC must be set before this
634 dnl glibcxx_stylesheets
638 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
640 glibcxx_docbook_url=http://docbook.sourceforge.net/release/xsl-ns/current/
642 AC_MSG_CHECKING([for local stylesheet directory])
643 glibcxx_local_stylesheets=no
644 if test x${XMLCATALOG} = xyes && xsl_style_dir=`xmlcatalog "" $glibcxx_docbook_url 2>/dev/null`
646 XSL_STYLE_DIR=`echo $xsl_style_dir | sed -n 's;^file://;;p'`
647 glibcxx_local_stylesheets=yes
650 /usr/share/sgml/docbook/xsl-ns-stylesheets \
651 /usr/share/xml/docbook/stylesheet/docbook-xsl-ns \
652 /usr/share/xml/docbook/stylesheet/nwalsh5/current \
653 /usr/share/xml/docbook/stylesheet/nwalsh/current
655 if test -d $dir; then
656 glibcxx_local_stylesheets=yes
662 AC_MSG_RESULT($glibcxx_local_stylesheets)
664 if test x"$glibcxx_local_stylesheets" = x"yes"; then
665 AC_SUBST(XSL_STYLE_DIR)
666 AC_MSG_NOTICE($XSL_STYLE_DIR)
668 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
669 glibcxx_stylesheets=no
670 if test x${XMLCATALOG} = xno || xmlcatalog "" $glibcxx_docbook_url/xhtml/docbook.xsl >/dev/null 2>&1; then
671 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude $glibcxx_docbook_url/xhtml/docbook.xsl - 2>/dev/null; then
672 glibcxx_stylesheets=yes
675 AC_MSG_RESULT($glibcxx_stylesheets)
678 glibcxx_stylesheets=no
681 # Check for epub3 dependencies.
682 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
683 glibcxx_epub_stylesheets=no
684 if test x"$glibcxx_local_stylesheets" = x"yes"; then
685 if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
686 glibcxx_epub_stylesheets=yes
689 AC_MSG_RESULT($glibcxx_epub_stylesheets)
690 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
696 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
700 dnl TOPLEVEL_INCLUDES
702 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
703 # Used for every C++ compile we perform.
705 -I$glibcxx_builddir/include/$host_alias \
706 -I$glibcxx_builddir/include \
707 -I$glibcxx_srcdir/libsupc++"
709 # For Canadian crosses, pick this up too.
710 if test $CANADIAN = yes; then
711 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
714 # Stuff in the actual top level. Currently only used by libsupc++ to
715 # get unwind* headers from the libgcc dir.
716 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
717 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
719 # Now, export this to all the little Makefiles....
720 AC_SUBST(GLIBCXX_INCLUDES)
721 AC_SUBST(TOPLEVEL_INCLUDES)
726 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
727 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
730 dnl OPTIMIZE_CXXFLAGS
733 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
734 # Optimization flags that are probably a good idea for thrill-seekers. Just
735 # uncomment the lines below and make, everything else is ready to go...
736 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
737 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
738 AC_SUBST(OPTIMIZE_CXXFLAGS)
740 WARN_FLAGS="-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi=2"
746 dnl All installation directory information is determined here.
750 dnl glibcxx_prefixdir
751 dnl glibcxx_toolexecdir
752 dnl glibcxx_toolexeclibdir
754 dnl Assumes cross_compiling bits already done, and with_cross_host in
757 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
758 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
759 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
760 glibcxx_toolexecdir=no
761 glibcxx_toolexeclibdir=no
762 glibcxx_prefixdir=$prefix
764 AC_MSG_CHECKING([for gxx-include-dir])
765 AC_ARG_WITH([gxx-include-dir],
766 AC_HELP_STRING([--with-gxx-include-dir=DIR],
767 [installation directory for include files]),
769 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
770 no) gxx_include_dir=no ;;
771 *) gxx_include_dir=$withval ;;
773 [gxx_include_dir=no])
774 AC_MSG_RESULT($gxx_include_dir)
776 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
777 AC_ARG_ENABLE([version-specific-runtime-libs],
778 AC_HELP_STRING([--enable-version-specific-runtime-libs],
779 [Specify that runtime libraries should be installed in a compiler-specific directory]),
780 [case "$enableval" in
781 yes) version_specific_libs=yes ;;
782 no) version_specific_libs=no ;;
783 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
785 [version_specific_libs=no])
786 AC_MSG_RESULT($version_specific_libs)
788 GCC_WITH_TOOLEXECLIBDIR
790 # Default case for install directory for include files.
791 if test $version_specific_libs = no && test $gxx_include_dir = no; then
792 gxx_include_dir='include/c++/${gcc_version}'
793 if test -n "$with_cross_host" &&
794 test x"$with_cross_host" != x"no"; then
795 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
797 gxx_include_dir='${prefix}/'"$gxx_include_dir"
801 # Version-specific runtime libs processing.
802 if test $version_specific_libs = yes; then
803 # Need the gcc compiler version to know where to install libraries
804 # and header files if --enable-version-specific-runtime-libs option
805 # is selected. FIXME: these variables are misnamed, there are
806 # no executables installed in _toolexecdir or _toolexeclibdir.
807 if test x"$gxx_include_dir" = x"no"; then
808 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
810 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
811 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
814 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
815 # Install a library built with a cross compiler in tooldir, not libdir.
816 if test x"$glibcxx_toolexecdir" = x"no"; then
817 if test -n "$with_cross_host" &&
818 test x"$with_cross_host" != x"no"; then
819 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
820 case ${with_toolexeclibdir} in
822 glibcxx_toolexeclibdir='${toolexecdir}/lib'
825 glibcxx_toolexeclibdir=${with_toolexeclibdir}
829 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
830 glibcxx_toolexeclibdir='${libdir}'
832 multi_os_directory=`$CXX -print-multi-os-directory`
833 case $multi_os_directory in
834 .) ;; # Avoid trailing /.
835 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
839 AC_MSG_CHECKING([for install location])
840 AC_MSG_RESULT($gxx_include_dir)
842 AC_SUBST(glibcxx_prefixdir)
843 AC_SUBST(gxx_include_dir)
844 AC_SUBST(glibcxx_toolexecdir)
845 AC_SUBST(glibcxx_toolexeclibdir)
851 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
852 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
853 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
855 dnl See manual/appendix_porting.html#appendix.porting.build_hacking for
858 m4_define([GLIBCXX_ENABLE],[dnl
859 m4_define([_g_switch],[--enable-$1])dnl
860 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
861 AC_ARG_ENABLE([$1],m4_dquote(_g_help),
866 m4_bpatsubst([$5],[permit ])) ;;
867 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
868 dnl Idea for future: generate a URL pointing to
869 dnl "onlinedocs/configopts.html#whatever"
876 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
880 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
881 m4_undefine([_g_switch])dnl
882 m4_undefine([_g_help])dnl
887 dnl Check for ISO/IEC 9899:1999 "C99" support.
889 dnl --enable-c99 defines _GLIBCXX_USE_C99
890 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
891 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
892 dnl Where DEFAULT is either `yes' or `no'.
893 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
895 AC_DEFUN([GLIBCXX_ENABLE_C99], [
896 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
898 if test x"$enable_c99" = x"yes"; then
902 # Use -std=c++98 (instead of -std=gnu++98) because leaving __STRICT_ANSI__
903 # undefined may cause fake C99 facilities, like pre-standard snprintf,
904 # to be spuriously enabled.
905 ac_save_CXXFLAGS="$CXXFLAGS"
906 CXXFLAGS="$CXXFLAGS -std=c++98"
908 ac_save_gcc_no_link="$gcc_no_link"
910 if test x$gcc_no_link != xyes; then
911 # Use -fno-exceptions to that the C driver can link these tests without
912 # hitting undefined references to personality routines.
913 CXXFLAGS="$CXXFLAGS -fno-exceptions"
914 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
915 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
920 # Check for the existence of <math.h> functions used if C99 is enabled.
921 AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++98])
922 AC_CACHE_VAL(glibcxx_cv_c99_math_cxx98, [
923 GCC_TRY_COMPILE_OR_LINK(
925 volatile double d1, d2;
933 i = isgreater(d1, d2);
934 i = isgreaterequal(d1, d2);
936 i = islessequal(d1, d2);
937 i = islessgreater(d1, d2);
938 i = islessgreater(d1, d2);
939 i = isunordered(d1, d2);
940 ], [glibcxx_cv_c99_math_cxx98=yes], [glibcxx_cv_c99_math_cxx98=no])
942 AC_MSG_RESULT($glibcxx_cv_c99_math_cxx98)
943 if test x"$glibcxx_cv_c99_math_cxx98" = x"yes"; then
944 AC_DEFINE(_GLIBCXX98_USE_C99_MATH, 1,
945 [Define if C99 functions or macros in <math.h> should be imported
946 in <cmath> in namespace std for C++98.])
949 # Check for the existence of <complex.h> complex math functions.
950 # This is necessary even though libstdc++ uses the builtin versions
951 # of these functions, because if the builtin cannot be used, a reference
952 # to the library function is emitted.
953 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
954 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
955 if test x"$ac_has_complex_h" = x"yes"; then
956 AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++98])
957 AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx98, [
958 GCC_TRY_COMPILE_OR_LINK(
959 [#include <complex.h>
960 typedef __complex__ float float_type;
961 typedef __complex__ double double_type;
962 typedef __complex__ long double ld_type;
963 volatile float_type tmpf;
964 volatile double_type tmpd;
965 volatile ld_type tmpld;
968 volatile long double ld;],
980 tmpf = cpowf(tmpf, tmpf);
993 tmpd = cpow(tmpd, tmpd);
997 tmpld = ccosl(tmpld);
998 tmpld = ccoshl(tmpld);
999 tmpld = cexpl(tmpld);
1000 tmpld = clogl(tmpld);
1001 tmpld = csinl(tmpld);
1002 tmpld = csinhl(tmpld);
1003 tmpld = csqrtl(tmpld);
1004 tmpld = ctanl(tmpld);
1005 tmpld = ctanhl(tmpld);
1006 tmpld = cpowl(tmpld, tmpld);
1007 tmpld = cprojl(tmpld);
1008 ], [glibcxx_cv_c99_complex_cxx98=yes], [glibcxx_cv_c99_complex_cxx98=no])
1011 AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx98)
1012 if test x"$glibcxx_cv_c99_complex_cxx98" = x"yes"; then
1013 AC_DEFINE(_GLIBCXX98_USE_C99_COMPLEX, 1,
1014 [Define if C99 functions in <complex.h> should be used in
1015 <complex> for C++98. Using compiler builtins for these functions
1016 requires corresponding C99 library functions to be present.])
1019 # Check for the existence in <stdio.h> of vscanf, et. al.
1020 AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++98])
1021 AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx98, [
1022 GCC_TRY_COMPILE_OR_LINK(
1025 void foo(char* fmt, ...)
1027 va_list args; va_start(args, fmt);
1028 vfscanf(stderr, "%i", args);
1030 vsnprintf(fmt, 0, "%i", args);
1031 vsscanf(fmt, "%i", args);
1032 snprintf(fmt, 0, "%i");
1034 [glibcxx_cv_c99_stdio_cxx98=yes], [glibcxx_cv_c99_stdio_cxx98=no])
1036 AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx98)
1037 if test x"$glibcxx_cv_c99_stdio_cxx98" = x"yes"; then
1038 AC_DEFINE(_GLIBCXX98_USE_C99_STDIO, 1,
1039 [Define if C99 functions or macros in <stdio.h> should be imported
1040 in <cstdio> in namespace std for C++98.])
1043 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1044 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++98])
1045 AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx98, [
1046 GCC_TRY_COMPILE_OR_LINK(
1047 [#include <stdlib.h>
1049 volatile long double ld;
1050 volatile unsigned long long ll;
1053 f = strtof("gnu", &tmp);
1054 ld = strtold("gnu", &tmp);
1055 ll = strtoll("gnu", &tmp, 10);
1056 ll = strtoull("gnu", &tmp, 10);
1058 mydivt = lldiv(10,1);
1063 ], [glibcxx_cv_c99_stdlib_cxx98=yes], [glibcxx_cv_c99_stdlib_cxx98=no])
1065 AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx98)
1066 if test x"$glibcxx_cv_c99_stdlib_cxx98" = x"yes"; then
1067 AC_DEFINE(_GLIBCXX98_USE_C99_STDLIB, 1,
1068 [Define if C99 functions or macros in <stdlib.h> should be imported
1069 in <cstdlib> in namespace std for C++98.])
1072 # Check for the existence in <wchar.h> of wcstold, etc.
1073 if test x"$ac_has_wchar_h" = xyes &&
1074 test x"$ac_has_wctype_h" = xyes; then
1075 AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++98])
1076 AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx98, [
1077 AC_TRY_COMPILE([#include <wchar.h>
1084 ], [], [glibcxx_cv_c99_wchar_cxx98=yes], [glibcxx_cv_c99_wchar_cxx98=no])
1087 # Checks for wide character functions that may not be present.
1088 # Injection of these is wrapped with guard macros.
1089 # NB: only put functions here, instead of immediately above, if
1090 # absolutely necessary.
1091 AC_TRY_COMPILE([#include <wchar.h>
1092 namespace test { using ::vfwscanf; }], [],
1093 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1095 AC_TRY_COMPILE([#include <wchar.h>
1096 namespace test { using ::vswscanf; }], [],
1097 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1099 AC_TRY_COMPILE([#include <wchar.h>
1100 namespace test { using ::vwscanf; }], [],
1101 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1103 AC_TRY_COMPILE([#include <wchar.h>
1104 namespace test { using ::wcstof; }], [],
1105 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1107 AC_TRY_COMPILE([#include <wctype.h>],
1108 [wint_t t; int i = iswblank(t);],
1109 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1111 AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx98)
1112 if test x"$glibcxx_cv_c99_wchar_cxx98" = x"yes"; then
1113 AC_DEFINE(_GLIBCXX98_USE_C99_WCHAR, 1,
1114 [Define if C99 functions or macros in <wchar.h> should be imported
1115 in <cwchar> in namespace std for C++98.])
1119 # Option parsed, now set things appropriately.
1120 if test x"$glibcxx_cv_c99_math_cxx98" = x"no" ||
1121 test x"$glibcxx_cv_c99_complex_cxx98" = x"no" ||
1122 test x"$glibcxx_cv_c99_stdio_cxx98" = x"no" ||
1123 test x"$glibcxx_cv_c99_stdlib_cxx98" = x"no" ||
1124 test x"$glibcxx_cv_c99_wchar_cxx98" = x"no"; then
1127 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1128 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1129 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1132 gcc_no_link="$ac_save_gcc_no_link"
1133 LIBS="$ac_save_LIBS"
1134 CXXFLAGS="$ac_save_CXXFLAGS"
1140 # Use -std=c++11 and test again for C99 library feature in C++11 mode.
1141 # For the reasons given above we use -std=c++11 not -std=gnu++11.
1142 ac_save_CXXFLAGS="$CXXFLAGS"
1143 CXXFLAGS="$CXXFLAGS -std=c++11"
1144 ac_save_LIBS="$LIBS"
1145 ac_save_gcc_no_link="$gcc_no_link"
1147 if test x$gcc_no_link != xyes; then
1148 # Use -fno-exceptions to that the C driver can link these tests without
1149 # hitting undefined references to personality routines.
1150 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1151 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
1152 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
1157 # Check for the existence of <math.h> functions used if C99 is enabled.
1158 AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++11])
1159 AC_CACHE_VAL(glibcxx_cv_c99_math_cxx11, [
1160 GCC_TRY_COMPILE_OR_LINK(
1162 volatile double d1, d2;
1164 [i = fpclassify(d1);
1170 i = isgreater(d1, d2);
1171 i = isgreaterequal(d1, d2);
1173 i = islessequal(d1, d2);
1174 i = islessgreater(d1, d2);
1175 i = islessgreater(d1, d2);
1176 i = isunordered(d1, d2);
1177 ], [glibcxx_cv_c99_math_cxx11=yes], [glibcxx_cv_c99_math_cxx11=no])
1179 AC_MSG_RESULT($glibcxx_cv_c99_math_cxx11)
1180 if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
1181 AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
1182 [Define if C99 functions or macros in <math.h> should be imported
1183 in <cmath> in namespace std for C++11.])
1186 # Check for the existence of <complex.h> complex math functions.
1187 # This is necessary even though libstdc++ uses the builtin versions
1188 # of these functions, because if the builtin cannot be used, a reference
1189 # to the library function is emitted.
1190 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
1191 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1192 if test x"$ac_has_complex_h" = x"yes"; then
1193 AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++11])
1194 AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx11, [
1195 GCC_TRY_COMPILE_OR_LINK(
1196 [#include <complex.h>
1197 typedef __complex__ float float_type;
1198 typedef __complex__ double double_type;
1199 typedef __complex__ long double ld_type;
1200 volatile float_type tmpf;
1201 volatile double_type tmpd;
1202 volatile ld_type tmpld;
1205 volatile long double ld;],
1209 tmpf = ccoshf(tmpf);
1213 tmpf = csinhf(tmpf);
1214 tmpf = csqrtf(tmpf);
1216 tmpf = ctanhf(tmpf);
1217 tmpf = cpowf(tmpf, tmpf);
1218 tmpf = cprojf(tmpf);
1230 tmpd = cpow(tmpd, tmpd);
1234 tmpld = ccosl(tmpld);
1235 tmpld = ccoshl(tmpld);
1236 tmpld = cexpl(tmpld);
1237 tmpld = clogl(tmpld);
1238 tmpld = csinl(tmpld);
1239 tmpld = csinhl(tmpld);
1240 tmpld = csqrtl(tmpld);
1241 tmpld = ctanl(tmpld);
1242 tmpld = ctanhl(tmpld);
1243 tmpld = cpowl(tmpld, tmpld);
1244 tmpld = cprojl(tmpld);
1245 ], [glibcxx_cv_c99_complex_cxx11=yes], [glibcxx_cv_c99_complex_cxx11=no])
1248 AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx11)
1249 if test x"$glibcxx_cv_c99_complex_cxx11" = x"yes"; then
1250 AC_DEFINE(_GLIBCXX11_USE_C99_COMPLEX, 1,
1251 [Define if C99 functions in <complex.h> should be used in
1252 <complex> for C++11. Using compiler builtins for these functions
1253 requires corresponding C99 library functions to be present.])
1256 # Check for the existence in <stdio.h> of vscanf, et. al.
1257 AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++11])
1258 AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx11, [
1259 GCC_TRY_COMPILE_OR_LINK(
1262 void foo(char* fmt, ...)
1264 va_list args; va_start(args, fmt);
1265 vfscanf(stderr, "%i", args);
1267 vsnprintf(fmt, 0, "%i", args);
1268 vsscanf(fmt, "%i", args);
1269 snprintf(fmt, 0, "%i");
1271 [glibcxx_cv_c99_stdio_cxx11=yes], [glibcxx_cv_c99_stdio_cxx11=no])
1273 AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx11)
1274 if test x"$glibcxx_cv_c99_stdio_cxx11" = x"yes"; then
1275 AC_DEFINE(_GLIBCXX11_USE_C99_STDIO, 1,
1276 [Define if C99 functions or macros in <stdio.h> should be imported
1277 in <cstdio> in namespace std for C++11.])
1280 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1281 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++11])
1282 AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx11, [
1283 GCC_TRY_COMPILE_OR_LINK(
1284 [#include <stdlib.h>
1286 volatile long double ld;
1287 volatile unsigned long long ll;
1290 f = strtof("gnu", &tmp);
1291 ld = strtold("gnu", &tmp);
1292 ll = strtoll("gnu", &tmp, 10);
1293 ll = strtoull("gnu", &tmp, 10);
1295 mydivt = lldiv(10,1);
1300 ], [glibcxx_cv_c99_stdlib_cxx11=yes], [glibcxx_cv_c99_stdlib_cxx11=no])
1302 AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx11)
1303 if test x"$glibcxx_cv_c99_stdlib_cxx11" = x"yes"; then
1304 AC_DEFINE(_GLIBCXX11_USE_C99_STDLIB, 1,
1305 [Define if C99 functions or macros in <stdlib.h> should be imported
1306 in <cstdlib> in namespace std for C++11.])
1309 # Check for the existence in <wchar.h> of wcstold, etc.
1310 if test x"$ac_has_wchar_h" = xyes &&
1311 test x"$ac_has_wctype_h" = xyes; then
1312 AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++11])
1313 AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx11, [
1314 AC_TRY_COMPILE([#include <wchar.h>
1321 ], [], [glibcxx_cv_c99_wchar_cxx11=yes], [glibcxx_cv_c99_wchar_cxx11=no])
1324 # Checks for wide character functions that may not be present.
1325 # Injection of these is wrapped with guard macros.
1326 # NB: only put functions here, instead of immediately above, if
1327 # absolutely necessary.
1328 AC_TRY_COMPILE([#include <wchar.h>
1329 namespace test { using ::vfwscanf; }], [],
1330 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1332 AC_TRY_COMPILE([#include <wchar.h>
1333 namespace test { using ::vswscanf; }], [],
1334 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1336 AC_TRY_COMPILE([#include <wchar.h>
1337 namespace test { using ::vwscanf; }], [],
1338 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1340 AC_TRY_COMPILE([#include <wchar.h>
1341 namespace test { using ::wcstof; }], [],
1342 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1344 AC_TRY_COMPILE([#include <wctype.h>],
1345 [wint_t t; int i = iswblank(t);],
1346 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1348 AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx11)
1349 if test x"$glibcxx_cv_c99_wchar_cxx11" = x"yes"; then
1350 AC_DEFINE(_GLIBCXX11_USE_C99_WCHAR, 1,
1351 [Define if C99 functions or macros in <wchar.h> should be imported
1352 in <cwchar> in namespace std for C++11.])
1356 gcc_no_link="$ac_save_gcc_no_link"
1357 LIBS="$ac_save_LIBS"
1358 CXXFLAGS="$ac_save_CXXFLAGS"
1362 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1363 AC_MSG_RESULT($enable_c99)
1368 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1369 dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this]
1370 dnl in the C++11 standard.
1372 dnl --enable-libstdcxx-time
1373 dnl --enable-libstdcxx-time=yes
1374 dnl checks for the availability of monotonic and realtime clocks,
1375 dnl nanosleep and sched_yield in libc and libposix4 and, if needed,
1376 dnl links in the latter.
1377 dnl --enable-libstdcxx-time=rt
1378 dnl also searches (and, if needed, links) librt. Note that this is
1379 dnl not always desirable because, in glibc 2.16 and earlier, for
1380 dnl example, in turn it triggers the linking of libpthread too,
1381 dnl which activates locking,
1382 dnl a large overhead for single-thread programs.
1383 dnl --enable-libstdcxx-time=no
1384 dnl --disable-libstdcxx-time
1385 dnl disables the checks completely
1387 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1388 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1389 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1390 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1392 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1394 GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]],
1395 [use KIND for check type],
1400 ac_save_CXXFLAGS="$CXXFLAGS"
1401 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1402 ac_save_LIBS="$LIBS"
1404 ac_has_clock_monotonic=no
1405 ac_has_clock_realtime=no
1407 ac_has_sched_yield=no
1409 if test x"$enable_libstdcxx_time" = x"auto"; then
1411 case "${target_os}" in
1413 ac_has_nanosleep=yes
1416 ac_has_nanosleep=yes
1417 ac_has_sched_yield=yes
1419 # VxWorks has nanosleep as soon as the kernel is configured with
1420 # INCLUDE_POSIX_TIMERS, which is normally/most-often the case.
1422 ac_has_nanosleep=yes
1424 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
1425 # Don't use link test for freestanding library, in case gcc_no_link=yes
1426 if test x"$is_hosted" = xyes; then
1427 # Versions of glibc before 2.17 needed -lrt for clock_gettime.
1428 AC_SEARCH_LIBS(clock_gettime, [rt])
1429 if test x"$ac_cv_search_clock_gettime" = x"none required"; then
1430 ac_has_clock_monotonic=yes
1431 ac_has_clock_realtime=yes
1434 ac_has_nanosleep=yes
1435 ac_has_sched_yield=yes
1437 freebsd*|netbsd*|dragonfly*|rtems*)
1438 ac_has_clock_monotonic=yes
1439 ac_has_clock_realtime=yes
1440 ac_has_nanosleep=yes
1441 ac_has_sched_yield=yes
1444 ac_has_clock_monotonic=yes
1445 ac_has_clock_realtime=yes
1446 ac_has_nanosleep=yes
1449 GLIBCXX_LIBS="$GLIBCXX_LIBS -lrt"
1450 ac_has_clock_monotonic=yes
1451 ac_has_clock_realtime=yes
1452 ac_has_nanosleep=yes
1453 ac_has_sched_yield=yes
1456 ac_has_nanosleep=yes
1457 ac_has_sched_yield=yes
1460 elif test x"$enable_libstdcxx_time" != x"no"; then
1462 if test x"$enable_libstdcxx_time" = x"rt"; then
1463 AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1464 AC_SEARCH_LIBS(nanosleep, [rt posix4])
1466 AC_SEARCH_LIBS(clock_gettime, [posix4])
1467 AC_SEARCH_LIBS(nanosleep, [posix4])
1470 case "$ac_cv_search_clock_gettime" in
1471 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1474 case "$ac_cv_search_nanosleep" in
1475 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1479 AC_SEARCH_LIBS(sched_yield, [rt posix4])
1481 case "$ac_cv_search_sched_yield" in
1483 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1484 ac_has_sched_yield=yes
1487 if test x"$enable_libstdcxx_time" = x"rt"; then
1488 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1489 ac_has_sched_yield=yes
1493 ac_has_sched_yield=yes
1497 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1499 if test x"$ac_has_unistd_h" = x"yes"; then
1500 AC_MSG_CHECKING([for monotonic clock])
1502 [#include <unistd.h>
1505 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1508 clock_gettime(CLOCK_MONOTONIC, &tp);
1509 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1511 AC_MSG_RESULT($ac_has_clock_monotonic)
1513 AC_MSG_CHECKING([for realtime clock])
1515 [#include <unistd.h>
1518 [#if _POSIX_TIMERS > 0
1521 clock_gettime(CLOCK_REALTIME, &tp);
1522 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1524 AC_MSG_RESULT($ac_has_clock_realtime)
1526 AC_MSG_CHECKING([for nanosleep])
1528 [#include <unistd.h>
1531 [#if _POSIX_TIMERS > 0
1535 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1537 AC_MSG_RESULT($ac_has_nanosleep)
1541 if test x"$ac_has_clock_monotonic" != x"yes"; then
1542 case ${target_os} in
1544 AC_MSG_CHECKING([for clock_gettime syscall])
1546 [#include <unistd.h>
1548 #include <sys/syscall.h>
1550 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1553 syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp);
1554 syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp);
1555 ], [ac_has_clock_monotonic_syscall=yes], [ac_has_clock_monotonic_syscall=no])
1556 AC_MSG_RESULT($ac_has_clock_monotonic_syscall)
1557 if test x"$ac_has_clock_monotonic_syscall" = x"yes"; then
1558 AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1,
1559 [ Defined if clock_gettime syscall has monotonic and realtime clock support. ])
1560 ac_has_clock_monotonic=yes
1561 ac_has_clock_realtime=yes
1566 if test x"$ac_has_clock_monotonic" = x"yes"; then
1567 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1568 [ Defined if clock_gettime has monotonic clock support. ])
1571 if test x"$ac_has_clock_realtime" = x"yes"; then
1572 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1573 [ Defined if clock_gettime has realtime clock support. ])
1576 if test x"$ac_has_sched_yield" = x"yes"; then
1577 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1578 [ Defined if sched_yield is available. ])
1581 if test x"$ac_has_nanosleep" = x"yes"; then
1582 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1583 [ Defined if nanosleep is available. ])
1585 AC_MSG_CHECKING([for sleep])
1586 AC_TRY_COMPILE([#include <unistd.h>],
1588 [ac_has_sleep=yes],[ac_has_sleep=no])
1589 if test x"$ac_has_sleep" = x"yes"; then
1590 AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.])
1592 AC_MSG_RESULT($ac_has_sleep)
1593 AC_MSG_CHECKING([for usleep])
1594 AC_TRY_COMPILE([#include <unistd.h>],
1597 [ac_has_usleep=yes],[ac_has_usleep=no])
1598 if test x"$ac_has_usleep" = x"yes"; then
1599 AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.])
1601 AC_MSG_RESULT($ac_has_usleep)
1604 if test x"$ac_has_nanosleep$ac_has_sleep" = x"nono"; then
1605 AC_MSG_CHECKING([for Sleep])
1606 AC_TRY_COMPILE([#include <windows.h>],
1608 [ac_has_win32_sleep=yes],[ac_has_win32_sleep=no])
1609 if test x"$ac_has_win32_sleep" = x"yes"; then
1610 AC_DEFINE(HAVE_WIN32_SLEEP,1, [Defined if Sleep exists.])
1612 AC_MSG_RESULT($ac_has_win32_sleep)
1615 AC_SUBST(GLIBCXX_LIBS)
1617 CXXFLAGS="$ac_save_CXXFLAGS"
1618 LIBS="$ac_save_LIBS"
1623 dnl Check for gettimeofday, used in the implementation of 20.11.7
1624 dnl [time.clock] in the C++11 standard.
1626 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1628 AC_MSG_CHECKING([for gettimeofday])
1632 ac_save_CXXFLAGS="$CXXFLAGS"
1633 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1635 ac_has_gettimeofday=no;
1636 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1637 if test x"$ac_has_sys_time_h" = x"yes"; then
1638 AC_MSG_CHECKING([for gettimeofday])
1639 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1640 [timeval tv; gettimeofday(&tv, 0);],
1641 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1643 AC_MSG_RESULT($ac_has_gettimeofday)
1646 if test x"$ac_has_gettimeofday" = x"yes"; then
1647 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1648 [ Defined if gettimeofday is available. ])
1651 CXXFLAGS="$ac_save_CXXFLAGS"
1656 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1657 dnl facilities in Chapter 8, "C compatibility".
1659 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1664 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1665 # undefined and fake C99 facilities may be spuriously enabled.
1666 ac_save_CXXFLAGS="$CXXFLAGS"
1667 CXXFLAGS="$CXXFLAGS -std=c++98"
1669 # Check for the existence of <complex.h> complex math functions used
1671 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1672 ac_c99_complex_tr1=no;
1673 if test x"$ac_has_complex_h" = x"yes"; then
1674 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1675 AC_TRY_COMPILE([#include <complex.h>],
1676 [typedef __complex__ float float_type; float_type tmpf;
1683 typedef __complex__ double double_type; double_type tmpd;
1690 typedef __complex__ long double ld_type; ld_type tmpld;
1697 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1699 AC_MSG_RESULT($ac_c99_complex_tr1)
1700 if test x"$ac_c99_complex_tr1" = x"yes"; then
1701 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1702 [Define if C99 functions in <complex.h> should be used in
1703 <tr1/complex>. Using compiler builtins for these functions
1704 requires corresponding C99 library functions to be present.])
1707 # Check for the existence of <ctype.h> functions.
1708 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1709 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1710 AC_TRY_COMPILE([#include <ctype.h>],
1714 ],[glibcxx_cv_c99_ctype_tr1=yes],
1715 [glibcxx_cv_c99_ctype_tr1=no])
1717 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1718 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1719 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1720 [Define if C99 functions in <ctype.h> should be imported in
1721 <tr1/cctype> in namespace std::tr1.])
1724 # Check for the existence of <fenv.h> functions.
1725 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1727 if test x"$ac_has_fenv_h" = x"yes"; then
1728 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1729 AC_TRY_COMPILE([#include <fenv.h>],
1734 ret = feclearexcept(except);
1735 ret = fegetexceptflag(pflag, except);
1736 ret = feraiseexcept(except);
1737 ret = fesetexceptflag(pflag, except);
1738 ret = fetestexcept(except);
1740 ret = fesetround(mode);
1741 ret = fegetenv(penv);
1742 ret = feholdexcept(penv);
1743 ret = fesetenv(penv);
1744 ret = feupdateenv(penv);
1745 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1747 AC_MSG_RESULT($ac_c99_fenv_tr1)
1748 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1749 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1750 [Define if C99 functions in <fenv.h> should be imported in
1751 <tr1/cfenv> in namespace std::tr1.])
1754 # Check for the existence of <stdint.h> types.
1755 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1756 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1757 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1758 #define __STDC_CONSTANT_MACROS
1759 #include <stdint.h>],
1760 [typedef int8_t my_int8_t;
1761 my_int8_t i8 = INT8_MIN;
1763 typedef int16_t my_int16_t;
1764 my_int16_t i16 = INT16_MIN;
1766 typedef int32_t my_int32_t;
1767 my_int32_t i32 = INT32_MIN;
1769 typedef int64_t my_int64_t;
1770 my_int64_t i64 = INT64_MIN;
1772 typedef int_fast8_t my_int_fast8_t;
1773 my_int_fast8_t if8 = INT_FAST8_MIN;
1774 if8 = INT_FAST8_MAX;
1775 typedef int_fast16_t my_int_fast16_t;
1776 my_int_fast16_t if16 = INT_FAST16_MIN;
1777 if16 = INT_FAST16_MAX;
1778 typedef int_fast32_t my_int_fast32_t;
1779 my_int_fast32_t if32 = INT_FAST32_MIN;
1780 if32 = INT_FAST32_MAX;
1781 typedef int_fast64_t my_int_fast64_t;
1782 my_int_fast64_t if64 = INT_FAST64_MIN;
1783 if64 = INT_FAST64_MAX;
1784 typedef int_least8_t my_int_least8_t;
1785 my_int_least8_t il8 = INT_LEAST8_MIN;
1786 il8 = INT_LEAST8_MAX;
1787 typedef int_least16_t my_int_least16_t;
1788 my_int_least16_t il16 = INT_LEAST16_MIN;
1789 il16 = INT_LEAST16_MAX;
1790 typedef int_least32_t my_int_least32_t;
1791 my_int_least32_t il32 = INT_LEAST32_MIN;
1792 il32 = INT_LEAST32_MAX;
1793 typedef int_least64_t my_int_least64_t;
1794 my_int_least64_t il64 = INT_LEAST64_MIN;
1795 il64 = INT_LEAST64_MAX;
1796 typedef intmax_t my_intmax_t;
1797 my_intmax_t im = INTMAX_MAX;
1799 typedef intptr_t my_intptr_t;
1800 my_intptr_t ip = INTPTR_MAX;
1802 typedef uint8_t my_uint8_t;
1803 my_uint8_t ui8 = UINT8_MAX;
1805 typedef uint16_t my_uint16_t;
1806 my_uint16_t ui16 = UINT16_MAX;
1808 typedef uint32_t my_uint32_t;
1809 my_uint32_t ui32 = UINT32_MAX;
1811 typedef uint64_t my_uint64_t;
1812 my_uint64_t ui64 = UINT64_MAX;
1814 typedef uint_fast8_t my_uint_fast8_t;
1815 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1816 uif8 = UINT_FAST8_MAX;
1817 typedef uint_fast16_t my_uint_fast16_t;
1818 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1819 uif16 = UINT_FAST16_MAX;
1820 typedef uint_fast32_t my_uint_fast32_t;
1821 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1822 uif32 = UINT_FAST32_MAX;
1823 typedef uint_fast64_t my_uint_fast64_t;
1824 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1825 uif64 = UINT_FAST64_MAX;
1826 typedef uint_least8_t my_uint_least8_t;
1827 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1828 uil8 = UINT_LEAST8_MAX;
1829 typedef uint_least16_t my_uint_least16_t;
1830 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1831 uil16 = UINT_LEAST16_MAX;
1832 typedef uint_least32_t my_uint_least32_t;
1833 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1834 uil32 = UINT_LEAST32_MAX;
1835 typedef uint_least64_t my_uint_least64_t;
1836 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1837 uil64 = UINT_LEAST64_MAX;
1838 typedef uintmax_t my_uintmax_t;
1839 my_uintmax_t uim = UINTMAX_MAX;
1841 typedef uintptr_t my_uintptr_t;
1842 my_uintptr_t uip = UINTPTR_MAX;
1844 ],[glibcxx_cv_c99_stdint_tr1=yes],
1845 [glibcxx_cv_c99_stdint_tr1=no])
1847 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1848 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1849 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1850 [Define if C99 types in <stdint.h> should be imported in
1851 <tr1/cstdint> in namespace std::tr1.])
1854 # Check for the existence of <math.h> functions.
1855 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1856 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1857 AC_TRY_COMPILE([#include <math.h>],
1858 [typedef double_t my_double_t;
1859 typedef float_t my_float_t;
1873 copysignf(0.0f, 0.0f);
1874 copysignl(0.0l, 0.0l);
1891 fmaf(0.0f, 0.0f, 0.0f);
1892 fmal(0.0l, 0.0l, 0.0l);
1908 #ifndef __APPLE__ /* see below */
1937 nextafter(0.0, 0.0);
1938 nextafterf(0.0f, 0.0f);
1939 nextafterl(0.0l, 0.0l);
1940 nexttoward(0.0, 0.0);
1941 nexttowardf(0.0f, 0.0f);
1942 nexttowardl(0.0l, 0.0l);
1943 remainder(0.0, 0.0);
1944 remainderf(0.0f, 0.0f);
1945 remainderl(0.0l, 0.0l);
1946 remquo(0.0, 0.0, 0);
1947 remquof(0.0f, 0.0f, 0);
1948 remquol(0.0l, 0.0l, 0);
1967 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1969 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1970 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1971 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1972 [Define if C99 functions or macros in <math.h> should be imported
1973 in <tr1/cmath> in namespace std::tr1.])
1975 case "${target_os}" in
1977 AC_MSG_CHECKING([for ISO C99 rounding functions in <math.h>])
1978 AC_CACHE_VAL(glibcxx_cv_c99_math_llround, [
1979 AC_TRY_COMPILE([#include <math.h>],
1987 [glibcxx_cv_c99_math_llround=yes],
1988 [glibcxx_cv_c99_math_llround=no])
1990 AC_MSG_RESULT($glibcxx_cv_c99_math_llround)
1993 if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
1994 AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
1995 [Define if C99 llrint and llround functions are missing from <math.h>.])
1999 # Check for the existence of <inttypes.h> functions (NB: doesn't make
2000 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
2001 ac_c99_inttypes_tr1=no;
2002 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2003 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
2004 AC_TRY_COMPILE([#include <inttypes.h>],
2005 [intmax_t i, numer, denom, base;
2008 intmax_t ret = imaxabs(i);
2009 imaxdiv_t dret = imaxdiv(numer, denom);
2010 ret = strtoimax(s, endptr, base);
2011 uintmax_t uret = strtoumax(s, endptr, base);
2012 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
2014 AC_MSG_RESULT($ac_c99_inttypes_tr1)
2015 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
2016 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
2017 [Define if C99 functions in <inttypes.h> should be imported in
2018 <tr1/cinttypes> in namespace std::tr1.])
2021 # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
2022 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
2023 ac_c99_inttypes_wchar_t_tr1=no;
2024 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2025 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
2026 AC_TRY_COMPILE([#include <inttypes.h>],
2030 intmax_t ret = wcstoimax(s, endptr, base);
2031 uintmax_t uret = wcstoumax(s, endptr, base);
2032 ],[ac_c99_inttypes_wchar_t_tr1=yes],
2033 [ac_c99_inttypes_wchar_t_tr1=no])
2035 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
2036 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
2037 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
2038 [Define if wchar_t C99 functions in <inttypes.h> should be
2039 imported in <tr1/cinttypes> in namespace std::tr1.])
2042 # Check for the existence of the <stdbool.h> header.
2043 AC_CHECK_HEADERS(stdbool.h)
2045 # Check for the existence of the <stdalign.h> header.
2046 AC_CHECK_HEADERS(stdalign.h)
2048 CXXFLAGS="$ac_save_CXXFLAGS"
2053 dnl Check for uchar.h and usability.
2055 AC_DEFUN([GLIBCXX_CHECK_UCHAR_H], [
2058 AC_CHECK_HEADERS(uchar.h, ac_has_uchar_h=yes, ac_has_uchar_h=no)
2062 ac_save_CXXFLAGS="$CXXFLAGS"
2063 CXXFLAGS="$CXXFLAGS -std=c++11"
2065 if test x"$ac_has_uchar_h" = x"yes"; then
2066 AC_MSG_CHECKING([for ISO C11 support for <uchar.h>])
2067 AC_TRY_COMPILE([#include <uchar.h>
2068 #ifdef __STDC_UTF_16__
2069 long i = __STDC_UTF_16__;
2071 #ifdef __STDC_UTF_32__
2072 long j = __STDC_UTF_32__;
2082 [], [ac_c11_uchar_cxx11=yes], [ac_c11_uchar_cxx11=no])
2084 ac_c11_uchar_cxx11=no
2086 AC_MSG_RESULT($ac_c11_uchar_cxx11)
2087 if test x"$ac_c11_uchar_cxx11" = x"yes"; then
2088 AC_DEFINE(_GLIBCXX_USE_C11_UCHAR_CXX11, 1,
2089 [Define if C11 functions in <uchar.h> should be imported into
2090 namespace std in <cuchar>.])
2093 CXXFLAGS="$ac_save_CXXFLAGS"
2099 dnl Check whether "/dev/random" and "/dev/urandom" are available for
2100 dnl class std::random_device from C++ 2011 [rand.device], and
2101 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
2103 AC_DEFUN([GLIBCXX_CHECK_DEV_RANDOM], [
2105 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for std::random_device])
2106 AC_CACHE_VAL(glibcxx_cv_dev_random, [
2107 if test -r /dev/random && test -r /dev/urandom; then
2108 ## For MSys environment the test above is detected as false-positive
2109 ## on mingw-targets. So disable it explicitly for them.
2110 case ${target_os} in
2111 *mingw*) glibcxx_cv_dev_random=no ;;
2112 *) glibcxx_cv_dev_random=yes ;;
2115 glibcxx_cv_dev_random=no;
2118 AC_MSG_RESULT($glibcxx_cv_dev_random)
2120 if test x"$glibcxx_cv_dev_random" = x"yes"; then
2121 AC_DEFINE(_GLIBCXX_USE_DEV_RANDOM, 1,
2122 [Define if /dev/random and /dev/urandom are available for
2123 std::random_device.])
2124 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
2125 [Define if /dev/random and /dev/urandom are available for
2126 the random_device of TR1 (Chapter 5.1).])
2132 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
2134 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
2136 AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
2137 AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
2138 [#include <stdio.h>],
2139 [AC_MSG_ERROR([computing EOF failed])])
2141 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
2142 [Define to the value of the EOF integer constant.])
2144 AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
2145 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
2146 [#include <stdio.h>],
2147 [AC_MSG_ERROR([computing SEEK_CUR failed])])
2149 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
2150 [Define to the value of the SEEK_CUR integer constant.])
2152 AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
2153 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
2154 [#include <stdio.h>],
2155 [AC_MSG_ERROR([computing SEEK_END failed])])
2157 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
2158 [Define to the value of the SEEK_END integer constant.])
2162 dnl Check whether required C++ overloads are present in <stdio.h>.
2164 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
2168 # Use C++11 because a conforming <stdio.h> won't define gets for C++14,
2169 # and we don't need a declaration for C++14 anyway.
2170 ac_save_CXXFLAGS="$CXXFLAGS"
2171 CXXFLAGS="$CXXFLAGS -std=gnu++11"
2173 AC_MSG_CHECKING([for gets declaration])
2174 AC_CACHE_VAL(glibcxx_cv_gets, [
2175 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2182 [glibcxx_cv_gets=yes],
2183 [glibcxx_cv_gets=no]
2186 if test $glibcxx_cv_gets = yes; then
2187 AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h> before C++14.])
2189 AC_MSG_RESULT($glibcxx_cv_gets)
2191 CXXFLAGS="$ac_save_CXXFLAGS"
2196 dnl Check whether required C++11 overloads for floating point and integral
2197 dnl types are present in <math.h>.
2199 AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
2203 ac_save_CXXFLAGS="$CXXFLAGS"
2204 CXXFLAGS="$CXXFLAGS -std=c++11"
2208 # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
2209 # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
2210 AC_MSG_CHECKING([for C++11 <math.h> floating point overloads])
2211 AC_CACHE_VAL(glibcxx_cv_math11_fp_overload, [
2212 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2216 inline bool isfinite(float __x)
2217 { return __builtin_isfinite(__x); }
2220 [glibcxx_cv_math11_fp_overload=no],
2221 [glibcxx_cv_math11_fp_overload=yes]
2224 # autoheader cannot handle indented templates.
2225 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP],
2226 [/* Define if all C++11 floating point overloads are available in <math.h>. */
2227 #if __cplusplus >= 201103L
2228 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2231 if test $glibcxx_cv_math11_fp_overload = yes; then
2232 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP)
2234 AC_MSG_RESULT([$glibcxx_cv_math11_fp_overload])
2236 # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
2237 # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
2238 AC_MSG_CHECKING([for C++11 <math.h> integral type overloads])
2239 AC_CACHE_VAL(glibcxx_cv_math11_int_overload, [
2240 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2243 template<typename _Tp>
2244 struct __is_integer;
2246 struct __is_integer<int>
2248 enum { __value = 1 };
2251 namespace __gnu_cxx {
2252 template<bool, typename>
2254 template<typename _Tp>
2255 struct __enable_if<true, _Tp>
2256 { typedef _Tp __type; };
2259 template<typename _Tp>
2260 constexpr typename __gnu_cxx::__enable_if
2261 <__is_integer<_Tp>::__value, double>::__type
2263 { return __builtin_log2(__x); }
2269 return std::log2(i);
2272 [glibcxx_cv_math11_int_overload=no],
2273 [glibcxx_cv_math11_int_overload=yes]
2276 # autoheader cannot handle indented templates.
2277 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT],
2278 [/* Define if all C++11 integral type overloads are available in <math.h>. */
2279 #if __cplusplus >= 201103L
2280 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2283 if test $glibcxx_cv_math11_int_overload = yes; then
2284 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT)
2286 AC_MSG_RESULT([$glibcxx_cv_math11_int_overload])
2289 # If <math.h> defines the obsolete isinf(double) and isnan(double)
2290 # functions (instead of or as well as the C99 generic macros) then we
2291 # can't define std::isinf(double) and std::isnan(double) in <cmath>
2292 # and must use the ones from <math.h> instead.
2293 AC_MSG_CHECKING([for obsolete isinf function in <math.h>])
2294 AC_CACHE_VAL(glibcxx_cv_obsolete_isinf, [
2295 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2296 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2302 bool isinf(long double);
2305 bool b = isinf(0.0);
2307 [glibcxx_cv_obsolete_isinf=yes],
2308 [glibcxx_cv_obsolete_isinf=no]
2310 AC_MSG_RESULT([$glibcxx_cv_obsolete_isinf])
2311 if test $glibcxx_cv_obsolete_isinf = yes; then
2312 AC_DEFINE(HAVE_OBSOLETE_ISINF, 1,
2313 [Define if <math.h> defines obsolete isinf function.])
2316 AC_MSG_CHECKING([for obsolete isnan function in <math.h>])
2317 AC_CACHE_VAL(glibcxx_cv_obsolete_isnan, [
2318 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2319 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2325 bool isnan(long double);
2328 bool b = isnan(0.0);
2330 [glibcxx_cv_obsolete_isnan=yes],
2331 [glibcxx_cv_obsolete_isnan=no]
2333 AC_MSG_RESULT([$glibcxx_cv_obsolete_isnan])
2334 if test $glibcxx_cv_obsolete_isnan = yes; then
2335 AC_DEFINE(HAVE_OBSOLETE_ISNAN, 1,
2336 [Define if <math.h> defines obsolete isnan function.])
2341 CXXFLAGS="$ac_save_CXXFLAGS"
2346 dnl Check whether macros, etc are present for <system_error>
2348 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
2350 m4_pushdef([n_syserr], [1])dnl
2351 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
2352 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
2353 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
2354 ECHILD, ENOSPC, EPERM,
2355 ETIMEDOUT, EWOULDBLOCK],
2356 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
2357 AC_MSG_CHECKING([for syserr])
2358 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
2359 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
2360 [int i = syserr;])],
2361 [glibcxx_cv_system_error[]n_syserr=yes],
2362 [glibcxx_cv_system_error[]n_syserr=no])
2364 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
2365 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
2366 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
2368 m4_define([n_syserr], m4_incr(n_syserr))dnl
2369 m4_popdef([SYSERR])dnl
2371 m4_popdef([n_syserr])dnl
2375 dnl Check for what type of C headers to use.
2377 dnl --enable-cheaders= [does stuff].
2378 dnl --disable-cheaders [does not do anything, really].
2379 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
2380 dnl Where DEFAULT is either 'c' or 'c_global' or 'c_std'.
2382 dnl To use the obsolete 'c_std' headers use --enable-cheaders-obsolete as
2383 dnl well as --enable-cheaders=c_std, otherwise configure will fail.
2385 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
2386 GLIBCXX_ENABLE(cheaders-obsolete,no,,
2387 [allow use of obsolete "C" headers for g++])
2388 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
2389 [construct "C" headers for g++], [permit c|c_global|c_std])
2390 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
2391 if test $enable_cheaders = c_std ; then
2392 AC_MSG_WARN([the --enable-cheaders=c_std configuration is obsolete, c_global should be used instead])
2393 AC_MSG_WARN([if you are unable to use c_global please report a bug or inform libstdc++@gcc.gnu.org])
2394 if test $enable_cheaders_obsolete != yes ; then
2395 AC_MSG_ERROR(use --enable-cheaders-obsolete to use c_std "C" headers)
2399 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
2401 # Allow overrides to configure.host here.
2402 if test $enable_cheaders = c_global; then
2406 AC_SUBST(C_INCLUDE_DIR)
2407 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
2408 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
2409 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
2410 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
2415 dnl Check for which locale library to use. The choice is mapped to
2416 dnl a subdirectory of config/locale.
2418 dnl Default is generic.
2420 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
2421 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
2422 [use MODEL for target locale package],
2423 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
2425 # Deal with gettext issues. Default to not using it (=no) until we detect
2426 # support for it later. Let the user turn it off via --e/d, but let that
2427 # default to on for easier handling.
2430 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
2434 # Either a known package, or "auto"
2435 if test $enable_clocale = no || test $enable_clocale = yes; then
2438 enable_clocale_flag=$enable_clocale
2440 # Probe for locale model to use if none specified.
2441 # Default to "generic".
2442 if test $enable_clocale_flag = auto; then
2443 case ${target_os} in
2444 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2445 enable_clocale_flag=gnu
2448 enable_clocale_flag=darwin
2450 dragonfly* | freebsd*)
2451 enable_clocale_flag=dragonfly
2454 enable_clocale_flag=newlib
2457 if test x"$with_newlib" = x"yes"; then
2458 enable_clocale_flag=newlib
2460 enable_clocale_flag=generic
2466 # Sanity check model, and test for special functionality.
2467 if test $enable_clocale_flag = gnu; then
2468 AC_EGREP_CPP([_GLIBCXX_ok], [
2469 #include <features.h>
2470 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
2473 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
2475 # Set it to scream when it hurts.
2476 ac_save_CFLAGS="$CFLAGS"
2477 CFLAGS="-Wimplicit-function-declaration -Werror"
2479 # Use strxfrm_l if available.
2480 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2482 #include <locale.h>],
2483 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
2484 AC_DEFINE(HAVE_STRXFRM_L, 1,
2485 [Define if strxfrm_l is available in <string.h>.]),)
2487 # Use strerror_l if available.
2488 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2490 #include <locale.h>],
2491 [__locale_t loc; strerror_l(5, loc);],
2492 AC_DEFINE(HAVE_STRERROR_L, 1,
2493 [Define if strerror_l is available in <string.h>.]),)
2495 CFLAGS="$ac_save_CFLAGS"
2498 # Perhaps use strerror_r if available, and strerror_l isn't.
2499 ac_save_CFLAGS="$CFLAGS"
2500 CFLAGS="-Wimplicit-function-declaration -Werror"
2501 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2503 #include <locale.h>],
2504 [char s[128]; strerror_r(5, s, 128);],
2505 AC_DEFINE(HAVE_STRERROR_R, 1,
2506 [Define if strerror_r is available in <string.h>.]),)
2507 CFLAGS="$ac_save_CFLAGS"
2509 # Set configure bits for specified locale package
2510 AC_MSG_CHECKING([for C locale to use])
2511 case ${enable_clocale_flag} in
2513 AC_MSG_RESULT(generic)
2515 CLOCALE_H=config/locale/generic/c_locale.h
2516 CLOCALE_CC=config/locale/generic/c_locale.cc
2517 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2518 CCOLLATE_CC=config/locale/generic/collate_members.cc
2519 CCTYPE_CC=config/locale/generic/ctype_members.cc
2520 CMESSAGES_H=config/locale/generic/messages_members.h
2521 CMESSAGES_CC=config/locale/generic/messages_members.cc
2522 CMONEY_CC=config/locale/generic/monetary_members.cc
2523 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2524 CTIME_H=config/locale/generic/time_members.h
2525 CTIME_CC=config/locale/generic/time_members.cc
2526 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2529 AC_MSG_RESULT(darwin)
2531 CLOCALE_H=config/locale/generic/c_locale.h
2532 CLOCALE_CC=config/locale/generic/c_locale.cc
2533 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2534 CCOLLATE_CC=config/locale/generic/collate_members.cc
2535 CCTYPE_CC=config/locale/darwin/ctype_members.cc
2536 CMESSAGES_H=config/locale/generic/messages_members.h
2537 CMESSAGES_CC=config/locale/generic/messages_members.cc
2538 CMONEY_CC=config/locale/generic/monetary_members.cc
2539 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2540 CTIME_H=config/locale/generic/time_members.h
2541 CTIME_CC=config/locale/generic/time_members.cc
2542 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2546 AC_MSG_RESULT(dragonfly or freebsd)
2548 CLOCALE_H=config/locale/dragonfly/c_locale.h
2549 CLOCALE_CC=config/locale/dragonfly/c_locale.cc
2550 CCODECVT_CC=config/locale/dragonfly/codecvt_members.cc
2551 CCOLLATE_CC=config/locale/dragonfly/collate_members.cc
2552 CCTYPE_CC=config/locale/dragonfly/ctype_members.cc
2553 CMESSAGES_H=config/locale/generic/messages_members.h
2554 CMESSAGES_CC=config/locale/generic/messages_members.cc
2555 CMONEY_CC=config/locale/dragonfly/monetary_members.cc
2556 CNUMERIC_CC=config/locale/dragonfly/numeric_members.cc
2557 CTIME_H=config/locale/dragonfly/time_members.h
2558 CTIME_CC=config/locale/dragonfly/time_members.cc
2559 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2565 # Declare intention to use gettext, and add support for specific
2567 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2570 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2571 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2572 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2575 # Export the build objects.
2576 for ling in $ALL_LINGUAS; do \
2577 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2578 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2580 AC_SUBST(glibcxx_MOFILES)
2581 AC_SUBST(glibcxx_POFILES)
2583 CLOCALE_H=config/locale/gnu/c_locale.h
2584 CLOCALE_CC=config/locale/gnu/c_locale.cc
2585 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2586 CCOLLATE_CC=config/locale/gnu/collate_members.cc
2587 CCTYPE_CC=config/locale/gnu/ctype_members.cc
2588 CMESSAGES_H=config/locale/gnu/messages_members.h
2589 CMESSAGES_CC=config/locale/gnu/messages_members.cc
2590 CMONEY_CC=config/locale/gnu/monetary_members.cc
2591 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2592 CTIME_H=config/locale/gnu/time_members.h
2593 CTIME_CC=config/locale/gnu/time_members.cc
2594 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2597 AC_MSG_RESULT(IEEE 1003.1)
2599 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2600 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2601 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2602 CCOLLATE_CC=config/locale/generic/collate_members.cc
2603 CCTYPE_CC=config/locale/generic/ctype_members.cc
2604 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2605 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2606 CMONEY_CC=config/locale/generic/monetary_members.cc
2607 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2608 CTIME_H=config/locale/generic/time_members.h
2609 CTIME_CC=config/locale/generic/time_members.cc
2610 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2613 AC_MSG_RESULT(newlib)
2615 CLOCALE_H=config/locale/generic/c_locale.h
2616 CLOCALE_CC=config/locale/generic/c_locale.cc
2617 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2618 CCOLLATE_CC=config/locale/generic/collate_members.cc
2619 CCTYPE_CC=config/locale/newlib/ctype_members.cc
2620 CMESSAGES_H=config/locale/generic/messages_members.h
2621 CMESSAGES_CC=config/locale/generic/messages_members.cc
2622 CMONEY_CC=config/locale/generic/monetary_members.cc
2623 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2624 CTIME_H=config/locale/generic/time_members.h
2625 CTIME_CC=config/locale/generic/time_members.cc
2626 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2630 # This is where the testsuite looks for locale catalogs, using the
2631 # -DLOCALEDIR define during testsuite compilation.
2632 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2633 AC_SUBST(glibcxx_localedir)
2635 # A standalone libintl (e.g., GNU libintl) may be in use.
2636 if test $USE_NLS = yes; then
2637 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2638 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2640 if test $USE_NLS = yes; then
2641 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2642 [Define if NLS translations are to be used.])
2647 AC_SUBST(CMESSAGES_H)
2648 AC_SUBST(CCODECVT_CC)
2649 AC_SUBST(CCOLLATE_CC)
2651 AC_SUBST(CMESSAGES_CC)
2653 AC_SUBST(CNUMERIC_CC)
2656 AC_SUBST(CLOCALE_CC)
2657 AC_SUBST(CLOCALE_INTERNAL_H)
2662 dnl Check for which std::allocator base class to use. The choice is
2663 dnl mapped from a subdirectory of include/ext.
2667 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2668 AC_MSG_CHECKING([for std::allocator base class])
2669 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2670 [use KIND for target std::allocator base],
2671 [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2673 # If they didn't use this option switch, or if they specified --enable
2674 # with no specific model, we'll have to look for one. If they
2675 # specified --disable (???), do likewise.
2676 if test $enable_libstdcxx_allocator = no ||
2677 test $enable_libstdcxx_allocator = yes;
2679 enable_libstdcxx_allocator=auto
2682 # Either a known package, or "auto". Auto implies the default choice
2683 # for a particular platform.
2684 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2686 # Probe for host-specific support if no specific model is specified.
2688 if test $enable_libstdcxx_allocator_flag = auto; then
2689 case ${target_os} in
2690 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2691 enable_libstdcxx_allocator_flag=new
2694 enable_libstdcxx_allocator_flag=new
2698 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2701 # Set configure bits for specified locale package
2702 case ${enable_libstdcxx_allocator_flag} in
2704 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2705 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2708 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2709 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2712 ALLOCATOR_H=config/allocator/mt_allocator_base.h
2713 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2716 ALLOCATOR_H=config/allocator/new_allocator_base.h
2717 ALLOCATOR_NAME=__gnu_cxx::new_allocator
2720 ALLOCATOR_H=config/allocator/pool_allocator_base.h
2721 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2725 GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
2726 test $enable_libstdcxx_allocator_flag = new)
2727 AC_SUBST(ALLOCATOR_H)
2728 AC_SUBST(ALLOCATOR_NAME)
2733 dnl Check for whether the Boost-derived checks should be turned on.
2735 dnl --enable-concept-checks turns them on.
2736 dnl --disable-concept-checks leaves them off.
2737 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2738 dnl Where DEFAULT is either `yes' or `no'.
2740 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2741 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2742 if test $enable_concept_checks = yes; then
2743 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2744 [Define to use concept checking code from the boost libraries.])
2749 dnl Use extern templates.
2751 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2752 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2754 dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2755 dnl Where DEFAULT is `yes' or `no'.
2757 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2759 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2761 AC_MSG_CHECKING([for extern template support])
2762 AC_MSG_RESULT([$enable_extern_template])
2764 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2768 dnl Use vtable verification.
2770 dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1
2771 dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0
2773 dnl + Usage: GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)]
2774 dnl Where DEFAULT is `yes' or `no'.
2776 AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [
2778 GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify])
2780 AC_MSG_CHECKING([for vtable verify support])
2781 AC_MSG_RESULT([$enable_vtable_verify])
2784 if test $enable_vtable_verify = yes; then
2785 case ${target_os} in
2787 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2788 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2792 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u,_vtable_map_vars_start -Wl,-u,_vtable_map_vars_end"
2793 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-rpath,${toplevel_builddir}/libvtv/.libs"
2796 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2797 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-R -Wl,${toplevel_builddir}/libvtv/.libs"
2800 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2801 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2804 VTV_PCH_CXXFLAGS="-fvtable-verify=std"
2811 AC_SUBST(VTV_CXXFLAGS)
2812 AC_SUBST(VTV_PCH_CXXFLAGS)
2813 AC_SUBST(VTV_CXXLINKFLAGS)
2814 AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes)
2815 GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes)
2819 dnl Check for parallel mode pre-requisites, including OpenMP support.
2821 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
2823 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2827 # See if configured libgomp/omp.h exists. (libgomp may be in
2828 # noconfigdirs but not explicitly disabled.)
2829 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2830 enable_parallel=yes;
2832 AC_MSG_NOTICE([target-libgomp not built])
2835 AC_MSG_CHECKING([for parallel mode support])
2836 AC_MSG_RESULT([$enable_parallel])
2841 dnl Check for which I/O library to use: stdio, or something specific.
2843 dnl Default is stdio.
2845 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2846 AC_MSG_CHECKING([for underlying I/O to use])
2847 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2848 [use target-specific I/O package], [permit stdio])
2850 # Now that libio has been removed, you can have any color you want as long
2851 # as it's black. This is one big no-op until other packages are added, but
2852 # showing the framework never hurts.
2853 case ${enable_cstdio} in
2855 CSTDIO_H=config/io/c_io_stdio.h
2856 BASIC_FILE_H=config/io/basic_file_stdio.h
2857 BASIC_FILE_CC=config/io/basic_file_stdio.cc
2858 AC_MSG_RESULT(stdio)
2863 AC_SUBST(BASIC_FILE_H)
2864 AC_SUBST(BASIC_FILE_CC)
2869 dnl Check for "unusual" flags to pass to the compiler while building.
2871 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2872 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2873 dnl --disable-cxx-flags passes nothing.
2874 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2875 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2876 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2877 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2878 dnl If "default flags" is an empty string, the effect is the same
2879 dnl as --disable or --enable=no.
2881 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2882 AC_MSG_CHECKING([for extra compiler flags for building])
2883 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2884 [pass compiler FLAGS when building library],
2885 [case "x$enable_cxx_flags" in
2886 xno | x) enable_cxx_flags= ;;
2888 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2891 # Run through flags (either default or command-line) and set anything
2892 # extra (e.g., #defines) that must accompany particular g++ options.
2893 if test -n "$enable_cxx_flags"; then
2894 for f in $enable_cxx_flags; do
2898 *) # and we're trying to pass /what/ exactly?
2899 AC_MSG_ERROR([compiler flags start with a -]) ;;
2904 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2905 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2906 AC_SUBST(EXTRA_CXX_FLAGS)
2911 dnl Check to see if debugging libraries are to be built.
2913 dnl --enable-libstdcxx-debug
2914 dnl builds a separate set of debugging libraries in addition to the
2915 dnl normal (shared, static) libstdc++ binaries.
2917 dnl --disable-libstdcxx-debug
2918 dnl builds only one (non-debug) version of libstdc++.
2920 dnl --enable-libstdcxx-debug-flags=FLAGS
2921 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2923 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2924 dnl Where DEFAULT is either `yes' or `no'.
2926 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2927 AC_MSG_CHECKING([for additional debug build])
2929 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2930 if test x$enable_libstdcxx_debug = xyes; then
2931 if test -f $toplevel_builddir/../stage_final \
2932 && test -f $toplevel_builddir/../stage_current; then
2933 stage_final=`cat $toplevel_builddir/../stage_final`
2934 stage_current=`cat $toplevel_builddir/../stage_current`
2935 if test x$stage_current != x$stage_final ; then
2936 skip_debug_build=" (skipped for bootstrap stage $stage_current)"
2937 enable_libstdcxx_debug=no
2941 AC_MSG_RESULT($enable_libstdcxx_debug$skip_debug_build)
2942 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2947 dnl Check for explicit debug flags.
2949 dnl --enable-libstdcxx-debug-flags='-O1'
2950 dnl is a general method for passing flags to be used when
2951 dnl building debug libraries with --enable-libstdcxx-debug.
2953 dnl --disable-libstdcxx-debug-flags does nothing.
2954 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2955 dnl If "default flags" is an empty string, the effect is the same
2956 dnl as --disable or --enable=no.
2958 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2959 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2960 [pass compiler FLAGS when building debug library],
2961 [case "x$enable_libstdcxx_debug_flags" in
2962 xno | x) enable_libstdcxx_debug_flags= ;;
2964 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2967 # Option parsed, now set things appropriately
2968 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2969 AC_SUBST(DEBUG_FLAGS)
2971 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2976 dnl Check if the user only wants a freestanding library implementation.
2978 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2979 dnl installing only the headers required by [17.4.1.3] and the language
2980 dnl support library. More than that will be built (to keep the Makefiles
2981 dnl conveniently clean), but not installed.
2984 dnl is_hosted (yes/no)
2987 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
2989 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2990 AC_ARG_ENABLE([hosted-libstdcxx],
2991 AC_HELP_STRING([--disable-hosted-libstdcxx],
2992 [only build freestanding C++ runtime support]),,
2995 enable_hosted_libstdcxx=no
2998 enable_hosted_libstdcxx=yes
3001 if test "$enable_hosted_libstdcxx" = no; then
3002 AC_MSG_NOTICE([Only freestanding libraries will be built])
3006 enable_libstdcxx_pch=no
3011 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
3012 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
3013 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
3018 dnl Check if the user wants a non-verbose library implementation.
3020 dnl --disable-libstdcxx-verbose will turn off descriptive messages to
3021 dnl standard error on termination.
3024 dnl _GLIBCXX_VERBOSE (always defined, either to 1 or 0)
3026 AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [
3027 AC_ARG_ENABLE([libstdcxx-verbose],
3028 AC_HELP_STRING([--disable-libstdcxx-verbose],
3029 [disable termination messages to standard error]),,
3030 [enable_libstdcxx_verbose=yes])
3031 if test x"$enable_libstdcxx_verbose" = xyes; then
3034 AC_MSG_NOTICE([verbose termination messages are disabled])
3037 AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define,
3038 [Define to 1 if a verbose library is built, or 0 otherwise.])
3043 dnl Check for template specializations for the 'long long' type.
3044 dnl The result determines only whether 'long long' I/O is enabled; things
3045 dnl like numeric_limits<> specializations are always available.
3047 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
3048 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
3049 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
3050 dnl Where DEFAULT is either `yes' or `no'.
3052 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
3053 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
3054 if test $enable_long_long = yes; then
3055 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
3056 [Define if code specialized for long long should be used.])
3058 AC_MSG_CHECKING([for enabled long long specializations])
3059 AC_MSG_RESULT([$enable_long_long])
3064 dnl Check for decimal floating point.
3066 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
3068 dnl This checks to see if the host supports decimal floating point types.
3071 dnl _GLIBCXX_USE_DECIMAL_FLOAT
3073 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
3075 # Fake what AC_TRY_COMPILE does, without linking as this is
3076 # unnecessary for this test.
3078 cat > conftest.$ac_ext << EOF
3079 [#]line __oline__ "configure"
3089 AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
3090 if AC_TRY_EVAL(ac_compile); then
3091 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
3092 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
3097 AC_MSG_RESULT($enable_dfp)
3102 dnl Check for GNU 128-bit integer and floating point types.
3104 dnl Note: also checks that the types aren't standard types.
3107 dnl _GLIBCXX_USE_INT128
3110 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
3115 # Fake what AC_TRY_COMPILE does, without linking as this is
3116 # unnecessary for this test.
3118 cat > conftest.$ac_ext << EOF
3119 [#]line __oline__ "configure"
3120 template<typename T1, typename T2>
3122 { typedef T2 type; };
3124 template<typename T>
3129 typename same<long, __int128>::type i1;
3130 typename same<long long, __int128>::type i2;
3134 AC_MSG_CHECKING([for __int128])
3135 if AC_TRY_EVAL(ac_compile); then
3136 AC_DEFINE(_GLIBCXX_USE_INT128, 1,
3137 [Define if __int128 is supported on this host.])
3142 AC_MSG_RESULT($enable_int128)
3145 cat > conftest.$ac_ext << EOF
3146 [#]line __oline__ "configure"
3147 template<typename T1, typename T2>
3149 { typedef T2 type; };
3151 template<typename T>
3156 typename same<double, __float128>::type f1;
3157 typename same<long double, __float128>::type f2;
3161 AC_MSG_CHECKING([for __float128])
3162 if AC_TRY_EVAL(ac_compile); then
3167 AC_MSG_RESULT($enable_float128)
3168 GLIBCXX_CONDITIONAL(ENABLE_FLOAT128, test $enable_float128 = yes)
3175 dnl Check for template specializations for the 'wchar_t' type.
3177 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
3178 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
3179 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
3180 dnl Where DEFAULT is either `yes' or `no'.
3182 dnl Necessary support must also be present.
3184 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
3185 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
3187 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
3188 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
3189 AC_MSG_CHECKING([for mbstate_t])
3190 AC_TRY_COMPILE([#include <wchar.h>],
3191 [mbstate_t teststate;],
3192 have_mbstate_t=yes, have_mbstate_t=no)
3193 AC_MSG_RESULT($have_mbstate_t)
3194 if test x"$have_mbstate_t" = xyes; then
3195 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
3198 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
3200 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
3202 if test x"$enable_wchar_t" = x"yes"; then
3207 if test x"$ac_has_wchar_h" = xyes &&
3208 test x"$ac_has_wctype_h" = xyes; then
3209 AC_TRY_COMPILE([#include <wchar.h>
3270 ],[],[], [enable_wchar_t=no])
3278 if test x"$enable_wchar_t" = x"yes"; then
3279 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
3280 [Define if code specialized for wchar_t should be used.])
3283 AC_MSG_CHECKING([for enabled wchar_t specializations])
3284 AC_MSG_RESULT([$enable_wchar_t])
3289 dnl Check to see if building and using a C++ precompiled header can be done.
3291 dnl --enable-libstdcxx-pch=yes
3292 dnl default, this shows intent to use stdc++.h.gch If it looks like it
3293 dnl may work, after some light-hearted attempts to puzzle out compiler
3294 dnl support, flip bits on in include/Makefile.am
3296 dnl --disable-libstdcxx-pch
3297 dnl turns off attempts to use or build stdc++.h.gch.
3300 dnl glibcxx_PCHFLAGS
3302 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
3303 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
3304 if test $enable_libstdcxx_pch = yes; then
3305 AC_CACHE_CHECK([for compiler with PCH support],
3306 [glibcxx_cv_prog_CXX_pch],
3307 [ac_save_CXXFLAGS="$CXXFLAGS"
3308 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
3311 echo '#include <math.h>' > conftest.h
3312 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
3313 -o conftest.h.gch 1>&5 2>&1 &&
3314 echo '#error "pch failed"' > conftest.h &&
3315 echo '#include "conftest.h"' > conftest.cc &&
3316 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
3318 glibcxx_cv_prog_CXX_pch=yes
3320 glibcxx_cv_prog_CXX_pch=no
3323 CXXFLAGS=$ac_save_CXXFLAGS
3326 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
3329 AC_MSG_CHECKING([for enabled PCH])
3330 AC_MSG_RESULT([$enable_libstdcxx_pch])
3332 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
3333 if test $enable_libstdcxx_pch = yes; then
3334 glibcxx_PCHFLAGS="-include bits/stdc++.h"
3338 AC_SUBST(glibcxx_PCHFLAGS)
3343 dnl Check for atomic builtins.
3345 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
3347 dnl This checks to see if the host supports the compiler-generated
3348 dnl builtins for atomic operations for various integral sizes. Note, this
3349 dnl is intended to be an all-or-nothing switch, so all the atomic operations
3350 dnl that are used should be checked.
3353 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
3355 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
3358 old_CXXFLAGS="$CXXFLAGS"
3360 # Do link tests if possible, instead asm tests, limited to some platforms
3361 # see discussion in PR target/40134, PR libstdc++/40133 and the thread
3362 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
3363 atomic_builtins_link_tests=no
3364 if test x$gcc_no_link != xyes; then
3365 # Can do link tests. Limit to some tested platforms
3367 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
3368 atomic_builtins_link_tests=yes
3373 if test x$atomic_builtins_link_tests = xyes; then
3377 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3379 AC_MSG_CHECKING([for atomic builtins for bool])
3380 AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
3383 [typedef bool atomic_type;
3387 // N.B. __atomic_fetch_add is not supported for bool.
3388 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3390 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3391 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3393 [glibcxx_cv_atomic_bool=yes],
3394 [glibcxx_cv_atomic_bool=no])
3396 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3398 AC_MSG_CHECKING([for atomic builtins for short])
3399 AC_CACHE_VAL(glibcxx_cv_atomic_short, [
3402 [typedef short atomic_type;
3406 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3407 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3409 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3410 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3412 [glibcxx_cv_atomic_short=yes],
3413 [glibcxx_cv_atomic_short=no])
3415 AC_MSG_RESULT($glibcxx_cv_atomic_short)
3417 AC_MSG_CHECKING([for atomic builtins for int])
3418 AC_CACHE_VAL(glibcxx_cv_atomic_int, [
3421 [typedef int atomic_type;
3425 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
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);
3431 [glibcxx_cv_atomic_int=yes],
3432 [glibcxx_cv_atomic_int=no])
3434 AC_MSG_RESULT($glibcxx_cv_atomic_int)
3436 AC_MSG_CHECKING([for atomic builtins for long long])
3437 AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
3440 [typedef long long atomic_type;
3444 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3445 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3447 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3448 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3450 [glibcxx_cv_atomic_long_long=yes],
3451 [glibcxx_cv_atomic_long_long=no])
3453 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3459 # Compile unoptimized.
3462 # Fake what AC_TRY_COMPILE does.
3464 cat > conftest.$ac_ext << EOF
3465 [#]line __oline__ "configure"
3468 typedef bool atomic_type;
3472 // N.B. __atomic_fetch_add is not supported for bool.
3473 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3475 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3476 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3482 AC_MSG_CHECKING([for atomic builtins for bool])
3483 if AC_TRY_EVAL(ac_compile); then
3484 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3485 glibcxx_cv_atomic_bool=no
3487 glibcxx_cv_atomic_bool=yes
3490 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3493 cat > conftest.$ac_ext << EOF
3494 [#]line __oline__ "configure"
3497 typedef short atomic_type;
3501 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3502 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3504 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3505 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3511 AC_MSG_CHECKING([for atomic builtins for short])
3512 if AC_TRY_EVAL(ac_compile); then
3513 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3514 glibcxx_cv_atomic_short=no
3516 glibcxx_cv_atomic_short=yes
3519 AC_MSG_RESULT($glibcxx_cv_atomic_short)
3522 cat > conftest.$ac_ext << EOF
3523 [#]line __oline__ "configure"
3526 // NB: _Atomic_word not necessarily int.
3527 typedef int atomic_type;
3531 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3532 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3534 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3535 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3541 AC_MSG_CHECKING([for atomic builtins for int])
3542 if AC_TRY_EVAL(ac_compile); then
3543 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3544 glibcxx_cv_atomic_int=no
3546 glibcxx_cv_atomic_int=yes
3549 AC_MSG_RESULT($glibcxx_cv_atomic_int)
3552 cat > conftest.$ac_ext << EOF
3553 [#]line __oline__ "configure"
3556 typedef long long atomic_type;
3560 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3561 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3563 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3564 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3570 AC_MSG_CHECKING([for atomic builtins for long long])
3571 if AC_TRY_EVAL(ac_compile); then
3572 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3573 glibcxx_cv_atomic_long_long=no
3575 glibcxx_cv_atomic_long_long=yes
3578 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3583 CXXFLAGS="$old_CXXFLAGS"
3586 # Set atomicity_dir to builtins if all but the long long test above passes,
3587 # or if the builtins were already chosen (e.g. by configure.host).
3588 if { test "$glibcxx_cv_atomic_bool" = yes \
3589 && test "$glibcxx_cv_atomic_short" = yes \
3590 && test "$glibcxx_cv_atomic_int" = yes; } \
3591 || test "$atomicity_dir" = "cpu/generic/atomicity_builtins"; then
3592 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
3593 [Define if the compiler supports C++11 atomics.])
3594 atomicity_dir=cpu/generic/atomicity_builtins
3597 # If still generic, set to mutex.
3598 if test $atomicity_dir = "cpu/generic" ; then
3599 atomicity_dir=cpu/generic/atomicity_mutex
3600 AC_MSG_WARN([No native atomic operations are provided for this platform.])
3601 if test "x$target_thread_file" = xsingle; then
3602 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
3603 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
3605 AC_MSG_WARN([They will be faked using a mutex.])
3606 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
3613 dnl Set default lock policy for synchronizing shared_ptr reference counting.
3615 dnl --with-libstdcxx-lock-policy=auto
3616 dnl Use atomic operations for shared_ptr reference counting only if
3617 dnl the default target supports atomic compare-and-swap.
3618 dnl --with-libstdcxx-lock-policy=atomic
3619 dnl Use atomic operations for shared_ptr reference counting.
3620 dnl --with-libstdcxx-lock-policy=mutex
3621 dnl Use a mutex to synchronize shared_ptr reference counting.
3623 dnl This controls the value of __gnu_cxx::__default_lock_policy, which
3624 dnl determines how shared_ptr reference counts are synchronized.
3625 dnl The option "atomic" means that atomic operations should be used,
3626 dnl "mutex" means that a mutex will be used. The default option, "auto",
3627 dnl will check if the target supports the compiler-generated builtins
3628 dnl for atomic compare-and-swap operations for 2-byte and 4-byte integers,
3629 dnl and will use "atomic" if supported, "mutex" otherwise.
3630 dnl This option is ignored if the thread model used by GCC is "single",
3631 dnl as no synchronization is used at all in that case.
3632 dnl This option affects the library ABI (except in the "single" thread model).
3634 dnl Defines _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY to 1 if atomics should be used.
3636 AC_DEFUN([GLIBCXX_ENABLE_LOCK_POLICY], [
3638 AC_ARG_WITH([libstdcxx-lock-policy],
3639 AC_HELP_STRING([--with-libstdcxx-lock-policy={atomic,mutex,auto}],
3640 [synchronization policy for shared_ptr reference counting [default=auto]]),
3641 [libstdcxx_atomic_lock_policy=$withval],
3642 [libstdcxx_atomic_lock_policy=auto])
3644 case "$libstdcxx_atomic_lock_policy" in
3645 atomic|mutex|auto) ;;
3646 *) AC_MSG_ERROR([Invalid argument for --with-libstdcxx-lock-policy]) ;;
3648 AC_MSG_CHECKING([for lock policy for shared_ptr reference counts])
3650 if test x"$libstdcxx_atomic_lock_policy" = x"auto"; then
3653 ac_save_CXXFLAGS="$CXXFLAGS"
3655 dnl Why do we care about 2-byte CAS on targets with 4-byte _Atomic_word?!
3657 #if ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
3658 # error "No 2-byte compare-and-swap"
3659 #elif ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
3660 # error "No 4-byte compare-and-swap"
3663 [libstdcxx_atomic_lock_policy=atomic],
3664 [libstdcxx_atomic_lock_policy=mutex])
3666 CXXFLAGS="$ac_save_CXXFLAGS"
3669 if test x"$libstdcxx_atomic_lock_policy" = x"atomic"; then
3670 AC_MSG_RESULT(atomic)
3671 AC_DEFINE(HAVE_ATOMIC_LOCK_POLICY,1,
3672 [Defined if shared_ptr reference counting should use atomic operations.])
3674 AC_MSG_RESULT(mutex)
3680 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3682 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3683 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3684 dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3685 dnl Where DEFAULT is 'yes'.
3687 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3688 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3690 if test x$enable_libstdcxx_visibility = xyes ; then
3691 dnl all hail libgfortran
3692 dnl Check whether the target supports hidden visibility.
3693 AC_CACHE_CHECK([whether the target supports hidden visibility],
3694 glibcxx_cv_have_attribute_visibility, [
3695 save_CFLAGS="$CFLAGS"
3696 CFLAGS="$CFLAGS -Werror"
3697 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3698 [], glibcxx_cv_have_attribute_visibility=yes,
3699 glibcxx_cv_have_attribute_visibility=no)
3700 CFLAGS="$save_CFLAGS"])
3701 if test $glibcxx_cv_have_attribute_visibility = no; then
3702 enable_libstdcxx_visibility=no
3706 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3707 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3712 dnl Add version tags to symbols in shared library (or not), additionally
3713 dnl marking other symbols as private/local (or not).
3715 dnl Sets libtool_VERSION, and determines shared library SONAME.
3717 dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3719 dnl --enable-symvers=style adds a version script to the linker call when
3720 dnl creating the shared library. The choice of version script is
3721 dnl controlled by 'style'.
3722 dnl --disable-symvers does not.
3724 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3725 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
3726 dnl choose a default style based on linker characteristics. Passing
3727 dnl 'no' disables versioning.
3729 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3731 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3732 [enables symbol versioning of the shared library],
3733 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3735 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3736 # don't know enough about $LD to do tricks...
3737 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3738 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3739 # with extern "C++" in version scripts.
3740 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3742 # Turn a 'yes' into a suitable default.
3743 if test x$enable_symvers = xyes ; then
3744 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3747 if test $with_gnu_ld = yes ; then
3748 case ${target_os} in
3750 enable_symvers=no ;;
3752 enable_symvers=gnu ;;
3755 case ${target_os} in
3757 enable_symvers=darwin ;;
3758 # Sun symbol versioning exists since Solaris 2.5.
3759 solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3760 # make_sunver.pl needs GNU c++filt to support extern "C++" in
3761 # version scripts, so disable symbol versioning if none can be
3763 if test -z "$ac_cv_path_CXXFILT"; then
3764 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3765 AC_MSG_WARN([=== no GNU c++filt could be found.])
3766 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3773 enable_symvers=no ;;
3779 # Check to see if 'darwin' or 'darwin-export' can win.
3780 if test x$enable_symvers = xdarwin-export ; then
3781 enable_symvers=darwin
3784 # Check if 'sun' was requested on non-Solaris 2 platforms.
3785 if test x$enable_symvers = xsun ; then
3786 case ${target_os} in
3792 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3793 AC_MSG_WARN([=== you are not targetting Solaris 2.])
3794 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3800 # Check to see if 'gnu' can win.
3801 if test $enable_symvers = gnu ||
3802 test $enable_symvers = gnu-versioned-namespace ||
3803 test $enable_symvers = sun; then
3804 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3805 AC_MSG_CHECKING([for shared libgcc])
3806 ac_save_CFLAGS="$CFLAGS"
3808 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3809 CFLAGS="$ac_save_CFLAGS"
3810 if test $glibcxx_shared_libgcc = no; then
3811 cat > conftest.c <<EOF
3812 int main (void) { return 0; }
3815 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3816 -shared -shared-libgcc -o conftest.so \
3817 conftest.c -v 2>&1 >/dev/null \
3818 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3820 rm -f conftest.c conftest.so
3821 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3822 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3823 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3824 CFLAGS="$ac_save_CFLAGS"
3827 AC_MSG_RESULT($glibcxx_shared_libgcc)
3829 # For GNU ld, we need at least this version. The format is described in
3830 # GLIBCXX_CHECK_LINKER_FEATURES above.
3831 glibcxx_min_gnu_ld_version=21400
3833 # If no shared libgcc, can't win.
3834 if test $glibcxx_shared_libgcc != yes; then
3835 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3836 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3837 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3839 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3840 : All interesting versions of Sun ld support sun style symbol versioning.
3841 elif test $with_gnu_ld != yes ; then
3843 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3844 AC_MSG_WARN([=== you are not using the GNU linker.])
3845 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3847 elif test $glibcxx_ld_is_gold = yes ; then
3848 : All versions of gold support symbol versioning.
3849 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3850 # The right tools, the right setup, but too old. Fallbacks?
3851 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3852 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3853 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3854 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3855 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3860 # For libtool versioning info, format is CURRENT:REVISION:AGE
3861 libtool_VERSION=6:29:0
3863 # Everything parsed; figure out what files and settings to use.
3864 case $enable_symvers in
3866 SYMVER_FILE=config/abi/pre/none.ver
3869 SYMVER_FILE=config/abi/pre/gnu.ver
3870 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3871 [Define to use GNU versioning in the shared library.])
3873 gnu-versioned-namespace)
3874 libtool_VERSION=8:0:0
3875 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3876 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3877 [Define to use GNU namespace versioning in the shared library.])
3880 SYMVER_FILE=config/abi/pre/gnu.ver
3881 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3882 [Define to use darwin versioning in the shared library.])
3885 SYMVER_FILE=config/abi/pre/gnu.ver
3886 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3887 [Define to use Sun versioning in the shared library.])
3891 if test x$enable_symvers != xno ; then
3892 AC_DEFINE(_GLIBCXX_SYMVER, 1,
3893 [Define to use symbol versioning in the shared library.])
3896 AC_CACHE_CHECK([whether the target supports .symver directive],
3897 glibcxx_cv_have_as_symver_directive, [
3898 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3899 [], glibcxx_cv_have_as_symver_directive=yes,
3900 glibcxx_cv_have_as_symver_directive=no)])
3901 if test $glibcxx_cv_have_as_symver_directive = yes; then
3902 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3903 [Define to 1 if the target assembler supports .symver directive.])
3906 AC_SUBST(SYMVER_FILE)
3907 AC_SUBST(port_specific_symbol_files)
3908 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3909 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3910 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3911 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3912 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3913 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3915 if test $enable_symvers != no ; then
3916 case ${target_os} in
3917 # The Solaris 2 runtime linker doesn't support the GNU extension of
3918 # binding the same symbol to different versions
3921 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3923 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3924 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3929 # Now, set up compatibility support, if any.
3930 # In addition, need this to deal with std::size_t mangling in
3931 # src/compatibility.cc. In a perfect world, could use
3932 # typeid(std::size_t).name()[0] to do direct substitution.
3933 AC_MSG_CHECKING([for size_t as unsigned int])
3934 ac_save_CFLAGS="$CFLAGS"
3936 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3937 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3938 CFLAGS=$ac_save_CFLAGS
3939 if test "$glibcxx_size_t_is_i" = yes; then
3940 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3942 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3944 AC_MSG_CHECKING([for ptrdiff_t as int])
3945 ac_save_CFLAGS="$CFLAGS"
3947 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3948 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3949 CFLAGS=$ac_save_CFLAGS
3950 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3951 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3953 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3958 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3959 dnl We must stage the required headers so that they will be installed
3960 dnl with the library (unlike libgcc, the STL implementation is provided
3961 dnl solely within headers). Since we must not inject random user-space
3962 dnl macro names into user-provided C++ code, we first stage into <file>-in
3963 dnl and process to <file> with an output command. The reason for a two-
3964 dnl stage process here is to correctly handle $srcdir!=$objdir without
3965 dnl having to write complex code (the sed commands to clean the macro
3966 dnl namespace are complex and fragile enough as it is). We must also
3967 dnl add a relative path so that -I- is supported properly.
3972 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3973 AC_MSG_CHECKING([for thread model used by GCC])
3974 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3975 AC_MSG_RESULT([$target_thread_file])
3976 GCC_AC_THREAD_HEADER([$target_thread_file])
3981 dnl Check if gthread implementation defines the types and functions
3982 dnl required by the c++0x thread library. Conforming gthread
3983 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3985 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3987 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3988 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3990 if test x$enable_libstdcxx_threads = xauto ||
3991 test x$enable_libstdcxx_threads = xyes; then
3996 ac_save_CXXFLAGS="$CXXFLAGS"
3997 CXXFLAGS="$CXXFLAGS -fno-exceptions \
3998 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
4000 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
4001 case $target_thread_file in
4003 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
4006 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
4008 AC_TRY_COMPILE([#include <unistd.h>],
4010 // In case of POSIX threads check _POSIX_TIMEOUTS.
4011 #if (defined(_PTHREADS) \
4012 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
4015 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
4017 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
4018 [Define to 1 if mutex_timedlock is available.])
4020 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
4021 else res_mutex_timedlock=no ; fi
4022 AC_MSG_RESULT([$res_mutex_timedlock])
4024 AC_MSG_CHECKING([for gthreads library])
4026 AC_TRY_COMPILE([#include "gthr.h"],
4028 #ifndef __GTHREADS_CXX0X
4031 ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
4036 AC_MSG_RESULT([$ac_has_gthreads])
4038 if test x"$ac_has_gthreads" = x"yes"; then
4039 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
4040 [Define if gthreads library is available.])
4042 # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14
4043 # but only do so if we're using pthread in the gthread library.
4044 # On VxWorks for example, pthread_rwlock_t is defined in sys/types.h
4045 # but the pthread library is not there by default and the gthread library
4047 AC_TRY_COMPILE([#include "gthr.h"],
4049 #if (!defined(_PTHREADS))
4052 ], [ac_gthread_use_pthreads=yes], [ac_gthread_use_pthreads=no])
4053 if test x"$ac_gthread_use_pthreads" = x"yes"; then
4054 AC_CHECK_TYPE([pthread_rwlock_t],
4055 [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1,
4056 [Define if POSIX read/write locks are available in <gthr.h>.])],
4058 [#include "gthr.h"])
4062 CXXFLAGS="$ac_save_CXXFLAGS"
4067 # Check whether LC_MESSAGES is available in <locale.h>.
4068 # Ulrich Drepper <drepper@cygnus.com>, 1995.
4070 # This file file be copied and used freely without restrictions. It can
4071 # be used in projects which are not available under the GNU Public License
4072 # but which still want to provide support for the GNU gettext functionality.
4073 # Please note that the actual code is *not* freely available.
4074 AC_DEFUN([AC_LC_MESSAGES], [
4075 AC_CHECK_HEADER(locale.h, [
4076 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
4077 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
4078 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
4079 if test $ac_cv_val_LC_MESSAGES = yes; then
4080 AC_DEFINE(HAVE_LC_MESSAGES, 1,
4081 [Define if LC_MESSAGES is available in <locale.h>.])
4087 dnl Check whether rdrand is supported in the assembler.
4088 AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [
4089 AC_MSG_CHECKING([for rdrand support in assembler])
4090 AC_CACHE_VAL(ac_cv_x86_rdrand, [
4095 AC_TRY_COMPILE(, [asm("rdrand %eax");],
4096 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no])
4099 if test $ac_cv_x86_rdrand = yes; then
4100 AC_DEFINE(_GLIBCXX_X86_RDRAND, 1,
4101 [ Defined if as can handle rdrand. ])
4103 AC_MSG_RESULT($ac_cv_x86_rdrand)
4107 dnl Check whether rdseed is supported in the assembler.
4108 AC_DEFUN([GLIBCXX_CHECK_X86_RDSEED], [
4109 AC_MSG_CHECKING([for rdseed support in assembler])
4110 AC_CACHE_VAL(ac_cv_x86_rdseed, [
4115 AC_TRY_COMPILE(, [asm("rdseed %eax");],
4116 [ac_cv_x86_rdseed=yes], [ac_cv_x86_rdseed=no])
4119 if test $ac_cv_x86_rdseed = yes; then
4120 AC_DEFINE(_GLIBCXX_X86_RDSEED, 1,
4121 [ Defined if as can handle rdseed. ])
4123 AC_MSG_RESULT($ac_cv_x86_rdseed)
4127 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
4129 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
4133 ac_save_CXXFLAGS="$CXXFLAGS"
4134 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4136 AC_MSG_CHECKING([for get_nprocs])
4137 AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
4138 GCC_TRY_COMPILE_OR_LINK(
4139 [#include <sys/sysinfo.h>],
4140 [int n = get_nprocs();],
4141 [glibcxx_cv_GET_NPROCS=yes],
4142 [glibcxx_cv_GET_NPROCS=no])
4144 if test $glibcxx_cv_GET_NPROCS = yes; then
4145 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
4147 AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
4149 CXXFLAGS="$ac_save_CXXFLAGS"
4154 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
4156 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
4160 ac_save_CXXFLAGS="$CXXFLAGS"
4161 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4163 AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
4164 AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
4165 GCC_TRY_COMPILE_OR_LINK(
4166 [#include <unistd.h>],
4167 [int n = sysconf(_SC_NPROCESSORS_ONLN);],
4168 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
4169 [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
4171 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
4172 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.])
4174 AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
4176 CXXFLAGS="$ac_save_CXXFLAGS"
4181 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
4183 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
4187 ac_save_CXXFLAGS="$CXXFLAGS"
4188 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4190 AC_MSG_CHECKING([for _SC_NPROC_ONLN])
4191 AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [
4192 GCC_TRY_COMPILE_OR_LINK(
4193 [#include <unistd.h>],
4194 [int n = sysconf(_SC_NPROC_ONLN);],
4195 [glibcxx_cv_SC_NPROC_ONLN=yes],
4196 [glibcxx_cv_SC_NPROC_ONLN=no])
4198 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
4199 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.])
4201 AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN)
4203 CXXFLAGS="$ac_save_CXXFLAGS"
4208 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
4210 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
4214 ac_save_CXXFLAGS="$CXXFLAGS"
4215 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4217 AC_MSG_CHECKING([for pthreads_num_processors_np])
4218 AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
4219 GCC_TRY_COMPILE_OR_LINK(
4220 [#include <pthread.h>],
4221 [int n = pthread_num_processors_np();],
4222 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
4223 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
4225 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
4226 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
4228 AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP)
4230 CXXFLAGS="$ac_save_CXXFLAGS"
4235 dnl Check whether pthread_cond_clockwait is available in <pthread.h> for std::condition_variable to use,
4236 dnl and define _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT.
4238 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_COND_CLOCKWAIT], [
4242 ac_save_CXXFLAGS="$CXXFLAGS"
4243 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4244 ac_save_LIBS="$LIBS"
4245 LIBS="$LIBS -lpthread"
4247 AC_MSG_CHECKING([for pthread_cond_clockwait])
4248 AC_CACHE_VAL(glibcxx_cv_PTHREAD_COND_CLOCKWAIT, [
4249 GCC_TRY_COMPILE_OR_LINK(
4250 [#include <pthread.h>],
4251 [pthread_mutex_t mutex; pthread_cond_t cond; struct timespec ts; int n = pthread_cond_clockwait(&cond, &mutex, 0, &ts);],
4252 [glibcxx_cv_PTHREAD_COND_CLOCKWAIT=yes],
4253 [glibcxx_cv_PTHREAD_COND_CLOCKWAIT=no])
4255 if test $glibcxx_cv_PTHREAD_COND_CLOCKWAIT = yes; then
4256 AC_DEFINE(_GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT, 1, [Define if pthread_cond_clockwait is available in <pthread.h>.])
4258 AC_MSG_RESULT($glibcxx_cv_PTHREAD_COND_CLOCKWAIT)
4260 CXXFLAGS="$ac_save_CXXFLAGS"
4261 LIBS="$ac_save_LIBS"
4266 dnl Check whether pthread_mutex_clocklock is available in <pthread.h> for std::timed_mutex to use,
4267 dnl and define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK.
4269 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_MUTEX_CLOCKLOCK], [
4273 ac_save_CXXFLAGS="$CXXFLAGS"
4274 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4275 ac_save_LIBS="$LIBS"
4276 LIBS="$LIBS -lpthread"
4278 AC_MSG_CHECKING([for pthread_mutex_clocklock])
4279 AC_CACHE_VAL(glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK, [
4280 GCC_TRY_COMPILE_OR_LINK(
4281 [#include <pthread.h>],
4282 [pthread_mutex_t mutex; struct timespec ts; int n = pthread_mutex_clocklock(&mutex, CLOCK_REALTIME, &ts);],
4283 [glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK=yes],
4284 [glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK=no])
4286 if test $glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK = yes; then
4287 AC_DEFINE(_GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK, 1, [Define if pthread_mutex_clocklock is available in <pthread.h>.])
4289 AC_MSG_RESULT($glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK)
4291 CXXFLAGS="$ac_save_CXXFLAGS"
4292 LIBS="$ac_save_LIBS"
4297 dnl Check whether pthread_mutex_clocklock is available in <pthread.h> for std::timed_mutex to use,
4298 dnl and define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK.
4300 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_RWLOCK_CLOCKLOCK], [
4304 ac_save_CXXFLAGS="$CXXFLAGS"
4305 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4306 ac_save_LIBS="$LIBS"
4307 LIBS="$LIBS -lpthread"
4309 AC_MSG_CHECKING([for pthread_rwlock_clockrdlock, pthread_wlock_clockwrlock])
4310 AC_CACHE_VAL(glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK, [
4311 GCC_TRY_COMPILE_OR_LINK(
4312 [#include <pthread.h>],
4313 [pthread_rwlock_t rwl; struct timespec ts;]
4314 [int n = pthread_rwlock_clockrdlock(&rwl, CLOCK_REALTIME, &ts);]
4315 [int m = pthread_rwlock_clockwrlock(&rwl, CLOCK_REALTIME, &ts);],
4316 [glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK=yes],
4317 [glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK=no])
4319 if test $glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK = yes; then
4320 AC_DEFINE(_GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK, 1, [Define if pthread_rwlock_clockrdlock and pthread_rwlock_clockwrlock are available in <pthread.h>.])
4322 AC_MSG_RESULT($glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK)
4324 CXXFLAGS="$ac_save_CXXFLAGS"
4325 LIBS="$ac_save_LIBS"
4330 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
4332 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
4336 ac_save_CXXFLAGS="$CXXFLAGS"
4337 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4339 AC_MSG_CHECKING([for hw.ncpu sysctl])
4340 AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [
4341 GCC_TRY_COMPILE_OR_LINK(
4344 #include <sys/sysctl.h>
4348 size_t size = sizeof(count);
4349 int mib[] = { CTL_HW, HW_NCPU };
4350 sysctl(mib, 2, &count, &size, NULL, 0);
4352 [glibcxx_cv_SYSCTL_HW_NCPU=yes],
4353 [glibcxx_cv_SYSCTL_HW_NCPU=no])
4355 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
4356 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
4358 AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU)
4360 CXXFLAGS="$ac_save_CXXFLAGS"
4365 dnl Check to see if python pretty printing can be activated.
4367 dnl --with-python-dir=dir
4368 dnl installs directory into $prefix/dir
4369 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
4371 AC_MSG_CHECKING([for custom python install directory])
4372 AC_ARG_WITH([python-dir],
4373 AS_HELP_STRING([--with-python-dir],
4374 [the location to install Python modules. This path is relative starting from the prefix.]),
4375 [with_python_dir=$withval], [with_python_dir="no"])
4376 AC_MSG_RESULT(${with_python_dir})
4378 # Needed for installing Python modules during make install.
4379 python_mod_dir="${with_python_dir}"
4380 AC_SUBST(python_mod_dir)
4381 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
4385 dnl Check to see if -Werror is disabled.
4387 dnl --enable-werror/--disable-werror
4388 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
4389 AC_MSG_CHECKING([for -Werror])
4390 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
4391 AC_MSG_RESULT($enable_werror)
4392 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
4396 dnl Check whether obsolescent tmpnam is available in <stdio.h>,
4397 dnl and define _GLIBCXX_USE_TMPNAM.
4399 AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl
4403 ac_save_CXXFLAGS="$CXXFLAGS"
4404 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4406 AC_MSG_CHECKING([for tmpnam])
4407 AC_CACHE_VAL(glibcxx_cv_TMPNAM, [dnl
4408 GCC_TRY_COMPILE_OR_LINK(
4409 [#include <stdio.h>],
4410 [char *tmp = tmpnam(NULL);],
4411 [glibcxx_cv_TMPNAM=yes],
4412 [glibcxx_cv_TMPNAM=no])
4414 if test $glibcxx_cv_TMPNAM = yes; then
4415 AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.])
4417 AC_MSG_RESULT($glibcxx_cv_TMPNAM)
4419 CXXFLAGS="$ac_save_CXXFLAGS"
4424 dnl Check to see if sys/sdt.h exists and that it is suitable for use.
4425 dnl Some versions of sdt.h were not compatible with C++11.
4427 AC_DEFUN([GLIBCXX_CHECK_SDT_H], [
4428 AC_MSG_CHECKING([for suitable sys/sdt.h])
4429 # Note that this test has to be run with the C language.
4430 # Otherwise, sdt.h will try to include some headers from
4434 AC_CACHE_VAL(glibcxx_cv_sys_sdt_h, [
4435 # Because we have to run the test in C, we use grep rather
4436 # than the compiler to check for the bug. The bug is that
4437 # were strings without trailing whitespace, causing g++
4438 # to look for operator"". The pattern searches for the fixed
4440 AC_EGREP_CPP([ \",\" ], [
4441 #include <sys/sdt.h>
4442 int f() { STAP_PROBE(hi, bob); }
4443 ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no])
4446 if test $glibcxx_cv_sys_sdt_h = yes; then
4447 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4448 [Define to 1 if you have a suitable <sys/sdt.h> header file])
4450 AC_MSG_RESULT($glibcxx_cv_sys_sdt_h)
4454 dnl Control whether the library should define symbols for old and new ABIs.
4455 dnl This affects definitions of strings, stringstreams and locale facets.
4457 dnl --disable-libstdcxx-dual-abi will use old ABI for all types.
4460 dnl _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0)
4462 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [
4463 GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string])
4464 if test x$enable_symvers = xgnu-versioned-namespace; then
4465 # gnu-versioned-namespace is incompatible with the dual ABI.
4466 enable_libstdcxx_dual_abi="no"
4468 if test x"$enable_libstdcxx_dual_abi" != xyes; then
4469 AC_MSG_NOTICE([dual ABI is disabled])
4470 default_libstdcxx_abi="gcc4-compatible"
4472 GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes)
4476 dnl Check to see which ABI should be enabled by default.
4478 dnl --with-default-libstdcxx-abi={gcc4-compatible,new}
4481 dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
4483 AC_DEFUN([GLIBCXX_DEFAULT_ABI], [
4484 if test x$enable_libstdcxx_dual_abi = xyes; then
4485 AC_MSG_CHECKING([for default std::string ABI to use])
4486 AC_ARG_WITH([default-libstdcxx-abi],
4487 AS_HELP_STRING([--with-default-libstdcxx-abi],
4488 [set the std::string ABI to use by default]),
4490 gcc4-compatible) default_libstdcxx_abi="gcc4-compatible" ;;
4491 new|cxx11) default_libstdcxx_abi="new" ;;
4492 c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;;
4493 *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
4496 [default_libstdcxx_abi="new"])
4497 AC_MSG_RESULT(${default_libstdcxx_abi})
4499 if test $default_libstdcxx_abi = "new"; then
4506 AC_SUBST(glibcxx_cxx98_abi)
4507 GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1)
4511 dnl Check to see whether to build libstdc++fs.a
4513 dnl --enable-libstdcxx-filesystem-ts
4515 AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [
4516 GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,,
4517 [turns on ISO/IEC TS 18822 support],
4518 [permit yes|no|auto])
4520 AC_MSG_CHECKING([whether to build Filesystem TS support])
4521 if test x"$ac_cv_header_dirent_h" != x"yes"; then
4522 enable_libstdcxx_filesystem_ts=no
4524 if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then
4525 case "${target_os}" in
4526 freebsd*|netbsd*|openbsd*|dragonfly*|darwin*)
4527 enable_libstdcxx_filesystem_ts=yes
4529 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu | uclinux*)
4530 enable_libstdcxx_filesystem_ts=yes
4533 enable_libstdcxx_filesystem_ts=yes
4536 enable_libstdcxx_filesystem_ts=yes
4539 enable_libstdcxx_filesystem_ts=yes
4542 enable_libstdcxx_filesystem_ts=no
4546 AC_MSG_RESULT($enable_libstdcxx_filesystem_ts)
4547 GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes)
4551 dnl Check whether the library calls required by the C++17 Filesystem library
4552 dnl and the Filesystem TS are present.
4554 dnl HAVE_STRUCT_DIRENT_D_TYPE
4555 dnl _GLIBCXX_USE_REALPATH
4556 dnl _GLIBCXX_USE_UTIMENSAT
4557 dnl _GLIBCXX_USE_ST_MTIM
4558 dnl _GLIBCXX_USE_FCHMOD
4559 dnl _GLIBCXX_USE_FCHMODAT
4560 dnl _GLIBCXX_USE_SENDFILE
4565 AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
4569 ac_save_CXXFLAGS="$CXXFLAGS"
4570 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4572 AC_MSG_CHECKING([for struct dirent.d_type])
4573 AC_CACHE_VAL(glibcxx_cv_dirent_d_type, [dnl
4574 GCC_TRY_COMPILE_OR_LINK(
4575 [#include <dirent.h>],
4578 if (sizeof d.d_type) return 0;
4580 [glibcxx_cv_dirent_d_type=yes],
4581 [glibcxx_cv_dirent_d_type=no])
4583 if test $glibcxx_cv_dirent_d_type = yes; then
4584 AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.])
4586 AC_MSG_RESULT($glibcxx_cv_dirent_d_type)
4588 AC_MSG_CHECKING([for realpath])
4589 AC_CACHE_VAL(glibcxx_cv_realpath, [dnl
4590 GCC_TRY_COMPILE_OR_LINK(
4597 #if _XOPEN_VERSION < 500
4599 #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX)
4600 char *tmp = realpath((const char*)NULL, (char*)NULL);
4605 [glibcxx_cv_realpath=yes],
4606 [glibcxx_cv_realpath=no])
4608 if test $glibcxx_cv_realpath = yes; then
4609 AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.])
4611 AC_MSG_RESULT($glibcxx_cv_realpath)
4613 AC_MSG_CHECKING([for utimensat])
4614 AC_CACHE_VAL(glibcxx_cv_utimensat, [dnl
4615 GCC_TRY_COMPILE_OR_LINK(
4618 #include <sys/stat.h>
4621 struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } };
4622 int i = utimensat(AT_FDCWD, "path", ts, 0);
4624 [glibcxx_cv_utimensat=yes],
4625 [glibcxx_cv_utimensat=no])
4627 if test $glibcxx_cv_utimensat = yes; then
4628 AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.])
4630 AC_MSG_RESULT($glibcxx_cv_utimensat)
4632 AC_MSG_CHECKING([for utime])
4633 AC_CACHE_VAL(glibcxx_cv_utime, [dnl
4634 GCC_TRY_COMPILE_OR_LINK(
4639 struct utimbuf t = { 1, 1 };
4640 int i = utime("path", &t);
4642 [glibcxx_cv_utime=yes],
4643 [glibcxx_cv_utime=no])
4645 if test $glibcxx_cv_utime = yes; then
4646 AC_DEFINE(_GLIBCXX_USE_UTIME, 1, [Define if utime is available in <utime.h>.])
4648 AC_MSG_RESULT($glibcxx_cv_utime)
4650 AC_MSG_CHECKING([for lstat])
4651 AC_CACHE_VAL(glibcxx_cv_lstat, [dnl
4652 GCC_TRY_COMPILE_OR_LINK(
4653 [ #include <sys/stat.h> ],
4656 int i = lstat("path", &st);
4658 [glibcxx_cv_lstat=yes],
4659 [glibcxx_cv_lstat=no])
4661 if test $glibcxx_cv_lstat = yes; then
4662 AC_DEFINE(_GLIBCXX_USE_LSTAT, 1, [Define if lstat is available in <sys/stat.h>.])
4664 AC_MSG_RESULT($glibcxx_cv_lstat)
4666 AC_MSG_CHECKING([for struct stat.st_mtim.tv_nsec])
4667 AC_CACHE_VAL(glibcxx_cv_st_mtim, [dnl
4668 GCC_TRY_COMPILE_OR_LINK(
4669 [ #include <sys/stat.h> ],
4672 return st.st_mtim.tv_nsec;
4674 [glibcxx_cv_st_mtim=yes],
4675 [glibcxx_cv_st_mtim=no])
4677 if test $glibcxx_cv_st_mtim = yes; then
4678 AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.])
4680 AC_MSG_RESULT($glibcxx_cv_st_mtim)
4682 AC_MSG_CHECKING([for fchmod])
4683 AC_CACHE_VAL(glibcxx_cv_fchmod, [dnl
4684 GCC_TRY_COMPILE_OR_LINK(
4685 [#include <sys/stat.h>],
4686 [fchmod(1, S_IWUSR);],
4687 [glibcxx_cv_fchmod=yes],
4688 [glibcxx_cv_fchmod=no])
4690 if test $glibcxx_cv_fchmod = yes; then
4691 AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.])
4693 AC_MSG_RESULT($glibcxx_cv_fchmod)
4695 AC_MSG_CHECKING([for fchmodat])
4696 AC_CACHE_VAL(glibcxx_cv_fchmodat, [dnl
4697 GCC_TRY_COMPILE_OR_LINK(
4700 #include <sys/stat.h>
4702 [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);],
4703 [glibcxx_cv_fchmodat=yes],
4704 [glibcxx_cv_fchmodat=no])
4706 if test $glibcxx_cv_fchmodat = yes; then
4707 AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.])
4709 AC_MSG_RESULT($glibcxx_cv_fchmodat)
4711 AC_MSG_CHECKING([for sendfile that can copy files])
4712 AC_CACHE_VAL(glibcxx_cv_sendfile, [dnl
4713 case "${target_os}" in
4714 gnu* | linux* | solaris* | uclinux*)
4715 GCC_TRY_COMPILE_OR_LINK(
4716 [#include <sys/sendfile.h>],
4717 [sendfile(1, 2, (off_t*)0, sizeof 1);],
4718 [glibcxx_cv_sendfile=yes],
4719 [glibcxx_cv_sendfile=no])
4722 glibcxx_cv_sendfile=no
4726 if test $glibcxx_cv_sendfile = yes; then
4727 AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.])
4729 AC_MSG_RESULT($glibcxx_cv_sendfile)
4731 AC_MSG_CHECKING([for link])
4732 AC_CACHE_VAL(glibcxx_cv_link, [dnl
4733 GCC_TRY_COMPILE_OR_LINK(
4734 [#include <unistd.h>],
4736 [glibcxx_cv_link=yes],
4737 [glibcxx_cv_link=no])
4739 if test $glibcxx_cv_link = yes; then
4740 AC_DEFINE(HAVE_LINK, 1, [Define if link is available in <unistd.h>.])
4742 AC_MSG_RESULT($glibcxx_cv_link)
4744 AC_MSG_CHECKING([for readlink])
4745 AC_CACHE_VAL(glibcxx_cv_readlink, [dnl
4746 GCC_TRY_COMPILE_OR_LINK(
4747 [#include <unistd.h>],
4748 [char buf[32]; readlink("", buf, sizeof(buf));],
4749 [glibcxx_cv_readlink=yes],
4750 [glibcxx_cv_readlink=no])
4752 if test $glibcxx_cv_readlink = yes; then
4753 AC_DEFINE(HAVE_READLINK, 1, [Define if readlink is available in <unistd.h>.])
4755 AC_MSG_RESULT($glibcxx_cv_readlink)
4757 AC_MSG_CHECKING([for symlink])
4758 AC_CACHE_VAL(glibcxx_cv_symlink, [dnl
4759 GCC_TRY_COMPILE_OR_LINK(
4760 [#include <unistd.h>],
4762 [glibcxx_cv_symlink=yes],
4763 [glibcxx_cv_symlink=no])
4765 if test $glibcxx_cv_symlink = yes; then
4766 AC_DEFINE(HAVE_SYMLINK, 1, [Define if symlink is available in <unistd.h>.])
4768 AC_MSG_RESULT($glibcxx_cv_symlink)
4770 AC_MSG_CHECKING([for truncate])
4771 AC_CACHE_VAL(glibcxx_cv_truncate, [dnl
4772 GCC_TRY_COMPILE_OR_LINK(
4773 [#include <unistd.h>],
4774 [truncate("", 99);],
4775 [glibcxx_cv_truncate=yes],
4776 [glibcxx_cv_truncate=no])
4778 if test $glibcxx_cv_truncate = yes; then
4779 AC_DEFINE(HAVE_TRUNCATE, 1, [Define if truncate is available in <unistd.h>.])
4781 AC_MSG_RESULT($glibcxx_cv_truncate)
4783 CXXFLAGS="$ac_save_CXXFLAGS"
4788 dnl Check how size_t is mangled. Copied from libitm.
4790 AC_DEFUN([GLIBCXX_CHECK_SIZE_T_MANGLING], [
4791 AC_CACHE_CHECK([how size_t is mangled],
4792 glibcxx_cv_size_t_mangling, [
4793 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
4794 [glibcxx_cv_size_t_mangling=m], [
4795 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
4796 [glibcxx_cv_size_t_mangling=j], [
4798 [extern __SIZE_TYPE__ x; extern unsigned long long x;],
4799 [glibcxx_cv_size_t_mangling=y], [
4801 [extern __SIZE_TYPE__ x; extern unsigned short x;],
4802 [glibcxx_cv_size_t_mangling=t], [
4804 [extern __SIZE_TYPE__ x; extern __int20 unsigned x;],
4805 [glibcxx_cv_size_t_mangling=u6uint20],
4806 [glibcxx_cv_size_t_mangling=x])
4812 if test $glibcxx_cv_size_t_mangling = x; then
4813 AC_MSG_ERROR([Unknown underlying type for size_t])
4815 AC_DEFINE_UNQUOTED(_GLIBCXX_MANGLE_SIZE_T, [$glibcxx_cv_size_t_mangling],
4816 [Define to the letter to which size_t is mangled.])
4820 dnl Determine whether std::exception_ptr symbols should be exported with
4821 dnl the symbol versions from GCC 4.6.0 or GCC 7.1.0, depending on which
4822 dnl release first added support for std::exception_ptr. Originally it was
4823 dnl only supported for targets with always-lock-free atomics for int, but
4824 dnl since GCC 7.1 it is supported for all targets.
4826 AC_DEFUN([GLIBCXX_CHECK_EXCEPTION_PTR_SYMVER], [
4827 if test $enable_symvers != no; then
4828 AC_MSG_CHECKING([for first version to support std::exception_ptr])
4830 aarch64-*-* | alpha-*-* | hppa*-*-* | i?86-*-* | x86_64-*-* | \
4831 m68k-*-* | powerpc*-*-* | s390*-*-* | *-*-solaris* )
4832 ac_exception_ptr_since_gcc46=yes
4835 # If the value of this macro changes then we will need to hardcode
4836 # yes/no here for additional targets based on the original value.
4837 AC_TRY_COMPILE([], [
4838 #if __GCC_ATOMIC_INT_LOCK_FREE <= 1
4839 # error atomic int not always lock free
4842 [ac_exception_ptr_since_gcc46=yes],
4843 [ac_exception_ptr_since_gcc46=no])
4846 if test x"$ac_exception_ptr_since_gcc46" = x"yes" ; then
4847 AC_DEFINE(HAVE_EXCEPTION_PTR_SINCE_GCC46, 1,
4848 [Define to 1 if GCC 4.6 supported std::exception_ptr for the target])
4849 AC_MSG_RESULT([4.6.0])
4851 AC_MSG_RESULT([7.1.0])
4856 # Macros from the top-level gcc directory.
4857 m4_include([../config/gc++filt.m4])
4858 m4_include([../config/tls.m4])
4859 m4_include([../config/gthr.m4])
4860 m4_include([../config/cet.m4])