Fix comments in testsuite script
[official-gcc.git] / libstdc++-v3 / acinclude.m4
blob6d68e9074268186e909d8022be8c28b855cc9789
1 dnl
2 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
3 dnl
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.
8 dnl
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])
13   )dnl
14 ])dnl
15 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
18 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.
22 dnl
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])
29 dnl
30 dnl Initialize the rest of the library configury.  At this point we have
31 dnl variables like $host.
32 dnl
33 dnl Sets:
34 dnl  SUBDIRS
35 dnl Substs:
36 dnl  glibcxx_builddir     (absolute path)
37 dnl  glibcxx_srcdir       (absolute path)
38 dnl  toplevel_builddir    (absolute path)
39 dnl  toplevel_srcdir      (absolute path)
40 dnl  with_cross_host
41 dnl  with_newlib
42 dnl  with_target_subdir
43 dnl plus
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
47 dnl
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}`
59   case $srcdir in
60     [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
61     *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
62   esac
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]))
80   AC_ARG_WITH([newlib],
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.
86   AC_PROG_LN_S
87   #LN_S='cp -p'
89   AC_CHECK_TOOL(AS, as)
90   AC_CHECK_TOOL(AR, ar)
91   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
93   AM_MAINTAINER_MODE
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], [
103   #include <stdio.h>
104   #if __UCLIBC__
105     _using_uclibc
106   #endif
107   ], uclibc=yes, uclibc=no)
109   AC_EGREP_CPP([_using_bionic], [
110   #include <stdio.h>
111   #if __BIONIC__
112     _using_bionic
113   #endif
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.
118   GLIBCXX_CHECK_HOST
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
125 dnl be placed here.
127 dnl Defines:
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.
138   AC_LANG_SAVE
139   AC_LANG_CPLUSPLUS
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"
149   else
150     # this is the suspicious part
151     CXXFLAGS=''
152   fi
153   if test x"$ac_fdsections" = x"yes"; then
154     SECTION_FLAGS='-ffunction-sections -fdata-sections'
155   fi
156   AC_MSG_RESULT($ac_fdsections)
158   AC_LANG_RESTORE
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).
168 dnl Defines:
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)
172 dnl Sets:
173 dnl  with_gnu_ld
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?
198       with_gnu_ld=no
199     else
200       with_gnu_ld=$ac_cv_prog_gnu_ld
201     fi
202   fi
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])
209     changequote(,)
210     if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
211       glibcxx_ld_is_gold=yes
212     fi
213     ldver=`$LD --version 2>/dev/null |
214            sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'`
215     changequote([,])
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)
219   fi
221   # Set --gc-sections.
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
226     fi
227   else
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
232     fi
233   fi
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
249       rm -f conftest.c
250       touch conftest.c
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
254           ac_gcsections=no
255         fi
256       fi
257       rm -f conftest.c conftest.o conftest
258     fi
259     if test "$ac_gcsections" = "yes"; then
260       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
261     fi
262     AC_MSG_RESULT($ac_gcsections)
264     if test "$ac_test_CFLAGS" = set; then
265       CFLAGS="$ac_save_CFLAGS"
266     else
267       # this is the suspicious part
268       CFLAGS=''
269     fi
270   fi
272   # Set -z,relro.
273   # Note this is only for shared objects.
274   ac_ld_relro=no
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"
280       ac_ld_relro=yes
281     fi
282     AC_MSG_RESULT($ac_ld_relro)
283   fi
285   # Set linker optimization flags.
286   if test x"$with_gnu_ld" = x"yes"; then
287     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
288   fi
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.
299 dnl Defines:
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])
305   AC_TRY_COMPILE(
306     [#include <unistd.h>
307      #include <sys/time.h>
308      #include <sys/resource.h>
309     ],
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
315   AC_MSG_RESULT($res)
318 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
319   setrlimit_have_headers=yes
320   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
321                    [],
322                    [setrlimit_have_headers=no])
323   # If don't have the headers, then we can't run the tests now, and we
324   # won't be seeing any of these during testsuite compilation.
325   if test $setrlimit_have_headers = yes; then
326     # Can't do these in a loop, else the resulting syntax is wrong.
327     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
328     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
329     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
330     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
331     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
333     # Check for rlimit, setrlimit.
334     AC_CACHE_VAL(glibcxx_cv_setrlimit, [
335       AC_TRY_COMPILE(
336         [#include <unistd.h>
337          #include <sys/time.h>
338          #include <sys/resource.h>
339         ],
340         [struct rlimit r;
341          setrlimit(0, &r);],
342         [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
343     ])
344   fi
346   AC_MSG_CHECKING([for testsuite resource limits support])
347   if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
348     ac_res_limits=yes
349     AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
350               [Define if using setrlimit to set resource limits during
351               "make check"])
352   else
353     ac_res_limits=no
354   fi
355   AC_MSG_RESULT($ac_res_limits)
360 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
361 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
363 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
365   AC_LANG_SAVE
366   AC_LANG_CPLUSPLUS
367   ac_save_CXXFLAGS="$CXXFLAGS"
368   CXXFLAGS="$CXXFLAGS -fno-exceptions"
370   AC_MSG_CHECKING([for S_ISREG or S_IFREG])
371   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
372     GCC_TRY_COMPILE_OR_LINK(
373       [#include <sys/stat.h>],
374       [struct stat buffer;
375        fstat(0, &buffer);
376        S_ISREG(buffer.st_mode);],
377       [glibcxx_cv_S_ISREG=yes],
378       [glibcxx_cv_S_ISREG=no])
379   ])
380   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
381     GCC_TRY_COMPILE_OR_LINK(
382       [#include <sys/stat.h>],
383       [struct stat buffer;
384        fstat(0, &buffer);
385        S_IFREG & buffer.st_mode;],
386       [glibcxx_cv_S_IFREG=yes],
387       [glibcxx_cv_S_IFREG=no])
388   ])
389   res=no
390   if test $glibcxx_cv_S_ISREG = yes; then
391     AC_DEFINE(HAVE_S_ISREG, 1,
392               [Define if S_ISREG is available in <sys/stat.h>.])
393     res=S_ISREG
394   elif test $glibcxx_cv_S_IFREG = yes; then
395     AC_DEFINE(HAVE_S_IFREG, 1,
396               [Define if S_IFREG is available in <sys/stat.h>.])
397     res=S_IFREG
398   fi
399   AC_MSG_RESULT($res)
401   CXXFLAGS="$ac_save_CXXFLAGS"
402   AC_LANG_RESTORE
407 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
409 AC_DEFUN([GLIBCXX_CHECK_POLL], [
411   AC_LANG_SAVE
412   AC_LANG_CPLUSPLUS
413   ac_save_CXXFLAGS="$CXXFLAGS"
414   CXXFLAGS="$CXXFLAGS -fno-exceptions"
416   AC_MSG_CHECKING([for poll])
417   AC_CACHE_VAL(glibcxx_cv_POLL, [
418     GCC_TRY_COMPILE_OR_LINK(
419       [#include <poll.h>],
420       [struct pollfd pfd[1];
421        pfd[0].events = POLLIN;
422        poll(pfd, 1, 0);],
423       [glibcxx_cv_POLL=yes],
424       [glibcxx_cv_POLL=no])
425   ])
426   if test $glibcxx_cv_POLL = yes; then
427     AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
428   fi
429   AC_MSG_RESULT($glibcxx_cv_POLL)
431   CXXFLAGS="$ac_save_CXXFLAGS"
432   AC_LANG_RESTORE
437 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
439 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
441   AC_LANG_SAVE
442   AC_LANG_CPLUSPLUS
443   ac_save_CXXFLAGS="$CXXFLAGS"
444   CXXFLAGS="$CXXFLAGS -fno-exceptions"
446   AC_MSG_CHECKING([for writev])
447   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
448     GCC_TRY_COMPILE_OR_LINK(
449       [#include <sys/uio.h>],
450       [struct iovec iov[2];
451        writev(0, iov, 0);],
452       [glibcxx_cv_WRITEV=yes],
453       [glibcxx_cv_WRITEV=no])
454   ])
455   if test $glibcxx_cv_WRITEV = yes; then
456     AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
457   fi
458   AC_MSG_RESULT($glibcxx_cv_WRITEV)
460   CXXFLAGS="$ac_save_CXXFLAGS"
461   AC_LANG_RESTORE
466 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
467 dnl Also check whether int64_t is actually a typedef to long or long long.
469 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
471   AC_LANG_SAVE
472   AC_LANG_CPLUSPLUS
474   AC_MSG_CHECKING([for int64_t])
475   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
476     AC_TRY_COMPILE(
477       [#include <stdint.h>],
478       [int64_t var;],
479       [glibcxx_cv_INT64_T=yes],
480       [glibcxx_cv_INT64_T=no])
481   ])
483   if test $glibcxx_cv_INT64_T = yes; then
484     AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
485     AC_MSG_RESULT($glibcxx_cv_INT64_T)
487     AC_MSG_CHECKING([for int64_t as long])
488     AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
489       AC_TRY_COMPILE(
490         [#include <stdint.h>
491         template<typename, typename> struct same { enum { value = -1 }; };
492         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
493         int array[same<int64_t, long>::value];], [],
494         [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
495     ])
497     if test $glibcxx_cv_int64_t_long = yes; then
498       AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
499       AC_MSG_RESULT($glibcxx_cv_int64_t_long)
500     fi
502     AC_MSG_CHECKING([for int64_t as long long])
503     AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
504       AC_TRY_COMPILE(
505         [#include <stdint.h>
506         template<typename, typename> struct same { enum { value = -1 }; };
507         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
508         int array[same<int64_t, long long>::value];], [],
509         [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
510     ])
512     if test $glibcxx_cv_int64_t_long_long = yes; then
513       AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
514       AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
515     fi
516   fi
518   AC_LANG_RESTORE
523 dnl Check whether LFS support is available.
525 AC_DEFUN([GLIBCXX_CHECK_LFS], [
526   AC_LANG_SAVE
527   AC_LANG_CPLUSPLUS
528   ac_save_CXXFLAGS="$CXXFLAGS"
529   CXXFLAGS="$CXXFLAGS -fno-exceptions"
530   AC_MSG_CHECKING([for LFS support])
531   AC_CACHE_VAL(glibcxx_cv_LFS, [
532     GCC_TRY_COMPILE_OR_LINK(
533       [#include <unistd.h>
534        #include <stdio.h>
535        #include <sys/stat.h>
536       ],
537       [FILE* fp;
538        fopen64("t", "w");
539        fseeko64(fp, 0, SEEK_CUR);
540        ftello64(fp);
541        lseek64(1, 0, SEEK_CUR);
542        struct stat64 buf;
543        fstat64(1, &buf);],
544       [glibcxx_cv_LFS=yes],
545       [glibcxx_cv_LFS=no])
546   ])
547   if test $glibcxx_cv_LFS = yes; then
548     AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
549   fi
550   AC_MSG_RESULT($glibcxx_cv_LFS)
551   CXXFLAGS="$ac_save_CXXFLAGS"
552   AC_LANG_RESTORE
557 dnl Check for whether a fully dynamic basic_string implementation should
558 dnl be turned on, that does not put empty objects in per-process static
559 dnl memory (mostly useful together with shared memory allocators, see PR
560 dnl libstdc++/16612 for details).
562 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
563 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
564 dnl otherwise undefined
565 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
566 dnl       Where DEFAULT is either `yes' or `no'.
568 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
569   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
570   if test $enable_fully_dynamic_string = yes; then
571     enable_fully_dynamic_string_def=1
572   else
573     enable_fully_dynamic_string_def=0
574   fi
575   AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
576               [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
581 dnl Does any necessary configuration of the testsuite directory.  Generates
582 dnl the testsuite_hooks.h header.
584 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
586 dnl Sets:
587 dnl  enable_abi_check
588 dnl  GLIBCXX_TEST_WCHAR_T
589 dnl  GLIBCXX_TEST_THREAD
590 dnl Substs:
591 dnl  baseline_dir
592 dnl  baseline_subdir_switch
594 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
595   # Do checks for resource limit functions.
596   GLIBCXX_CHECK_SETRLIMIT
598   if $GLIBCXX_IS_NATIVE ; then
599     # Look for setenv, so that extended locale tests can be performed.
600     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
601   fi
603   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
604      test $enable_symvers != no; then
605     case "$host" in
606       *-*-cygwin*)
607         enable_abi_check=no ;;
608       *)
609         enable_abi_check=yes ;;
610     esac
611   else
612     # Only build this as native, since automake does not understand
613     # CXX_FOR_BUILD.
614     enable_abi_check=no
615   fi
617   # Export file names for ABI checking.
618   baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
619   AC_SUBST(baseline_dir)
620   baseline_subdir_switch="$abi_baseline_subdir_switch"
621   AC_SUBST(baseline_subdir_switch)
626 dnl Does any necessary configuration for docbook in the docs directory.
628 dnl XSLTPROC must be set before this
630 dnl Sets:
631 dnl  glibcxx_stylesheets
632 dnl Substs:
633 dnl  XSL_STYLE_DIR
635 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
637 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
638 glibcxx_stylesheets=no
639 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then
640   glibcxx_stylesheets=yes
642 AC_MSG_RESULT($glibcxx_stylesheets)
644 AC_MSG_CHECKING([for local stylesheet directory])
645 glibcxx_local_stylesheets=no
646 if test x"$glibcxx_stylesheets" = x"yes"; then
647   if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then
648     glibcxx_local_stylesheets=yes
649     XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets
650   fi
651   if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then
652     glibcxx_local_stylesheets=yes
653     XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
654   fi
655   if test -d /usr/share/xml/docbook/stylesheet/nwalsh5/current; then
656     glibcxx_local_stylesheets=yes
657     XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/nwalsh5/current
658   fi
660 AC_MSG_RESULT($glibcxx_local_stylesheets)
662 if test x"$glibcxx_local_stylesheets" = x"yes"; then
663   AC_SUBST(XSL_STYLE_DIR)
664   AC_MSG_NOTICE($XSL_STYLE_DIR)
665 else
666   glibcxx_stylesheets=no
669 # Check for epub3 dependencies.
670 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
671 glibcxx_epub_stylesheets=no
672 if test x"$glibcxx_local_stylesheets" = x"yes"; then
673    if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
674       glibcxx_epub_stylesheets=yes
675    fi
677 AC_MSG_RESULT($glibcxx_epub_stylesheets)
678 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
684 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
686 dnl Substs:
687 dnl  GLIBCXX_INCLUDES
688 dnl  TOPLEVEL_INCLUDES
690 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
691   # Used for every C++ compile we perform.
692   GLIBCXX_INCLUDES="\
693 -I$glibcxx_builddir/include/$host_alias \
694 -I$glibcxx_builddir/include \
695 -I$glibcxx_srcdir/libsupc++"
697   # For Canadian crosses, pick this up too.
698   if test $CANADIAN = yes; then
699     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
700   fi
702   # Stuff in the actual top level.  Currently only used by libsupc++ to
703   # get unwind* headers from the libgcc dir.
704   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
705   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
707   # Now, export this to all the little Makefiles....
708   AC_SUBST(GLIBCXX_INCLUDES)
709   AC_SUBST(TOPLEVEL_INCLUDES)
714 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
715 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
717 dnl Substs:
718 dnl  OPTIMIZE_CXXFLAGS
719 dnl  WARN_FLAGS
721 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
722   # Optimization flags that are probably a good idea for thrill-seekers. Just
723   # uncomment the lines below and make, everything else is ready to go...
724   # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
725   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
726   AC_SUBST(OPTIMIZE_CXXFLAGS)
728   WARN_FLAGS="-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi=2"
729   AC_SUBST(WARN_FLAGS)
734 dnl All installation directory information is determined here.
736 dnl Substs:
737 dnl  gxx_install_dir
738 dnl  glibcxx_prefixdir
739 dnl  glibcxx_toolexecdir
740 dnl  glibcxx_toolexeclibdir
742 dnl Assumes cross_compiling bits already done, and with_cross_host in
743 dnl particular.
745 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
746 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
747 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
748   glibcxx_toolexecdir=no
749   glibcxx_toolexeclibdir=no
750   glibcxx_prefixdir=$prefix
752   AC_MSG_CHECKING([for gxx-include-dir])
753   AC_ARG_WITH([gxx-include-dir],
754     AC_HELP_STRING([--with-gxx-include-dir=DIR],
755                    [installation directory for include files]),
756     [case "$withval" in
757       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
758       no)  gxx_include_dir=no ;;
759       *)   gxx_include_dir=$withval ;;
760      esac],
761     [gxx_include_dir=no])
762   AC_MSG_RESULT($gxx_include_dir)
764   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
765   AC_ARG_ENABLE([version-specific-runtime-libs],
766     AC_HELP_STRING([--enable-version-specific-runtime-libs],
767                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
768     [case "$enableval" in
769       yes) version_specific_libs=yes ;;
770       no)  version_specific_libs=no ;;
771       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
772      esac],
773     [version_specific_libs=no])
774   AC_MSG_RESULT($version_specific_libs)
776   # Default case for install directory for include files.
777   if test $version_specific_libs = no && test $gxx_include_dir = no; then
778     gxx_include_dir='include/c++/${gcc_version}'
779     if test -n "$with_cross_host" &&
780        test x"$with_cross_host" != x"no"; then
781       gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
782     else
783       gxx_include_dir='${prefix}/'"$gxx_include_dir"
784     fi
785   fi
787   # Version-specific runtime libs processing.
788   if test $version_specific_libs = yes; then
789     # Need the gcc compiler version to know where to install libraries
790     # and header files if --enable-version-specific-runtime-libs option
791     # is selected.  FIXME: these variables are misnamed, there are
792     # no executables installed in _toolexecdir or _toolexeclibdir.
793     if test x"$gxx_include_dir" = x"no"; then
794       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
795     fi
796     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
797     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
798   fi
800   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
801   # Install a library built with a cross compiler in tooldir, not libdir.
802   if test x"$glibcxx_toolexecdir" = x"no"; then
803     if test -n "$with_cross_host" &&
804        test x"$with_cross_host" != x"no"; then
805       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
806       glibcxx_toolexeclibdir='${toolexecdir}/lib'
807     else
808       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
809       glibcxx_toolexeclibdir='${libdir}'
810     fi
811     multi_os_directory=`$CXX -print-multi-os-directory`
812     case $multi_os_directory in
813       .) ;; # Avoid trailing /.
814       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
815     esac
816   fi
818   AC_MSG_CHECKING([for install location])
819   AC_MSG_RESULT($gxx_include_dir)
821   AC_SUBST(glibcxx_prefixdir)
822   AC_SUBST(gxx_include_dir)
823   AC_SUBST(glibcxx_toolexecdir)
824   AC_SUBST(glibcxx_toolexeclibdir)
829 dnl GLIBCXX_ENABLE
830 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
831 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
832 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
834 dnl See manual/appendix_porting.html#appendix.porting.build_hacking for
835 dnl documentation.
837 m4_define([GLIBCXX_ENABLE],[dnl
838 m4_define([_g_switch],[--enable-$1])dnl
839 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
840  AC_ARG_ENABLE([$1],m4_dquote(_g_help),
841   m4_bmatch([$5],
842    [^permit ],
843      [[
844       case "$enableval" in
845        m4_bpatsubst([$5],[permit ])) ;;
846        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
847           dnl Idea for future:  generate a URL pointing to
848           dnl "onlinedocs/configopts.html#whatever"
849       esac
850      ]],
851    [^$],
852      [[
853       case "$enableval" in
854        yes|no) ;;
855        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
856       esac
857      ]],
858    [[$5]]),
859   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
860 m4_undefine([_g_switch])dnl
861 m4_undefine([_g_help])dnl
866 dnl Check for ISO/IEC 9899:1999 "C99" support.
868 dnl --enable-c99 defines _GLIBCXX_USE_C99
869 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
870 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
871 dnl       Where DEFAULT is either `yes' or `no'.
872 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
874 AC_DEFUN([GLIBCXX_ENABLE_C99], [
875   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
877   if test x"$enable_c99" = x"yes"; then
878     AC_LANG_SAVE
879     AC_LANG_CPLUSPLUS
881     # Use -std=c++98 (instead of -std=gnu++98) because leaving __STRICT_ANSI__
882     # undefined may cause fake C99 facilities, like pre-standard snprintf,
883     # to be spuriously enabled.
884     ac_save_CXXFLAGS="$CXXFLAGS"
885     CXXFLAGS="$CXXFLAGS -std=c++98"
886     ac_save_LIBS="$LIBS"
887     ac_save_gcc_no_link="$gcc_no_link"
889     if test x$gcc_no_link != xyes; then
890       # Use -fno-exceptions to that the C driver can link these tests without
891       # hitting undefined references to personality routines.
892       CXXFLAGS="$CXXFLAGS -fno-exceptions"
893       AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
894         # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
895         gcc_no_link=yes
896       ])
897     fi
899     # Check for the existence of <math.h> functions used if C99 is enabled.
900     AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++98])
901     AC_CACHE_VAL(glibcxx_cv_c99_math_cxx98, [
902       GCC_TRY_COMPILE_OR_LINK(
903         [#include <math.h>
904          volatile double d1, d2;
905          volatile int i;],
906         [i = fpclassify(d1);
907          i = isfinite(d1);
908          i = isinf(d1);
909          i = isnan(d1);
910          i = isnormal(d1);
911          i = signbit(d1);
912          i = isgreater(d1, d2);
913          i = isgreaterequal(d1, d2);
914          i = isless(d1, d2);
915          i = islessequal(d1, d2);
916          i = islessgreater(d1, d2);
917          i = islessgreater(d1, d2);
918          i = isunordered(d1, d2);
919         ], [glibcxx_cv_c99_math_cxx98=yes], [glibcxx_cv_c99_math_cxx98=no])
920     ])
921     AC_MSG_RESULT($glibcxx_cv_c99_math_cxx98)
922     if test x"$glibcxx_cv_c99_math_cxx98" = x"yes"; then
923       AC_DEFINE(_GLIBCXX98_USE_C99_MATH, 1,
924         [Define if C99 functions or macros in <math.h> should be imported
925         in <cmath> in namespace std for C++98.])
926     fi
928     # Check for the existence of <complex.h> complex math functions.
929     # This is necessary even though libstdc++ uses the builtin versions
930     # of these functions, because if the builtin cannot be used, a reference
931     # to the library function is emitted.
932     AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
933     AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
934     if test x"$ac_has_complex_h" = x"yes"; then
935       AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++98])
936       AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx98, [
937         GCC_TRY_COMPILE_OR_LINK(
938           [#include <complex.h>
939            typedef __complex__ float float_type;
940            typedef __complex__ double double_type;
941            typedef __complex__ long double ld_type;
942            volatile float_type tmpf;
943            volatile double_type tmpd;
944            volatile ld_type tmpld;
945            volatile float f;
946            volatile double d;
947            volatile long double ld;],
948           [f = cabsf(tmpf);
949            f = cargf(tmpf);
950            tmpf = ccosf(tmpf);
951            tmpf = ccoshf(tmpf);
952            tmpf = cexpf(tmpf);
953            tmpf = clogf(tmpf);
954            tmpf = csinf(tmpf);
955            tmpf = csinhf(tmpf);
956            tmpf = csqrtf(tmpf);
957            tmpf = ctanf(tmpf);
958            tmpf = ctanhf(tmpf);
959            tmpf = cpowf(tmpf, tmpf);
960            tmpf = cprojf(tmpf);
961            d = cabs(tmpd);
962            d = carg(tmpd);
963            tmpd = ccos(tmpd);
964            tmpd = ccosh(tmpd);
965            tmpd = cexp(tmpd);
966            tmpd = clog(tmpd);
967            tmpd = csin(tmpd);
968            tmpd = csinh(tmpd);
969            tmpd = csqrt(tmpd);
970            tmpd = ctan(tmpd);
971            tmpd = ctanh(tmpd);
972            tmpd = cpow(tmpd, tmpd);
973            tmpd = cproj(tmpd);
974            ld = cabsl(tmpld);
975            ld = cargl(tmpld);
976            tmpld = ccosl(tmpld);
977            tmpld = ccoshl(tmpld);
978            tmpld = cexpl(tmpld);
979            tmpld = clogl(tmpld);
980            tmpld = csinl(tmpld);
981            tmpld = csinhl(tmpld);
982            tmpld = csqrtl(tmpld);
983            tmpld = ctanl(tmpld);
984            tmpld = ctanhl(tmpld);
985            tmpld = cpowl(tmpld, tmpld);
986            tmpld = cprojl(tmpld);
987           ], [glibcxx_cv_c99_complex_cxx98=yes], [glibcxx_cv_c99_complex_cxx98=no])
988       ])
989     fi
990     AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx98)
991     if test x"$glibcxx_cv_c99_complex_cxx98" = x"yes"; then
992       AC_DEFINE(_GLIBCXX98_USE_C99_COMPLEX, 1,
993         [Define if C99 functions in <complex.h> should be used in
994         <complex> for C++98. Using compiler builtins for these functions
995         requires corresponding C99 library functions to be present.])
996     fi
998     # Check for the existence in <stdio.h> of vscanf, et. al.
999     AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++98])
1000     AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx98, [
1001       GCC_TRY_COMPILE_OR_LINK(
1002         [#include <stdio.h>
1003          #include <stdarg.h>
1004          void foo(char* fmt, ...)
1005          {
1006            va_list args; va_start(args, fmt);
1007            vfscanf(stderr, "%i", args);
1008            vscanf("%i", args);
1009            vsnprintf(fmt, 0, "%i", args);
1010            vsscanf(fmt, "%i", args);
1011            snprintf(fmt, 0, "%i");
1012          }], [],
1013         [glibcxx_cv_c99_stdio_cxx98=yes], [glibcxx_cv_c99_stdio_cxx98=no])
1014     ])
1015     AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx98)
1016     if test x"$glibcxx_cv_c99_stdio_cxx98" = x"yes"; then
1017       AC_DEFINE(_GLIBCXX98_USE_C99_STDIO, 1,
1018         [Define if C99 functions or macros in <stdio.h> should be imported
1019         in <cstdio> in namespace std for C++98.])
1020     fi
1022     # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1023     AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++98])
1024     AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx98, [
1025       GCC_TRY_COMPILE_OR_LINK(
1026         [#include <stdlib.h>
1027          volatile float f;
1028          volatile long double ld;
1029          volatile unsigned long long ll;
1030          lldiv_t mydivt;],
1031         [char* tmp;
1032          f = strtof("gnu", &tmp);
1033          ld = strtold("gnu", &tmp);
1034          ll = strtoll("gnu", &tmp, 10);
1035          ll = strtoull("gnu", &tmp, 10);
1036          ll = llabs(10);
1037          mydivt = lldiv(10,1);
1038          ll = mydivt.quot;
1039          ll = mydivt.rem;
1040          ll = atoll("10");
1041          _Exit(0);
1042         ], [glibcxx_cv_c99_stdlib_cxx98=yes], [glibcxx_cv_c99_stdlib_cxx98=no])
1043     ])
1044     AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx98)
1045     if test x"$glibcxx_cv_c99_stdlib_cxx98" = x"yes"; then
1046       AC_DEFINE(_GLIBCXX98_USE_C99_STDLIB, 1,
1047         [Define if C99 functions or macros in <stdlib.h> should be imported
1048         in <cstdlib> in namespace std for C++98.])
1049     fi
1051     # Check for the existence in <wchar.h> of wcstold, etc.
1052     if test x"$ac_has_wchar_h" = xyes &&
1053        test x"$ac_has_wctype_h" = xyes; then
1054       AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++98])
1055       AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx98, [
1056         AC_TRY_COMPILE([#include <wchar.h>
1057           namespace test
1058           {
1059             using ::wcstold;
1060             using ::wcstoll;
1061             using ::wcstoull;
1062           }
1063         ], [], [glibcxx_cv_c99_wchar_cxx98=yes], [glibcxx_cv_c99_wchar_cxx98=no])
1064       ])
1066       # Checks for wide character functions that may not be present.
1067       # Injection of these is wrapped with guard macros.
1068       # NB: only put functions here, instead of immediately above, if
1069       # absolutely necessary.
1070       AC_TRY_COMPILE([#include <wchar.h>
1071         namespace test { using ::vfwscanf; }], [],
1072         [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1074       AC_TRY_COMPILE([#include <wchar.h>
1075         namespace test { using ::vswscanf; }], [],
1076         [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1078       AC_TRY_COMPILE([#include <wchar.h>
1079         namespace test { using ::vwscanf; }], [],
1080         [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1082       AC_TRY_COMPILE([#include <wchar.h>
1083         namespace test { using ::wcstof; }], [],
1084         [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1086       AC_TRY_COMPILE([#include <wctype.h>],
1087         [wint_t t; int i = iswblank(t);],
1088         [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1090       AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx98)
1091       if test x"$glibcxx_cv_c99_wchar_cxx98" = x"yes"; then
1092         AC_DEFINE(_GLIBCXX98_USE_C99_WCHAR, 1,
1093           [Define if C99 functions or macros in <wchar.h> should be imported
1094           in <cwchar> in namespace std for C++98.])
1095       fi
1096     fi
1098     # Option parsed, now set things appropriately.
1099     if test x"$glibcxx_cv_c99_math_cxx98" = x"no" ||
1100        test x"$glibcxx_cv_c99_complex_cxx98" = x"no" ||
1101        test x"$glibcxx_cv_c99_stdio_cxx98" = x"no" ||
1102        test x"$glibcxx_cv_c99_stdlib_cxx98" = x"no" ||
1103        test x"$glibcxx_cv_c99_wchar_cxx98" = x"no"; then
1104       enable_c99=no;
1105     else
1106       AC_DEFINE(_GLIBCXX_USE_C99, 1,
1107         [Define if C99 functions or macros from <wchar.h>, <math.h>,
1108         <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1109     fi
1111     gcc_no_link="$ac_save_gcc_no_link"
1112     LIBS="$ac_save_LIBS"
1113     CXXFLAGS="$ac_save_CXXFLAGS"
1114     AC_LANG_RESTORE
1116     AC_LANG_SAVE
1117     AC_LANG_CPLUSPLUS
1119     # Use -std=c++11 and test again for C99 library feature in C++11 mode.
1120     # For the reasons given above we use -std=c++11 not -std=gnu++11.
1121     ac_save_CXXFLAGS="$CXXFLAGS"
1122     CXXFLAGS="$CXXFLAGS -std=c++11"
1123     ac_save_LIBS="$LIBS"
1124     ac_save_gcc_no_link="$gcc_no_link"
1126     if test x$gcc_no_link != xyes; then
1127       # Use -fno-exceptions to that the C driver can link these tests without
1128       # hitting undefined references to personality routines.
1129       CXXFLAGS="$CXXFLAGS -fno-exceptions"
1130       AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
1131         # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
1132         gcc_no_link=yes
1133       ])
1134     fi
1136     # Check for the existence of <math.h> functions used if C99 is enabled.
1137     AC_MSG_CHECKING([for ISO C99 support in <math.h> for C++11])
1138     AC_CACHE_VAL(glibcxx_cv_c99_math_cxx11, [
1139       GCC_TRY_COMPILE_OR_LINK(
1140         [#include <math.h>
1141          volatile double d1, d2;
1142          volatile int i;],
1143         [i = fpclassify(d1);
1144          i = isfinite(d1);
1145          i = isinf(d1);
1146          i = isnan(d1);
1147          i = isnormal(d1);
1148          i = signbit(d1);
1149          i = isgreater(d1, d2);
1150          i = isgreaterequal(d1, d2);
1151          i = isless(d1, d2);
1152          i = islessequal(d1, d2);
1153          i = islessgreater(d1, d2);
1154          i = islessgreater(d1, d2);
1155          i = isunordered(d1, d2);
1156         ], [glibcxx_cv_c99_math_cxx11=yes], [glibcxx_cv_c99_math_cxx11=no])
1157     ])
1158     AC_MSG_RESULT($glibcxx_cv_c99_math_cxx11)
1159     if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
1160       AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
1161         [Define if C99 functions or macros in <math.h> should be imported
1162         in <cmath> in namespace std for C++11.])
1163     fi
1165     # Check for the existence of <complex.h> complex math functions.
1166     # This is necessary even though libstdc++ uses the builtin versions
1167     # of these functions, because if the builtin cannot be used, a reference
1168     # to the library function is emitted.
1169     AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
1170     AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1171     if test x"$ac_has_complex_h" = x"yes"; then
1172       AC_MSG_CHECKING([for ISO C99 support in <complex.h> for C++11])
1173       AC_CACHE_VAL(glibcxx_cv_c99_complex_cxx11, [
1174         GCC_TRY_COMPILE_OR_LINK(
1175           [#include <complex.h>
1176            typedef __complex__ float float_type;
1177            typedef __complex__ double double_type;
1178            typedef __complex__ long double ld_type;
1179            volatile float_type tmpf;
1180            volatile double_type tmpd;
1181            volatile ld_type tmpld;
1182            volatile float f;
1183            volatile double d;
1184            volatile long double ld;],
1185           [f = cabsf(tmpf);
1186            f = cargf(tmpf);
1187            tmpf = ccosf(tmpf);
1188            tmpf = ccoshf(tmpf);
1189            tmpf = cexpf(tmpf);
1190            tmpf = clogf(tmpf);
1191            tmpf = csinf(tmpf);
1192            tmpf = csinhf(tmpf);
1193            tmpf = csqrtf(tmpf);
1194            tmpf = ctanf(tmpf);
1195            tmpf = ctanhf(tmpf);
1196            tmpf = cpowf(tmpf, tmpf);
1197            tmpf = cprojf(tmpf);
1198            d = cabs(tmpd);
1199            d = carg(tmpd);
1200            tmpd = ccos(tmpd);
1201            tmpd = ccosh(tmpd);
1202            tmpd = cexp(tmpd);
1203            tmpd = clog(tmpd);
1204            tmpd = csin(tmpd);
1205            tmpd = csinh(tmpd);
1206            tmpd = csqrt(tmpd);
1207            tmpd = ctan(tmpd);
1208            tmpd = ctanh(tmpd);
1209            tmpd = cpow(tmpd, tmpd);
1210            tmpd = cproj(tmpd);
1211            ld = cabsl(tmpld);
1212            ld = cargl(tmpld);
1213            tmpld = ccosl(tmpld);
1214            tmpld = ccoshl(tmpld);
1215            tmpld = cexpl(tmpld);
1216            tmpld = clogl(tmpld);
1217            tmpld = csinl(tmpld);
1218            tmpld = csinhl(tmpld);
1219            tmpld = csqrtl(tmpld);
1220            tmpld = ctanl(tmpld);
1221            tmpld = ctanhl(tmpld);
1222            tmpld = cpowl(tmpld, tmpld);
1223            tmpld = cprojl(tmpld);
1224           ], [glibcxx_cv_c99_complex_cxx11=yes], [glibcxx_cv_c99_complex_cxx11=no])
1225       ])
1226     fi
1227     AC_MSG_RESULT($glibcxx_cv_c99_complex_cxx11)
1228     if test x"$glibcxx_cv_c99_complex_cxx11" = x"yes"; then
1229       AC_DEFINE(_GLIBCXX11_USE_C99_COMPLEX, 1,
1230         [Define if C99 functions in <complex.h> should be used in
1231         <complex> for C++11. Using compiler builtins for these functions
1232         requires corresponding C99 library functions to be present.])
1233     fi
1235     # Check for the existence in <stdio.h> of vscanf, et. al.
1236     AC_MSG_CHECKING([for ISO C99 support in <stdio.h> for C++11])
1237     AC_CACHE_VAL(glibcxx_cv_c99_stdio_cxx11, [
1238       GCC_TRY_COMPILE_OR_LINK(
1239         [#include <stdio.h>
1240          #include <stdarg.h>
1241          void foo(char* fmt, ...)
1242          {
1243            va_list args; va_start(args, fmt);
1244            vfscanf(stderr, "%i", args);
1245            vscanf("%i", args);
1246            vsnprintf(fmt, 0, "%i", args);
1247            vsscanf(fmt, "%i", args);
1248            snprintf(fmt, 0, "%i");
1249          }], [],
1250         [glibcxx_cv_c99_stdio_cxx11=yes], [glibcxx_cv_c99_stdio_cxx11=no])
1251     ])
1252     AC_MSG_RESULT($glibcxx_cv_c99_stdio_cxx11)
1253     if test x"$glibcxx_cv_c99_stdio_cxx11" = x"yes"; then
1254       AC_DEFINE(_GLIBCXX11_USE_C99_STDIO, 1,
1255         [Define if C99 functions or macros in <stdio.h> should be imported
1256         in <cstdio> in namespace std for C++11.])
1257     fi
1259     # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1260     AC_MSG_CHECKING([for ISO C99 support in <stdlib.h> for C++11])
1261     AC_CACHE_VAL(glibcxx_cv_c99_stdlib_cxx11, [
1262       GCC_TRY_COMPILE_OR_LINK(
1263         [#include <stdlib.h>
1264          volatile float f;
1265          volatile long double ld;
1266          volatile unsigned long long ll;
1267          lldiv_t mydivt;],
1268         [char* tmp;
1269          f = strtof("gnu", &tmp);
1270          ld = strtold("gnu", &tmp);
1271          ll = strtoll("gnu", &tmp, 10);
1272          ll = strtoull("gnu", &tmp, 10);
1273          ll = llabs(10);
1274          mydivt = lldiv(10,1);
1275          ll = mydivt.quot;
1276          ll = mydivt.rem;
1277          ll = atoll("10");
1278          _Exit(0);
1279         ], [glibcxx_cv_c99_stdlib_cxx11=yes], [glibcxx_cv_c99_stdlib_cxx11=no])
1280     ])
1281     AC_MSG_RESULT($glibcxx_cv_c99_stdlib_cxx11)
1282     if test x"$glibcxx_cv_c99_stdlib_cxx11" = x"yes"; then
1283       AC_DEFINE(_GLIBCXX11_USE_C99_STDLIB, 1,
1284         [Define if C99 functions or macros in <stdlib.h> should be imported
1285         in <cstdlib> in namespace std for C++11.])
1286     fi
1288     # Check for the existence in <wchar.h> of wcstold, etc.
1289     if test x"$ac_has_wchar_h" = xyes &&
1290        test x"$ac_has_wctype_h" = xyes; then
1291       AC_MSG_CHECKING([for ISO C99 support in <wchar.h> for C++11])
1292       AC_CACHE_VAL(glibcxx_cv_c99_wchar_cxx11, [
1293         AC_TRY_COMPILE([#include <wchar.h>
1294           namespace test
1295           {
1296             using ::wcstold;
1297             using ::wcstoll;
1298             using ::wcstoull;
1299           }
1300         ], [], [glibcxx_cv_c99_wchar_cxx11=yes], [glibcxx_cv_c99_wchar_cxx11=no])
1301       ])
1303       # Checks for wide character functions that may not be present.
1304       # Injection of these is wrapped with guard macros.
1305       # NB: only put functions here, instead of immediately above, if
1306       # absolutely necessary.
1307       AC_TRY_COMPILE([#include <wchar.h>
1308         namespace test { using ::vfwscanf; }], [],
1309         [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1311       AC_TRY_COMPILE([#include <wchar.h>
1312         namespace test { using ::vswscanf; }], [],
1313         [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1315       AC_TRY_COMPILE([#include <wchar.h>
1316         namespace test { using ::vwscanf; }], [],
1317         [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1319       AC_TRY_COMPILE([#include <wchar.h>
1320         namespace test { using ::wcstof; }], [],
1321         [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1323       AC_TRY_COMPILE([#include <wctype.h>],
1324         [wint_t t; int i = iswblank(t);],
1325         [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1327       AC_MSG_RESULT($glibcxx_cv_c99_wchar_cxx11)
1328       if test x"$glibcxx_cv_c99_wchar_cxx11" = x"yes"; then
1329         AC_DEFINE(_GLIBCXX11_USE_C99_WCHAR, 1,
1330           [Define if C99 functions or macros in <wchar.h> should be imported
1331           in <cwchar> in namespace std for C++11.])
1332       fi
1333     fi
1335     gcc_no_link="$ac_save_gcc_no_link"
1336     LIBS="$ac_save_LIBS"
1337     CXXFLAGS="$ac_save_CXXFLAGS"
1338     AC_LANG_RESTORE
1339   fi
1341   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1342   AC_MSG_RESULT($enable_c99)
1347 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1348 dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this]
1349 dnl in the C++11 standard.
1351 dnl --enable-libstdcxx-time
1352 dnl --enable-libstdcxx-time=yes
1353 dnl        checks for the availability of monotonic and realtime clocks,
1354 dnl        nanosleep and sched_yield in libc and libposix4 and, if needed,
1355 dnl        links in the latter.
1356 dnl --enable-libstdcxx-time=rt
1357 dnl        also searches (and, if needed, links) librt.  Note that this is
1358 dnl        not always desirable because, in glibc 2.16 and earlier, for
1359 dnl        example, in turn it triggers the linking of libpthread too,
1360 dnl        which activates locking,
1361 dnl        a large overhead for single-thread programs.
1362 dnl --enable-libstdcxx-time=no
1363 dnl --disable-libstdcxx-time
1364 dnl        disables the checks completely
1366 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1367 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1368 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1369 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1371 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1373   GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]],
1374     [use KIND for check type],
1375     [permit yes|no|rt])
1377   AC_LANG_SAVE
1378   AC_LANG_CPLUSPLUS
1379   ac_save_CXXFLAGS="$CXXFLAGS"
1380   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1381   ac_save_LIBS="$LIBS"
1383   ac_has_clock_monotonic=no
1384   ac_has_clock_realtime=no
1385   ac_has_nanosleep=no
1386   ac_has_sched_yield=no
1388   if test x"$enable_libstdcxx_time" = x"auto"; then
1390     case "${target_os}" in
1391       cygwin*)
1392         ac_has_nanosleep=yes
1393         ;;
1394       darwin*)
1395         ac_has_nanosleep=yes
1396         ac_has_sched_yield=yes
1397         ;;
1398       gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
1399         AC_MSG_CHECKING([for at least GNU libc 2.17])
1400         AC_TRY_COMPILE(
1401           [#include <features.h>],
1402           [
1403           #if ! __GLIBC_PREREQ(2, 17)
1404           #error 
1405           #endif
1406           ],
1407           [glibcxx_glibc217=yes], [glibcxx_glibc217=no])
1408         AC_MSG_RESULT($glibcxx_glibc217)
1410         if test x"$glibcxx_glibc217" = x"yes"; then
1411           ac_has_clock_monotonic=yes
1412           ac_has_clock_realtime=yes
1413         fi
1414         ac_has_nanosleep=yes
1415         ac_has_sched_yield=yes
1416         ;;
1417       freebsd*|netbsd*|dragonfly*|rtems*)
1418         ac_has_clock_monotonic=yes
1419         ac_has_clock_realtime=yes
1420         ac_has_nanosleep=yes
1421         ac_has_sched_yield=yes
1422         ;;
1423       openbsd*)
1424         ac_has_clock_monotonic=yes
1425         ac_has_clock_realtime=yes
1426         ac_has_nanosleep=yes
1427         ;;
1428       solaris*)
1429         GLIBCXX_LIBS="$GLIBCXX_LIBS -lrt"
1430         ac_has_clock_monotonic=yes
1431         ac_has_clock_realtime=yes
1432         ac_has_nanosleep=yes
1433         ac_has_sched_yield=yes
1434         ;;
1435     esac
1437   elif test x"$enable_libstdcxx_time" != x"no"; then
1439     if test x"$enable_libstdcxx_time" = x"rt"; then
1440       AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1441       AC_SEARCH_LIBS(nanosleep, [rt posix4])
1442     else
1443       AC_SEARCH_LIBS(clock_gettime, [posix4])
1444       AC_SEARCH_LIBS(nanosleep, [posix4])
1445     fi
1447     case "$ac_cv_search_clock_gettime" in
1448       -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1449       ;;
1450     esac
1451     case "$ac_cv_search_nanosleep" in
1452       -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1453       ;;
1454     esac
1456     AC_SEARCH_LIBS(sched_yield, [rt posix4])
1458     case "$ac_cv_search_sched_yield" in
1459       -lposix4*)
1460       GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1461       ac_has_sched_yield=yes
1462       ;;
1463       -lrt*)
1464       if test x"$enable_libstdcxx_time" = x"rt"; then
1465         GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1466         ac_has_sched_yield=yes
1467       fi
1468       ;;
1469       *)
1470       ac_has_sched_yield=yes
1471       ;;
1472     esac
1474     AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1476     if test x"$ac_has_unistd_h" = x"yes"; then
1477       AC_MSG_CHECKING([for monotonic clock])
1478       AC_TRY_LINK(
1479         [#include <unistd.h>
1480          #include <time.h>
1481         ],
1482         [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1483           timespec tp;
1484          #endif
1485           clock_gettime(CLOCK_MONOTONIC, &tp);
1486         ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1488       AC_MSG_RESULT($ac_has_clock_monotonic)
1490       AC_MSG_CHECKING([for realtime clock])
1491       AC_TRY_LINK(
1492         [#include <unistd.h>
1493          #include <time.h>
1494         ],
1495         [#if _POSIX_TIMERS > 0
1496           timespec tp;
1497          #endif
1498           clock_gettime(CLOCK_REALTIME, &tp);
1499         ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1501       AC_MSG_RESULT($ac_has_clock_realtime)
1503       AC_MSG_CHECKING([for nanosleep])
1504       AC_TRY_LINK(
1505         [#include <unistd.h>
1506          #include <time.h>
1507         ],
1508         [#if _POSIX_TIMERS > 0
1509           timespec tp;
1510          #endif
1511           nanosleep(&tp, 0);
1512         ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1514       AC_MSG_RESULT($ac_has_nanosleep)
1515     fi
1516   fi
1518   if test x"$ac_has_clock_monotonic" != x"yes"; then
1519     case ${target_os} in
1520       linux*)
1521         AC_MSG_CHECKING([for clock_gettime syscall])
1522         AC_TRY_COMPILE(
1523           [#include <unistd.h>
1524            #include <time.h>
1525            #include <sys/syscall.h>
1526           ],
1527           [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1528             timespec tp;
1529            #endif
1530            syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp);
1531            syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp);
1532           ], [ac_has_clock_monotonic_syscall=yes], [ac_has_clock_monotonic_syscall=no])
1533         AC_MSG_RESULT($ac_has_clock_monotonic_syscall)
1534         if test x"$ac_has_clock_monotonic_syscall" = x"yes"; then
1535           AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1,
1536           [ Defined if clock_gettime syscall has monotonic and realtime clock support. ])
1537           ac_has_clock_monotonic=yes
1538           ac_has_clock_realtime=yes
1539         fi;;
1540     esac
1541   fi
1543   if test x"$ac_has_clock_monotonic" = x"yes"; then
1544     AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1545       [ Defined if clock_gettime has monotonic clock support. ])
1546   fi
1548   if test x"$ac_has_clock_realtime" = x"yes"; then
1549     AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1550       [ Defined if clock_gettime has realtime clock support. ])
1551   fi
1553   if test x"$ac_has_sched_yield" = x"yes"; then
1554     AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1555               [ Defined if sched_yield is available. ])
1556   fi
1558   if test x"$ac_has_nanosleep" = x"yes"; then
1559     AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1560       [ Defined if nanosleep is available. ])
1561   else
1562       AC_MSG_CHECKING([for sleep])
1563       AC_TRY_COMPILE([#include <unistd.h>],
1564                      [sleep(1)],
1565                      [ac_has_sleep=yes],[ac_has_sleep=no])
1566       if test x"$ac_has_sleep" = x"yes"; then
1567         AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.])
1568       fi
1569       AC_MSG_RESULT($ac_has_sleep)
1570       AC_MSG_CHECKING([for usleep])
1571       AC_TRY_COMPILE([#include <unistd.h>],
1572                      [sleep(1);
1573                       usleep(100);],
1574                      [ac_has_usleep=yes],[ac_has_usleep=no])
1575       if test x"$ac_has_usleep" = x"yes"; then
1576         AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.])
1577       fi
1578       AC_MSG_RESULT($ac_has_usleep)
1579   fi
1581   if test x"$ac_has_nanosleep$ac_has_sleep" = x"nono"; then
1582       AC_MSG_CHECKING([for Sleep])
1583       AC_TRY_COMPILE([#include <windows.h>],
1584                      [Sleep(1)],
1585                      [ac_has_win32_sleep=yes],[ac_has_win32_sleep=no])
1586       if test x"$ac_has_win32_sleep" = x"yes"; then
1587         AC_DEFINE(HAVE_WIN32_SLEEP,1, [Defined if Sleep exists.])
1588       fi
1589       AC_MSG_RESULT($ac_has_win32_sleep)
1590   fi
1592   AC_SUBST(GLIBCXX_LIBS)
1594   CXXFLAGS="$ac_save_CXXFLAGS"
1595   LIBS="$ac_save_LIBS"
1596   AC_LANG_RESTORE
1600 dnl Check for gettimeofday, used in the implementation of 20.11.7
1601 dnl [time.clock] in the C++11 standard.
1603 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1605   AC_MSG_CHECKING([for gettimeofday])
1607   AC_LANG_SAVE
1608   AC_LANG_CPLUSPLUS
1609   ac_save_CXXFLAGS="$CXXFLAGS"
1610   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1612   ac_has_gettimeofday=no;
1613   AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1614   if test x"$ac_has_sys_time_h" = x"yes"; then
1615     AC_MSG_CHECKING([for gettimeofday])
1616     GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1617       [timeval tv; gettimeofday(&tv, 0);],
1618       [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1620     AC_MSG_RESULT($ac_has_gettimeofday)
1621   fi
1623   if test x"$ac_has_gettimeofday" = x"yes"; then
1624     AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1625       [ Defined if gettimeofday is available. ])
1626   fi
1628   CXXFLAGS="$ac_save_CXXFLAGS"
1629   AC_LANG_RESTORE
1633 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1634 dnl facilities in Chapter 8, "C compatibility".
1636 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1638   AC_LANG_SAVE
1639   AC_LANG_CPLUSPLUS
1641   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1642   # undefined and fake C99 facilities may be spuriously enabled.
1643   ac_save_CXXFLAGS="$CXXFLAGS"
1644   CXXFLAGS="$CXXFLAGS -std=c++98"
1646   # Check for the existence of <complex.h> complex math functions used
1647   # by tr1/complex.
1648   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1649   ac_c99_complex_tr1=no;
1650   if test x"$ac_has_complex_h" = x"yes"; then
1651     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1652     AC_TRY_COMPILE([#include <complex.h>],
1653                    [typedef __complex__ float float_type; float_type tmpf;
1654                     cacosf(tmpf);
1655                     casinf(tmpf);
1656                     catanf(tmpf);
1657                     cacoshf(tmpf);
1658                     casinhf(tmpf);
1659                     catanhf(tmpf);
1660                     typedef __complex__ double double_type; double_type tmpd;
1661                     cacos(tmpd);
1662                     casin(tmpd);
1663                     catan(tmpd);
1664                     cacosh(tmpd);
1665                     casinh(tmpd);
1666                     catanh(tmpd);
1667                     typedef __complex__ long double ld_type; ld_type tmpld;
1668                     cacosl(tmpld);
1669                     casinl(tmpld);
1670                     catanl(tmpld);
1671                     cacoshl(tmpld);
1672                     casinhl(tmpld);
1673                     catanhl(tmpld);
1674                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1675   fi
1676   AC_MSG_RESULT($ac_c99_complex_tr1)
1677   if test x"$ac_c99_complex_tr1" = x"yes"; then
1678     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1679               [Define if C99 functions in <complex.h> should be used in
1680               <tr1/complex>. Using compiler builtins for these functions
1681               requires corresponding C99 library functions to be present.])
1682   fi
1684   # Check for the existence of <ctype.h> functions.
1685   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1686   AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1687   AC_TRY_COMPILE([#include <ctype.h>],
1688                  [int ch;
1689                   int ret;
1690                   ret = isblank(ch);
1691                  ],[glibcxx_cv_c99_ctype_tr1=yes],
1692                    [glibcxx_cv_c99_ctype_tr1=no])
1693   ])
1694   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1695   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1696     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1697               [Define if C99 functions in <ctype.h> should be imported in
1698               <tr1/cctype> in namespace std::tr1.])
1699   fi
1701   # Check for the existence of <fenv.h> functions.
1702   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1703   ac_c99_fenv_tr1=no;
1704   if test x"$ac_has_fenv_h" = x"yes"; then
1705     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1706     AC_TRY_COMPILE([#include <fenv.h>],
1707                    [int except, mode;
1708                     fexcept_t* pflag;
1709                     fenv_t* penv;
1710                     int ret;
1711                     ret = feclearexcept(except);
1712                     ret = fegetexceptflag(pflag, except);
1713                     ret = feraiseexcept(except);
1714                     ret = fesetexceptflag(pflag, except);
1715                     ret = fetestexcept(except);
1716                     ret = fegetround();
1717                     ret = fesetround(mode);
1718                     ret = fegetenv(penv);
1719                     ret = feholdexcept(penv);
1720                     ret = fesetenv(penv);
1721                     ret = feupdateenv(penv);
1722                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1723   fi
1724   AC_MSG_RESULT($ac_c99_fenv_tr1)
1725   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1726     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1727               [Define if C99 functions in <fenv.h> should be imported in
1728               <tr1/cfenv> in namespace std::tr1.])
1729   fi
1731   # Check for the existence of <stdint.h> types.
1732   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1733   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1734   AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1735                   #define __STDC_CONSTANT_MACROS
1736                   #include <stdint.h>],
1737                  [typedef int8_t          my_int8_t;
1738                   my_int8_t               i8 = INT8_MIN;
1739                   i8 = INT8_MAX;
1740                   typedef int16_t         my_int16_t;
1741                   my_int16_t              i16 = INT16_MIN;
1742                   i16 = INT16_MAX;
1743                   typedef int32_t         my_int32_t;
1744                   my_int32_t              i32 = INT32_MIN;
1745                   i32 = INT32_MAX;
1746                   typedef int64_t         my_int64_t;
1747                   my_int64_t              i64 = INT64_MIN;
1748                   i64 = INT64_MAX;
1749                   typedef int_fast8_t     my_int_fast8_t;
1750                   my_int_fast8_t          if8 = INT_FAST8_MIN;
1751                   if8 = INT_FAST8_MAX;
1752                   typedef int_fast16_t    my_int_fast16_t;
1753                   my_int_fast16_t         if16 = INT_FAST16_MIN;
1754                   if16 = INT_FAST16_MAX;
1755                   typedef int_fast32_t    my_int_fast32_t;
1756                   my_int_fast32_t         if32 = INT_FAST32_MIN;
1757                   if32 = INT_FAST32_MAX;
1758                   typedef int_fast64_t    my_int_fast64_t;
1759                   my_int_fast64_t         if64 = INT_FAST64_MIN;
1760                   if64 = INT_FAST64_MAX;
1761                   typedef int_least8_t    my_int_least8_t;
1762                   my_int_least8_t         il8 = INT_LEAST8_MIN;
1763                   il8 = INT_LEAST8_MAX;
1764                   typedef int_least16_t   my_int_least16_t;
1765                   my_int_least16_t        il16 = INT_LEAST16_MIN;
1766                   il16 = INT_LEAST16_MAX;
1767                   typedef int_least32_t   my_int_least32_t;
1768                   my_int_least32_t        il32 = INT_LEAST32_MIN;
1769                   il32 = INT_LEAST32_MAX;
1770                   typedef int_least64_t   my_int_least64_t;
1771                   my_int_least64_t        il64 = INT_LEAST64_MIN;
1772                   il64 = INT_LEAST64_MAX;
1773                   typedef intmax_t        my_intmax_t;
1774                   my_intmax_t             im = INTMAX_MAX;
1775                   im = INTMAX_MIN;
1776                   typedef intptr_t        my_intptr_t;
1777                   my_intptr_t             ip = INTPTR_MAX;
1778                   ip = INTPTR_MIN;
1779                   typedef uint8_t         my_uint8_t;
1780                   my_uint8_t              ui8 = UINT8_MAX;
1781                   ui8 = UINT8_MAX;
1782                   typedef uint16_t        my_uint16_t;
1783                   my_uint16_t             ui16 = UINT16_MAX;
1784                   ui16 = UINT16_MAX;
1785                   typedef uint32_t        my_uint32_t;
1786                   my_uint32_t             ui32 = UINT32_MAX;
1787                   ui32 = UINT32_MAX;
1788                   typedef uint64_t        my_uint64_t;
1789                   my_uint64_t             ui64 = UINT64_MAX;
1790                   ui64 = UINT64_MAX;
1791                   typedef uint_fast8_t    my_uint_fast8_t;
1792                   my_uint_fast8_t         uif8 = UINT_FAST8_MAX;
1793                   uif8 = UINT_FAST8_MAX;
1794                   typedef uint_fast16_t   my_uint_fast16_t;
1795                   my_uint_fast16_t        uif16 = UINT_FAST16_MAX;
1796                   uif16 = UINT_FAST16_MAX;
1797                   typedef uint_fast32_t   my_uint_fast32_t;
1798                   my_uint_fast32_t        uif32 = UINT_FAST32_MAX;
1799                   uif32 = UINT_FAST32_MAX;
1800                   typedef uint_fast64_t   my_uint_fast64_t;
1801                   my_uint_fast64_t        uif64 = UINT_FAST64_MAX;
1802                   uif64 = UINT_FAST64_MAX;
1803                   typedef uint_least8_t   my_uint_least8_t;
1804                   my_uint_least8_t        uil8 = UINT_LEAST8_MAX;
1805                   uil8 = UINT_LEAST8_MAX;
1806                   typedef uint_least16_t  my_uint_least16_t;
1807                   my_uint_least16_t       uil16 = UINT_LEAST16_MAX;
1808                   uil16 = UINT_LEAST16_MAX;
1809                   typedef uint_least32_t  my_uint_least32_t;
1810                   my_uint_least32_t       uil32 = UINT_LEAST32_MAX;
1811                   uil32 = UINT_LEAST32_MAX;
1812                   typedef uint_least64_t  my_uint_least64_t;
1813                   my_uint_least64_t       uil64 = UINT_LEAST64_MAX;
1814                   uil64 = UINT_LEAST64_MAX;
1815                   typedef uintmax_t       my_uintmax_t;
1816                   my_uintmax_t            uim = UINTMAX_MAX;
1817                   uim = UINTMAX_MAX;
1818                   typedef uintptr_t       my_uintptr_t;
1819                   my_uintptr_t            uip = UINTPTR_MAX;
1820                   uip = UINTPTR_MAX;
1821                  ],[glibcxx_cv_c99_stdint_tr1=yes],
1822                    [glibcxx_cv_c99_stdint_tr1=no])
1823   ])
1824   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1825   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1826     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1827               [Define if C99 types in <stdint.h> should be imported in
1828               <tr1/cstdint> in namespace std::tr1.])
1829   fi
1831   # Check for the existence of <math.h> functions.
1832   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1833   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1834   AC_TRY_COMPILE([#include <math.h>],
1835                  [typedef double_t  my_double_t;
1836                   typedef float_t   my_float_t;
1837                   acosh(0.0);
1838                   acoshf(0.0f);
1839                   acoshl(0.0l);
1840                   asinh(0.0);
1841                   asinhf(0.0f);
1842                   asinhl(0.0l);
1843                   atanh(0.0);
1844                   atanhf(0.0f);
1845                   atanhl(0.0l);
1846                   cbrt(0.0);
1847                   cbrtf(0.0f);
1848                   cbrtl(0.0l);
1849                   copysign(0.0, 0.0);
1850                   copysignf(0.0f, 0.0f);
1851                   copysignl(0.0l, 0.0l);
1852                   erf(0.0);
1853                   erff(0.0f);
1854                   erfl(0.0l);
1855                   erfc(0.0);
1856                   erfcf(0.0f);
1857                   erfcl(0.0l);
1858                   exp2(0.0);
1859                   exp2f(0.0f);
1860                   exp2l(0.0l);
1861                   expm1(0.0);
1862                   expm1f(0.0f);
1863                   expm1l(0.0l);
1864                   fdim(0.0, 0.0);
1865                   fdimf(0.0f, 0.0f);
1866                   fdiml(0.0l, 0.0l);
1867                   fma(0.0, 0.0, 0.0);
1868                   fmaf(0.0f, 0.0f, 0.0f);
1869                   fmal(0.0l, 0.0l, 0.0l);
1870                   fmax(0.0, 0.0);
1871                   fmaxf(0.0f, 0.0f);
1872                   fmaxl(0.0l, 0.0l);
1873                   fmin(0.0, 0.0);
1874                   fminf(0.0f, 0.0f);
1875                   fminl(0.0l, 0.0l);
1876                   hypot(0.0, 0.0);
1877                   hypotf(0.0f, 0.0f);
1878                   hypotl(0.0l, 0.0l);
1879                   ilogb(0.0);
1880                   ilogbf(0.0f);
1881                   ilogbl(0.0l);
1882                   lgamma(0.0);
1883                   lgammaf(0.0f);
1884                   lgammal(0.0l);
1885                   #ifndef __APPLE__ /* see below */
1886                   llrint(0.0);
1887                   llrintf(0.0f);
1888                   llrintl(0.0l);
1889                   llround(0.0);
1890                   llroundf(0.0f);
1891                   llroundl(0.0l);
1892                   #endif
1893                   log1p(0.0);
1894                   log1pf(0.0f);
1895                   log1pl(0.0l);
1896                   log2(0.0);
1897                   log2f(0.0f);
1898                   log2l(0.0l);
1899                   logb(0.0);
1900                   logbf(0.0f);
1901                   logbl(0.0l);
1902                   lrint(0.0);
1903                   lrintf(0.0f);
1904                   lrintl(0.0l);
1905                   lround(0.0);
1906                   lroundf(0.0f);
1907                   lroundl(0.0l);
1908                   nan(0);
1909                   nanf(0);
1910                   nanl(0);
1911                   nearbyint(0.0);
1912                   nearbyintf(0.0f);
1913                   nearbyintl(0.0l);
1914                   nextafter(0.0, 0.0);
1915                   nextafterf(0.0f, 0.0f);
1916                   nextafterl(0.0l, 0.0l);
1917                   nexttoward(0.0, 0.0);
1918                   nexttowardf(0.0f, 0.0f);
1919                   nexttowardl(0.0l, 0.0l);
1920                   remainder(0.0, 0.0);
1921                   remainderf(0.0f, 0.0f);
1922                   remainderl(0.0l, 0.0l);
1923                   remquo(0.0, 0.0, 0);
1924                   remquof(0.0f, 0.0f, 0);
1925                   remquol(0.0l, 0.0l, 0);
1926                   rint(0.0);
1927                   rintf(0.0f);
1928                   rintl(0.0l);
1929                   round(0.0);
1930                   roundf(0.0f);
1931                   roundl(0.0l);
1932                   scalbln(0.0, 0l);
1933                   scalblnf(0.0f, 0l);
1934                   scalblnl(0.0l, 0l);
1935                   scalbn(0.0, 0);
1936                   scalbnf(0.0f, 0);
1937                   scalbnl(0.0l, 0);
1938                   tgamma(0.0);
1939                   tgammaf(0.0f);
1940                   tgammal(0.0l);
1941                   trunc(0.0);
1942                   truncf(0.0f);
1943                   truncl(0.0l);
1944                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1945   ])
1946   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1947   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1948     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1949               [Define if C99 functions or macros in <math.h> should be imported
1950               in <tr1/cmath> in namespace std::tr1.])
1952     case "${target_os}" in
1953       darwin*)
1954         AC_MSG_CHECKING([for ISO C99 rounding functions in <math.h>])
1955         AC_CACHE_VAL(glibcxx_cv_c99_math_llround, [
1956           AC_TRY_COMPILE([#include <math.h>],
1957                  [llrint(0.0);
1958                   llrintf(0.0f);
1959                   llrintl(0.0l);
1960                   llround(0.0);
1961                   llroundf(0.0f);
1962                   llroundl(0.0l);
1963                  ],
1964                  [glibcxx_cv_c99_math_llround=yes],
1965                  [glibcxx_cv_c99_math_llround=no])
1966           ])
1967         AC_MSG_RESULT($glibcxx_cv_c99_math_llround)
1968         ;;
1969     esac
1970     if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
1971       AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
1972                 [Define if C99 llrint and llround functions are missing from <math.h>.])
1973     fi
1974   fi
1976   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1977   # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1978   ac_c99_inttypes_tr1=no;
1979   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1980     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1981     AC_TRY_COMPILE([#include <inttypes.h>],
1982                    [intmax_t i, numer, denom, base;
1983                     const char* s;
1984                     char** endptr;
1985                     intmax_t ret = imaxabs(i);
1986                     imaxdiv_t dret = imaxdiv(numer, denom);
1987                     ret = strtoimax(s, endptr, base);
1988                     uintmax_t uret = strtoumax(s, endptr, base);
1989                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1990   fi
1991   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1992   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1993     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1994               [Define if C99 functions in <inttypes.h> should be imported in
1995               <tr1/cinttypes> in namespace std::tr1.])
1996   fi
1998   # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
1999   # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
2000   ac_c99_inttypes_wchar_t_tr1=no;
2001   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2002     AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
2003     AC_TRY_COMPILE([#include <inttypes.h>],
2004                    [intmax_t base;
2005                     const wchar_t* s;
2006                     wchar_t** endptr;
2007                     intmax_t ret = wcstoimax(s, endptr, base);
2008                     uintmax_t uret = wcstoumax(s, endptr, base);
2009                    ],[ac_c99_inttypes_wchar_t_tr1=yes],
2010                      [ac_c99_inttypes_wchar_t_tr1=no])
2011   fi
2012   AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
2013   if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
2014     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
2015               [Define if wchar_t C99 functions in <inttypes.h> should be
2016               imported in <tr1/cinttypes> in namespace std::tr1.])
2017   fi
2019   # Check for the existence of the <stdbool.h> header.
2020   AC_CHECK_HEADERS(stdbool.h)
2022   # Check for the existence of the <stdalign.h> header.
2023   AC_CHECK_HEADERS(stdalign.h)
2025   CXXFLAGS="$ac_save_CXXFLAGS"
2026   AC_LANG_RESTORE
2030 dnl Check for uchar.h and usability.
2032 AC_DEFUN([GLIBCXX_CHECK_UCHAR_H], [
2034   # Test uchar.h.
2035   AC_CHECK_HEADERS(uchar.h, ac_has_uchar_h=yes, ac_has_uchar_h=no)
2037   AC_LANG_SAVE
2038   AC_LANG_CPLUSPLUS
2039   ac_save_CXXFLAGS="$CXXFLAGS"
2040   CXXFLAGS="$CXXFLAGS -std=c++11"
2042   if test x"$ac_has_uchar_h" = x"yes"; then
2043     AC_MSG_CHECKING([for ISO C11 support for <uchar.h>])
2044     AC_TRY_COMPILE([#include <uchar.h>
2045                     #ifdef __STDC_UTF_16__
2046                     long i = __STDC_UTF_16__;
2047                     #endif
2048                     #ifdef __STDC_UTF_32__
2049                     long j = __STDC_UTF_32__;
2050                     #endif
2051                     namespace test
2052                     {
2053                       using ::c16rtomb;
2054                       using ::c32rtomb;
2055                       using ::mbrtoc16;
2056                       using ::mbrtoc32;
2057                     }
2058                    ],
2059                    [], [ac_c11_uchar_cxx11=yes], [ac_c11_uchar_cxx11=no])
2060   else
2061     ac_c11_uchar_cxx11=no
2062   fi
2063   AC_MSG_RESULT($ac_c11_uchar_cxx11)
2064   if test x"$ac_c11_uchar_cxx11" = x"yes"; then
2065     AC_DEFINE(_GLIBCXX_USE_C11_UCHAR_CXX11, 1,
2066               [Define if C11 functions in <uchar.h> should be imported into
2067               namespace std in <cuchar>.])
2068   fi
2070   CXXFLAGS="$ac_save_CXXFLAGS"
2071   AC_LANG_RESTORE
2076 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
2077 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
2079 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
2081   AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
2082   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
2083     if test -r /dev/random && test -r /dev/urandom; then
2084   ## For MSys environment the test above is detect as false-positive
2085   ## on mingw-targets.  So disable it explicit for them.
2086       case ${target_os} in
2087         *mingw*) glibcxx_cv_random_tr1=no ;;
2088         *) glibcxx_cv_random_tr1=yes ;;
2089       esac
2090     else
2091       glibcxx_cv_random_tr1=no;
2092     fi
2093   ])
2094   AC_MSG_RESULT($glibcxx_cv_random_tr1)
2096   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
2097     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
2098               [Define if /dev/random and /dev/urandom are available for
2099                the random_device of TR1 (Chapter 5.1).])
2100   fi
2105 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
2107 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
2109   AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
2110   AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
2111                  [#include <stdio.h>],
2112                  [AC_MSG_ERROR([computing EOF failed])])
2113   ])
2114   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
2115                      [Define to the value of the EOF integer constant.])
2117   AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
2118   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
2119                  [#include <stdio.h>],
2120                  [AC_MSG_ERROR([computing SEEK_CUR failed])])
2121   ])
2122   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
2123                      [Define to the value of the SEEK_CUR integer constant.])
2125   AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
2126   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
2127                  [#include <stdio.h>],
2128                  [AC_MSG_ERROR([computing SEEK_END failed])])
2129   ])
2130   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
2131                      [Define to the value of the SEEK_END integer constant.])
2135 dnl Check whether required C++ overloads are present in <stdio.h>.
2137 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
2139   AC_LANG_SAVE
2140   AC_LANG_CPLUSPLUS
2141   # Use C++11 because a conforming <stdio.h> won't define gets for C++14,
2142   # and we don't need a declaration for C++14 anyway.
2143   ac_save_CXXFLAGS="$CXXFLAGS"
2144   CXXFLAGS="$CXXFLAGS -std=gnu++11"
2146   AC_MSG_CHECKING([for gets declaration])
2147   AC_CACHE_VAL(glibcxx_cv_gets, [
2148   AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2149           [#include <stdio.h>
2150            namespace test 
2151            {
2152               using ::gets;
2153            }
2154         ])],
2155         [glibcxx_cv_gets=yes],
2156         [glibcxx_cv_gets=no]
2157       )])
2159   if test $glibcxx_cv_gets = yes; then
2160     AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h> before C++14.])
2161   fi
2162   AC_MSG_RESULT($glibcxx_cv_gets)
2164   CXXFLAGS="$ac_save_CXXFLAGS"
2165   AC_LANG_RESTORE
2169 dnl Check whether required C++11 overloads for floating point and integral
2170 dnl types are present in <math.h>.
2172 AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
2174   AC_LANG_SAVE
2175   AC_LANG_CPLUSPLUS
2176   ac_save_CXXFLAGS="$CXXFLAGS"
2177   CXXFLAGS="$CXXFLAGS -std=c++11"
2179   case "$host" in
2180     *-*-solaris2.*)
2181       # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
2182       # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
2183       AC_MSG_CHECKING([for C++11 <math.h> floating point overloads])
2184       AC_CACHE_VAL(glibcxx_cv_math11_fp_overload, [
2185         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2186           [#include <math.h>
2187            #undef isfinite
2188            namespace std {
2189              inline bool isfinite(float __x)
2190              { return __builtin_isfinite(__x); }
2191            }
2192         ])],
2193         [glibcxx_cv_math11_fp_overload=no],
2194         [glibcxx_cv_math11_fp_overload=yes]
2195       )])
2197       # autoheader cannot handle indented templates.
2198       AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP],
2199         [/* Define if all C++11 floating point overloads are available in <math.h>.  */
2200 #if __cplusplus >= 201103L
2201 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2202 #endif])
2204       if test $glibcxx_cv_math11_fp_overload = yes; then
2205         AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP)
2206       fi
2207       AC_MSG_RESULT([$glibcxx_cv_math11_fp_overload])
2209       # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
2210       # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
2211       AC_MSG_CHECKING([for C++11 <math.h> integral type overloads])
2212       AC_CACHE_VAL(glibcxx_cv_math11_int_overload, [
2213         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2214           [#include <math.h>
2215            namespace std {
2216              template<typename _Tp>
2217                struct __is_integer;
2218              template<>
2219                struct __is_integer<int>
2220                {
2221                  enum { __value = 1 };
2222                };
2223            }
2224            namespace __gnu_cxx {
2225              template<bool, typename>
2226                struct __enable_if;
2227              template<typename _Tp>
2228                struct __enable_if<true, _Tp>
2229                { typedef _Tp __type; };
2230            }
2231            namespace std {
2232              template<typename _Tp>
2233                constexpr typename __gnu_cxx::__enable_if
2234                          <__is_integer<_Tp>::__value, double>::__type
2235                log2(_Tp __x)
2236                { return __builtin_log2(__x); }
2237            }
2238            int
2239            main (void)
2240            {
2241              int i = 1000;
2242              return std::log2(i);
2243            }
2244         ])],
2245         [glibcxx_cv_math11_int_overload=no],
2246         [glibcxx_cv_math11_int_overload=yes]
2247       )])
2249       # autoheader cannot handle indented templates.
2250       AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT],
2251         [/* Define if all C++11 integral type overloads are available in <math.h>.  */
2252 #if __cplusplus >= 201103L
2253 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2254 #endif])
2256       if test $glibcxx_cv_math11_int_overload = yes; then
2257         AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT)
2258       fi
2259       AC_MSG_RESULT([$glibcxx_cv_math11_int_overload])
2260       ;;
2261     *)
2262       # If <math.h> defines the obsolete isinf(double) and isnan(double)
2263       # functions (instead of or as well as the C99 generic macros) then we
2264       # can't define std::isinf(double) and std::isnan(double) in <cmath>
2265       # and must use the ones from <math.h> instead.
2266       AC_MSG_CHECKING([for obsolete isinf function in <math.h>])
2267         AC_CACHE_VAL(glibcxx_cv_obsolete_isinf, [
2268           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2269             [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2270              #include <math.h>
2271              #undef isinf
2272              namespace std {
2273                using ::isinf;
2274                bool isinf(float);
2275                bool isinf(long double);
2276              }
2277              using std::isinf;
2278              bool b = isinf(0.0);
2279           ])],
2280           [glibcxx_cv_obsolete_isinf=yes],
2281           [glibcxx_cv_obsolete_isinf=no]
2282         )])
2283       AC_MSG_RESULT([$glibcxx_cv_obsolete_isinf])
2284       if test $glibcxx_cv_obsolete_isinf = yes; then
2285         AC_DEFINE(HAVE_OBSOLETE_ISINF, 1,
2286                   [Define if <math.h> defines obsolete isinf function.])
2287       fi
2289       AC_MSG_CHECKING([for obsolete isnan function in <math.h>])
2290         AC_CACHE_VAL(glibcxx_cv_obsolete_isnan, [
2291           AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2292             [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2293              #include <math.h>
2294              #undef isnan
2295              namespace std {
2296                using ::isnan;
2297                bool isnan(float);
2298                bool isnan(long double);
2299              }
2300              using std::isnan;
2301              bool b = isnan(0.0);
2302           ])],
2303           [glibcxx_cv_obsolete_isnan=yes],
2304           [glibcxx_cv_obsolete_isnan=no]
2305         )])
2306       AC_MSG_RESULT([$glibcxx_cv_obsolete_isnan])
2307       if test $glibcxx_cv_obsolete_isnan = yes; then
2308         AC_DEFINE(HAVE_OBSOLETE_ISNAN, 1,
2309                   [Define if <math.h> defines obsolete isnan function.])
2310       fi
2311       ;;
2312   esac
2314   CXXFLAGS="$ac_save_CXXFLAGS"
2315   AC_LANG_RESTORE
2319 dnl Check whether macros, etc are present for <system_error>
2321 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
2323 m4_pushdef([n_syserr], [1])dnl
2324 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
2325                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
2326                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
2327                       ECHILD, ENOSPC, EPERM,
2328                       ETIMEDOUT, EWOULDBLOCK],
2329 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
2330 AC_MSG_CHECKING([for syserr])
2331 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
2332 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
2333                                    [int i = syserr;])],
2334                   [glibcxx_cv_system_error[]n_syserr=yes],
2335                   [glibcxx_cv_system_error[]n_syserr=no])
2337 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
2338 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
2339   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
2341 m4_define([n_syserr], m4_incr(n_syserr))dnl
2342 m4_popdef([SYSERR])dnl
2344 m4_popdef([n_syserr])dnl
2348 dnl Check for what type of C headers to use.
2350 dnl --enable-cheaders= [does stuff].
2351 dnl --disable-cheaders [does not do anything, really].
2352 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
2353 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
2355 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
2356   GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
2357     [construct "C" headers for g++], [permit c|c_std|c_global])
2358   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
2360   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
2362   # Allow overrides to configure.host here.
2363   if test $enable_cheaders = c_global; then
2364      c_compatibility=yes
2365   fi
2367   AC_SUBST(C_INCLUDE_DIR)
2368   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
2369   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
2370   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
2371   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
2376 dnl Check for which locale library to use.  The choice is mapped to
2377 dnl a subdirectory of config/locale.
2379 dnl Default is generic.
2381 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
2382   GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
2383     [use MODEL for target locale package],
2384     [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
2386   # Deal with gettext issues.  Default to not using it (=no) until we detect
2387   # support for it later.  Let the user turn it off via --e/d, but let that
2388   # default to on for easier handling.
2389   USE_NLS=no
2390   AC_ARG_ENABLE(nls,
2391     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
2392     [],
2393     [enable_nls=yes])
2395   # Either a known package, or "auto"
2396   if test $enable_clocale = no || test $enable_clocale = yes; then
2397      enable_clocale=auto
2398   fi
2399   enable_clocale_flag=$enable_clocale
2401   # Probe for locale model to use if none specified.
2402   # Default to "generic".
2403   if test $enable_clocale_flag = auto; then
2404     case ${target_os} in
2405       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2406         enable_clocale_flag=gnu
2407         ;;
2408       darwin*)
2409         enable_clocale_flag=darwin
2410         ;;
2411       dragonfly* | freebsd*)
2412         enable_clocale_flag=dragonfly
2413         ;;
2414       openbsd*)
2415         enable_clocale_flag=newlib
2416         ;;
2417       *)
2418         if test x"$with_newlib" = x"yes"; then
2419           enable_clocale_flag=newlib
2420         else
2421           enable_clocale_flag=generic
2422         fi
2423         ;;
2424     esac
2425   fi
2427   # Sanity check model, and test for special functionality.
2428   if test $enable_clocale_flag = gnu; then
2429     AC_EGREP_CPP([_GLIBCXX_ok], [
2430     #include <features.h>
2431     #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
2432       _GLIBCXX_ok
2433     #endif
2434     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
2436     # Set it to scream when it hurts.
2437     ac_save_CFLAGS="$CFLAGS"
2438     CFLAGS="-Wimplicit-function-declaration -Werror"
2440     # Use strxfrm_l if available.
2441     AC_TRY_COMPILE([#define _GNU_SOURCE 1
2442                     #include <string.h>
2443                     #include <locale.h>],
2444                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
2445                     AC_DEFINE(HAVE_STRXFRM_L, 1,
2446                     [Define if strxfrm_l is available in <string.h>.]),)
2448     # Use strerror_l if available.
2449     AC_TRY_COMPILE([#define _GNU_SOURCE 1
2450                     #include <string.h>
2451                     #include <locale.h>],
2452                     [__locale_t loc; strerror_l(5, loc);],
2453                     AC_DEFINE(HAVE_STRERROR_L, 1,
2454                     [Define if strerror_l is available in <string.h>.]),)
2456     CFLAGS="$ac_save_CFLAGS"
2457   fi
2459   # Perhaps use strerror_r if available, and strerror_l isn't.
2460   ac_save_CFLAGS="$CFLAGS"
2461   CFLAGS="-Wimplicit-function-declaration -Werror"
2462   AC_TRY_COMPILE([#define _GNU_SOURCE 1
2463                   #include <string.h>
2464                   #include <locale.h>],
2465                   [char s[128]; strerror_r(5, s, 128);],
2466                   AC_DEFINE(HAVE_STRERROR_R, 1,
2467                   [Define if strerror_r is available in <string.h>.]),)
2468   CFLAGS="$ac_save_CFLAGS"
2470   # Set configure bits for specified locale package
2471   AC_MSG_CHECKING([for C locale to use])
2472   case ${enable_clocale_flag} in
2473     generic)
2474       AC_MSG_RESULT(generic)
2476       CLOCALE_H=config/locale/generic/c_locale.h
2477       CLOCALE_CC=config/locale/generic/c_locale.cc
2478       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2479       CCOLLATE_CC=config/locale/generic/collate_members.cc
2480       CCTYPE_CC=config/locale/generic/ctype_members.cc
2481       CMESSAGES_H=config/locale/generic/messages_members.h
2482       CMESSAGES_CC=config/locale/generic/messages_members.cc
2483       CMONEY_CC=config/locale/generic/monetary_members.cc
2484       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2485       CTIME_H=config/locale/generic/time_members.h
2486       CTIME_CC=config/locale/generic/time_members.cc
2487       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2488       ;;
2489     darwin)
2490       AC_MSG_RESULT(darwin)
2492       CLOCALE_H=config/locale/generic/c_locale.h
2493       CLOCALE_CC=config/locale/generic/c_locale.cc
2494       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2495       CCOLLATE_CC=config/locale/generic/collate_members.cc
2496       CCTYPE_CC=config/locale/darwin/ctype_members.cc
2497       CMESSAGES_H=config/locale/generic/messages_members.h
2498       CMESSAGES_CC=config/locale/generic/messages_members.cc
2499       CMONEY_CC=config/locale/generic/monetary_members.cc
2500       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2501       CTIME_H=config/locale/generic/time_members.h
2502       CTIME_CC=config/locale/generic/time_members.cc
2503       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2504       ;;
2506     dragonfly)
2507       AC_MSG_RESULT(dragonfly or freebsd)
2509       CLOCALE_H=config/locale/dragonfly/c_locale.h
2510       CLOCALE_CC=config/locale/dragonfly/c_locale.cc
2511       CCODECVT_CC=config/locale/dragonfly/codecvt_members.cc
2512       CCOLLATE_CC=config/locale/dragonfly/collate_members.cc
2513       CCTYPE_CC=config/locale/dragonfly/ctype_members.cc
2514       CMESSAGES_H=config/locale/generic/messages_members.h
2515       CMESSAGES_CC=config/locale/generic/messages_members.cc
2516       CMONEY_CC=config/locale/dragonfly/monetary_members.cc
2517       CNUMERIC_CC=config/locale/dragonfly/numeric_members.cc
2518       CTIME_H=config/locale/dragonfly/time_members.h
2519       CTIME_CC=config/locale/dragonfly/time_members.cc
2520       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2521       ;;
2523     gnu)
2524       AC_MSG_RESULT(gnu)
2526       # Declare intention to use gettext, and add support for specific
2527       # languages.
2528       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2529       ALL_LINGUAS="de fr"
2531       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2532       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2533       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2534         USE_NLS=yes
2535       fi
2536       # Export the build objects.
2537       for ling in $ALL_LINGUAS; do \
2538         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2539         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2540       done
2541       AC_SUBST(glibcxx_MOFILES)
2542       AC_SUBST(glibcxx_POFILES)
2544       CLOCALE_H=config/locale/gnu/c_locale.h
2545       CLOCALE_CC=config/locale/gnu/c_locale.cc
2546       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2547       CCOLLATE_CC=config/locale/gnu/collate_members.cc
2548       CCTYPE_CC=config/locale/gnu/ctype_members.cc
2549       CMESSAGES_H=config/locale/gnu/messages_members.h
2550       CMESSAGES_CC=config/locale/gnu/messages_members.cc
2551       CMONEY_CC=config/locale/gnu/monetary_members.cc
2552       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2553       CTIME_H=config/locale/gnu/time_members.h
2554       CTIME_CC=config/locale/gnu/time_members.cc
2555       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2556       ;;
2557     ieee_1003.1-2001)
2558       AC_MSG_RESULT(IEEE 1003.1)
2560       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2561       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2562       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2563       CCOLLATE_CC=config/locale/generic/collate_members.cc
2564       CCTYPE_CC=config/locale/generic/ctype_members.cc
2565       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2566       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2567       CMONEY_CC=config/locale/generic/monetary_members.cc
2568       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2569       CTIME_H=config/locale/generic/time_members.h
2570       CTIME_CC=config/locale/generic/time_members.cc
2571       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2572       ;;
2573     newlib)
2574       AC_MSG_RESULT(newlib)
2576       CLOCALE_H=config/locale/generic/c_locale.h
2577       CLOCALE_CC=config/locale/generic/c_locale.cc
2578       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2579       CCOLLATE_CC=config/locale/generic/collate_members.cc
2580       CCTYPE_CC=config/locale/newlib/ctype_members.cc
2581       CMESSAGES_H=config/locale/generic/messages_members.h
2582       CMESSAGES_CC=config/locale/generic/messages_members.cc
2583       CMONEY_CC=config/locale/generic/monetary_members.cc
2584       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2585       CTIME_H=config/locale/generic/time_members.h
2586       CTIME_CC=config/locale/generic/time_members.cc
2587       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2588       ;;
2589   esac
2591   # This is where the testsuite looks for locale catalogs, using the
2592   # -DLOCALEDIR define during testsuite compilation.
2593   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2594   AC_SUBST(glibcxx_localedir)
2596   # A standalone libintl (e.g., GNU libintl) may be in use.
2597   if test $USE_NLS = yes; then
2598     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2599     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2600   fi
2601   if test $USE_NLS = yes; then
2602     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2603               [Define if NLS translations are to be used.])
2604   fi
2606   AC_SUBST(USE_NLS)
2607   AC_SUBST(CLOCALE_H)
2608   AC_SUBST(CMESSAGES_H)
2609   AC_SUBST(CCODECVT_CC)
2610   AC_SUBST(CCOLLATE_CC)
2611   AC_SUBST(CCTYPE_CC)
2612   AC_SUBST(CMESSAGES_CC)
2613   AC_SUBST(CMONEY_CC)
2614   AC_SUBST(CNUMERIC_CC)
2615   AC_SUBST(CTIME_H)
2616   AC_SUBST(CTIME_CC)
2617   AC_SUBST(CLOCALE_CC)
2618   AC_SUBST(CLOCALE_INTERNAL_H)
2623 dnl Check for which std::allocator base class to use.  The choice is
2624 dnl mapped from a subdirectory of include/ext.
2626 dnl Default is new.
2628 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2629   AC_MSG_CHECKING([for std::allocator base class])
2630   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2631     [use KIND for target std::allocator base],
2632     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2634   # If they didn't use this option switch, or if they specified --enable
2635   # with no specific model, we'll have to look for one.  If they
2636   # specified --disable (???), do likewise.
2637   if test $enable_libstdcxx_allocator = no ||
2638      test $enable_libstdcxx_allocator = yes;
2639   then
2640      enable_libstdcxx_allocator=auto
2641   fi
2643   # Either a known package, or "auto". Auto implies the default choice
2644   # for a particular platform.
2645   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2647   # Probe for host-specific support if no specific model is specified.
2648   # Default to "new".
2649   if test $enable_libstdcxx_allocator_flag = auto; then
2650     case ${target_os} in
2651       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2652         enable_libstdcxx_allocator_flag=new
2653         ;;
2654       *)
2655         enable_libstdcxx_allocator_flag=new
2656         ;;
2657     esac
2658   fi
2659   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2662   # Set configure bits for specified locale package
2663   case ${enable_libstdcxx_allocator_flag} in
2664     bitmap)
2665       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2666       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2667       ;;
2668     malloc)
2669       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2670       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2671       ;;
2672     mt)
2673       ALLOCATOR_H=config/allocator/mt_allocator_base.h
2674       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2675       ;;
2676     new)
2677       ALLOCATOR_H=config/allocator/new_allocator_base.h
2678       ALLOCATOR_NAME=__gnu_cxx::new_allocator
2679       ;;
2680     pool)
2681       ALLOCATOR_H=config/allocator/pool_allocator_base.h
2682       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2683       ;;
2684   esac
2686   GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
2687                       test $enable_libstdcxx_allocator_flag = new)
2688   AC_SUBST(ALLOCATOR_H)
2689   AC_SUBST(ALLOCATOR_NAME)
2694 dnl Check for whether the Boost-derived checks should be turned on.
2696 dnl --enable-concept-checks turns them on.
2697 dnl --disable-concept-checks leaves them off.
2698 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2699 dnl       Where DEFAULT is either `yes' or `no'.
2701 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2702   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2703   if test $enable_concept_checks = yes; then
2704     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2705               [Define to use concept checking code from the boost libraries.])
2706   fi
2710 dnl Use extern templates.
2712 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2713 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2715 dnl  +  Usage:  GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2716 dnl       Where DEFAULT is `yes' or `no'.
2718 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2720   GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2722   AC_MSG_CHECKING([for extern template support])
2723   AC_MSG_RESULT([$enable_extern_template])
2725   GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2729 dnl Use vtable verification.
2731 dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1
2732 dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0
2734 dnl  +  Usage:  GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)]
2735 dnl       Where DEFAULT is `yes' or `no'.
2737 AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [
2739   GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify])
2741   AC_MSG_CHECKING([for vtable verify support])
2742   AC_MSG_RESULT([$enable_vtable_verify])
2744   vtv_cygmin=no
2745   if test $enable_vtable_verify = yes; then
2746     case ${target_os} in
2747       cygwin*|mingw32*)
2748         VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2749         VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2750         vtv_cygmin=yes
2751         ;;
2752       darwin*)
2753         VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u,_vtable_map_vars_start -Wl,-u,_vtable_map_vars_end"
2754         VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-rpath,${toplevel_builddir}/libvtv/.libs"
2755         ;;
2756       solaris2*)
2757         VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2758         VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-R -Wl,${toplevel_builddir}/libvtv/.libs"
2759         ;;
2760       *)
2761         VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2762         VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2763         ;;
2764     esac
2765     VTV_PCH_CXXFLAGS="-fvtable-verify=std"
2766   else
2767     VTV_CXXFLAGS= 
2768     VTV_PCH_CXXFLAGS=
2769     VTV_CXXLINKFLAGS= 
2770   fi
2772   AC_SUBST(VTV_CXXFLAGS)
2773   AC_SUBST(VTV_PCH_CXXFLAGS)
2774   AC_SUBST(VTV_CXXLINKFLAGS)
2775   AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes)
2776   GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes)
2780 dnl Check for parallel mode pre-requisites, including OpenMP support.
2782 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
2784 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2786   enable_parallel=no;
2788   # See if configured libgomp/omp.h exists. (libgomp may be in
2789   # noconfigdirs but not explicitly disabled.)
2790   if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2791     enable_parallel=yes;
2792   else
2793     AC_MSG_NOTICE([target-libgomp not built])
2794   fi
2796   AC_MSG_CHECKING([for parallel mode support])
2797   AC_MSG_RESULT([$enable_parallel])
2802 dnl Check for which I/O library to use:  stdio, or something specific.
2804 dnl Default is stdio.
2806 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2807   AC_MSG_CHECKING([for underlying I/O to use])
2808   GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2809     [use target-specific I/O package], [permit stdio])
2811   # Now that libio has been removed, you can have any color you want as long
2812   # as it's black.  This is one big no-op until other packages are added, but
2813   # showing the framework never hurts.
2814   case ${enable_cstdio} in
2815     stdio)
2816       CSTDIO_H=config/io/c_io_stdio.h
2817       BASIC_FILE_H=config/io/basic_file_stdio.h
2818       BASIC_FILE_CC=config/io/basic_file_stdio.cc
2819       AC_MSG_RESULT(stdio)
2820       ;;
2821   esac
2823   AC_SUBST(CSTDIO_H)
2824   AC_SUBST(BASIC_FILE_H)
2825   AC_SUBST(BASIC_FILE_CC)
2830 dnl Check for "unusual" flags to pass to the compiler while building.
2832 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2833 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2834 dnl --disable-cxx-flags passes nothing.
2835 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2836 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2837 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2838 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2839 dnl       If "default flags" is an empty string, the effect is the same
2840 dnl       as --disable or --enable=no.
2842 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2843   AC_MSG_CHECKING([for extra compiler flags for building])
2844   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2845     [pass compiler FLAGS when building library],
2846     [case "x$enable_cxx_flags" in
2847       xno | x)   enable_cxx_flags= ;;
2848       x-*)       ;;
2849       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2850      esac])
2852   # Run through flags (either default or command-line) and set anything
2853   # extra (e.g., #defines) that must accompany particular g++ options.
2854   if test -n "$enable_cxx_flags"; then
2855     for f in $enable_cxx_flags; do
2856       case "$f" in
2857         -fhonor-std)  ;;
2858         -*)  ;;
2859         *)   # and we're trying to pass /what/ exactly?
2860              AC_MSG_ERROR([compiler flags start with a -]) ;;
2861       esac
2862     done
2863   fi
2865   EXTRA_CXX_FLAGS="$enable_cxx_flags"
2866   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2867   AC_SUBST(EXTRA_CXX_FLAGS)
2872 dnl Check to see if debugging libraries are to be built.
2874 dnl --enable-libstdcxx-debug
2875 dnl builds a separate set of debugging libraries in addition to the
2876 dnl normal (shared, static) libstdc++ binaries.
2878 dnl --disable-libstdcxx-debug
2879 dnl builds only one (non-debug) version of libstdc++.
2881 dnl --enable-libstdcxx-debug-flags=FLAGS
2882 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2884 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2885 dnl       Where DEFAULT is either `yes' or `no'.
2887 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2888   AC_MSG_CHECKING([for additional debug build])
2889   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2890   AC_MSG_RESULT($enable_libstdcxx_debug)
2891   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2896 dnl Check for explicit debug flags.
2898 dnl --enable-libstdcxx-debug-flags='-O1'
2899 dnl is a general method for passing flags to be used when
2900 dnl building debug libraries with --enable-libstdcxx-debug.
2902 dnl --disable-libstdcxx-debug-flags does nothing.
2903 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2904 dnl       If "default flags" is an empty string, the effect is the same
2905 dnl       as --disable or --enable=no.
2907 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2908   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2909     [pass compiler FLAGS when building debug library],
2910     [case "x$enable_libstdcxx_debug_flags" in
2911       xno | x)    enable_libstdcxx_debug_flags= ;;
2912       x-*)        ;;
2913       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2914      esac])
2916   # Option parsed, now set things appropriately
2917   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2918   AC_SUBST(DEBUG_FLAGS)
2920   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2925 dnl Check if the user only wants a freestanding library implementation.
2927 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2928 dnl installing only the headers required by [17.4.1.3] and the language
2929 dnl support library.  More than that will be built (to keep the Makefiles
2930 dnl conveniently clean), but not installed.
2932 dnl Sets:
2933 dnl  is_hosted  (yes/no)
2935 dnl Defines:
2936 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2938 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2939   AC_ARG_ENABLE([hosted-libstdcxx],
2940     AC_HELP_STRING([--disable-hosted-libstdcxx],
2941                    [only build freestanding C++ runtime support]),,
2942     [case "$host" in
2943         arm*-*-symbianelf*)
2944             enable_hosted_libstdcxx=no
2945             ;;
2946         *)
2947             enable_hosted_libstdcxx=yes
2948             ;;
2949      esac])
2950   if test "$enable_hosted_libstdcxx" = no; then
2951     AC_MSG_NOTICE([Only freestanding libraries will be built])
2952     is_hosted=no
2953     hosted_define=0
2954     enable_abi_check=no
2955     enable_libstdcxx_pch=no
2956   else
2957     is_hosted=yes
2958     hosted_define=1
2959   fi
2960   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2961   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2962     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2967 dnl Check if the user wants a non-verbose library implementation.
2969 dnl --disable-libstdcxx-verbose will turn off descriptive messages to
2970 dnl standard error on termination.
2972 dnl Defines:
2973 dnl  _GLIBCXX_VERBOSE (always defined, either to 1 or 0)
2975 AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [
2976   AC_ARG_ENABLE([libstdcxx-verbose],
2977     AC_HELP_STRING([--disable-libstdcxx-verbose],
2978                    [disable termination messages to standard error]),,
2979                    [enable_libstdcxx_verbose=yes])
2980   if test x"$enable_libstdcxx_verbose" = xyes; then
2981     verbose_define=1
2982   else
2983     AC_MSG_NOTICE([verbose termination messages are disabled])
2984     verbose_define=0
2985   fi
2986   AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define,
2987     [Define to 1 if a verbose library is built, or 0 otherwise.])
2992 dnl Check for template specializations for the 'long long' type.
2993 dnl The result determines only whether 'long long' I/O is enabled; things
2994 dnl like numeric_limits<> specializations are always available.
2996 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2997 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2998 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2999 dnl       Where DEFAULT is either `yes' or `no'.
3001 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
3002   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
3003   if test $enable_long_long = yes; then
3004     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
3005               [Define if code specialized for long long should be used.])
3006   fi
3007   AC_MSG_CHECKING([for enabled long long specializations])
3008   AC_MSG_RESULT([$enable_long_long])
3013 dnl Check for decimal floating point.
3014 dnl See:
3015 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
3017 dnl This checks to see if the host supports decimal floating point types.
3019 dnl Defines:
3020 dnl  _GLIBCXX_USE_DECIMAL_FLOAT
3022 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
3024   # Fake what AC_TRY_COMPILE does, without linking as this is
3025   # unnecessary for this test.
3027     cat > conftest.$ac_ext << EOF
3028 [#]line __oline__ "configure"
3029 int main()
3031   _Decimal32 d1;
3032   _Decimal64 d2;
3033   _Decimal128 d3;
3034   return 0;
3038     AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
3039     if AC_TRY_EVAL(ac_compile); then
3040       AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
3041       [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
3042       enable_dfp=yes
3043     else
3044       enable_dfp=no
3045     fi
3046     AC_MSG_RESULT($enable_dfp)
3047     rm -f conftest*
3051 dnl Check for GNU 128-bit integer and floating point types.
3053 dnl Note: also checks that the types aren't standard types.
3055 dnl Defines:
3056 dnl  _GLIBCXX_USE_INT128
3057 dnl  ENABLE_FLOAT128
3059 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
3061   AC_LANG_SAVE
3062   AC_LANG_CPLUSPLUS
3064   # Fake what AC_TRY_COMPILE does, without linking as this is
3065   # unnecessary for this test.
3067     cat > conftest.$ac_ext << EOF
3068 [#]line __oline__ "configure"
3069 template<typename T1, typename T2>
3070   struct same
3071   { typedef T2 type; };
3073 template<typename T>
3074   struct same<T, T>;
3076 int main()
3078   typename same<long, __int128>::type                i1;
3079   typename same<long long, __int128>::type           i2;
3083     AC_MSG_CHECKING([for __int128])
3084     if AC_TRY_EVAL(ac_compile); then
3085       AC_DEFINE(_GLIBCXX_USE_INT128, 1,
3086       [Define if __int128 is supported on this host.])
3087       enable_int128=yes
3088     else
3089       enable_int128=no
3090     fi
3091     AC_MSG_RESULT($enable_int128)
3092     rm -f conftest*
3094     cat > conftest.$ac_ext << EOF
3095 [#]line __oline__ "configure"
3096 template<typename T1, typename T2>
3097   struct same
3098   { typedef T2 type; };
3100 template<typename T>
3101   struct same<T, T>;
3103 int main()
3105   typename same<double, __float128>::type      f1;
3106   typename same<long double, __float128>::type f2;
3110     AC_MSG_CHECKING([for __float128])
3111     if AC_TRY_EVAL(ac_compile); then
3112       enable_float128=yes
3113     else
3114       enable_float128=no
3115     fi
3116     AC_MSG_RESULT($enable_float128)
3117     GLIBCXX_CONDITIONAL(ENABLE_FLOAT128, test $enable_float128 = yes)
3118     rm -f conftest*
3120   AC_LANG_RESTORE
3124 dnl Check for template specializations for the 'wchar_t' type.
3126 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
3127 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
3128 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
3129 dnl       Where DEFAULT is either `yes' or `no'.
3131 dnl Necessary support must also be present.
3133 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
3134   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
3136   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
3137   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
3138   AC_MSG_CHECKING([for mbstate_t])
3139   AC_TRY_COMPILE([#include <wchar.h>],
3140   [mbstate_t teststate;],
3141   have_mbstate_t=yes, have_mbstate_t=no)
3142   AC_MSG_RESULT($have_mbstate_t)
3143   if test x"$have_mbstate_t" = xyes; then
3144     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
3145   fi
3147   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
3148   # ac_has_wchar_h.
3149   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
3151   if test x"$enable_wchar_t" = x"yes"; then
3153     AC_LANG_SAVE
3154     AC_LANG_CPLUSPLUS
3156     if test x"$ac_has_wchar_h" = xyes &&
3157        test x"$ac_has_wctype_h" = xyes; then
3158       AC_TRY_COMPILE([#include <wchar.h>
3159                       #include <stddef.h>
3160                       wint_t i;
3161                       long l = WEOF;
3162                       long j = WCHAR_MIN;
3163                       long k = WCHAR_MAX;
3164                       namespace test
3165                       {
3166                         using ::btowc;
3167                         using ::fgetwc;
3168                         using ::fgetws;
3169                         using ::fputwc;
3170                         using ::fputws;
3171                         using ::fwide;
3172                         using ::fwprintf;
3173                         using ::fwscanf;
3174                         using ::getwc;
3175                         using ::getwchar;
3176                         using ::mbrlen;
3177                         using ::mbrtowc;
3178                         using ::mbsinit;
3179                         using ::mbsrtowcs;
3180                         using ::putwc;
3181                         using ::putwchar;
3182                         using ::swprintf;
3183                         using ::swscanf;
3184                         using ::ungetwc;
3185                         using ::vfwprintf;
3186                         using ::vswprintf;
3187                         using ::vwprintf;
3188                         using ::wcrtomb;
3189                         using ::wcscat;
3190                         using ::wcschr;
3191                         using ::wcscmp;
3192                         using ::wcscoll;
3193                         using ::wcscpy;
3194                         using ::wcscspn;
3195                         using ::wcsftime;
3196                         using ::wcslen;
3197                         using ::wcsncat;
3198                         using ::wcsncmp;
3199                         using ::wcsncpy;
3200                         using ::wcspbrk;
3201                         using ::wcsrchr;
3202                         using ::wcsrtombs;
3203                         using ::wcsspn;
3204                         using ::wcsstr;
3205                         using ::wcstod;
3206                         using ::wcstok;
3207                         using ::wcstol;
3208                         using ::wcstoul;
3209                         using ::wcsxfrm;
3210                         using ::wctob;
3211                         using ::wmemchr;
3212                         using ::wmemcmp;
3213                         using ::wmemcpy;
3214                         using ::wmemmove;
3215                         using ::wmemset;
3216                         using ::wprintf;
3217                         using ::wscanf;
3218                       }
3219                      ],[],[], [enable_wchar_t=no])
3220     else
3221       enable_wchar_t=no
3222     fi
3224     AC_LANG_RESTORE
3225   fi
3227   if test x"$enable_wchar_t" = x"yes"; then
3228     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
3229               [Define if code specialized for wchar_t should be used.])
3230   fi
3232   AC_MSG_CHECKING([for enabled wchar_t specializations])
3233   AC_MSG_RESULT([$enable_wchar_t])
3238 dnl Check to see if building and using a C++ precompiled header can be done.
3240 dnl --enable-libstdcxx-pch=yes
3241 dnl default, this shows intent to use stdc++.h.gch If it looks like it
3242 dnl may work, after some light-hearted attempts to puzzle out compiler
3243 dnl support, flip bits on in include/Makefile.am
3245 dnl --disable-libstdcxx-pch
3246 dnl turns off attempts to use or build stdc++.h.gch.
3248 dnl Substs:
3249 dnl  glibcxx_PCHFLAGS
3251 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
3252   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
3253   if test $enable_libstdcxx_pch = yes; then
3254     AC_CACHE_CHECK([for compiler with PCH support],
3255       [glibcxx_cv_prog_CXX_pch],
3256       [ac_save_CXXFLAGS="$CXXFLAGS"
3257        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
3258        AC_LANG_SAVE
3259        AC_LANG_CPLUSPLUS
3260        echo '#include <math.h>' > conftest.h
3261        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
3262                           -o conftest.h.gch 1>&5 2>&1 &&
3263                 echo '#error "pch failed"' > conftest.h &&
3264           echo '#include "conftest.h"' > conftest.cc &&
3265                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
3266        then
3267          glibcxx_cv_prog_CXX_pch=yes
3268        else
3269          glibcxx_cv_prog_CXX_pch=no
3270        fi
3271        rm -f conftest*
3272        CXXFLAGS=$ac_save_CXXFLAGS
3273        AC_LANG_RESTORE
3274       ])
3275     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
3276   fi
3278   AC_MSG_CHECKING([for enabled PCH])
3279   AC_MSG_RESULT([$enable_libstdcxx_pch])
3281   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
3282   if test $enable_libstdcxx_pch = yes; then
3283     glibcxx_PCHFLAGS="-include bits/stdc++.h"
3284   else
3285     glibcxx_PCHFLAGS=""
3286   fi
3287   AC_SUBST(glibcxx_PCHFLAGS)
3292 dnl Check for atomic builtins.
3293 dnl See:
3294 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
3296 dnl This checks to see if the host supports the compiler-generated
3297 dnl builtins for atomic operations for various integral sizes. Note, this
3298 dnl is intended to be an all-or-nothing switch, so all the atomic operations
3299 dnl that are used should be checked.
3301 dnl Note:
3302 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
3304 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
3305   AC_LANG_SAVE
3306   AC_LANG_CPLUSPLUS
3307   old_CXXFLAGS="$CXXFLAGS"
3309   # Do link tests if possible, instead asm tests, limited to some platforms
3310   # see discussion in PR target/40134, PR libstdc++/40133 and the thread
3311   # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
3312   atomic_builtins_link_tests=no
3313   if test x$gcc_no_link != xyes; then
3314     # Can do link tests. Limit to some tested platforms
3315     case "$host" in
3316       *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
3317         atomic_builtins_link_tests=yes
3318         ;;
3319     esac
3320   fi
3322   if test x$atomic_builtins_link_tests = xyes; then
3324   # Do link tests.
3326   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3328   AC_MSG_CHECKING([for atomic builtins for bool])
3329   AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
3330     AC_TRY_LINK(
3331       [ ],
3332       [typedef bool atomic_type;
3333        atomic_type c1;
3334        atomic_type c2;
3335        atomic_type c3(0);
3336        // N.B. __atomic_fetch_add is not supported for bool.
3337        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3338                                    __ATOMIC_RELAXED);
3339        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3340        __atomic_load_n(&c1, __ATOMIC_RELAXED);
3341       ],
3342       [glibcxx_cv_atomic_bool=yes],
3343       [glibcxx_cv_atomic_bool=no])
3344   ])
3345   AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3347   AC_MSG_CHECKING([for atomic builtins for short])
3348   AC_CACHE_VAL(glibcxx_cv_atomic_short, [
3349     AC_TRY_LINK(
3350       [ ],
3351       [typedef short atomic_type;
3352        atomic_type c1;
3353        atomic_type c2;
3354        atomic_type c3(0);
3355        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3356        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3357                                    __ATOMIC_RELAXED);
3358        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3359        __atomic_load_n(&c1, __ATOMIC_RELAXED);
3360       ],
3361       [glibcxx_cv_atomic_short=yes],
3362       [glibcxx_cv_atomic_short=no])
3363   ])
3364   AC_MSG_RESULT($glibcxx_cv_atomic_short)
3366   AC_MSG_CHECKING([for atomic builtins for int])
3367   AC_CACHE_VAL(glibcxx_cv_atomic_int, [
3368     AC_TRY_LINK(
3369       [ ],
3370       [typedef int atomic_type;
3371        atomic_type c1;
3372        atomic_type c2;
3373        atomic_type c3(0);
3374        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3375        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3376                                    __ATOMIC_RELAXED);
3377        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3378        __atomic_load_n(&c1, __ATOMIC_RELAXED);
3379       ],
3380       [glibcxx_cv_atomic_int=yes],
3381       [glibcxx_cv_atomic_int=no])
3382   ])
3383   AC_MSG_RESULT($glibcxx_cv_atomic_int)
3385   AC_MSG_CHECKING([for atomic builtins for long long])
3386   AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
3387     AC_TRY_LINK(
3388       [ ],
3389       [typedef long long atomic_type;
3390        atomic_type c1;
3391        atomic_type c2;
3392        atomic_type c3(0);
3393        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3394        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3395                                    __ATOMIC_RELAXED);
3396        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3397        __atomic_load_n(&c1, __ATOMIC_RELAXED);
3398       ],
3399       [glibcxx_cv_atomic_long_long=yes],
3400       [glibcxx_cv_atomic_long_long=no])
3401   ])
3402   AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3404   else
3406   # Do asm tests.
3408   # Compile unoptimized.
3409   CXXFLAGS='-O0 -S'
3411   # Fake what AC_TRY_COMPILE does.
3413     cat > conftest.$ac_ext << EOF
3414 [#]line __oline__ "configure"
3415 int main()
3417   typedef bool atomic_type;
3418   atomic_type c1;
3419   atomic_type c2;
3420   atomic_type c3(0);
3421   // N.B. __atomic_fetch_add is not supported for bool.
3422   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3423                               __ATOMIC_RELAXED);
3424   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3425   __atomic_load_n(&c1, __ATOMIC_RELAXED);
3427   return 0;
3431     AC_MSG_CHECKING([for atomic builtins for bool])
3432     if AC_TRY_EVAL(ac_compile); then
3433       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3434         glibcxx_cv_atomic_bool=no
3435       else
3436         glibcxx_cv_atomic_bool=yes
3437       fi
3438     fi
3439     AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3440     rm -f conftest*
3442     cat > conftest.$ac_ext << EOF
3443 [#]line __oline__ "configure"
3444 int main()
3446   typedef short atomic_type;
3447   atomic_type c1;
3448   atomic_type c2;
3449   atomic_type c3(0);
3450   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3451   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3452                               __ATOMIC_RELAXED);
3453   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3454   __atomic_load_n(&c1, __ATOMIC_RELAXED);
3456   return 0;
3460     AC_MSG_CHECKING([for atomic builtins for short])
3461     if AC_TRY_EVAL(ac_compile); then
3462       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3463         glibcxx_cv_atomic_short=no
3464       else
3465         glibcxx_cv_atomic_short=yes
3466       fi
3467     fi
3468     AC_MSG_RESULT($glibcxx_cv_atomic_short)
3469     rm -f conftest*
3471     cat > conftest.$ac_ext << EOF
3472 [#]line __oline__ "configure"
3473 int main()
3475   // NB: _Atomic_word not necessarily int.
3476   typedef int atomic_type;
3477   atomic_type c1;
3478   atomic_type c2;
3479   atomic_type c3(0);
3480   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3481   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3482                               __ATOMIC_RELAXED);
3483   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3484   __atomic_load_n(&c1, __ATOMIC_RELAXED);
3486   return 0;
3490     AC_MSG_CHECKING([for atomic builtins for int])
3491     if AC_TRY_EVAL(ac_compile); then
3492       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3493         glibcxx_cv_atomic_int=no
3494       else
3495         glibcxx_cv_atomic_int=yes
3496       fi
3497     fi
3498     AC_MSG_RESULT($glibcxx_cv_atomic_int)
3499     rm -f conftest*
3501     cat > conftest.$ac_ext << EOF
3502 [#]line __oline__ "configure"
3503 int main()
3505   typedef long long atomic_type;
3506   atomic_type c1;
3507   atomic_type c2;
3508   atomic_type c3(0);
3509   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3510   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3511                               __ATOMIC_RELAXED);
3512   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3513   __atomic_load_n(&c1, __ATOMIC_RELAXED);
3515   return 0;
3519     AC_MSG_CHECKING([for atomic builtins for long long])
3520     if AC_TRY_EVAL(ac_compile); then
3521       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3522         glibcxx_cv_atomic_long_long=no
3523       else
3524         glibcxx_cv_atomic_long_long=yes
3525       fi
3526     fi
3527     AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3528     rm -f conftest*
3530   fi
3532   CXXFLAGS="$old_CXXFLAGS"
3533   AC_LANG_RESTORE
3535   # Set atomicity_dir to builtins if all but the long long test above passes,
3536   # or if the builtins were already chosen (e.g. by configure.host).
3537   if { test "$glibcxx_cv_atomic_bool" = yes \
3538      && test "$glibcxx_cv_atomic_short" = yes \
3539      && test "$glibcxx_cv_atomic_int" = yes; } \
3540      || test "$atomicity_dir" = "cpu/generic/atomicity_builtins"; then
3541     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
3542     [Define if the compiler supports C++11 atomics.])
3543     atomicity_dir=cpu/generic/atomicity_builtins
3544   fi
3546   # If still generic, set to mutex.
3547   if test $atomicity_dir = "cpu/generic" ; then
3548     atomicity_dir=cpu/generic/atomicity_mutex
3549     AC_MSG_WARN([No native atomic operations are provided for this platform.])
3550       if test "x$target_thread_file" = xsingle; then
3551         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
3552         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
3553       else
3554         AC_MSG_WARN([They will be faked using a mutex.])
3555         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
3556       fi
3557   fi
3563 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3565 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3566 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3567 dnl  +  Usage:  GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3568 dnl       Where DEFAULT is 'yes'.
3570 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3571 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3573 if test x$enable_libstdcxx_visibility = xyes ; then
3574   dnl all hail libgfortran
3575   dnl Check whether the target supports hidden visibility.
3576   AC_CACHE_CHECK([whether the target supports hidden visibility],
3577                  glibcxx_cv_have_attribute_visibility, [
3578   save_CFLAGS="$CFLAGS"
3579   CFLAGS="$CFLAGS -Werror"
3580   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3581                  [], glibcxx_cv_have_attribute_visibility=yes,
3582                  glibcxx_cv_have_attribute_visibility=no)
3583   CFLAGS="$save_CFLAGS"])
3584   if test $glibcxx_cv_have_attribute_visibility = no; then
3585     enable_libstdcxx_visibility=no
3586   fi
3589 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3590 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3595 dnl Add version tags to symbols in shared library (or not), additionally
3596 dnl marking other symbols as private/local (or not).
3598 dnl Sets libtool_VERSION, and determines shared library SONAME.
3600 dnl  This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3602 dnl --enable-symvers=style adds a version script to the linker call when
3603 dnl       creating the shared library.  The choice of version script is
3604 dnl       controlled by 'style'.
3605 dnl --disable-symvers does not.
3607 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3608 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
3609 dnl       choose a default style based on linker characteristics.  Passing
3610 dnl       'no' disables versioning.
3612 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3614 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3615   [enables symbol versioning of the shared library],
3616   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3618 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3619 # don't know enough about $LD to do tricks...
3620 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3621 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3622 # with extern "C++" in version scripts.
3623 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3625 # Turn a 'yes' into a suitable default.
3626 if test x$enable_symvers = xyes ; then
3627   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3628     enable_symvers=no
3629   else
3630     if test $with_gnu_ld = yes ; then
3631       case ${target_os} in
3632         hpux*)
3633           enable_symvers=no ;;
3634         *)
3635           enable_symvers=gnu ;;
3636       esac
3637     else
3638       case ${target_os} in
3639         darwin*)
3640           enable_symvers=darwin ;;
3641         # Sun symbol versioning exists since Solaris 2.5.
3642         solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3643           # make_sunver.pl needs GNU c++filt to support extern "C++" in
3644           # version scripts, so disable symbol versioning if none can be
3645           # found.
3646           if test -z "$ac_cv_path_CXXFILT"; then
3647             AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3648             AC_MSG_WARN([=== no GNU c++filt could  be found.])
3649             AC_MSG_WARN([=== Symbol versioning will be disabled.])
3650             enable_symvers=no
3651           else
3652             enable_symvers=sun
3653           fi
3654           ;;
3655         *)
3656           enable_symvers=no ;;
3657       esac
3658     fi
3659   fi
3662 # Check to see if 'darwin' or 'darwin-export' can win.
3663 if test x$enable_symvers = xdarwin-export ; then
3664     enable_symvers=darwin
3667 # Check if 'sun' was requested on non-Solaris 2 platforms.
3668 if test x$enable_symvers = xsun ; then
3669   case ${target_os} in
3670     solaris2*)
3671       # All fine.
3672       ;;
3673     *)
3674       # Unlikely to work.
3675       AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3676       AC_MSG_WARN([=== you are not targetting Solaris 2.])
3677       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3678       enable_symvers=no
3679       ;;
3680   esac
3683 # Check to see if 'gnu' can win.
3684 if test $enable_symvers = gnu ||
3685   test $enable_symvers = gnu-versioned-namespace ||
3686   test $enable_symvers = sun; then
3687   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3688   AC_MSG_CHECKING([for shared libgcc])
3689   ac_save_CFLAGS="$CFLAGS"
3690   CFLAGS=' -lgcc_s'
3691   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3692   CFLAGS="$ac_save_CFLAGS"
3693   if test $glibcxx_shared_libgcc = no; then
3694     cat > conftest.c <<EOF
3695 int main (void) { return 0; }
3697 changequote(,)dnl
3698     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3699                              -shared -shared-libgcc -o conftest.so \
3700                              conftest.c -v 2>&1 >/dev/null \
3701                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3702 changequote([,])dnl
3703     rm -f conftest.c conftest.so
3704     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3705       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3706       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3707       CFLAGS="$ac_save_CFLAGS"
3708     fi
3709   fi
3710   AC_MSG_RESULT($glibcxx_shared_libgcc)
3712   # For GNU ld, we need at least this version.  The format is described in
3713   # GLIBCXX_CHECK_LINKER_FEATURES above.
3714   glibcxx_min_gnu_ld_version=21400
3716   # If no shared libgcc, can't win.
3717   if test $glibcxx_shared_libgcc != yes; then
3718       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3719       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3720       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3721       enable_symvers=no
3722   elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3723     : All interesting versions of Sun ld support sun style symbol versioning.
3724   elif test $with_gnu_ld != yes ; then
3725     # just fail for now
3726     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3727     AC_MSG_WARN([=== you are not using the GNU linker.])
3728     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3729     enable_symvers=no
3730   elif test $glibcxx_ld_is_gold = yes ; then
3731     : All versions of gold support symbol versioning.
3732   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3733     # The right tools, the right setup, but too old.  Fallbacks?
3734     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3735     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3736     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3737     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3738     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3739     enable_symvers=no
3740   fi
3743 # For libtool versioning info, format is CURRENT:REVISION:AGE
3744 libtool_VERSION=6:26:0
3746 # Everything parsed; figure out what files and settings to use.
3747 case $enable_symvers in
3748   no)
3749     SYMVER_FILE=config/abi/pre/none.ver
3750     ;;
3751   gnu)
3752     SYMVER_FILE=config/abi/pre/gnu.ver
3753     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3754               [Define to use GNU versioning in the shared library.])
3755     ;;
3756   gnu-versioned-namespace)
3757     libtool_VERSION=8:0:0
3758     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3759     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3760               [Define to use GNU namespace versioning in the shared library.])
3761     ;;
3762   darwin)
3763     SYMVER_FILE=config/abi/pre/gnu.ver
3764     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3765               [Define to use darwin versioning in the shared library.])
3766     ;;
3767   sun)
3768     SYMVER_FILE=config/abi/pre/gnu.ver
3769     AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3770               [Define to use Sun versioning in the shared library.])
3771     ;;
3772 esac
3774 if test x$enable_symvers != xno ; then
3775   AC_DEFINE(_GLIBCXX_SYMVER, 1,
3776          [Define to use symbol versioning in the shared library.])
3779 AC_CACHE_CHECK([whether the target supports .symver directive],
3780                glibcxx_cv_have_as_symver_directive, [
3781   AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3782                  [], glibcxx_cv_have_as_symver_directive=yes,
3783                  glibcxx_cv_have_as_symver_directive=no)])
3784 if test $glibcxx_cv_have_as_symver_directive = yes; then
3785   AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3786     [Define to 1 if the target assembler supports .symver directive.])
3789 AC_SUBST(SYMVER_FILE)
3790 AC_SUBST(port_specific_symbol_files)
3791 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3792 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3793 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3794 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3795 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3796 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3798 if test $enable_symvers != no ; then
3799    case ${target_os} in
3800      # The Solaris 2 runtime linker doesn't support the GNU extension of
3801      # binding the same symbol to different versions
3802      solaris2*)
3803        ;;
3804      # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3805      *)
3806        AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3807          [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3808        ;;
3809     esac
3812 # Now, set up compatibility support, if any.
3813 # In addition, need this to deal with std::size_t mangling in
3814 # src/compatibility.cc.  In a perfect world, could use
3815 # typeid(std::size_t).name()[0] to do direct substitution.
3816 AC_MSG_CHECKING([for size_t as unsigned int])
3817 ac_save_CFLAGS="$CFLAGS"
3818 CFLAGS="-Werror"
3819 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3820                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3821 CFLAGS=$ac_save_CFLAGS
3822 if test "$glibcxx_size_t_is_i" = yes; then
3823   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3825 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3827 AC_MSG_CHECKING([for ptrdiff_t as int])
3828 ac_save_CFLAGS="$CFLAGS"
3829 CFLAGS="-Werror"
3830 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3831                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3832 CFLAGS=$ac_save_CFLAGS
3833 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3834   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3836 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3841 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3842 dnl We must stage the required headers so that they will be installed
3843 dnl with the library (unlike libgcc, the STL implementation is provided
3844 dnl solely within headers).  Since we must not inject random user-space
3845 dnl macro names into user-provided C++ code, we first stage into <file>-in
3846 dnl and process to <file> with an output command.  The reason for a two-
3847 dnl stage process here is to correctly handle $srcdir!=$objdir without
3848 dnl having to write complex code (the sed commands to clean the macro
3849 dnl namespace are complex and fragile enough as it is).  We must also
3850 dnl add a relative path so that -I- is supported properly.
3852 dnl Substs:
3853 dnl  thread_header
3855 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3856   AC_MSG_CHECKING([for thread model used by GCC])
3857   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3858   AC_MSG_RESULT([$target_thread_file])
3859   GCC_AC_THREAD_HEADER([$target_thread_file])
3864 dnl Check if gthread implementation defines the types and functions
3865 dnl required by the c++0x thread library.  Conforming gthread
3866 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3868 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3870 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3871   GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3873   if test x$enable_libstdcxx_threads = xauto || 
3874      test x$enable_libstdcxx_threads = xyes; then
3876   AC_LANG_SAVE
3877   AC_LANG_CPLUSPLUS
3879   ac_save_CXXFLAGS="$CXXFLAGS"
3880   CXXFLAGS="$CXXFLAGS -fno-exceptions \
3881         -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3883   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3884   case $target_thread_file in
3885     posix)
3886       CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3887   esac
3889   AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3891   AC_TRY_COMPILE([#include <unistd.h>],
3892     [
3893       // In case of POSIX threads check _POSIX_TIMEOUTS.
3894       #if (defined(_PTHREADS) \
3895           && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3896       #error
3897       #endif
3898     ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3900   AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3901                      [Define to 1 if mutex_timedlock is available.])
3903   if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3904   else res_mutex_timedlock=no ; fi
3905   AC_MSG_RESULT([$res_mutex_timedlock])
3907   AC_MSG_CHECKING([for gthreads library])
3909   AC_TRY_COMPILE([#include "gthr.h"],
3910     [
3911       #ifndef __GTHREADS_CXX0X
3912       #error
3913       #endif
3914     ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
3915   else
3916     ac_has_gthreads=no
3917   fi
3919   AC_MSG_RESULT([$ac_has_gthreads])
3921   if test x"$ac_has_gthreads" = x"yes"; then
3922     AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3923               [Define if gthreads library is available.])
3925     # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14
3926     AC_CHECK_TYPE([pthread_rwlock_t],
3927             [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1,
3928             [Define if POSIX read/write locks are available in <gthr.h>.])],
3929             [],
3930             [#include "gthr.h"])
3931   fi
3933   CXXFLAGS="$ac_save_CXXFLAGS"
3934   AC_LANG_RESTORE
3938 # Check whether LC_MESSAGES is available in <locale.h>.
3939 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3941 # This file file be copied and used freely without restrictions.  It can
3942 # be used in projects which are not available under the GNU Public License
3943 # but which still want to provide support for the GNU gettext functionality.
3944 # Please note that the actual code is *not* freely available.
3945 AC_DEFUN([AC_LC_MESSAGES], [
3946   AC_CHECK_HEADER(locale.h, [
3947     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3948       [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3949        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3950     if test $ac_cv_val_LC_MESSAGES = yes; then
3951       AC_DEFINE(HAVE_LC_MESSAGES, 1,
3952                 [Define if LC_MESSAGES is available in <locale.h>.])
3953     fi
3954   ])
3958 dnl Check whether rdrand is supported in the assembler.
3959 AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [
3960   AC_MSG_CHECKING([for rdrand support in assembler])
3961   AC_CACHE_VAL(ac_cv_x86_rdrand, [
3962   ac_cv_x86_rdrand=no
3963   case "$target" in
3964     i?86-*-* | \
3965     x86_64-*-*)
3966     AC_TRY_COMPILE(, [asm("rdrand %eax");],
3967                 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no])
3968   esac
3969   ])
3970   if test $ac_cv_x86_rdrand = yes; then
3971     AC_DEFINE(_GLIBCXX_X86_RDRAND, 1,
3972                 [ Defined if as can handle rdrand. ])
3973   fi
3974   AC_MSG_RESULT($ac_cv_x86_rdrand)
3978 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
3980 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
3982   AC_LANG_SAVE
3983   AC_LANG_CPLUSPLUS
3984   ac_save_CXXFLAGS="$CXXFLAGS"
3985   CXXFLAGS="$CXXFLAGS -fno-exceptions"
3987   AC_MSG_CHECKING([for get_nprocs])
3988   AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
3989     GCC_TRY_COMPILE_OR_LINK(
3990       [#include <sys/sysinfo.h>],
3991       [int n = get_nprocs();],
3992       [glibcxx_cv_GET_NPROCS=yes],
3993       [glibcxx_cv_GET_NPROCS=no])
3994   ])
3995   if test $glibcxx_cv_GET_NPROCS = yes; then
3996     AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
3997   fi
3998   AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
4000   CXXFLAGS="$ac_save_CXXFLAGS"
4001   AC_LANG_RESTORE
4005 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
4007 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
4009   AC_LANG_SAVE
4010   AC_LANG_CPLUSPLUS
4011   ac_save_CXXFLAGS="$CXXFLAGS"
4012   CXXFLAGS="$CXXFLAGS -fno-exceptions"
4014   AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
4015   AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
4016     GCC_TRY_COMPILE_OR_LINK(
4017       [#include <unistd.h>],
4018       [int n = sysconf(_SC_NPROCESSORS_ONLN);],
4019       [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
4020       [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
4021   ])
4022   if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
4023     AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN  is available in <unistd.h>.])
4024   fi
4025   AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
4027   CXXFLAGS="$ac_save_CXXFLAGS"
4028   AC_LANG_RESTORE
4032 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
4034 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
4036   AC_LANG_SAVE
4037   AC_LANG_CPLUSPLUS
4038   ac_save_CXXFLAGS="$CXXFLAGS"
4039   CXXFLAGS="$CXXFLAGS -fno-exceptions"
4041   AC_MSG_CHECKING([for _SC_NPROC_ONLN])
4042   AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [
4043     GCC_TRY_COMPILE_OR_LINK(
4044       [#include <unistd.h>],
4045       [int n = sysconf(_SC_NPROC_ONLN);],
4046       [glibcxx_cv_SC_NPROC_ONLN=yes],
4047       [glibcxx_cv_SC_NPROC_ONLN=no])
4048   ])
4049   if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
4050     AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN  is available in <unistd.h>.])
4051   fi
4052   AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN)
4054   CXXFLAGS="$ac_save_CXXFLAGS"
4055   AC_LANG_RESTORE
4059 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
4061 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
4063   AC_LANG_SAVE
4064   AC_LANG_CPLUSPLUS
4065   ac_save_CXXFLAGS="$CXXFLAGS"
4066   CXXFLAGS="$CXXFLAGS -fno-exceptions"
4068   AC_MSG_CHECKING([for pthreads_num_processors_np])
4069   AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
4070     GCC_TRY_COMPILE_OR_LINK(
4071       [#include <pthread.h>],
4072       [int n = pthread_num_processors_np();],
4073       [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
4074       [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
4075   ])
4076   if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
4077     AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
4078   fi
4079   AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP)
4081   CXXFLAGS="$ac_save_CXXFLAGS"
4082   AC_LANG_RESTORE
4086 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
4088 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
4090   AC_LANG_SAVE
4091   AC_LANG_CPLUSPLUS
4092   ac_save_CXXFLAGS="$CXXFLAGS"
4093   CXXFLAGS="$CXXFLAGS -fno-exceptions"
4095   AC_MSG_CHECKING([for hw.ncpu sysctl])
4096   AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [
4097     GCC_TRY_COMPILE_OR_LINK(
4098       [
4099        #include <stddef.h>
4100        #include <sys/sysctl.h>
4101        ],
4102       [
4103        int count;
4104        size_t size = sizeof(count);
4105        int mib[] = { CTL_HW, HW_NCPU };
4106        sysctl(mib, 2, &count, &size, NULL, 0);
4107       ],
4108       [glibcxx_cv_SYSCTL_HW_NCPU=yes],
4109       [glibcxx_cv_SYSCTL_HW_NCPU=no])
4110   ])
4111   if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
4112     AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
4113   fi
4114   AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU)
4116   CXXFLAGS="$ac_save_CXXFLAGS"
4117   AC_LANG_RESTORE
4121 dnl Check to see if python pretty printing can be activated.
4123 dnl --with-python-dir=dir
4124 dnl installs directory into $prefix/dir
4125 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
4127 AC_MSG_CHECKING([for custom python install directory])
4128 AC_ARG_WITH([python-dir],
4129             AS_HELP_STRING([--with-python-dir],
4130                            [the location to install Python modules. This path is relative starting from the prefix.]),
4131             [with_python_dir=$withval], [with_python_dir="no"])
4132 AC_MSG_RESULT(${with_python_dir})
4134 # Needed for installing Python modules during make install.
4135 python_mod_dir="${with_python_dir}"
4136 AC_SUBST(python_mod_dir)
4137 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
4141 dnl Check to see if -Werror is disabled.
4143 dnl --enable-werror/--disable-werror
4144 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
4145   AC_MSG_CHECKING([for -Werror])
4146   GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
4147   AC_MSG_RESULT($enable_werror)
4148   GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
4152 dnl Check whether obsolescent tmpnam is available in <stdio.h>,
4153 dnl and define _GLIBCXX_USE_TMPNAM.
4155 AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl
4157   AC_LANG_SAVE
4158   AC_LANG_CPLUSPLUS
4159   ac_save_CXXFLAGS="$CXXFLAGS"
4160   CXXFLAGS="$CXXFLAGS -fno-exceptions"
4162   AC_MSG_CHECKING([for tmpnam])
4163   AC_CACHE_VAL(glibcxx_cv_TMPNAM, [dnl
4164     GCC_TRY_COMPILE_OR_LINK(
4165       [#include <stdio.h>],
4166       [char *tmp = tmpnam(NULL);],
4167       [glibcxx_cv_TMPNAM=yes],
4168       [glibcxx_cv_TMPNAM=no])
4169   ])
4170   if test $glibcxx_cv_TMPNAM = yes; then
4171     AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.])
4172   fi
4173   AC_MSG_RESULT($glibcxx_cv_TMPNAM)
4175   CXXFLAGS="$ac_save_CXXFLAGS"
4176   AC_LANG_RESTORE
4180 dnl Check to see if sys/sdt.h exists and that it is suitable for use.
4181 dnl Some versions of sdt.h were not compatible with C++11.
4183 AC_DEFUN([GLIBCXX_CHECK_SDT_H], [
4184   AC_MSG_CHECKING([for suitable sys/sdt.h])
4185   # Note that this test has to be run with the C language.
4186   # Otherwise, sdt.h will try to include some headers from
4187   # libstdc++ itself.
4188   AC_LANG_SAVE
4189   AC_LANG_C
4190   AC_CACHE_VAL(glibcxx_cv_sys_sdt_h, [
4191     # Because we have to run the test in C, we use grep rather
4192     # than the compiler to check for the bug.  The bug is that
4193     # were strings without trailing whitespace, causing g++
4194     # to look for operator"".  The pattern searches for the fixed
4195     # output.
4196     AC_EGREP_CPP([ \",\" ], [
4197       #include <sys/sdt.h>
4198       int f() { STAP_PROBE(hi, bob); }
4199     ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no])
4200   ])
4201   AC_LANG_RESTORE
4202   if test $glibcxx_cv_sys_sdt_h = yes; then
4203     AC_DEFINE(HAVE_SYS_SDT_H, 1,
4204               [Define to 1 if you have a suitable <sys/sdt.h> header file])
4205   fi
4206   AC_MSG_RESULT($glibcxx_cv_sys_sdt_h)
4210 dnl Control whether the library should define symbols for old and new ABIs.
4211 dnl This affects definitions of strings, stringstreams and locale facets.
4213 dnl --disable-libstdcxx-dual-abi will use old ABI for all types.
4215 dnl Defines:
4216 dnl  _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0)
4218 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [
4219   GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string])
4220   if test x$enable_symvers = xgnu-versioned-namespace; then
4221     # gnu-versioned-namespace is incompatible with the dual ABI.
4222     enable_libstdcxx_dual_abi="no"
4223   fi
4224   if test x"$enable_libstdcxx_dual_abi" != xyes; then
4225     AC_MSG_NOTICE([dual ABI is disabled])
4226     default_libstdcxx_abi="gcc4-compatible"
4227   fi
4228   GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes)
4232 dnl Check to see which ABI should be enabled by default.
4234 dnl --with-default-libstdcxx-abi={gcc4-compatible,new}
4236 dnl Defines:
4237 dnl  _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
4239 AC_DEFUN([GLIBCXX_DEFAULT_ABI], [
4240   if test x$enable_libstdcxx_dual_abi = xyes; then
4241   AC_MSG_CHECKING([for default std::string ABI to use])
4242   AC_ARG_WITH([default-libstdcxx-abi],
4243     AS_HELP_STRING([--with-default-libstdcxx-abi],
4244                    [set the std::string ABI to use by default]),
4245     [case "$withval" in
4246       gcc4-compatible)  default_libstdcxx_abi="gcc4-compatible" ;;
4247       new|cxx11)  default_libstdcxx_abi="new" ;;
4248       c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;;
4249       *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
4250      esac
4251      ],
4252     [default_libstdcxx_abi="new"])
4253   AC_MSG_RESULT(${default_libstdcxx_abi})
4254   fi
4255   if test $default_libstdcxx_abi = "new"; then
4256     glibcxx_cxx11_abi=1
4257     glibcxx_cxx98_abi=0
4258   else
4259     glibcxx_cxx11_abi=0
4260     glibcxx_cxx98_abi=1
4261   fi
4262   AC_SUBST(glibcxx_cxx98_abi)
4263   GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1)
4267 dnl Check to see whether to build libstdc++fs.a
4269 dnl --enable-libstdcxx-filesystem-ts
4271 AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [
4272   GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,,
4273     [turns on ISO/IEC TS 18822 support],
4274     [permit yes|no|auto])
4276   AC_MSG_CHECKING([whether to build Filesystem TS support])
4277   if test x"$ac_cv_header_dirent_h" != x"yes"; then
4278     enable_libstdcxx_filesystem_ts=no
4279   fi
4280   if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then
4281     case "${target_os}" in
4282       freebsd*|netbsd*|openbsd*|dragonfly*|darwin*)
4283         enable_libstdcxx_filesystem_ts=yes
4284         ;;
4285       gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
4286         enable_libstdcxx_filesystem_ts=yes
4287         ;;
4288       rtems*)
4289         enable_libstdcxx_filesystem_ts=yes
4290         ;;
4291       solaris*)
4292         enable_libstdcxx_filesystem_ts=yes
4293         ;;
4294       *)
4295         enable_libstdcxx_filesystem_ts=no
4296         ;;
4297     esac
4298   fi
4299   AC_MSG_RESULT($enable_libstdcxx_filesystem_ts)
4300   GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes)
4304 dnl Check whether the library calls required by the Filesystem TS are present.
4305 dnl Defines:
4306 dnl  HAVE_STRUCT_DIRENT_D_TYPE
4307 dnl  _GLIBCXX_USE_REALPATH
4308 dnl  _GLIBCXX_USE_UTIMENSAT
4309 dnl  _GLIBCXX_USE_ST_MTIM
4310 dnl  _GLIBCXX_USE_FCHMOD
4311 dnl  _GLIBCXX_USE_FCHMODAT
4312 dnl  _GLIBCXX_USE_SENDFILE
4313 dnl  HAVE_LINK
4314 dnl  HAVE_READLINK
4315 dnl  HAVE_SYMLINK
4317 AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
4319   if test $enable_libstdcxx_filesystem_ts = yes; then
4320     AC_LANG_SAVE
4321     AC_LANG_CPLUSPLUS
4322     ac_save_CXXFLAGS="$CXXFLAGS"
4323     CXXFLAGS="$CXXFLAGS -fno-exceptions"
4325     AC_MSG_CHECKING([for struct dirent.d_type])
4326     AC_CACHE_VAL(glibcxx_cv_dirent_d_type, [dnl
4327       GCC_TRY_COMPILE_OR_LINK(
4328         [#include <dirent.h>],
4329         [
4330          struct dirent d;
4331          if (sizeof d.d_type) return 0;
4332         ],
4333         [glibcxx_cv_dirent_d_type=yes],
4334         [glibcxx_cv_dirent_d_type=no])
4335     ])
4336     if test $glibcxx_cv_dirent_d_type = yes; then
4337       AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.])
4338     fi
4339     AC_MSG_RESULT($glibcxx_cv_dirent_d_type)
4341     AC_MSG_CHECKING([for realpath])
4342     AC_CACHE_VAL(glibcxx_cv_realpath, [dnl
4343       GCC_TRY_COMPILE_OR_LINK(
4344         [
4345          #include <limits.h>
4346          #include <stdlib.h>
4347          #include <unistd.h>
4348         ],
4349         [
4350          #if _XOPEN_VERSION < 500
4351          #error
4352          #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX)
4353          char *tmp = realpath((const char*)NULL, (char*)NULL);
4354          #else
4355          #error
4356          #endif
4357         ],
4358         [glibcxx_cv_realpath=yes],
4359         [glibcxx_cv_realpath=no])
4360     ])
4361     if test $glibcxx_cv_realpath = yes; then
4362       AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.])
4363     fi
4364     AC_MSG_RESULT($glibcxx_cv_realpath)
4366     AC_MSG_CHECKING([for utimensat])
4367     AC_CACHE_VAL(glibcxx_cv_utimensat, [dnl
4368       GCC_TRY_COMPILE_OR_LINK(
4369         [
4370           #include <fcntl.h>
4371           #include <sys/stat.h>
4372         ],
4373         [
4374           struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } };
4375           int i = utimensat(AT_FDCWD, "path", ts, 0);
4376         ],
4377         [glibcxx_cv_utimensat=yes],
4378         [glibcxx_cv_utimensat=no])
4379     ])
4380     if test $glibcxx_cv_utimensat = yes; then
4381       AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.])
4382     fi
4383     AC_MSG_RESULT($glibcxx_cv_utimensat)
4385     AC_MSG_CHECKING([for struct stat.st_mtim.tv_nsec])
4386     AC_CACHE_VAL(glibcxx_cv_st_mtim, [dnl
4387       GCC_TRY_COMPILE_OR_LINK(
4388         [ #include <sys/stat.h> ],
4389         [
4390           struct stat st;
4391           return st.st_mtim.tv_nsec;
4392         ],
4393         [glibcxx_cv_st_mtim=yes],
4394         [glibcxx_cv_st_mtim=no])
4395     ])
4396     if test $glibcxx_cv_st_mtim = yes; then
4397       AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.])
4398     fi
4399     AC_MSG_RESULT($glibcxx_cv_st_mtim)
4401     AC_MSG_CHECKING([for fchmod])
4402     AC_CACHE_VAL(glibcxx_cv_fchmod, [dnl
4403       GCC_TRY_COMPILE_OR_LINK(
4404         [#include <sys/stat.h>],
4405         [fchmod(1, S_IWUSR);],
4406         [glibcxx_cv_fchmod=yes],
4407         [glibcxx_cv_fchmod=no])
4408     ])
4409     if test $glibcxx_cv_fchmod = yes; then
4410       AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.])
4411     fi
4412     AC_MSG_RESULT($glibcxx_cv_fchmod)
4414     AC_MSG_CHECKING([for fchmodat])
4415     AC_CACHE_VAL(glibcxx_cv_fchmodat, [dnl
4416       GCC_TRY_COMPILE_OR_LINK(
4417         [
4418           #include <fcntl.h>
4419           #include <sys/stat.h>
4420         ],
4421         [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);],
4422         [glibcxx_cv_fchmodat=yes],
4423         [glibcxx_cv_fchmodat=no])
4424     ])
4425     if test $glibcxx_cv_fchmodat = yes; then
4426       AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.])
4427     fi
4428     AC_MSG_RESULT($glibcxx_cv_fchmodat)
4430     AC_MSG_CHECKING([for sendfile that can copy files])
4431     AC_CACHE_VAL(glibcxx_cv_sendfile, [dnl
4432       case "${target_os}" in
4433         gnu* | linux* | solaris*)
4434           GCC_TRY_COMPILE_OR_LINK(
4435             [#include <sys/sendfile.h>],
4436             [sendfile(1, 2, (off_t*)0, sizeof 1);],
4437             [glibcxx_cv_sendfile=yes],
4438             [glibcxx_cv_sendfile=no])
4439           ;;
4440         *)
4441           glibcxx_cv_sendfile=no
4442           ;;
4443       esac
4444     ])
4445     if test $glibcxx_cv_sendfile = yes; then
4446       AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.])
4447     fi
4448     AC_MSG_RESULT($glibcxx_cv_sendfile)
4450     AC_MSG_CHECKING([for link])
4451     AC_CACHE_VAL(glibcxx_cv_link, [dnl
4452       GCC_TRY_COMPILE_OR_LINK(
4453         [#include <unistd.h>],
4454         [link("", "");],
4455         [glibcxx_cv_link=yes],
4456         [glibcxx_cv_link=no])
4457     ])
4458     if test $glibcxx_cv_link = yes; then
4459       AC_DEFINE(HAVE_LINK, 1, [Define if link is available in <unistd.h>.])
4460     fi
4461     AC_MSG_RESULT($glibcxx_cv_link)
4463     AC_MSG_CHECKING([for readlink])
4464     AC_CACHE_VAL(glibcxx_cv_readlink, [dnl
4465       GCC_TRY_COMPILE_OR_LINK(
4466         [#include <unistd.h>],
4467         [char buf[32]; readlink("", buf, sizeof(buf));],
4468         [glibcxx_cv_readlink=yes],
4469         [glibcxx_cv_readlink=no])
4470     ])
4471     if test $glibcxx_cv_readlink = yes; then
4472       AC_DEFINE(HAVE_READLINK, 1, [Define if readlink is available in <unistd.h>.])
4473     fi
4474     AC_MSG_RESULT($glibcxx_cv_readlink)
4476     AC_MSG_CHECKING([for symlink])
4477     AC_CACHE_VAL(glibcxx_cv_symlink, [dnl
4478       GCC_TRY_COMPILE_OR_LINK(
4479         [#include <unistd.h>],
4480         [symlink("", "");],
4481         [glibcxx_cv_symlink=yes],
4482         [glibcxx_cv_symlink=no])
4483     ])
4484     if test $glibcxx_cv_symlink = yes; then
4485       AC_DEFINE(HAVE_SYMLINK, 1, [Define if symlink is available in <unistd.h>.])
4486     fi
4487     AC_MSG_RESULT($glibcxx_cv_symlink)
4489     CXXFLAGS="$ac_save_CXXFLAGS"
4490     AC_LANG_RESTORE
4491   fi
4495 dnl Check how size_t is mangled.  Copied from libitm.
4497 AC_DEFUN([GLIBCXX_CHECK_SIZE_T_MANGLING], [
4498   AC_CACHE_CHECK([how size_t is mangled],
4499                  glibcxx_cv_size_t_mangling, [
4500     AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
4501                    [glibcxx_cv_size_t_mangling=m], [
4502       AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
4503                      [glibcxx_cv_size_t_mangling=j], [
4504         AC_TRY_COMPILE([],
4505                        [extern __SIZE_TYPE__ x; extern unsigned long long x;],
4506                        [glibcxx_cv_size_t_mangling=y], [
4507           AC_TRY_COMPILE([],
4508                          [extern __SIZE_TYPE__ x; extern unsigned short x;],
4509                          [glibcxx_cv_size_t_mangling=t], [
4510             AC_TRY_COMPILE([],
4511                            [extern __SIZE_TYPE__ x; extern __int20 unsigned x;],
4512                            [glibcxx_cv_size_t_mangling=u6uint20],
4513                            [glibcxx_cv_size_t_mangling=x])
4514           ])
4515         ])
4516       ])
4517     ])
4518   ])
4519   if test $glibcxx_cv_size_t_mangling = x; then
4520     AC_MSG_ERROR([Unknown underlying type for size_t])
4521   fi
4522   AC_DEFINE_UNQUOTED(_GLIBCXX_MANGLE_SIZE_T, [$glibcxx_cv_size_t_mangling],
4523     [Define to the letter to which size_t is mangled.])
4527 dnl Determine whether std::exception_ptr symbols should be exported with
4528 dnl the symbol versions from GCC 4.6.0 or GCC 7.1.0, depending on which
4529 dnl release first added support for std::exception_ptr. Originally it was
4530 dnl only supported for targets with always-lock-free atomics for int, but
4531 dnl since GCC 7.1 it is supported for all targets.
4533 AC_DEFUN([GLIBCXX_CHECK_EXCEPTION_PTR_SYMVER], [
4534   if test $enable_symvers != no; then
4535     AC_MSG_CHECKING([for first version to support std::exception_ptr])
4536     case ${target} in
4537       aarch64-*-* | alpha-*-* | hppa*-*-* | i?86-*-* | x86_64-*-* | \
4538       m68k-*-* | powerpc*-*-* | s390*-*-* | *-*-solaris* )
4539         ac_exception_ptr_since_gcc46=yes
4540         ;;
4541       *)
4542         # If the value of this macro changes then we will need to hardcode
4543         # yes/no here for additional targets based on the original value.
4544         AC_TRY_COMPILE([], [
4545           #if __GCC_ATOMIC_INT_LOCK_FREE <= 1
4546           # error atomic int not always lock free
4547           #endif
4548           ],
4549           [ac_exception_ptr_since_gcc46=yes],
4550           [ac_exception_ptr_since_gcc46=no])
4551         ;;
4552     esac
4553     if test x"$ac_exception_ptr_since_gcc46" = x"yes" ; then
4554       AC_DEFINE(HAVE_EXCEPTION_PTR_SINCE_GCC46, 1,
4555         [Define to 1 if GCC 4.6 supported std::exception_ptr for the target])
4556       AC_MSG_RESULT([4.6.0])
4557     else
4558       AC_MSG_RESULT([7.1.0])
4559     fi
4560   fi
4563 # Macros from the top-level gcc directory.
4564 m4_include([../config/gc++filt.m4])
4565 m4_include([../config/tls.m4])
4566 m4_include([../config/gthr.m4])
4567 m4_include([../config/cet.m4])