| blob | 71321055de72f1f193b6a4d453b9d65b5dc7f88f |
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])
27 ])
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/c++20 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
119 ])
122 dnl
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.
126 dnl
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.
133 dnl
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)
160 ])
163 dnl
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).
167 dnl
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)
176 dnl
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.
179 dnl
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/[. ][0-9]\{8\}$//;s/.* \([^ ]\{1,\}\)$/\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 # cygwin and mingw uses PE, which has no ELF relro support,
277 # multi target ld may confuse configure machinery
278 case "$host" in
279 *-*-cygwin*)
280 ;;
281 *-*-mingw*)
282 ;;
283 *)
284 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
285 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
286 if test -n "$cxx_z_relo"; then
287 OPT_LDFLAGS="-Wl,-z,relro"
288 ac_ld_relro=yes
289 fi
290 AC_MSG_RESULT($ac_ld_relro)
291 esac
292 fi
294 # Set linker optimization flags.
295 if test x"$with_gnu_ld" = x"yes"; then
296 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
297 fi
299 AC_SUBST(SECTION_LDFLAGS)
300 AC_SUBST(OPT_LDFLAGS)
301 ])
304 dnl
305 dnl Check for headers for, and arguments to, the setrlimit() function.
306 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
307 dnl
308 dnl Defines:
309 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
310 dnl various HAVE_LIMIT_* for individual limit names
311 dnl
312 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
313 AC_MSG_CHECKING([for RLIMIT_$1])
314 AC_TRY_COMPILE(
315 [#include <unistd.h>
316 #include <sys/time.h>
317 #include <sys/resource.h>
318 ],
319 [ int f = RLIMIT_$1 ; ],
320 [glibcxx_mresult=1], [glibcxx_mresult=0])
321 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
322 [Only used in build directory testsuite_hooks.h.])
323 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
324 AC_MSG_RESULT($res)
325 ])
327 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
328 AC_LANG_SAVE
329 AC_LANG_CPLUSPLUS
330 setrlimit_have_headers=yes
331 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
332 [],
333 [setrlimit_have_headers=no])
334 # If don't have the headers, then we can't run the tests now, and we
335 # won't be seeing any of these during testsuite compilation.
336 if test $setrlimit_have_headers = yes; then
337 # Can't do these in a loop, else the resulting syntax is wrong.
338 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
339 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
340 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
341 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
342 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
344 # Check for rlimit, setrlimit.
345 AC_CACHE_CHECK([for testsuite resource limits support],
346 glibcxx_cv_setrlimit, [
347 AC_TRY_COMPILE(
348 [#include <unistd.h>
349 #include <sys/time.h>
350 #include <sys/resource.h>
351 ],
352 [struct rlimit r;
353 setrlimit(0, &r);],
354 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
355 ])
357 if test $glibcxx_cv_setrlimit = yes; then
358 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
359 [Define if using setrlimit to set resource limits during
360 "make check"])
361 fi
362 fi
363 AC_LANG_RESTORE
364 ])
367 dnl
368 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
369 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
370 dnl
371 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
373 AC_LANG_SAVE
374 AC_LANG_CPLUSPLUS
375 ac_save_CXXFLAGS="$CXXFLAGS"
376 CXXFLAGS="$CXXFLAGS -fno-exceptions"
378 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
379 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
380 GCC_TRY_COMPILE_OR_LINK(
381 [#include <sys/stat.h>],
382 [struct stat buffer;
383 fstat(0, &buffer);
384 S_ISREG(buffer.st_mode);],
385 [glibcxx_cv_S_ISREG=yes],
386 [glibcxx_cv_S_ISREG=no])
387 ])
388 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
389 GCC_TRY_COMPILE_OR_LINK(
390 [#include <sys/stat.h>],
391 [struct stat buffer;
392 fstat(0, &buffer);
393 S_IFREG & buffer.st_mode;],
394 [glibcxx_cv_S_IFREG=yes],
395 [glibcxx_cv_S_IFREG=no])
396 ])
397 res=no
398 if test $glibcxx_cv_S_ISREG = yes; then
399 AC_DEFINE(HAVE_S_ISREG, 1,
400 [Define if S_ISREG is available in <sys/stat.h>.])
401 res=S_ISREG
402 elif test $glibcxx_cv_S_IFREG = yes; then
403 AC_DEFINE(HAVE_S_IFREG, 1,
404 [Define if S_IFREG is available in <sys/stat.h>.])
405 res=S_IFREG
406 fi
407 AC_MSG_RESULT($res)
409 CXXFLAGS="$ac_save_CXXFLAGS"
410 AC_LANG_RESTORE
411 ])
414 dnl
415 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
416 dnl
417 AC_DEFUN([GLIBCXX_CHECK_POLL], [
419 AC_LANG_SAVE
420 AC_LANG_CPLUSPLUS
421 ac_save_CXXFLAGS="$CXXFLAGS"
422 CXXFLAGS="$CXXFLAGS -fno-exceptions"
424 AC_CACHE_CHECK([for poll], glibcxx_cv_POLL, [
425 GCC_TRY_COMPILE_OR_LINK(
426 [#include <poll.h>],
427 [struct pollfd pfd[1];
428 pfd[0].events = POLLIN;
429 poll(pfd, 1, 0);],
430 [glibcxx_cv_POLL=yes],
431 [glibcxx_cv_POLL=no])
432 ])
433 if test $glibcxx_cv_POLL = yes; then
434 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
435 fi
437 CXXFLAGS="$ac_save_CXXFLAGS"
438 AC_LANG_RESTORE
439 ])
442 dnl
443 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
444 dnl
445 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
447 AC_LANG_SAVE
448 AC_LANG_CPLUSPLUS
449 ac_save_CXXFLAGS="$CXXFLAGS"
450 CXXFLAGS="$CXXFLAGS -fno-exceptions"
452 AC_CACHE_CHECK([for writev], glibcxx_cv_WRITEV, [
453 GCC_TRY_COMPILE_OR_LINK(
454 [#include <sys/uio.h>],
455 [struct iovec iov[2];
456 writev(0, iov, 0);],
457 [glibcxx_cv_WRITEV=yes],
458 [glibcxx_cv_WRITEV=no])
459 ])
460 if test $glibcxx_cv_WRITEV = yes; then
461 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
462 fi
464 CXXFLAGS="$ac_save_CXXFLAGS"
465 AC_LANG_RESTORE
466 ])
469 dnl
470 dnl Check whether LFS support is available.
471 dnl
472 AC_DEFUN([GLIBCXX_CHECK_LFS], [
473 AC_LANG_SAVE
474 AC_LANG_CPLUSPLUS
475 ac_save_CXXFLAGS="$CXXFLAGS"
476 CXXFLAGS="$CXXFLAGS -fno-exceptions"
477 AC_CACHE_CHECK([for LFS support], glibcxx_cv_LFS, [
478 GCC_TRY_COMPILE_OR_LINK(
479 [#include <unistd.h>
480 #include <stdio.h>
481 #include <sys/stat.h>
482 ],
483 [FILE* fp;
484 fopen64("t", "w");
485 fseeko64(fp, 0, SEEK_CUR);
486 ftello64(fp);
487 lseek64(1, 0, SEEK_CUR);
488 struct stat64 buf;
489 fstat64(1, &buf);],
490 [glibcxx_cv_LFS=yes],
491 [glibcxx_cv_LFS=no])
492 ])
493 if test $glibcxx_cv_LFS = yes; then
494 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
495 fi
496 CXXFLAGS="$ac_save_CXXFLAGS"
497 AC_LANG_RESTORE
498 ])
501 dnl
502 dnl Check for whether a fully dynamic basic_string implementation should
503 dnl be turned on, that does not put empty objects in per-process static
504 dnl memory (mostly useful together with shared memory allocators, see PR
505 dnl libstdc++/16612 for details).
506 dnl
507 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
508 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
509 dnl otherwise undefined
510 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
511 dnl Where DEFAULT is either `yes' or `no'.
512 dnl
513 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
514 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
515 if test $enable_fully_dynamic_string = yes; then
516 enable_fully_dynamic_string_def=1
517 else
518 enable_fully_dynamic_string_def=0
519 fi
520 AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
521 [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
522 ])
525 dnl
526 dnl Does any necessary configuration of the testsuite directory. Generates
527 dnl the testsuite_hooks.h header.
528 dnl
529 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
530 dnl
531 dnl Sets:
532 dnl enable_abi_check
533 dnl GLIBCXX_TEST_WCHAR_T
534 dnl GLIBCXX_TEST_THREAD
535 dnl Substs:
536 dnl baseline_dir
537 dnl baseline_subdir_switch
538 dnl
539 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
540 # Do checks for resource limit functions.
541 GLIBCXX_CHECK_SETRLIMIT
543 if $GLIBCXX_IS_NATIVE ; then
544 # Look for setenv, so that extended locale tests can be performed.
545 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
546 fi
548 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
549 test $enable_symvers != no; then
550 case "$host" in
551 *-*-cygwin*)
552 enable_abi_check=no ;;
553 *)
554 enable_abi_check=yes ;;
555 esac
556 else
557 # Only build this as native, since automake does not understand
558 # CXX_FOR_BUILD.
559 enable_abi_check=no
560 fi
562 # Export file names for ABI checking.
563 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
564 AC_SUBST(baseline_dir)
565 baseline_subdir_switch="$abi_baseline_subdir_switch"
566 AC_SUBST(baseline_subdir_switch)
567 ])
570 dnl
571 dnl Does any necessary configuration for docbook in the docs directory.
572 dnl
573 dnl XSLTPROC must be set before this
574 dnl
575 dnl Sets:
576 dnl glibcxx_stylesheets
577 dnl Substs:
578 dnl XSL_STYLE_DIR
579 dnl
580 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
582 glibcxx_docbook_url=http://docbook.sourceforge.net/release/xsl-ns/current/
584 AC_MSG_CHECKING([for local stylesheet directory])
585 glibcxx_local_stylesheets=no
586 if test x${XMLCATALOG} = xyes && xsl_style_dir=`xmlcatalog "" $glibcxx_docbook_url 2>/dev/null`
587 then
588 XSL_STYLE_DIR=`echo $xsl_style_dir | sed -n 's;^file://;;p'`
589 glibcxx_local_stylesheets=yes
590 else
591 for dir in \
592 /usr/share/sgml/docbook/xsl-ns-stylesheets \
593 /usr/share/xml/docbook/stylesheet/docbook-xsl-ns \
594 /usr/share/xml/docbook/stylesheet/nwalsh5/current \
595 /usr/share/xml/docbook/stylesheet/nwalsh/current
596 do
597 if test -d $dir; then
598 glibcxx_local_stylesheets=yes
599 XSL_STYLE_DIR=$dir
600 break
601 fi
602 done
603 fi
604 AC_MSG_RESULT($glibcxx_local_stylesheets)
606 if test x"$glibcxx_local_stylesheets" = x"yes"; then
607 AC_SUBST(XSL_STYLE_DIR)
608 AC_MSG_NOTICE($XSL_STYLE_DIR)
610 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
611 glibcxx_stylesheets=no
612 if test x${XMLCATALOG} = xno || xmlcatalog "" $glibcxx_docbook_url/xhtml/docbook.xsl >/dev/null 2>&1; then
613 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude $glibcxx_docbook_url/xhtml/docbook.xsl - 2>/dev/null; then
614 glibcxx_stylesheets=yes
615 fi
616 fi
617 AC_MSG_RESULT($glibcxx_stylesheets)
619 else
620 glibcxx_stylesheets=no
621 fi
623 # Check for epub3 dependencies.
624 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
625 glibcxx_epub_stylesheets=no
626 if test x"$glibcxx_local_stylesheets" = x"yes"; then
627 if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
628 glibcxx_epub_stylesheets=yes
629 fi
630 fi
631 AC_MSG_RESULT($glibcxx_epub_stylesheets)
632 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
634 ])
637 dnl
638 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
639 dnl
640 dnl Substs:
641 dnl GLIBCXX_INCLUDES
642 dnl TOPLEVEL_INCLUDES
643 dnl
644 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
645 # Used for every C++ compile we perform.
646 GLIBCXX_INCLUDES="\
647 -I$glibcxx_builddir/include/$host_alias \
648 -I$glibcxx_builddir/include \
649 -I$glibcxx_srcdir/libsupc++"
651 # For Canadian crosses, pick this up too.
652 if test $CANADIAN = yes; then
653 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
654 fi
656 # Stuff in the actual top level. Currently only used by libsupc++ to
657 # get unwind* headers from the libgcc dir.
658 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
659 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
661 # Now, export this to all the little Makefiles....
662 AC_SUBST(GLIBCXX_INCLUDES)
663 AC_SUBST(TOPLEVEL_INCLUDES)
664 ])
667 dnl
668 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
669 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
670 dnl
671 dnl Substs:
672 dnl OPTIMIZE_CXXFLAGS
673 dnl WARN_FLAGS
674 dnl
675 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
676 # Optimization flags that are probably a good idea for thrill-seekers. Just
677 # uncomment the lines below and make, everything else is ready to go...
678 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
679 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
680 AC_SUBST(OPTIMIZE_CXXFLAGS)
682 WARN_FLAGS="-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi=2"
683 AC_SUBST(WARN_FLAGS)
684 ])
687 dnl
688 dnl All installation directory information is determined here.
689 dnl
690 dnl Substs:
691 dnl gxx_install_dir
692 dnl glibcxx_prefixdir
693 dnl glibcxx_toolexecdir
694 dnl glibcxx_toolexeclibdir
695 dnl
696 dnl Assumes cross_compiling bits already done, and with_cross_host in
697 dnl particular.
698 dnl
699 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
700 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
701 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
702 glibcxx_toolexecdir=no
703 glibcxx_toolexeclibdir=no
704 glibcxx_prefixdir=$prefix
706 AC_MSG_CHECKING([for gxx-include-dir])
707 AC_ARG_WITH([gxx-include-dir],
708 AC_HELP_STRING([--with-gxx-include-dir=DIR],
709 [installation directory for include files]),
710 [case "$withval" in
711 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
712 no) gxx_include_dir=no ;;
713 *) gxx_include_dir=$withval ;;
714 esac],
715 [gxx_include_dir=no])
716 AC_MSG_RESULT($gxx_include_dir)
718 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
719 AC_ARG_ENABLE([version-specific-runtime-libs],
720 AC_HELP_STRING([--enable-version-specific-runtime-libs],
721 [Specify that runtime libraries should be installed in a compiler-specific directory]),
722 [case "$enableval" in
723 yes) version_specific_libs=yes ;;
724 no) version_specific_libs=no ;;
725 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
726 esac],
727 [version_specific_libs=no])
728 AC_MSG_RESULT($version_specific_libs)
730 GCC_WITH_TOOLEXECLIBDIR
732 # Default case for install directory for include files.
733 if test $version_specific_libs = no && test $gxx_include_dir = no; then
734 gxx_include_dir='include/c++/${gcc_version}'
735 if test -n "$with_cross_host" &&
736 test x"$with_cross_host" != x"no"; then
737 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
738 else
739 gxx_include_dir='${prefix}/'"$gxx_include_dir"
740 fi
741 fi
743 # Version-specific runtime libs processing.
744 if test $version_specific_libs = yes; then
745 # Need the gcc compiler version to know where to install libraries
746 # and header files if --enable-version-specific-runtime-libs option
747 # is selected. FIXME: these variables are misnamed, there are
748 # no executables installed in _toolexecdir or _toolexeclibdir.
749 if test x"$gxx_include_dir" = x"no"; then
750 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
751 fi
752 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
753 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
754 fi
756 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
757 # Install a library built with a cross compiler in tooldir, not libdir.
758 if test x"$glibcxx_toolexecdir" = x"no"; then
759 if test -n "$with_cross_host" &&
760 test x"$with_cross_host" != x"no"; then
761 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
762 case ${with_toolexeclibdir} in
763 no)
764 glibcxx_toolexeclibdir='${toolexecdir}/lib'
765 ;;
766 *)
767 glibcxx_toolexeclibdir=${with_toolexeclibdir}
768 ;;
769 esac
770 else
771 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
772 glibcxx_toolexeclibdir='${libdir}'
773 fi
774 multi_os_directory=`$CXX -print-multi-os-directory`
775 case $multi_os_directory in
776 .) ;; # Avoid trailing /.
777 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
778 esac
779 fi
781 AC_MSG_CHECKING([for install location])
782 AC_MSG_RESULT($gxx_include_dir)
784 AC_SUBST(glibcxx_prefixdir)
785 AC_SUBST(gxx_include_dir)
786 AC_SUBST(glibcxx_toolexecdir)
787 AC_SUBST(glibcxx_toolexeclibdir)
788 ])
791 dnl
792 dnl GLIBCXX_ENABLE
793 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
794 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
795 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
796 dnl
797 dnl See manual/appendix_porting.html#appendix.porting.build_hacking for
798 dnl documentation.
799 dnl
800 m4_define([GLIBCXX_ENABLE],[dnl
801 m4_define([_g_switch],[--enable-$1])dnl
802 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
803 AC_ARG_ENABLE([$1],m4_dquote(_g_help),
804 m4_bmatch([$5],
805 [^permit ],
806 [[
807 case "$enableval" in
808 m4_bpatsubst([$5],[permit ])) ;;
809 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
810 dnl Idea for future: generate a URL pointing to
811 dnl "onlinedocs/configopts.html#whatever"
812 esac
813 ]],
814 [^$],
815 [[
816 case "$enableval" in
817 yes|no) ;;
818 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
819 esac
820 ]],
821 [[$5]]),
822 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
823 m4_undefine([_g_switch])dnl
824 m4_undefine([_g_help])dnl
825 ])
828 dnl
829 dnl Check for ISO/IEC 9899:1999 "C99" support.
830 dnl
831 dnl --enable-c99 defines _GLIBCXX_USE_C99
832 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
833 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
834 dnl Where DEFAULT is either `yes' or `no'.
835 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
836 dnl
837 AC_DEFUN([GLIBCXX_ENABLE_C99], [
838 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
840 if test x"$enable_c99" = x"yes"; then
841 AC_LANG_SAVE
842 AC_LANG_CPLUSPLUS
844 # Use -std=c++98 (instead of -std=gnu++98) because leaving __STRICT_ANSI__
845 # undefined may cause fake C99 facilities, like pre-standard snprintf,
846 # to be spuriously enabled.
847 ac_save_CXXFLAGS="$CXXFLAGS"
848 CXXFLAGS="$CXXFLAGS -std=c++98"
849 ac_save_LIBS="$LIBS"
850 ac_save_gcc_no_link="$gcc_no_link"
852 if test x$gcc_no_link != xyes; then
853 # Use -fno-exceptions to that the C driver can link these tests without
854 # hitting undefined references to personality routines.
855 CXXFLAGS="$CXXFLAGS -fno-exceptions"
856 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
857 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
858 gcc_no_link=yes
859 ])
860 fi
862 # Check for the existence of <math.h> functions used if C99 is enabled.
863 AC_CACHE_CHECK([for ISO C99 support in <math.h> for C++98],
864 glibcxx_cv_c99_math_cxx98, [
865 GCC_TRY_COMPILE_OR_LINK(
866 [#include <math.h>
867 volatile double d1, d2;
868 volatile int i;],
869 [i = fpclassify(d1);
870 i = isfinite(d1);
871 i = isinf(d1);
872 i = isnan(d1);
873 i = isnormal(d1);
874 i = signbit(d1);
875 i = isgreater(d1, d2);
876 i = isgreaterequal(d1, d2);
877 i = isless(d1, d2);
878 i = islessequal(d1, d2);
879 i = islessgreater(d1, d2);
880 i = islessgreater(d1, d2);
881 i = isunordered(d1, d2);
882 ], [glibcxx_cv_c99_math_cxx98=yes], [glibcxx_cv_c99_math_cxx98=no])
883 ])
884 if test x"$glibcxx_cv_c99_math_cxx98" = x"yes"; then
885 AC_DEFINE(_GLIBCXX98_USE_C99_MATH, 1,
886 [Define if C99 functions or macros in <math.h> should be imported
887 in <cmath> in namespace std for C++98.])
888 fi
890 # Check for the existence of <complex.h> complex math functions.
891 # This is necessary even though libstdc++ uses the builtin versions
892 # of these functions, because if the builtin cannot be used, a reference
893 # to the library function is emitted.
894 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
895 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
896 if test x"$ac_has_complex_h" = x"yes"; then
897 AC_CACHE_CHECK([for ISO C99 support in <complex.h> for C++98],
898 glibcxx_cv_c99_complex_cxx98, [
899 GCC_TRY_COMPILE_OR_LINK(
900 [#include <complex.h>
901 typedef __complex__ float float_type;
902 typedef __complex__ double double_type;
903 typedef __complex__ long double ld_type;
904 volatile float_type tmpf;
905 volatile double_type tmpd;
906 volatile ld_type tmpld;
907 volatile float f;
908 volatile double d;
909 volatile long double ld;],
910 [f = cabsf(tmpf);
911 f = cargf(tmpf);
912 tmpf = ccosf(tmpf);
913 tmpf = ccoshf(tmpf);
914 tmpf = cexpf(tmpf);
915 tmpf = clogf(tmpf);
916 tmpf = csinf(tmpf);
917 tmpf = csinhf(tmpf);
918 tmpf = csqrtf(tmpf);
919 tmpf = ctanf(tmpf);
920 tmpf = ctanhf(tmpf);
921 tmpf = cpowf(tmpf, tmpf);
922 tmpf = cprojf(tmpf);
923 d = cabs(tmpd);
924 d = carg(tmpd);
925 tmpd = ccos(tmpd);
926 tmpd = ccosh(tmpd);
927 tmpd = cexp(tmpd);
928 tmpd = clog(tmpd);
929 tmpd = csin(tmpd);
930 tmpd = csinh(tmpd);
931 tmpd = csqrt(tmpd);
932 tmpd = ctan(tmpd);
933 tmpd = ctanh(tmpd);
934 tmpd = cpow(tmpd, tmpd);
935 tmpd = cproj(tmpd);
936 ld = cabsl(tmpld);
937 ld = cargl(tmpld);
938 tmpld = ccosl(tmpld);
939 tmpld = ccoshl(tmpld);
940 tmpld = cexpl(tmpld);
941 tmpld = clogl(tmpld);
942 tmpld = csinl(tmpld);
943 tmpld = csinhl(tmpld);
944 tmpld = csqrtl(tmpld);
945 tmpld = ctanl(tmpld);
946 tmpld = ctanhl(tmpld);
947 tmpld = cpowl(tmpld, tmpld);
948 tmpld = cprojl(tmpld);
949 ], [glibcxx_cv_c99_complex_cxx98=yes], [glibcxx_cv_c99_complex_cxx98=no])
950 ])
951 fi
952 if test x"$glibcxx_cv_c99_complex_cxx98" = x"yes"; then
953 AC_DEFINE(_GLIBCXX98_USE_C99_COMPLEX, 1,
954 [Define if C99 functions in <complex.h> should be used in
955 <complex> for C++98. Using compiler builtins for these functions
956 requires corresponding C99 library functions to be present.])
957 fi
959 # Check for the existence in <stdio.h> of vscanf, et. al.
960 AC_CACHE_CHECK([for ISO C99 support in <stdio.h> for C++98],
961 glibcxx_cv_c99_stdio_cxx98, [
962 GCC_TRY_COMPILE_OR_LINK(
963 [#include <stdio.h>
964 #include <stdarg.h>
965 void foo(char* fmt, ...)
966 {
967 va_list args; va_start(args, fmt);
968 vfscanf(stderr, "%i", args);
969 vscanf("%i", args);
970 vsnprintf(fmt, 0, "%i", args);
971 vsscanf(fmt, "%i", args);
972 snprintf(fmt, 0, "%i");
973 }], [],
974 [glibcxx_cv_c99_stdio_cxx98=yes], [glibcxx_cv_c99_stdio_cxx98=no])
975 ])
976 if test x"$glibcxx_cv_c99_stdio_cxx98" = x"yes"; then
977 AC_DEFINE(_GLIBCXX98_USE_C99_STDIO, 1,
978 [Define if C99 functions or macros in <stdio.h> should be imported
979 in <cstdio> in namespace std for C++98.])
980 fi
982 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
983 AC_CACHE_CHECK([for ISO C99 support in <stdlib.h> for C++98],
984 glibcxx_cv_c99_stdlib_cxx98, [
985 GCC_TRY_COMPILE_OR_LINK(
986 [#include <stdlib.h>
987 volatile float f;
988 volatile long double ld;
989 volatile unsigned long long ll;
990 lldiv_t mydivt;],
991 [char* tmp;
992 f = strtof("gnu", &tmp);
993 ld = strtold("gnu", &tmp);
994 ll = strtoll("gnu", &tmp, 10);
995 ll = strtoull("gnu", &tmp, 10);
996 ll = llabs(10);
997 mydivt = lldiv(10,1);
998 ll = mydivt.quot;
999 ll = mydivt.rem;
1000 ll = atoll("10");
1001 _Exit(0);
1002 ], [glibcxx_cv_c99_stdlib_cxx98=yes], [glibcxx_cv_c99_stdlib_cxx98=no])
1003 ])
1004 if test x"$glibcxx_cv_c99_stdlib_cxx98" = x"yes"; then
1005 AC_DEFINE(_GLIBCXX98_USE_C99_STDLIB, 1,
1006 [Define if C99 functions or macros in <stdlib.h> should be imported
1007 in <cstdlib> in namespace std for C++98.])
1008 fi
1010 # Check for the existence in <wchar.h> of wcstold, etc.
1011 if test x"$ac_has_wchar_h" = xyes &&
1012 test x"$ac_has_wctype_h" = xyes; then
1013 AC_CACHE_CHECK([for ISO C99 support in <wchar.h> for C++98],
1014 glibcxx_cv_c99_wchar_cxx98, [
1015 AC_TRY_COMPILE([#include <wchar.h>
1016 namespace test
1017 {
1018 using ::wcstold;
1019 using ::wcstoll;
1020 using ::wcstoull;
1021 }
1022 ], [], [glibcxx_cv_c99_wchar_cxx98=yes], [glibcxx_cv_c99_wchar_cxx98=no])
1023 ])
1025 # Checks for wide character functions that may not be present.
1026 # Injection of these is wrapped with guard macros.
1027 # NB: only put functions here, instead of immediately above, if
1028 # absolutely necessary.
1029 AC_TRY_COMPILE([#include <wchar.h>
1030 namespace test { using ::vfwscanf; }], [],
1031 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1033 AC_TRY_COMPILE([#include <wchar.h>
1034 namespace test { using ::vswscanf; }], [],
1035 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1037 AC_TRY_COMPILE([#include <wchar.h>
1038 namespace test { using ::vwscanf; }], [],
1039 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1041 AC_TRY_COMPILE([#include <wchar.h>
1042 namespace test { using ::wcstof; }], [],
1043 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1045 AC_TRY_COMPILE([#include <wctype.h>],
1046 [wint_t t; int i = iswblank(t);],
1047 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1049 if test x"$glibcxx_cv_c99_wchar_cxx98" = x"yes"; then
1050 AC_DEFINE(_GLIBCXX98_USE_C99_WCHAR, 1,
1051 [Define if C99 functions or macros in <wchar.h> should be imported
1052 in <cwchar> in namespace std for C++98.])
1053 fi
1054 fi
1056 # Option parsed, now set things appropriately.
1057 if test x"$glibcxx_cv_c99_math_cxx98" = x"no" ||
1058 test x"$glibcxx_cv_c99_complex_cxx98" = x"no" ||
1059 test x"$glibcxx_cv_c99_stdio_cxx98" = x"no" ||
1060 test x"$glibcxx_cv_c99_stdlib_cxx98" = x"no" ||
1061 test x"$glibcxx_cv_c99_wchar_cxx98" = x"no"; then
1062 enable_c99=no;
1063 else
1064 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1065 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1066 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1067 fi
1069 gcc_no_link="$ac_save_gcc_no_link"
1070 LIBS="$ac_save_LIBS"
1071 CXXFLAGS="$ac_save_CXXFLAGS"
1072 AC_LANG_RESTORE
1074 AC_LANG_SAVE
1075 AC_LANG_CPLUSPLUS
1077 # Use -std=c++11 and test again for C99 library feature in C++11 mode.
1078 # For the reasons given above we use -std=c++11 not -std=gnu++11.
1079 ac_save_CXXFLAGS="$CXXFLAGS"
1080 CXXFLAGS="$CXXFLAGS -std=c++11"
1081 ac_save_LIBS="$LIBS"
1082 ac_save_gcc_no_link="$gcc_no_link"
1084 if test x$gcc_no_link != xyes; then
1085 # Use -fno-exceptions to that the C driver can link these tests without
1086 # hitting undefined references to personality routines.
1087 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1088 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
1089 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
1090 gcc_no_link=yes
1091 ])
1092 fi
1094 # Check for the existence of <math.h> functions used if C99 is enabled.
1095 AC_CACHE_CHECK([for ISO C99 support in <math.h> for C++11],
1096 glibcxx_cv_c99_math_cxx11, [
1097 GCC_TRY_COMPILE_OR_LINK(
1098 [#include <math.h>
1099 volatile double d1, d2;
1100 volatile int i;],
1101 [i = fpclassify(d1);
1102 i = isfinite(d1);
1103 i = isinf(d1);
1104 i = isnan(d1);
1105 i = isnormal(d1);
1106 i = signbit(d1);
1107 i = isgreater(d1, d2);
1108 i = isgreaterequal(d1, d2);
1109 i = isless(d1, d2);
1110 i = islessequal(d1, d2);
1111 i = islessgreater(d1, d2);
1112 i = islessgreater(d1, d2);
1113 i = isunordered(d1, d2);
1114 ], [glibcxx_cv_c99_math_cxx11=yes], [glibcxx_cv_c99_math_cxx11=no])
1115 ])
1116 if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
1117 AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
1118 [Define if C99 functions or macros in <math.h> should be imported
1119 in <cmath> in namespace std for C++11.])
1120 fi
1122 # Check for the existence of <complex.h> complex math functions.
1123 # This is necessary even though libstdc++ uses the builtin versions
1124 # of these functions, because if the builtin cannot be used, a reference
1125 # to the library function is emitted.
1126 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
1127 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1128 if test x"$ac_has_complex_h" = x"yes"; then
1129 AC_CACHE_CHECK([for ISO C99 support in <complex.h> for C++11],
1130 glibcxx_cv_c99_complex_cxx11, [
1131 GCC_TRY_COMPILE_OR_LINK(
1132 [#include <complex.h>
1133 typedef __complex__ float float_type;
1134 typedef __complex__ double double_type;
1135 typedef __complex__ long double ld_type;
1136 volatile float_type tmpf;
1137 volatile double_type tmpd;
1138 volatile ld_type tmpld;
1139 volatile float f;
1140 volatile double d;
1141 volatile long double ld;],
1142 [f = cabsf(tmpf);
1143 f = cargf(tmpf);
1144 tmpf = ccosf(tmpf);
1145 tmpf = ccoshf(tmpf);
1146 tmpf = cexpf(tmpf);
1147 tmpf = clogf(tmpf);
1148 tmpf = csinf(tmpf);
1149 tmpf = csinhf(tmpf);
1150 tmpf = csqrtf(tmpf);
1151 tmpf = ctanf(tmpf);
1152 tmpf = ctanhf(tmpf);
1153 tmpf = cpowf(tmpf, tmpf);
1154 tmpf = cprojf(tmpf);
1155 d = cabs(tmpd);
1156 d = carg(tmpd);
1157 tmpd = ccos(tmpd);
1158 tmpd = ccosh(tmpd);
1159 tmpd = cexp(tmpd);
1160 tmpd = clog(tmpd);
1161 tmpd = csin(tmpd);
1162 tmpd = csinh(tmpd);
1163 tmpd = csqrt(tmpd);
1164 tmpd = ctan(tmpd);
1165 tmpd = ctanh(tmpd);
1166 tmpd = cpow(tmpd, tmpd);
1167 tmpd = cproj(tmpd);
1168 ld = cabsl(tmpld);
1169 ld = cargl(tmpld);
1170 tmpld = ccosl(tmpld);
1171 tmpld = ccoshl(tmpld);
1172 tmpld = cexpl(tmpld);
1173 tmpld = clogl(tmpld);
1174 tmpld = csinl(tmpld);
1175 tmpld = csinhl(tmpld);
1176 tmpld = csqrtl(tmpld);
1177 tmpld = ctanl(tmpld);
1178 tmpld = ctanhl(tmpld);
1179 tmpld = cpowl(tmpld, tmpld);
1180 tmpld = cprojl(tmpld);
1181 ], [glibcxx_cv_c99_complex_cxx11=yes], [glibcxx_cv_c99_complex_cxx11=no])
1182 ])
1183 fi
1184 if test x"$glibcxx_cv_c99_complex_cxx11" = x"yes"; then
1185 AC_DEFINE(_GLIBCXX11_USE_C99_COMPLEX, 1,
1186 [Define if C99 functions in <complex.h> should be used in
1187 <complex> for C++11. Using compiler builtins for these functions
1188 requires corresponding C99 library functions to be present.])
1189 fi
1191 # Check for the existence in <stdio.h> of vscanf, et. al.
1192 AC_CACHE_CHECK([for ISO C99 support in <stdio.h> for C++11],
1193 glibcxx_cv_c99_stdio_cxx11, [
1194 GCC_TRY_COMPILE_OR_LINK(
1195 [#include <stdio.h>
1196 #include <stdarg.h>
1197 void foo(char* fmt, ...)
1198 {
1199 va_list args; va_start(args, fmt);
1200 vfscanf(stderr, "%i", args);
1201 vscanf("%i", args);
1202 vsnprintf(fmt, 0, "%i", args);
1203 vsscanf(fmt, "%i", args);
1204 snprintf(fmt, 0, "%i");
1205 }], [],
1206 [glibcxx_cv_c99_stdio_cxx11=yes], [glibcxx_cv_c99_stdio_cxx11=no])
1207 ])
1208 if test x"$glibcxx_cv_c99_stdio_cxx11" = x"yes"; then
1209 AC_DEFINE(_GLIBCXX11_USE_C99_STDIO, 1,
1210 [Define if C99 functions or macros in <stdio.h> should be imported
1211 in <cstdio> in namespace std for C++11.])
1212 fi
1214 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1215 AC_CACHE_CHECK([for ISO C99 support in <stdlib.h> for C++11],
1216 glibcxx_cv_c99_stdlib_cxx11, [
1217 GCC_TRY_COMPILE_OR_LINK(
1218 [#include <stdlib.h>
1219 volatile float f;
1220 volatile long double ld;
1221 volatile unsigned long long ll;
1222 lldiv_t mydivt;],
1223 [char* tmp;
1224 f = strtof("gnu", &tmp);
1225 ld = strtold("gnu", &tmp);
1226 ll = strtoll("gnu", &tmp, 10);
1227 ll = strtoull("gnu", &tmp, 10);
1228 ll = llabs(10);
1229 mydivt = lldiv(10,1);
1230 ll = mydivt.quot;
1231 ll = mydivt.rem;
1232 ll = atoll("10");
1233 _Exit(0);
1234 ], [glibcxx_cv_c99_stdlib_cxx11=yes], [glibcxx_cv_c99_stdlib_cxx11=no])
1235 ])
1236 if test x"$glibcxx_cv_c99_stdlib_cxx11" = x"yes"; then
1237 AC_DEFINE(_GLIBCXX11_USE_C99_STDLIB, 1,
1238 [Define if C99 functions or macros in <stdlib.h> should be imported
1239 in <cstdlib> in namespace std for C++11.])
1240 fi
1242 # Check for the existence in <wchar.h> of wcstold, etc.
1243 if test x"$ac_has_wchar_h" = xyes &&
1244 test x"$ac_has_wctype_h" = xyes; then
1245 AC_CACHE_CHECK([for ISO C99 support in <wchar.h> for C++11],
1246 glibcxx_cv_c99_wchar_cxx11, [
1247 AC_TRY_COMPILE([#include <wchar.h>
1248 namespace test
1249 {
1250 using ::wcstold;
1251 using ::wcstoll;
1252 using ::wcstoull;
1253 }
1254 ], [], [glibcxx_cv_c99_wchar_cxx11=yes], [glibcxx_cv_c99_wchar_cxx11=no])
1255 ])
1257 # Checks for wide character functions that may not be present.
1258 # Injection of these is wrapped with guard macros.
1259 # NB: only put functions here, instead of immediately above, if
1260 # absolutely necessary.
1261 AC_TRY_COMPILE([#include <wchar.h>
1262 namespace test { using ::vfwscanf; }], [],
1263 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1265 AC_TRY_COMPILE([#include <wchar.h>
1266 namespace test { using ::vswscanf; }], [],
1267 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1269 AC_TRY_COMPILE([#include <wchar.h>
1270 namespace test { using ::vwscanf; }], [],
1271 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1273 AC_TRY_COMPILE([#include <wchar.h>
1274 namespace test { using ::wcstof; }], [],
1275 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1277 AC_TRY_COMPILE([#include <wctype.h>],
1278 [wint_t t; int i = iswblank(t);],
1279 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1281 if test x"$glibcxx_cv_c99_wchar_cxx11" = x"yes"; then
1282 AC_DEFINE(_GLIBCXX11_USE_C99_WCHAR, 1,
1283 [Define if C99 functions or macros in <wchar.h> should be imported
1284 in <cwchar> in namespace std for C++11.])
1285 fi
1286 fi
1288 gcc_no_link="$ac_save_gcc_no_link"
1289 LIBS="$ac_save_LIBS"
1290 CXXFLAGS="$ac_save_CXXFLAGS"
1291 AC_LANG_RESTORE
1292 fi
1294 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1295 AC_MSG_RESULT($enable_c99)
1296 ])
1299 dnl
1300 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1301 dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this]
1302 dnl in the C++11 standard.
1303 dnl
1304 dnl --enable-libstdcxx-time
1305 dnl --enable-libstdcxx-time=yes
1306 dnl checks for the availability of monotonic and realtime clocks,
1307 dnl nanosleep and sched_yield in libc.
1308 dnl --enable-libstdcxx-time=rt
1309 dnl also searches (and, if needed, links) librt. Note that this is
1310 dnl not always desirable because, in glibc 2.16 and earlier, for
1311 dnl example, in turn it triggers the linking of libpthread too,
1312 dnl which activates locking,
1313 dnl a large overhead for single-thread programs.
1314 dnl --enable-libstdcxx-time=no
1315 dnl --disable-libstdcxx-time
1316 dnl disables the checks completely
1317 dnl
1318 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1319 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1320 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1321 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1322 dnl
1323 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1325 GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]],
1326 [use KIND for check type],
1327 [permit yes|no|rt])
1329 AC_LANG_SAVE
1330 AC_LANG_CPLUSPLUS
1331 ac_save_CXXFLAGS="$CXXFLAGS"
1332 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1333 ac_save_LIBS="$LIBS"
1335 ac_has_clock_monotonic=no
1336 ac_has_clock_realtime=no
1337 ac_has_nanosleep=no
1338 ac_has_sched_yield=no
1340 if test x"$enable_libstdcxx_time" = x"auto"; then
1342 case "${target_os}" in
1343 cygwin*)
1344 ac_has_nanosleep=yes
1345 ;;
1346 darwin*)
1347 ac_has_nanosleep=yes
1348 ac_has_sched_yield=yes
1349 ;;
1350 # VxWorks has nanosleep as soon as the kernel is configured with
1351 # INCLUDE_POSIX_TIMERS, which is normally/most-often the case.
1352 vxworks*)
1353 ac_has_nanosleep=yes
1354 ;;
1355 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
1356 # Don't use link test for freestanding library, in case gcc_no_link=yes
1357 if test x"$is_hosted" = xyes; then
1358 # Versions of glibc before 2.17 needed -lrt for clock_gettime.
1359 AC_SEARCH_LIBS(clock_gettime, [rt])
1360 if test x"$ac_cv_search_clock_gettime" = x"none required"; then
1361 ac_has_clock_monotonic=yes
1362 ac_has_clock_realtime=yes
1363 fi
1364 fi
1365 ac_has_nanosleep=yes
1366 ac_has_sched_yield=yes
1367 ;;
1368 freebsd*|netbsd*|dragonfly*|rtems*)
1369 ac_has_clock_monotonic=yes
1370 ac_has_clock_realtime=yes
1371 ac_has_nanosleep=yes
1372 ac_has_sched_yield=yes
1373 ;;
1374 openbsd*)
1375 ac_has_clock_monotonic=yes
1376 ac_has_clock_realtime=yes
1377 ac_has_nanosleep=yes
1378 ;;
1379 solaris*)
1380 ac_has_clock_monotonic=yes
1381 ac_has_clock_realtime=yes
1382 ac_has_nanosleep=yes
1383 ac_has_sched_yield=yes
1384 ;;
1385 uclinux*)
1386 ac_has_nanosleep=yes
1387 ac_has_sched_yield=yes
1388 esac
1390 elif test x"$enable_libstdcxx_time" != x"no"; then
1392 if test x"$enable_libstdcxx_time" = x"rt"; then
1393 AC_SEARCH_LIBS(clock_gettime, [rt])
1394 AC_SEARCH_LIBS(nanosleep, [rt])
1395 else
1396 AC_CHECK_FUNC(clock_gettime)
1397 AC_CHECK_FUNC(nanosleep)
1398 fi
1400 case "$ac_cv_search_clock_gettime" in
1401 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1402 ;;
1403 esac
1404 case "$ac_cv_search_nanosleep" in
1405 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1406 ;;
1407 esac
1409 AC_SEARCH_LIBS(sched_yield, [rt])
1411 case "$ac_cv_search_sched_yield" in
1412 -lrt*)
1413 if test x"$enable_libstdcxx_time" = x"rt"; then
1414 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1415 ac_has_sched_yield=yes
1416 fi
1417 ;;
1418 *)
1419 ac_has_sched_yield=yes
1420 ;;
1421 esac
1423 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1425 if test x"$ac_has_unistd_h" = x"yes"; then
1426 AC_MSG_CHECKING([for monotonic clock])
1427 AC_TRY_LINK(
1428 [#include <unistd.h>
1429 #include <time.h>
1430 ],
1431 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1432 timespec tp;
1433 #endif
1434 clock_gettime(CLOCK_MONOTONIC, &tp);
1435 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1437 AC_MSG_RESULT($ac_has_clock_monotonic)
1439 AC_MSG_CHECKING([for realtime clock])
1440 AC_TRY_LINK(
1441 [#include <unistd.h>
1442 #include <time.h>
1443 ],
1444 [#if _POSIX_TIMERS > 0
1445 timespec tp;
1446 #endif
1447 clock_gettime(CLOCK_REALTIME, &tp);
1448 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1450 AC_MSG_RESULT($ac_has_clock_realtime)
1452 AC_MSG_CHECKING([for nanosleep])
1453 AC_TRY_LINK(
1454 [#include <unistd.h>
1455 #include <time.h>
1456 ],
1457 [#if _POSIX_TIMERS > 0
1458 timespec tp;
1459 #endif
1460 nanosleep(&tp, 0);
1461 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1463 AC_MSG_RESULT($ac_has_nanosleep)
1464 fi
1465 fi
1467 if test x"$ac_has_clock_monotonic" != x"yes"; then
1468 case ${target_os} in
1469 linux* | uclinux*)
1470 AC_MSG_CHECKING([for clock_gettime syscall])
1471 AC_TRY_COMPILE(
1472 [#include <unistd.h>
1473 #include <time.h>
1474 #include <sys/syscall.h>
1475 ],
1476 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1477 timespec tp;
1478 #endif
1479 syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp);
1480 syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp);
1481 ], [ac_has_clock_gettime_syscall=yes], [ac_has_clock_gettime_syscall=no])
1482 AC_MSG_RESULT($ac_has_clock_gettime_syscall)
1483 if test x"$ac_has_clock_gettime_syscall" = x"yes"; then
1484 AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1,
1485 [Defined if clock_gettime syscall has monotonic and realtime clock support. ])
1486 ac_has_clock_monotonic=yes
1487 ac_has_clock_realtime=yes
1488 AC_MSG_CHECKING([for struct timespec that matches syscall])
1489 AC_TRY_COMPILE(
1490 [#include <time.h>
1491 #include <sys/syscall.h>
1492 ],
1493 [#ifdef SYS_clock_gettime64
1494 #if SYS_clock_gettime64 != SYS_clock_gettime
1495 // We need to use SYS_clock_gettime and libc appears to
1496 // also know about the SYS_clock_gettime64 syscall.
1497 // Check that userspace doesn't use time64 version of timespec.
1498 static_assert(sizeof(timespec::tv_sec) == sizeof(long),
1499 "struct timespec must be compatible with SYS_clock_gettime");
1500 #endif
1501 #endif
1502 ],
1503 [ac_timespec_matches_syscall=yes],
1504 [ac_timespec_matches_syscall=no])
1505 AC_MSG_RESULT($ac_timespec_matches_syscall)
1506 if test x"$ac_timespec_matches_syscall" = no; then
1507 AC_MSG_ERROR([struct timespec is not compatible with SYS_clock_gettime, please report a bug to http://gcc.gnu.org/bugzilla])
1508 fi
1509 fi;;
1510 esac
1511 fi
1513 if test x"$ac_has_clock_monotonic" = x"yes"; then
1514 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1515 [ Defined if clock_gettime has monotonic clock support. ])
1516 fi
1518 if test x"$ac_has_clock_realtime" = x"yes"; then
1519 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1520 [ Defined if clock_gettime has realtime clock support. ])
1521 fi
1523 if test x"$ac_has_sched_yield" = x"yes"; then
1524 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1525 [ Defined if sched_yield is available. ])
1526 fi
1528 if test x"$ac_has_nanosleep" = x"yes"; then
1529 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1530 [ Defined if nanosleep is available. ])
1531 else
1532 AC_MSG_CHECKING([for sleep])
1533 AC_TRY_COMPILE([#include <unistd.h>],
1534 [sleep(1)],
1535 [ac_has_sleep=yes],[ac_has_sleep=no])
1536 if test x"$ac_has_sleep" = x"yes"; then
1537 AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.])
1538 fi
1539 AC_MSG_RESULT($ac_has_sleep)
1540 AC_MSG_CHECKING([for usleep])
1541 AC_TRY_COMPILE([#include <unistd.h>],
1542 [sleep(1);
1543 usleep(100);],
1544 [ac_has_usleep=yes],[ac_has_usleep=no])
1545 if test x"$ac_has_usleep" = x"yes"; then
1546 AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.])
1547 fi
1548 AC_MSG_RESULT($ac_has_usleep)
1549 fi
1551 if test x"$ac_has_nanosleep$ac_has_sleep" = x"nono"; then
1552 ac_no_sleep=yes
1553 AC_MSG_CHECKING([for Sleep])
1554 AC_TRY_COMPILE([#include <windows.h>],
1555 [Sleep(1)],
1556 [ac_has_win32_sleep=yes],[ac_has_win32_sleep=no])
1557 if test x"$ac_has_win32_sleep" = x"yes"; then
1558 AC_DEFINE(HAVE_WIN32_SLEEP,1, [Defined if Sleep exists.])
1559 ac_no_sleep=no
1560 fi
1561 AC_MSG_RESULT($ac_has_win32_sleep)
1562 fi
1564 if test x"$ac_no_sleep" = x"yes"; then
1565 AC_DEFINE(NO_SLEEP,1, [Defined if no way to sleep is available.])
1566 fi
1568 AC_SUBST(GLIBCXX_LIBS)
1570 CXXFLAGS="$ac_save_CXXFLAGS"
1571 LIBS="$ac_save_LIBS"
1572 AC_LANG_RESTORE
1573 ])
1575 dnl
1576 dnl Check for gettimeofday, used in the implementation of 20.11.7
1577 dnl [time.clock] in the C++11 standard.
1578 dnl
1579 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1581 AC_MSG_CHECKING([for gettimeofday])
1583 AC_LANG_SAVE
1584 AC_LANG_CPLUSPLUS
1585 ac_save_CXXFLAGS="$CXXFLAGS"
1586 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1588 ac_has_gettimeofday=no;
1589 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1590 if test x"$ac_has_sys_time_h" = x"yes"; then
1591 AC_MSG_CHECKING([for gettimeofday])
1592 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1593 [timeval tv; gettimeofday(&tv, 0);],
1594 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1596 AC_MSG_RESULT($ac_has_gettimeofday)
1597 fi
1599 if test x"$ac_has_gettimeofday" = x"yes"; then
1600 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1601 [ Defined if gettimeofday is available. ])
1602 fi
1604 CXXFLAGS="$ac_save_CXXFLAGS"
1605 AC_LANG_RESTORE
1606 ])
1608 dnl
1609 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1610 dnl facilities in Chapter 8, "C compatibility".
1611 dnl
1612 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1614 AC_LANG_SAVE
1615 AC_LANG_CPLUSPLUS
1617 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1618 # undefined and fake C99 facilities may be spuriously enabled.
1619 ac_save_CXXFLAGS="$CXXFLAGS"
1620 CXXFLAGS="$CXXFLAGS -std=c++98"
1622 # Check for the existence of <complex.h> complex math functions used
1623 # by tr1/complex.
1624 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1625 ac_c99_complex_tr1=no;
1626 if test x"$ac_has_complex_h" = x"yes"; then
1627 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1628 AC_TRY_COMPILE([#include <complex.h>],
1629 [typedef __complex__ float float_type; float_type tmpf;
1630 cacosf(tmpf);
1631 casinf(tmpf);
1632 catanf(tmpf);
1633 cacoshf(tmpf);
1634 casinhf(tmpf);
1635 catanhf(tmpf);
1636 typedef __complex__ double double_type; double_type tmpd;
1637 cacos(tmpd);
1638 casin(tmpd);
1639 catan(tmpd);
1640 cacosh(tmpd);
1641 casinh(tmpd);
1642 catanh(tmpd);
1643 typedef __complex__ long double ld_type; ld_type tmpld;
1644 cacosl(tmpld);
1645 casinl(tmpld);
1646 catanl(tmpld);
1647 cacoshl(tmpld);
1648 casinhl(tmpld);
1649 catanhl(tmpld);
1650 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1651 fi
1652 AC_MSG_RESULT($ac_c99_complex_tr1)
1653 if test x"$ac_c99_complex_tr1" = x"yes"; then
1654 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1655 [Define if C99 functions in <complex.h> should be used in
1656 <tr1/complex>. Using compiler builtins for these functions
1657 requires corresponding C99 library functions to be present.])
1658 fi
1660 # Check for the existence of <ctype.h> functions.
1661 AC_CACHE_CHECK([for ISO C99 support to TR1 in <ctype.h>],
1662 glibcxx_cv_c99_ctype_tr1, [
1663 AC_TRY_COMPILE([#include <ctype.h>],
1664 [int ch;
1665 int ret;
1666 ret = isblank(ch);
1667 ],[glibcxx_cv_c99_ctype_tr1=yes],
1668 [glibcxx_cv_c99_ctype_tr1=no])
1669 ])
1670 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1671 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1672 [Define if C99 functions in <ctype.h> should be imported in
1673 <tr1/cctype> in namespace std::tr1.])
1674 fi
1676 # Check for the existence of <fenv.h> functions.
1677 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1678 ac_c99_fenv_tr1=no;
1679 if test x"$ac_has_fenv_h" = x"yes"; then
1680 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1681 AC_TRY_COMPILE([#include <fenv.h>],
1682 [int except, mode;
1683 fexcept_t* pflag;
1684 fenv_t* penv;
1685 int ret;
1686 ret = feclearexcept(except);
1687 ret = fegetexceptflag(pflag, except);
1688 ret = feraiseexcept(except);
1689 ret = fesetexceptflag(pflag, except);
1690 ret = fetestexcept(except);
1691 ret = fegetround();
1692 ret = fesetround(mode);
1693 ret = fegetenv(penv);
1694 ret = feholdexcept(penv);
1695 ret = fesetenv(penv);
1696 ret = feupdateenv(penv);
1697 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1698 AC_MSG_RESULT($ac_c99_fenv_tr1)
1699 fi
1700 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1701 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1702 [Define if C99 functions in <fenv.h> should be imported in
1703 <tr1/cfenv> in namespace std::tr1.])
1704 fi
1706 # Check for the existence of <stdint.h> types.
1707 AC_CACHE_CHECK([for ISO C99 support to TR1 in <stdint.h>],
1708 glibcxx_cv_c99_stdint_tr1, [
1709 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1710 #define __STDC_CONSTANT_MACROS
1711 #include <stdint.h>],
1712 [typedef int8_t my_int8_t;
1713 my_int8_t i8 = INT8_MIN;
1714 i8 = INT8_MAX;
1715 typedef int16_t my_int16_t;
1716 my_int16_t i16 = INT16_MIN;
1717 i16 = INT16_MAX;
1718 typedef int32_t my_int32_t;
1719 my_int32_t i32 = INT32_MIN;
1720 i32 = INT32_MAX;
1721 typedef int64_t my_int64_t;
1722 my_int64_t i64 = INT64_MIN;
1723 i64 = INT64_MAX;
1724 typedef int_fast8_t my_int_fast8_t;
1725 my_int_fast8_t if8 = INT_FAST8_MIN;
1726 if8 = INT_FAST8_MAX;
1727 typedef int_fast16_t my_int_fast16_t;
1728 my_int_fast16_t if16 = INT_FAST16_MIN;
1729 if16 = INT_FAST16_MAX;
1730 typedef int_fast32_t my_int_fast32_t;
1731 my_int_fast32_t if32 = INT_FAST32_MIN;
1732 if32 = INT_FAST32_MAX;
1733 typedef int_fast64_t my_int_fast64_t;
1734 my_int_fast64_t if64 = INT_FAST64_MIN;
1735 if64 = INT_FAST64_MAX;
1736 typedef int_least8_t my_int_least8_t;
1737 my_int_least8_t il8 = INT_LEAST8_MIN;
1738 il8 = INT_LEAST8_MAX;
1739 typedef int_least16_t my_int_least16_t;
1740 my_int_least16_t il16 = INT_LEAST16_MIN;
1741 il16 = INT_LEAST16_MAX;
1742 typedef int_least32_t my_int_least32_t;
1743 my_int_least32_t il32 = INT_LEAST32_MIN;
1744 il32 = INT_LEAST32_MAX;
1745 typedef int_least64_t my_int_least64_t;
1746 my_int_least64_t il64 = INT_LEAST64_MIN;
1747 il64 = INT_LEAST64_MAX;
1748 typedef intmax_t my_intmax_t;
1749 my_intmax_t im = INTMAX_MAX;
1750 im = INTMAX_MIN;
1751 typedef intptr_t my_intptr_t;
1752 my_intptr_t ip = INTPTR_MAX;
1753 ip = INTPTR_MIN;
1754 typedef uint8_t my_uint8_t;
1755 my_uint8_t ui8 = UINT8_MAX;
1756 ui8 = UINT8_MAX;
1757 typedef uint16_t my_uint16_t;
1758 my_uint16_t ui16 = UINT16_MAX;
1759 ui16 = UINT16_MAX;
1760 typedef uint32_t my_uint32_t;
1761 my_uint32_t ui32 = UINT32_MAX;
1762 ui32 = UINT32_MAX;
1763 typedef uint64_t my_uint64_t;
1764 my_uint64_t ui64 = UINT64_MAX;
1765 ui64 = UINT64_MAX;
1766 typedef uint_fast8_t my_uint_fast8_t;
1767 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1768 uif8 = UINT_FAST8_MAX;
1769 typedef uint_fast16_t my_uint_fast16_t;
1770 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1771 uif16 = UINT_FAST16_MAX;
1772 typedef uint_fast32_t my_uint_fast32_t;
1773 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1774 uif32 = UINT_FAST32_MAX;
1775 typedef uint_fast64_t my_uint_fast64_t;
1776 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1777 uif64 = UINT_FAST64_MAX;
1778 typedef uint_least8_t my_uint_least8_t;
1779 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1780 uil8 = UINT_LEAST8_MAX;
1781 typedef uint_least16_t my_uint_least16_t;
1782 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1783 uil16 = UINT_LEAST16_MAX;
1784 typedef uint_least32_t my_uint_least32_t;
1785 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1786 uil32 = UINT_LEAST32_MAX;
1787 typedef uint_least64_t my_uint_least64_t;
1788 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1789 uil64 = UINT_LEAST64_MAX;
1790 typedef uintmax_t my_uintmax_t;
1791 my_uintmax_t uim = UINTMAX_MAX;
1792 uim = UINTMAX_MAX;
1793 typedef uintptr_t my_uintptr_t;
1794 my_uintptr_t uip = UINTPTR_MAX;
1795 uip = UINTPTR_MAX;
1796 ],[glibcxx_cv_c99_stdint_tr1=yes],
1797 [glibcxx_cv_c99_stdint_tr1=no])
1798 ])
1799 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1800 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1801 [Define if C99 types in <stdint.h> should be imported in
1802 <tr1/cstdint> in namespace std::tr1.])
1803 fi
1805 # Check for the existence of <math.h> functions.
1806 AC_CACHE_CHECK([for ISO C99 support to TR1 in <math.h>],
1807 glibcxx_cv_c99_math_tr1, [
1808 AC_TRY_COMPILE([#include <math.h>],
1809 [typedef double_t my_double_t;
1810 typedef float_t my_float_t;
1811 acosh(0.0);
1812 acoshf(0.0f);
1813 acoshl(0.0l);
1814 asinh(0.0);
1815 asinhf(0.0f);
1816 asinhl(0.0l);
1817 atanh(0.0);
1818 atanhf(0.0f);
1819 atanhl(0.0l);
1820 cbrt(0.0);
1821 cbrtf(0.0f);
1822 cbrtl(0.0l);
1823 copysign(0.0, 0.0);
1824 copysignf(0.0f, 0.0f);
1825 copysignl(0.0l, 0.0l);
1826 erf(0.0);
1827 erff(0.0f);
1828 erfl(0.0l);
1829 erfc(0.0);
1830 erfcf(0.0f);
1831 erfcl(0.0l);
1832 exp2(0.0);
1833 exp2f(0.0f);
1834 exp2l(0.0l);
1835 expm1(0.0);
1836 expm1f(0.0f);
1837 expm1l(0.0l);
1838 fdim(0.0, 0.0);
1839 fdimf(0.0f, 0.0f);
1840 fdiml(0.0l, 0.0l);
1841 fma(0.0, 0.0, 0.0);
1842 fmaf(0.0f, 0.0f, 0.0f);
1843 fmal(0.0l, 0.0l, 0.0l);
1844 fmax(0.0, 0.0);
1845 fmaxf(0.0f, 0.0f);
1846 fmaxl(0.0l, 0.0l);
1847 fmin(0.0, 0.0);
1848 fminf(0.0f, 0.0f);
1849 fminl(0.0l, 0.0l);
1850 hypot(0.0, 0.0);
1851 hypotf(0.0f, 0.0f);
1852 hypotl(0.0l, 0.0l);
1853 ilogb(0.0);
1854 ilogbf(0.0f);
1855 ilogbl(0.0l);
1856 lgamma(0.0);
1857 lgammaf(0.0f);
1858 lgammal(0.0l);
1859 #ifndef __APPLE__ /* see below */
1860 llrint(0.0);
1861 llrintf(0.0f);
1862 llrintl(0.0l);
1863 llround(0.0);
1864 llroundf(0.0f);
1865 llroundl(0.0l);
1866 #endif
1867 log1p(0.0);
1868 log1pf(0.0f);
1869 log1pl(0.0l);
1870 log2(0.0);
1871 log2f(0.0f);
1872 log2l(0.0l);
1873 logb(0.0);
1874 logbf(0.0f);
1875 logbl(0.0l);
1876 lrint(0.0);
1877 lrintf(0.0f);
1878 lrintl(0.0l);
1879 lround(0.0);
1880 lroundf(0.0f);
1881 lroundl(0.0l);
1882 nan(0);
1883 nanf(0);
1884 nanl(0);
1885 nearbyint(0.0);
1886 nearbyintf(0.0f);
1887 nearbyintl(0.0l);
1888 nextafter(0.0, 0.0);
1889 nextafterf(0.0f, 0.0f);
1890 nextafterl(0.0l, 0.0l);
1891 nexttoward(0.0, 0.0);
1892 nexttowardf(0.0f, 0.0f);
1893 nexttowardl(0.0l, 0.0l);
1894 remainder(0.0, 0.0);
1895 remainderf(0.0f, 0.0f);
1896 remainderl(0.0l, 0.0l);
1897 remquo(0.0, 0.0, 0);
1898 remquof(0.0f, 0.0f, 0);
1899 remquol(0.0l, 0.0l, 0);
1900 rint(0.0);
1901 rintf(0.0f);
1902 rintl(0.0l);
1903 round(0.0);
1904 roundf(0.0f);
1905 roundl(0.0l);
1906 scalbln(0.0, 0l);
1907 scalblnf(0.0f, 0l);
1908 scalblnl(0.0l, 0l);
1909 scalbn(0.0, 0);
1910 scalbnf(0.0f, 0);
1911 scalbnl(0.0l, 0);
1912 tgamma(0.0);
1913 tgammaf(0.0f);
1914 tgammal(0.0l);
1915 trunc(0.0);
1916 truncf(0.0f);
1917 truncl(0.0l);
1918 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1919 ])
1920 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1921 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1922 [Define if C99 functions or macros in <math.h> should be imported
1923 in <tr1/cmath> in namespace std::tr1.])
1925 case "${target_os}" in
1926 darwin*)
1927 AC_CACHE_CHECK([for ISO C99 rounding functions in <math.h>],
1928 glibcxx_cv_c99_math_llround, [
1929 AC_TRY_COMPILE([#include <math.h>],
1930 [llrint(0.0);
1931 llrintf(0.0f);
1932 llrintl(0.0l);
1933 llround(0.0);
1934 llroundf(0.0f);
1935 llroundl(0.0l);
1936 ],
1937 [glibcxx_cv_c99_math_llround=yes],
1938 [glibcxx_cv_c99_math_llround=no])
1939 ])
1940 ;;
1941 esac
1942 if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
1943 AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
1944 [Define if C99 llrint and llround functions are missing from <math.h>.])
1945 fi
1946 fi
1948 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1949 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1950 ac_c99_inttypes_tr1=no;
1951 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1952 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1953 AC_TRY_COMPILE([#include <inttypes.h>],
1954 [intmax_t i, numer, denom, base;
1955 const char* s;
1956 char** endptr;
1957 intmax_t ret = imaxabs(i);
1958 imaxdiv_t dret = imaxdiv(numer, denom);
1959 ret = strtoimax(s, endptr, base);
1960 uintmax_t uret = strtoumax(s, endptr, base);
1961 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1962 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1963 fi
1964 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1965 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1966 [Define if C99 functions in <inttypes.h> should be imported in
1967 <tr1/cinttypes> in namespace std::tr1.])
1968 fi
1970 # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
1971 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1972 ac_c99_inttypes_wchar_t_tr1=no;
1973 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1974 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1975 AC_TRY_COMPILE([#include <inttypes.h>],
1976 [intmax_t base;
1977 const wchar_t* s;
1978 wchar_t** endptr;
1979 intmax_t ret = wcstoimax(s, endptr, base);
1980 uintmax_t uret = wcstoumax(s, endptr, base);
1981 ],[ac_c99_inttypes_wchar_t_tr1=yes],
1982 [ac_c99_inttypes_wchar_t_tr1=no])
1983 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1984 fi
1985 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1986 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1987 [Define if wchar_t C99 functions in <inttypes.h> should be
1988 imported in <tr1/cinttypes> in namespace std::tr1.])
1989 fi
1991 # Check for the existence of the <stdbool.h> header.
1992 AC_CHECK_HEADERS(stdbool.h)
1994 # Check for the existence of the <stdalign.h> header.
1995 AC_CHECK_HEADERS(stdalign.h)
1997 CXXFLAGS="$ac_save_CXXFLAGS"
1998 AC_LANG_RESTORE
1999 ])
2001 dnl
2002 dnl Check for uchar.h and usability.
2003 dnl
2004 AC_DEFUN([GLIBCXX_CHECK_UCHAR_H], [
2006 # Test uchar.h.
2007 AC_CHECK_HEADERS(uchar.h, ac_has_uchar_h=yes, ac_has_uchar_h=no)
2009 AC_LANG_SAVE
2010 AC_LANG_CPLUSPLUS
2011 ac_save_CXXFLAGS="$CXXFLAGS"
2012 CXXFLAGS="$CXXFLAGS -std=c++11"
2014 if test x"$ac_has_uchar_h" = x"yes"; then
2015 AC_MSG_CHECKING([for ISO C11 support for <uchar.h>])
2016 AC_TRY_COMPILE([#include <uchar.h>
2017 #ifdef __STDC_UTF_16__
2018 long i = __STDC_UTF_16__;
2019 #endif
2020 #ifdef __STDC_UTF_32__
2021 long j = __STDC_UTF_32__;
2022 #endif
2023 namespace test
2024 {
2025 using ::c16rtomb;
2026 using ::c32rtomb;
2027 using ::mbrtoc16;
2028 using ::mbrtoc32;
2029 }
2030 ],
2031 [], [ac_c11_uchar_cxx11=yes], [ac_c11_uchar_cxx11=no])
2032 AC_MSG_RESULT($ac_c11_uchar_cxx11)
2033 else
2034 ac_c11_uchar_cxx11=no
2035 fi
2036 if test x"$ac_c11_uchar_cxx11" = x"yes"; then
2037 AC_DEFINE(_GLIBCXX_USE_C11_UCHAR_CXX11, 1,
2038 [Define if C11 functions in <uchar.h> should be imported into
2039 namespace std in <cuchar>.])
2040 fi
2042 CXXFLAGS="$ac_save_CXXFLAGS"
2043 AC_LANG_RESTORE
2044 ])
2047 dnl
2048 dnl Check whether "/dev/random" and "/dev/urandom" are available for
2049 dnl class std::random_device from C++ 2011 [rand.device], and
2050 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
2051 dnl
2052 AC_DEFUN([GLIBCXX_CHECK_DEV_RANDOM], [
2054 AC_CACHE_CHECK([for "/dev/random" and "/dev/urandom" for std::random_device],
2055 glibcxx_cv_dev_random, [
2056 if test -r /dev/random && test -r /dev/urandom; then
2057 ## For MSys environment the test above is detected as false-positive
2058 ## on mingw-targets. So disable it explicitly for them.
2059 case ${target_os} in
2060 *mingw*) glibcxx_cv_dev_random=no ;;
2061 *) glibcxx_cv_dev_random=yes ;;
2062 esac
2063 else
2064 glibcxx_cv_dev_random=no;
2065 fi
2066 ])
2068 if test x"$glibcxx_cv_dev_random" = x"yes"; then
2069 AC_DEFINE(_GLIBCXX_USE_DEV_RANDOM, 1,
2070 [Define if /dev/random and /dev/urandom are available for
2071 std::random_device.])
2072 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
2073 [Define if /dev/random and /dev/urandom are available for
2074 the random_device of TR1 (Chapter 5.1).])
2075 fi
2077 ])
2079 dnl
2080 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
2081 dnl
2082 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
2084 AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
2085 AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
2086 [#include <stdio.h>],
2087 [AC_MSG_ERROR([computing EOF failed])])
2088 ])
2089 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
2090 [Define to the value of the EOF integer constant.])
2092 AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
2093 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
2094 [#include <stdio.h>],
2095 [AC_MSG_ERROR([computing SEEK_CUR failed])])
2096 ])
2097 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
2098 [Define to the value of the SEEK_CUR integer constant.])
2100 AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
2101 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
2102 [#include <stdio.h>],
2103 [AC_MSG_ERROR([computing SEEK_END failed])])
2104 ])
2105 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
2106 [Define to the value of the SEEK_END integer constant.])
2107 ])
2109 dnl
2110 dnl Check whether required C++ overloads are present in <stdio.h>.
2111 dnl
2112 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
2114 AC_LANG_SAVE
2115 AC_LANG_CPLUSPLUS
2116 # Use C++11 because a conforming <stdio.h> won't define gets for C++14,
2117 # and we don't need a declaration for C++14 anyway.
2118 ac_save_CXXFLAGS="$CXXFLAGS"
2119 CXXFLAGS="$CXXFLAGS -std=gnu++11"
2121 AC_CACHE_CHECK([for gets declaration], glibcxx_cv_gets, [
2122 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2123 [#include <stdio.h>
2124 namespace test
2125 {
2126 using ::gets;
2127 }
2128 ])],
2129 [glibcxx_cv_gets=yes],
2130 [glibcxx_cv_gets=no]
2131 )])
2133 if test $glibcxx_cv_gets = yes; then
2134 AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h> before C++14.])
2135 fi
2137 CXXFLAGS="$ac_save_CXXFLAGS"
2138 AC_LANG_RESTORE
2139 ])
2141 dnl
2142 dnl Check whether required C++11 overloads for floating point and integral
2143 dnl types are present in <math.h>.
2144 dnl
2145 AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
2147 AC_LANG_SAVE
2148 AC_LANG_CPLUSPLUS
2149 ac_save_CXXFLAGS="$CXXFLAGS"
2150 CXXFLAGS="$CXXFLAGS -std=c++11"
2152 case "$host" in
2153 *-*-solaris2.*)
2154 # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
2155 # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
2156 AC_CACHE_CHECK([for C++11 <math.h> floating point overloads],
2157 glibcxx_cv_math11_fp_overload, [
2158 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2159 [#include <math.h>
2160 #undef isfinite
2161 namespace std {
2162 inline bool isfinite(float __x)
2163 { return __builtin_isfinite(__x); }
2164 }
2165 ])],
2166 [glibcxx_cv_math11_fp_overload=no],
2167 [glibcxx_cv_math11_fp_overload=yes]
2168 )])
2170 # autoheader cannot handle indented templates.
2171 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP],
2172 [/* Define if all C++11 floating point overloads are available in <math.h>. */
2173 #if __cplusplus >= 201103L
2174 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2175 #endif])
2177 if test $glibcxx_cv_math11_fp_overload = yes; then
2178 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP)
2179 fi
2181 # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
2182 # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
2183 AC_CACHE_CHECK([for C++11 <math.h> integral type overloads],
2184 glibcxx_cv_math11_int_overload, [
2185 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2186 [#include <math.h>
2187 namespace std {
2188 template<typename _Tp>
2189 struct __is_integer;
2190 template<>
2191 struct __is_integer<int>
2192 {
2193 enum { __value = 1 };
2194 };
2195 }
2196 namespace __gnu_cxx {
2197 template<bool, typename>
2198 struct __enable_if;
2199 template<typename _Tp>
2200 struct __enable_if<true, _Tp>
2201 { typedef _Tp __type; };
2202 }
2203 namespace std {
2204 template<typename _Tp>
2205 constexpr typename __gnu_cxx::__enable_if
2206 <__is_integer<_Tp>::__value, double>::__type
2207 log2(_Tp __x)
2208 { return __builtin_log2(__x); }
2209 }
2210 int
2211 main (void)
2212 {
2213 int i = 1000;
2214 return std::log2(i);
2215 }
2216 ])],
2217 [glibcxx_cv_math11_int_overload=no],
2218 [glibcxx_cv_math11_int_overload=yes]
2219 )])
2221 # autoheader cannot handle indented templates.
2222 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT],
2223 [/* Define if all C++11 integral type overloads are available in <math.h>. */
2224 #if __cplusplus >= 201103L
2225 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2226 #endif])
2228 if test $glibcxx_cv_math11_int_overload = yes; then
2229 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT)
2230 fi
2231 ;;
2232 *)
2233 # If <math.h> defines the obsolete isinf(double) and isnan(double)
2234 # functions (instead of or as well as the C99 generic macros) then we
2235 # can't define std::isinf(double) and std::isnan(double) in <cmath>
2236 # and must use the ones from <math.h> instead.
2237 AC_CACHE_CHECK([for obsolete isinf function in <math.h>],
2238 glibcxx_cv_obsolete_isinf, [
2239 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2240 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2241 #include <math.h>
2242 #undef isinf
2243 namespace std {
2244 using ::isinf;
2245 bool isinf(float);
2246 bool isinf(long double);
2247 }
2248 using std::isinf;
2249 bool b = isinf(0.0);
2250 ])],
2251 [glibcxx_cv_obsolete_isinf=yes],
2252 [glibcxx_cv_obsolete_isinf=no]
2253 )])
2254 if test $glibcxx_cv_obsolete_isinf = yes; then
2255 AC_DEFINE(HAVE_OBSOLETE_ISINF, 1,
2256 [Define if <math.h> defines obsolete isinf function.])
2257 fi
2259 AC_CACHE_CHECK([for obsolete isnan function in <math.h>],
2260 glibcxx_cv_obsolete_isnan, [
2261 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2262 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2263 #include <math.h>
2264 #undef isnan
2265 namespace std {
2266 using ::isnan;
2267 bool isnan(float);
2268 bool isnan(long double);
2269 }
2270 using std::isnan;
2271 bool b = isnan(0.0);
2272 ])],
2273 [glibcxx_cv_obsolete_isnan=yes],
2274 [glibcxx_cv_obsolete_isnan=no]
2275 )])
2276 if test $glibcxx_cv_obsolete_isnan = yes; then
2277 AC_DEFINE(HAVE_OBSOLETE_ISNAN, 1,
2278 [Define if <math.h> defines obsolete isnan function.])
2279 fi
2280 ;;
2281 esac
2283 CXXFLAGS="$ac_save_CXXFLAGS"
2284 AC_LANG_RESTORE
2285 ])
2287 dnl
2288 dnl Check for what type of C headers to use.
2289 dnl
2290 dnl --enable-cheaders= [does stuff].
2291 dnl --disable-cheaders [does not do anything, really].
2292 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
2293 dnl Where DEFAULT is either 'c' or 'c_global' or 'c_std'.
2294 dnl
2295 dnl To use the obsolete 'c_std' headers use --enable-cheaders-obsolete as
2296 dnl well as --enable-cheaders=c_std, otherwise configure will fail.
2297 dnl
2298 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
2299 GLIBCXX_ENABLE(cheaders-obsolete,no,,
2300 [allow use of obsolete "C" headers for g++])
2301 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
2302 [construct "C" headers for g++], [permit c|c_global|c_std])
2303 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
2304 if test $enable_cheaders = c_std ; then
2305 AC_MSG_WARN([the --enable-cheaders=c_std configuration is obsolete, c_global should be used instead])
2306 AC_MSG_WARN([if you are unable to use c_global please report a bug or inform libstdc++@gcc.gnu.org])
2307 if test $enable_cheaders_obsolete != yes ; then
2308 AC_MSG_ERROR(use --enable-cheaders-obsolete to use c_std "C" headers)
2309 fi
2310 fi
2312 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
2314 # Allow overrides to configure.host here.
2315 if test $enable_cheaders = c_global; then
2316 c_compatibility=yes
2317 fi
2319 AC_SUBST(C_INCLUDE_DIR)
2320 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
2321 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
2322 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
2323 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
2324 ])
2327 dnl
2328 dnl Check for which locale library to use. The choice is mapped to
2329 dnl a subdirectory of config/locale.
2330 dnl
2331 dnl Default is generic.
2332 dnl
2333 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
2334 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
2335 [use MODEL for target locale package],
2336 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
2338 # Deal with gettext issues. Default to not using it (=no) until we detect
2339 # support for it later. Let the user turn it off via --e/d, but let that
2340 # default to on for easier handling.
2341 USE_NLS=no
2342 AC_ARG_ENABLE(nls,
2343 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
2344 [],
2345 [enable_nls=yes])
2347 # Either a known package, or "auto"
2348 if test $enable_clocale = no || test $enable_clocale = yes; then
2349 enable_clocale=auto
2350 fi
2351 enable_clocale_flag=$enable_clocale
2353 # Probe for locale model to use if none specified.
2354 # Default to "generic".
2355 if test $enable_clocale_flag = auto; then
2356 case ${target_os} in
2357 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2358 enable_clocale_flag=gnu
2359 ;;
2360 darwin*)
2361 enable_clocale_flag=darwin
2362 ;;
2363 vxworks*)
2364 enable_clocale_flag=vxworks
2365 ;;
2366 dragonfly* | freebsd*)
2367 enable_clocale_flag=dragonfly
2368 ;;
2369 openbsd*)
2370 enable_clocale_flag=newlib
2371 ;;
2372 *)
2373 if test x"$with_newlib" = x"yes"; then
2374 enable_clocale_flag=newlib
2375 else
2376 enable_clocale_flag=generic
2377 fi
2378 ;;
2379 esac
2380 fi
2382 # Sanity check model, and test for special functionality.
2383 if test $enable_clocale_flag = gnu; then
2384 AC_EGREP_CPP([_GLIBCXX_ok], [
2385 #include <features.h>
2386 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
2387 _GLIBCXX_ok
2388 #endif
2389 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
2391 # Set it to scream when it hurts.
2392 ac_save_CFLAGS="$CFLAGS"
2393 CFLAGS="-Wimplicit-function-declaration -Werror"
2395 # Use strxfrm_l if available.
2396 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2397 #include <string.h>
2398 #include <locale.h>],
2399 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
2400 AC_DEFINE(HAVE_STRXFRM_L, 1,
2401 [Define if strxfrm_l is available in <string.h>.]),)
2403 # Use strerror_l if available.
2404 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2405 #include <string.h>
2406 #include <locale.h>],
2407 [__locale_t loc; strerror_l(5, loc);],
2408 AC_DEFINE(HAVE_STRERROR_L, 1,
2409 [Define if strerror_l is available in <string.h>.]),)
2411 CFLAGS="$ac_save_CFLAGS"
2412 fi
2414 # Perhaps use strerror_r if available, and strerror_l isn't.
2415 ac_save_CFLAGS="$CFLAGS"
2416 CFLAGS="-Wimplicit-function-declaration -Werror"
2417 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2418 #include <string.h>
2419 #include <locale.h>],
2420 [char s[128]; strerror_r(5, s, 128);],
2421 AC_DEFINE(HAVE_STRERROR_R, 1,
2422 [Define if strerror_r is available in <string.h>.]),)
2423 CFLAGS="$ac_save_CFLAGS"
2425 # Set configure bits for specified locale package
2426 AC_MSG_CHECKING([for C locale to use])
2427 case ${enable_clocale_flag} in
2428 generic)
2429 AC_MSG_RESULT(generic)
2431 CLOCALE_H=config/locale/generic/c_locale.h
2432 CLOCALE_CC=config/locale/generic/c_locale.cc
2433 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2434 CCOLLATE_CC=config/locale/generic/collate_members.cc
2435 CCTYPE_CC=config/locale/generic/ctype_members.cc
2436 CMESSAGES_H=config/locale/generic/messages_members.h
2437 CMESSAGES_CC=config/locale/generic/messages_members.cc
2438 CMONEY_CC=config/locale/generic/monetary_members.cc
2439 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2440 CTIME_H=config/locale/generic/time_members.h
2441 CTIME_CC=config/locale/generic/time_members.cc
2442 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2443 ;;
2444 darwin)
2445 AC_MSG_RESULT(darwin)
2447 CLOCALE_H=config/locale/generic/c_locale.h
2448 CLOCALE_CC=config/locale/generic/c_locale.cc
2449 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2450 CCOLLATE_CC=config/locale/generic/collate_members.cc
2451 CCTYPE_CC=config/locale/darwin/ctype_members.cc
2452 CMESSAGES_H=config/locale/generic/messages_members.h
2453 CMESSAGES_CC=config/locale/generic/messages_members.cc
2454 CMONEY_CC=config/locale/generic/monetary_members.cc
2455 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2456 CTIME_H=config/locale/generic/time_members.h
2457 CTIME_CC=config/locale/generic/time_members.cc
2458 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2459 ;;
2460 vxworks)
2461 AC_MSG_RESULT(vxworks)
2463 CLOCALE_H=config/locale/generic/c_locale.h
2464 CLOCALE_CC=config/locale/generic/c_locale.cc
2465 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2466 CCOLLATE_CC=config/locale/generic/collate_members.cc
2467 CCTYPE_CC=config/locale/vxworks/ctype_members.cc
2468 CMESSAGES_H=config/locale/generic/messages_members.h
2469 CMESSAGES_CC=config/locale/generic/messages_members.cc
2470 CMONEY_CC=config/locale/generic/monetary_members.cc
2471 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2472 CTIME_H=config/locale/generic/time_members.h
2473 CTIME_CC=config/locale/generic/time_members.cc
2474 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2475 ;;
2476 dragonfly)
2477 AC_MSG_RESULT(dragonfly or freebsd)
2479 CLOCALE_H=config/locale/dragonfly/c_locale.h
2480 CLOCALE_CC=config/locale/dragonfly/c_locale.cc
2481 CCODECVT_CC=config/locale/dragonfly/codecvt_members.cc
2482 CCOLLATE_CC=config/locale/dragonfly/collate_members.cc
2483 CCTYPE_CC=config/locale/dragonfly/ctype_members.cc
2484 CMESSAGES_H=config/locale/generic/messages_members.h
2485 CMESSAGES_CC=config/locale/generic/messages_members.cc
2486 CMONEY_CC=config/locale/dragonfly/monetary_members.cc
2487 CNUMERIC_CC=config/locale/dragonfly/numeric_members.cc
2488 CTIME_H=config/locale/dragonfly/time_members.h
2489 CTIME_CC=config/locale/dragonfly/time_members.cc
2490 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2491 ;;
2493 gnu)
2494 AC_MSG_RESULT(gnu)
2496 # Declare intention to use gettext, and add support for specific
2497 # languages.
2498 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2499 ALL_LINGUAS="de fr"
2501 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2502 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2503 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2504 USE_NLS=yes
2505 fi
2506 # Export the build objects.
2507 for ling in $ALL_LINGUAS; do \
2508 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2509 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2510 done
2511 AC_SUBST(glibcxx_MOFILES)
2512 AC_SUBST(glibcxx_POFILES)
2514 CLOCALE_H=config/locale/gnu/c_locale.h
2515 CLOCALE_CC=config/locale/gnu/c_locale.cc
2516 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2517 CCOLLATE_CC=config/locale/gnu/collate_members.cc
2518 CCTYPE_CC=config/locale/gnu/ctype_members.cc
2519 CMESSAGES_H=config/locale/gnu/messages_members.h
2520 CMESSAGES_CC=config/locale/gnu/messages_members.cc
2521 CMONEY_CC=config/locale/gnu/monetary_members.cc
2522 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2523 CTIME_H=config/locale/gnu/time_members.h
2524 CTIME_CC=config/locale/gnu/time_members.cc
2525 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2526 ;;
2527 ieee_1003.1-2001)
2528 AC_MSG_RESULT(IEEE 1003.1)
2530 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2531 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2532 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2533 CCOLLATE_CC=config/locale/generic/collate_members.cc
2534 CCTYPE_CC=config/locale/generic/ctype_members.cc
2535 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2536 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2537 CMONEY_CC=config/locale/generic/monetary_members.cc
2538 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2539 CTIME_H=config/locale/generic/time_members.h
2540 CTIME_CC=config/locale/generic/time_members.cc
2541 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2542 ;;
2543 newlib)
2544 AC_MSG_RESULT(newlib)
2546 CLOCALE_H=config/locale/generic/c_locale.h
2547 CLOCALE_CC=config/locale/generic/c_locale.cc
2548 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2549 CCOLLATE_CC=config/locale/generic/collate_members.cc
2550 CCTYPE_CC=config/locale/newlib/ctype_members.cc
2551 CMESSAGES_H=config/locale/generic/messages_members.h
2552 CMESSAGES_CC=config/locale/generic/messages_members.cc
2553 CMONEY_CC=config/locale/generic/monetary_members.cc
2554 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2555 CTIME_H=config/locale/generic/time_members.h
2556 CTIME_CC=config/locale/generic/time_members.cc
2557 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2558 ;;
2559 esac
2561 # This is where the testsuite looks for locale catalogs, using the
2562 # -DLOCALEDIR define during testsuite compilation.
2563 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2564 AC_SUBST(glibcxx_localedir)
2566 # A standalone libintl (e.g., GNU libintl) may be in use.
2567 if test $USE_NLS = yes; then
2568 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2569 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2570 fi
2571 if test $USE_NLS = yes; then
2572 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2573 [Define if NLS translations are to be used.])
2574 fi
2576 AC_SUBST(USE_NLS)
2577 AC_SUBST(CLOCALE_H)
2578 AC_SUBST(CMESSAGES_H)
2579 AC_SUBST(CCODECVT_CC)
2580 AC_SUBST(CCOLLATE_CC)
2581 AC_SUBST(CCTYPE_CC)
2582 AC_SUBST(CMESSAGES_CC)
2583 AC_SUBST(CMONEY_CC)
2584 AC_SUBST(CNUMERIC_CC)
2585 AC_SUBST(CTIME_H)
2586 AC_SUBST(CTIME_CC)
2587 AC_SUBST(CLOCALE_CC)
2588 AC_SUBST(CLOCALE_INTERNAL_H)
2589 ])
2592 dnl
2593 dnl Check for which std::allocator base class to use. The choice is
2594 dnl mapped from a subdirectory of include/ext.
2595 dnl
2596 dnl Default is new.
2597 dnl
2598 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2599 AC_MSG_CHECKING([for std::allocator base class])
2600 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2601 [use KIND for target std::allocator base],
2602 [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2604 # If they didn't use this option switch, or if they specified --enable
2605 # with no specific model, we'll have to look for one. If they
2606 # specified --disable (???), do likewise.
2607 if test $enable_libstdcxx_allocator = no ||
2608 test $enable_libstdcxx_allocator = yes;
2609 then
2610 enable_libstdcxx_allocator=auto
2611 fi
2613 # Either a known package, or "auto". Auto implies the default choice
2614 # for a particular platform.
2615 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2617 # Probe for host-specific support if no specific model is specified.
2618 # Default to "new".
2619 if test $enable_libstdcxx_allocator_flag = auto; then
2620 case ${target_os} in
2621 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2622 enable_libstdcxx_allocator_flag=new
2623 ;;
2624 *)
2625 enable_libstdcxx_allocator_flag=new
2626 ;;
2627 esac
2628 fi
2629 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2632 # Set configure bits for specified locale package
2633 case ${enable_libstdcxx_allocator_flag} in
2634 bitmap)
2635 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2636 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2637 ;;
2638 malloc)
2639 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2640 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2641 ;;
2642 mt)
2643 ALLOCATOR_H=config/allocator/mt_allocator_base.h
2644 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2645 ;;
2646 new)
2647 ALLOCATOR_H=config/allocator/new_allocator_base.h
2648 ALLOCATOR_NAME=__gnu_cxx::new_allocator
2649 ;;
2650 pool)
2651 ALLOCATOR_H=config/allocator/pool_allocator_base.h
2652 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2653 ;;
2654 esac
2656 GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
2657 test $enable_libstdcxx_allocator_flag = new)
2658 AC_SUBST(ALLOCATOR_H)
2659 AC_SUBST(ALLOCATOR_NAME)
2660 ])
2663 dnl
2664 dnl Check for whether the Boost-derived checks should be turned on.
2665 dnl
2666 dnl --enable-concept-checks turns them on.
2667 dnl --disable-concept-checks leaves them off.
2668 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2669 dnl Where DEFAULT is either `yes' or `no'.
2670 dnl
2671 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2672 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2673 if test $enable_concept_checks = yes; then
2674 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2675 [Define to use concept checking code from the boost libraries.])
2676 fi
2677 ])
2679 dnl
2680 dnl Use extern templates.
2681 dnl
2682 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2683 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2685 dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2686 dnl Where DEFAULT is `yes' or `no'.
2687 dnl
2688 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2690 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2692 AC_MSG_CHECKING([for extern template support])
2693 AC_MSG_RESULT([$enable_extern_template])
2695 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2696 ])
2698 dnl
2699 dnl Use vtable verification.
2700 dnl
2701 dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1
2702 dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0
2704 dnl + Usage: GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)]
2705 dnl Where DEFAULT is `yes' or `no'.
2706 dnl
2707 AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [
2709 GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify])
2711 AC_MSG_CHECKING([for vtable verify support])
2712 AC_MSG_RESULT([$enable_vtable_verify])
2714 vtv_cygmin=no
2715 if test $enable_vtable_verify = yes; then
2716 case ${target_os} in
2717 cygwin*|mingw32*)
2718 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2719 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2720 vtv_cygmin=yes
2721 ;;
2722 darwin*)
2723 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u,_vtable_map_vars_start -Wl,-u,_vtable_map_vars_end"
2724 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-rpath,${toplevel_builddir}/libvtv/.libs"
2725 ;;
2726 solaris2*)
2727 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2728 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-R -Wl,${toplevel_builddir}/libvtv/.libs"
2729 ;;
2730 *)
2731 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2732 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2733 ;;
2734 esac
2735 VTV_PCH_CXXFLAGS="-fvtable-verify=std"
2736 else
2737 VTV_CXXFLAGS=
2738 VTV_PCH_CXXFLAGS=
2739 VTV_CXXLINKFLAGS=
2740 fi
2742 AC_SUBST(VTV_CXXFLAGS)
2743 AC_SUBST(VTV_PCH_CXXFLAGS)
2744 AC_SUBST(VTV_CXXLINKFLAGS)
2745 AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes)
2746 GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes)
2747 ])
2749 dnl
2750 dnl Check for parallel mode pre-requisites, including OpenMP support.
2751 dnl
2752 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
2753 dnl
2754 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2756 enable_parallel=no;
2758 # See if configured libgomp/omp.h exists. (libgomp may be in
2759 # noconfigdirs but not explicitly disabled.)
2760 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2761 enable_parallel=yes;
2762 else
2763 AC_MSG_NOTICE([target-libgomp not built])
2764 fi
2766 AC_MSG_CHECKING([for parallel mode support])
2767 AC_MSG_RESULT([$enable_parallel])
2768 ])
2771 dnl
2772 dnl Check for which I/O library to use: stdio and POSIX, or pure stdio.
2773 dnl
2774 dnl Default is stdio_posix.
2775 dnl
2776 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2777 AC_MSG_CHECKING([for underlying I/O to use])
2778 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2779 [use target-specific I/O package], [permit stdio|stdio_posix|stdio_pure])
2781 # The only available I/O model is based on stdio, via basic_file_stdio.
2782 # The default "stdio" is actually "stdio + POSIX" because it uses fdopen(3)
2783 # to get a file descriptor and then uses read(3) and write(3) with it.
2784 # The "stdio_pure" model doesn't use fdopen and only uses FILE* for I/O.
2785 case ${enable_cstdio} in
2786 stdio*)
2787 CSTDIO_H=config/io/c_io_stdio.h
2788 BASIC_FILE_H=config/io/basic_file_stdio.h
2789 BASIC_FILE_CC=config/io/basic_file_stdio.cc
2790 AC_MSG_RESULT(stdio)
2792 if test "x$enable_cstdio" = "xstdio_pure" ; then
2793 AC_DEFINE(_GLIBCXX_USE_STDIO_PURE, 1,
2794 [Define to restrict std::__basic_file<> to stdio APIs.])
2795 fi
2796 ;;
2797 esac
2799 AC_SUBST(CSTDIO_H)
2800 AC_SUBST(BASIC_FILE_H)
2801 AC_SUBST(BASIC_FILE_CC)
2802 ])
2805 dnl
2806 dnl Check for "unusual" flags to pass to the compiler while building.
2807 dnl
2808 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2809 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2810 dnl --disable-cxx-flags passes nothing.
2811 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2812 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2813 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2814 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2815 dnl If "default flags" is an empty string, the effect is the same
2816 dnl as --disable or --enable=no.
2817 dnl
2818 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2819 AC_MSG_CHECKING([for extra compiler flags for building])
2820 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2821 [pass compiler FLAGS when building library],
2822 [case "x$enable_cxx_flags" in
2823 xno | x) enable_cxx_flags= ;;
2824 x-*) ;;
2825 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2826 esac])
2828 # Run through flags (either default or command-line) and set anything
2829 # extra (e.g., #defines) that must accompany particular g++ options.
2830 if test -n "$enable_cxx_flags"; then
2831 for f in $enable_cxx_flags; do
2832 case "$f" in
2833 -fhonor-std) ;;
2834 -*) ;;
2835 *) # and we're trying to pass /what/ exactly?
2836 AC_MSG_ERROR([compiler flags start with a -]) ;;
2837 esac
2838 done
2839 fi
2841 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2842 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2843 AC_SUBST(EXTRA_CXX_FLAGS)
2844 ])
2847 dnl
2848 dnl Check to see if debugging libraries are to be built.
2849 dnl
2850 dnl --enable-libstdcxx-debug
2851 dnl builds a separate set of debugging libraries in addition to the
2852 dnl normal (shared, static) libstdc++ binaries.
2853 dnl
2854 dnl --disable-libstdcxx-debug
2855 dnl builds only one (non-debug) version of libstdc++.
2856 dnl
2857 dnl --enable-libstdcxx-debug-flags=FLAGS
2858 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2859 dnl
2860 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2861 dnl Where DEFAULT is either `yes' or `no'.
2862 dnl
2863 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2864 AC_MSG_CHECKING([for additional debug build])
2865 skip_debug_build=
2866 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2867 if test x$enable_libstdcxx_debug = xyes; then
2868 if test -f $toplevel_builddir/../stage_final \
2869 && test -f $toplevel_builddir/../stage_current; then
2870 stage_final=`cat $toplevel_builddir/../stage_final`
2871 stage_current=`cat $toplevel_builddir/../stage_current`
2872 if test x$stage_current != x$stage_final ; then
2873 skip_debug_build=" (skipped for bootstrap stage $stage_current)"
2874 enable_libstdcxx_debug=no
2875 fi
2876 fi
2877 fi
2878 AC_MSG_RESULT($enable_libstdcxx_debug$skip_debug_build)
2879 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2880 ])
2883 dnl
2884 dnl Check for explicit debug flags.
2885 dnl
2886 dnl --enable-libstdcxx-debug-flags='-O1'
2887 dnl is a general method for passing flags to be used when
2888 dnl building debug libraries with --enable-libstdcxx-debug.
2889 dnl
2890 dnl --disable-libstdcxx-debug-flags does nothing.
2891 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2892 dnl If "default flags" is an empty string, the effect is the same
2893 dnl as --disable or --enable=no.
2894 dnl
2895 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2896 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2897 [pass compiler FLAGS when building debug library],
2898 [case "x$enable_libstdcxx_debug_flags" in
2899 xno | x) enable_libstdcxx_debug_flags= ;;
2900 x-*) ;;
2901 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2902 esac])
2904 # Option parsed, now set things appropriately
2905 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2906 AC_SUBST(DEBUG_FLAGS)
2908 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2909 ])
2912 dnl
2913 dnl Check if the user only wants a freestanding library implementation.
2914 dnl
2915 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2916 dnl installing only the headers required by [17.4.1.3] and the language
2917 dnl support library. More than that will be built (to keep the Makefiles
2918 dnl conveniently clean), but not installed.
2919 dnl
2920 dnl Sets:
2921 dnl is_hosted (yes/no)
2922 dnl
2923 dnl Defines:
2924 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
2925 dnl
2926 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2927 AC_ARG_ENABLE([hosted-libstdcxx],
2928 AC_HELP_STRING([--disable-hosted-libstdcxx],
2929 [only build freestanding C++ runtime support]),,
2930 [case "$host" in
2931 arm*-*-symbianelf*)
2932 enable_hosted_libstdcxx=no
2933 ;;
2934 *)
2935 enable_hosted_libstdcxx=yes
2936 ;;
2937 esac])
2938 if test "$enable_hosted_libstdcxx" = no; then
2939 AC_MSG_NOTICE([Only freestanding libraries will be built])
2940 is_hosted=no
2941 hosted_define=0
2942 enable_abi_check=no
2943 enable_libstdcxx_pch=no
2944 else
2945 is_hosted=yes
2946 hosted_define=1
2947 fi
2948 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2949 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2950 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2951 ])
2954 dnl
2955 dnl Check if the user wants a non-verbose library implementation.
2956 dnl
2957 dnl --disable-libstdcxx-verbose will turn off descriptive messages to
2958 dnl standard error on termination.
2959 dnl
2960 dnl Defines:
2961 dnl _GLIBCXX_VERBOSE (always defined, either to 1 or 0)
2962 dnl
2963 AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [
2964 AC_ARG_ENABLE([libstdcxx-verbose],
2965 AC_HELP_STRING([--disable-libstdcxx-verbose],
2966 [disable termination messages to standard error]),,
2967 [enable_libstdcxx_verbose=yes])
2968 if test x"$enable_libstdcxx_verbose" = xyes; then
2969 verbose_define=1
2970 else
2971 AC_MSG_NOTICE([verbose termination messages are disabled])
2972 verbose_define=0
2973 fi
2974 AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define,
2975 [Define to 1 if a verbose library is built, or 0 otherwise.])
2976 ])
2979 dnl
2980 dnl Check for template specializations for the 'long long' type.
2981 dnl The result determines only whether 'long long' I/O is enabled; things
2982 dnl like numeric_limits<> specializations are always available.
2983 dnl
2984 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2985 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2986 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2987 dnl Where DEFAULT is either `yes' or `no'.
2988 dnl
2989 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2990 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2991 if test $enable_long_long = yes; then
2992 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2993 [Define if code specialized for long long should be used.])
2994 fi
2995 AC_MSG_CHECKING([for enabled long long specializations])
2996 AC_MSG_RESULT([$enable_long_long])
2997 ])
3000 dnl
3001 dnl Check for decimal floating point.
3002 dnl See:
3003 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
3004 dnl
3005 dnl This checks to see if the host supports decimal floating point types.
3006 dnl
3007 dnl Defines:
3008 dnl _GLIBCXX_USE_DECIMAL_FLOAT
3009 dnl
3010 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
3012 # Fake what AC_TRY_COMPILE does, without linking as this is
3013 # unnecessary for this test.
3015 cat > conftest.$ac_ext << EOF
3016 [#]line __oline__ "configure"
3017 int main()
3018 {
3019 _Decimal32 d1;
3020 _Decimal64 d2;
3021 _Decimal128 d3;
3022 return 0;
3023 }
3024 EOF
3026 AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
3027 if AC_TRY_EVAL(ac_compile); then
3028 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
3029 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
3030 enable_dfp=yes
3031 else
3032 enable_dfp=no
3033 fi
3034 AC_MSG_RESULT($enable_dfp)
3035 rm -f conftest*
3036 ])
3038 dnl
3039 dnl Check for GNU 128-bit floating point type.
3040 dnl
3041 dnl Note: also checks that the type isn't a standard types.
3042 dnl
3043 dnl Defines:
3044 dnl ENABLE_FLOAT128
3045 dnl
3046 AC_DEFUN([GLIBCXX_ENABLE_FLOAT128], [
3048 AC_LANG_SAVE
3049 AC_LANG_CPLUSPLUS
3051 # Fake what AC_TRY_COMPILE does, without linking as this is
3052 # unnecessary for this test.
3054 cat > conftest.$ac_ext << EOF
3055 [#]line __oline__ "configure"
3056 template<typename T1, typename T2>
3057 struct same
3058 { typedef T2 type; };
3060 template<typename T>
3061 struct same<T, T>;
3063 int main()
3064 {
3065 typename same<double, __float128>::type f1;
3066 typename same<long double, __float128>::type f2;
3067 }
3068 EOF
3070 AC_MSG_CHECKING([for __float128])
3071 if AC_TRY_EVAL(ac_compile); then
3072 enable_float128=yes
3073 else
3074 enable_float128=no
3075 fi
3076 AC_MSG_RESULT($enable_float128)
3077 GLIBCXX_CONDITIONAL(ENABLE_FLOAT128, test $enable_float128 = yes)
3078 rm -f conftest*
3080 AC_LANG_RESTORE
3081 ])
3083 dnl
3084 dnl Check for template specializations for the 'wchar_t' type.
3085 dnl
3086 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
3087 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
3088 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
3089 dnl Where DEFAULT is either `yes' or `no'.
3090 dnl
3091 dnl Necessary support must also be present.
3092 dnl
3093 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
3094 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
3096 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
3097 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
3098 AC_MSG_CHECKING([for mbstate_t])
3099 AC_TRY_COMPILE([#include <wchar.h>],
3100 [mbstate_t teststate;],
3101 have_mbstate_t=yes, have_mbstate_t=no)
3102 AC_MSG_RESULT($have_mbstate_t)
3103 if test x"$have_mbstate_t" = xyes; then
3104 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
3105 fi
3107 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
3108 # ac_has_wchar_h.
3109 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
3111 if test x"$enable_wchar_t" = x"yes"; then
3113 AC_LANG_SAVE
3114 AC_LANG_CPLUSPLUS
3116 if test x"$ac_has_wchar_h" = xyes &&
3117 test x"$ac_has_wctype_h" = xyes; then
3118 AC_TRY_COMPILE([#include <wchar.h>
3119 #include <stddef.h>
3120 wint_t i;
3121 long l = WEOF;
3122 long j = WCHAR_MIN;
3123 long k = WCHAR_MAX;
3124 namespace test
3125 {
3126 using ::btowc;
3127 using ::fgetwc;
3128 using ::fgetws;
3129 using ::fputwc;
3130 using ::fputws;
3131 using ::fwide;
3132 using ::fwprintf;
3133 using ::fwscanf;
3134 using ::getwc;
3135 using ::getwchar;
3136 using ::mbrlen;
3137 using ::mbrtowc;
3138 using ::mbsinit;
3139 using ::mbsrtowcs;
3140 using ::putwc;
3141 using ::putwchar;
3142 using ::swprintf;
3143 using ::swscanf;
3144 using ::ungetwc;
3145 using ::vfwprintf;
3146 using ::vswprintf;
3147 using ::vwprintf;
3148 using ::wcrtomb;
3149 using ::wcscat;
3150 using ::wcschr;
3151 using ::wcscmp;
3152 using ::wcscoll;
3153 using ::wcscpy;
3154 using ::wcscspn;
3155 using ::wcsftime;
3156 using ::wcslen;
3157 using ::wcsncat;
3158 using ::wcsncmp;
3159 using ::wcsncpy;
3160 using ::wcspbrk;
3161 using ::wcsrchr;
3162 using ::wcsrtombs;
3163 using ::wcsspn;
3164 using ::wcsstr;
3165 using ::wcstod;
3166 using ::wcstok;
3167 using ::wcstol;
3168 using ::wcstoul;
3169 using ::wcsxfrm;
3170 using ::wctob;
3171 using ::wmemchr;
3172 using ::wmemcmp;
3173 using ::wmemcpy;
3174 using ::wmemmove;
3175 using ::wmemset;
3176 using ::wprintf;
3177 using ::wscanf;
3178 }
3179 ],[],[], [enable_wchar_t=no])
3180 else
3181 enable_wchar_t=no
3182 fi
3184 AC_LANG_RESTORE
3185 fi
3187 if test x"$enable_wchar_t" = x"yes"; then
3188 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
3189 [Define if code specialized for wchar_t should be used.])
3190 fi
3192 AC_MSG_CHECKING([for enabled wchar_t specializations])
3193 AC_MSG_RESULT([$enable_wchar_t])
3194 ])
3197 dnl
3198 dnl Check to see if building and using a C++ precompiled header can be done.
3199 dnl
3200 dnl --enable-libstdcxx-pch=yes
3201 dnl default, this shows intent to use stdc++.h.gch If it looks like it
3202 dnl may work, after some light-hearted attempts to puzzle out compiler
3203 dnl support, flip bits on in include/Makefile.am
3204 dnl
3205 dnl --disable-libstdcxx-pch
3206 dnl turns off attempts to use or build stdc++.h.gch.
3207 dnl
3208 dnl Substs:
3209 dnl glibcxx_PCHFLAGS
3210 dnl
3211 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
3212 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
3213 if test $enable_libstdcxx_pch = yes; then
3214 AC_CACHE_CHECK([for compiler with PCH support],
3215 [glibcxx_cv_prog_CXX_pch],
3216 [ac_save_CXXFLAGS="$CXXFLAGS"
3217 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
3218 AC_LANG_SAVE
3219 AC_LANG_CPLUSPLUS
3220 echo '#include <math.h>' > conftest.h
3221 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
3222 -o conftest.h.gch 1>&5 2>&1 &&
3223 echo '#error "pch failed"' > conftest.h &&
3224 echo '#include "conftest.h"' > conftest.cc &&
3225 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
3226 then
3227 glibcxx_cv_prog_CXX_pch=yes
3228 else
3229 glibcxx_cv_prog_CXX_pch=no
3230 fi
3231 rm -f conftest*
3232 CXXFLAGS=$ac_save_CXXFLAGS
3233 AC_LANG_RESTORE
3234 ])
3235 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
3236 fi
3238 AC_MSG_CHECKING([for enabled PCH])
3239 AC_MSG_RESULT([$enable_libstdcxx_pch])
3241 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
3242 if test $enable_libstdcxx_pch = yes; then
3243 glibcxx_PCHFLAGS="-include bits/stdc++.h"
3244 else
3245 glibcxx_PCHFLAGS=""
3246 fi
3247 AC_SUBST(glibcxx_PCHFLAGS)
3248 ])
3251 dnl
3252 dnl Check for atomic builtins.
3253 dnl See:
3254 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
3255 dnl
3256 dnl This checks to see if the host supports the compiler-generated
3257 dnl builtins for atomic operations for various integral sizes. Note, this
3258 dnl is intended to be an all-or-nothing switch, so all the atomic operations
3259 dnl that are used should be checked.
3260 dnl
3261 dnl Note:
3262 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
3263 dnl
3264 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
3265 AC_LANG_SAVE
3266 AC_LANG_CPLUSPLUS
3267 old_CXXFLAGS="$CXXFLAGS"
3269 # Do link tests if possible, instead asm tests, limited to some platforms
3270 # see discussion in PR target/40134, PR libstdc++/40133 and the thread
3271 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
3272 atomic_builtins_link_tests=no
3273 if test x$gcc_no_link != xyes; then
3274 # Can do link tests. Limit to some tested platforms
3275 case "$host" in
3276 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
3277 atomic_builtins_link_tests=yes
3278 ;;
3279 esac
3280 fi
3282 if test x$atomic_builtins_link_tests = xyes; then
3284 # Do link tests.
3286 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3288 AC_CACHE_CHECK([for atomic builtins for bool],
3289 glibcxx_cv_atomic_bool, [
3290 AC_TRY_LINK(
3291 [ ],
3292 [typedef bool atomic_type;
3293 atomic_type c1;
3294 atomic_type c2;
3295 atomic_type c3(0);
3296 // N.B. __atomic_fetch_add is not supported for bool.
3297 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3298 __ATOMIC_RELAXED);
3299 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3300 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3301 ],
3302 [glibcxx_cv_atomic_bool=yes],
3303 [glibcxx_cv_atomic_bool=no])
3304 ])
3306 AC_CACHE_CHECK([for atomic builtins for short],
3307 glibcxx_cv_atomic_short, [
3308 AC_TRY_LINK(
3309 [ ],
3310 [typedef short atomic_type;
3311 atomic_type c1;
3312 atomic_type c2;
3313 atomic_type c3(0);
3314 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3315 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3316 __ATOMIC_RELAXED);
3317 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3318 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3319 ],
3320 [glibcxx_cv_atomic_short=yes],
3321 [glibcxx_cv_atomic_short=no])
3322 ])
3324 AC_CACHE_CHECK([for atomic builtins for int],
3325 glibcxx_cv_atomic_int, [
3326 AC_TRY_LINK(
3327 [ ],
3328 [typedef int atomic_type;
3329 atomic_type c1;
3330 atomic_type c2;
3331 atomic_type c3(0);
3332 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3333 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3334 __ATOMIC_RELAXED);
3335 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3336 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3337 ],
3338 [glibcxx_cv_atomic_int=yes],
3339 [glibcxx_cv_atomic_int=no])
3340 ])
3342 AC_CACHE_CHECK([for atomic builtins for long long],
3343 glibcxx_cv_atomic_long_long, [
3344 AC_TRY_LINK(
3345 [ ],
3346 [typedef long long atomic_type;
3347 atomic_type c1;
3348 atomic_type c2;
3349 atomic_type c3(0);
3350 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3351 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3352 __ATOMIC_RELAXED);
3353 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3354 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3355 ],
3356 [glibcxx_cv_atomic_long_long=yes],
3357 [glibcxx_cv_atomic_long_long=no])
3358 ])
3360 else
3362 # Do asm tests.
3364 # Compile unoptimized.
3365 CXXFLAGS='-O0 -S'
3367 # Fake what AC_TRY_COMPILE does.
3369 cat > conftest.$ac_ext << EOF
3370 [#]line __oline__ "configure"
3371 int main()
3372 {
3373 typedef bool atomic_type;
3374 atomic_type c1;
3375 atomic_type c2;
3376 atomic_type c3(0);
3377 // N.B. __atomic_fetch_add is not supported for bool.
3378 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3379 __ATOMIC_RELAXED);
3380 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3381 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3383 return 0;
3384 }
3385 EOF
3387 AC_MSG_CHECKING([for atomic builtins for bool])
3388 if AC_TRY_EVAL(ac_compile); then
3389 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3390 glibcxx_cv_atomic_bool=no
3391 else
3392 glibcxx_cv_atomic_bool=yes
3393 fi
3394 fi
3395 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3396 rm -f conftest*
3398 cat > conftest.$ac_ext << EOF
3399 [#]line __oline__ "configure"
3400 int main()
3401 {
3402 typedef short atomic_type;
3403 atomic_type c1;
3404 atomic_type c2;
3405 atomic_type c3(0);
3406 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3407 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3408 __ATOMIC_RELAXED);
3409 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3410 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3412 return 0;
3413 }
3414 EOF
3416 AC_MSG_CHECKING([for atomic builtins for short])
3417 if AC_TRY_EVAL(ac_compile); then
3418 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3419 glibcxx_cv_atomic_short=no
3420 else
3421 glibcxx_cv_atomic_short=yes
3422 fi
3423 fi
3424 AC_MSG_RESULT($glibcxx_cv_atomic_short)
3425 rm -f conftest*
3427 cat > conftest.$ac_ext << EOF
3428 [#]line __oline__ "configure"
3429 int main()
3430 {
3431 // NB: _Atomic_word not necessarily int.
3432 typedef int atomic_type;
3433 atomic_type c1;
3434 atomic_type c2;
3435 atomic_type c3(0);
3436 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3437 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3438 __ATOMIC_RELAXED);
3439 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3440 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3442 return 0;
3443 }
3444 EOF
3446 AC_MSG_CHECKING([for atomic builtins for int])
3447 if AC_TRY_EVAL(ac_compile); then
3448 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3449 glibcxx_cv_atomic_int=no
3450 else
3451 glibcxx_cv_atomic_int=yes
3452 fi
3453 fi
3454 AC_MSG_RESULT($glibcxx_cv_atomic_int)
3455 rm -f conftest*
3457 cat > conftest.$ac_ext << EOF
3458 [#]line __oline__ "configure"
3459 int main()
3460 {
3461 typedef long long atomic_type;
3462 atomic_type c1;
3463 atomic_type c2;
3464 atomic_type c3(0);
3465 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3466 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3467 __ATOMIC_RELAXED);
3468 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3469 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3471 return 0;
3472 }
3473 EOF
3475 AC_MSG_CHECKING([for atomic builtins for long long])
3476 if AC_TRY_EVAL(ac_compile); then
3477 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3478 glibcxx_cv_atomic_long_long=no
3479 else
3480 glibcxx_cv_atomic_long_long=yes
3481 fi
3482 fi
3483 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3484 rm -f conftest*
3486 fi
3488 CXXFLAGS="$old_CXXFLAGS"
3489 AC_LANG_RESTORE
3491 # Set atomicity_dir to builtins if all but the long long test above passes,
3492 # or if the builtins were already chosen (e.g. by configure.host).
3493 if { test "$glibcxx_cv_atomic_bool" = yes \
3494 && test "$glibcxx_cv_atomic_short" = yes \
3495 && test "$glibcxx_cv_atomic_int" = yes; } \
3496 || test "$atomicity_dir" = "cpu/generic/atomicity_builtins"; then
3497 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
3498 [Define if the compiler supports C++11 atomics.])
3499 atomicity_dir=cpu/generic/atomicity_builtins
3500 fi
3502 # If still generic, set to mutex.
3503 if test $atomicity_dir = "cpu/generic" ; then
3504 atomicity_dir=cpu/generic/atomicity_mutex
3505 AC_MSG_WARN([No native atomic operations are provided for this platform.])
3506 if test "x$target_thread_file" = xsingle; then
3507 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
3508 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
3509 else
3510 AC_MSG_WARN([They will be faked using a mutex.])
3511 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
3512 fi
3513 fi
3515 ])
3517 dnl
3518 dnl Set default lock policy for synchronizing shared_ptr reference counting.
3519 dnl
3520 dnl --with-libstdcxx-lock-policy=auto
3521 dnl Use atomic operations for shared_ptr reference counting only if
3522 dnl the default target supports atomic compare-and-swap.
3523 dnl --with-libstdcxx-lock-policy=atomic
3524 dnl Use atomic operations for shared_ptr reference counting.
3525 dnl --with-libstdcxx-lock-policy=mutex
3526 dnl Use a mutex to synchronize shared_ptr reference counting.
3527 dnl
3528 dnl This controls the value of __gnu_cxx::__default_lock_policy, which
3529 dnl determines how shared_ptr reference counts are synchronized.
3530 dnl The option "atomic" means that atomic operations should be used,
3531 dnl "mutex" means that a mutex will be used. The default option, "auto",
3532 dnl will check if the target supports the compiler-generated builtins
3533 dnl for atomic compare-and-swap operations for 2-byte and 4-byte integers,
3534 dnl and will use "atomic" if supported, "mutex" otherwise.
3535 dnl This option is ignored if the thread model used by GCC is "single",
3536 dnl as no synchronization is used at all in that case.
3537 dnl This option affects the library ABI (except in the "single" thread model).
3538 dnl
3539 dnl Defines _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY to 1 if atomics should be used.
3540 dnl
3541 AC_DEFUN([GLIBCXX_ENABLE_LOCK_POLICY], [
3543 AC_ARG_WITH([libstdcxx-lock-policy],
3544 AC_HELP_STRING([--with-libstdcxx-lock-policy={atomic,mutex,auto}],
3545 [synchronization policy for shared_ptr reference counting [default=auto]]),
3546 [libstdcxx_atomic_lock_policy=$withval],
3547 [libstdcxx_atomic_lock_policy=auto])
3549 case "$libstdcxx_atomic_lock_policy" in
3550 atomic|mutex|auto) ;;
3551 *) AC_MSG_ERROR([Invalid argument for --with-libstdcxx-lock-policy]) ;;
3552 esac
3553 AC_MSG_CHECKING([for lock policy for shared_ptr reference counts])
3555 if test x"$libstdcxx_atomic_lock_policy" = x"auto"; then
3556 AC_LANG_SAVE
3557 AC_LANG_CPLUSPLUS
3558 ac_save_CXXFLAGS="$CXXFLAGS"
3560 dnl Why do we care about 2-byte CAS on targets with 4-byte _Atomic_word?!
3561 AC_TRY_COMPILE([
3562 #if ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
3563 # error "No 2-byte compare-and-swap"
3564 #elif ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
3565 # error "No 4-byte compare-and-swap"
3566 #endif
3567 ],,
3568 [libstdcxx_atomic_lock_policy=atomic],
3569 [libstdcxx_atomic_lock_policy=mutex])
3570 AC_LANG_RESTORE
3571 CXXFLAGS="$ac_save_CXXFLAGS"
3572 fi
3574 if test x"$libstdcxx_atomic_lock_policy" = x"atomic"; then
3575 AC_MSG_RESULT(atomic)
3576 AC_DEFINE(HAVE_ATOMIC_LOCK_POLICY,1,
3577 [Defined if shared_ptr reference counting should use atomic operations.])
3578 else
3579 AC_MSG_RESULT(mutex)
3580 fi
3582 ])
3584 dnl
3585 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3586 dnl
3587 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3588 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3589 dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3590 dnl Where DEFAULT is 'yes'.
3591 dnl
3592 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3593 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3595 if test x$enable_libstdcxx_visibility = xyes ; then
3596 dnl all hail libgfortran
3597 dnl Check whether the target supports hidden visibility.
3598 AC_CACHE_CHECK([whether the target supports hidden visibility],
3599 glibcxx_cv_have_attribute_visibility, [
3600 save_CFLAGS="$CFLAGS"
3601 CFLAGS="$CFLAGS -Werror"
3602 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3603 [], glibcxx_cv_have_attribute_visibility=yes,
3604 glibcxx_cv_have_attribute_visibility=no)
3605 CFLAGS="$save_CFLAGS"])
3606 if test $glibcxx_cv_have_attribute_visibility = no; then
3607 enable_libstdcxx_visibility=no
3608 fi
3609 fi
3611 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3612 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3613 ])
3616 dnl
3617 dnl Add version tags to symbols in shared library (or not), additionally
3618 dnl marking other symbols as private/local (or not).
3619 dnl
3620 dnl Sets libtool_VERSION, and determines shared library SONAME.
3621 dnl
3622 dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3623 dnl
3624 dnl --enable-symvers=style adds a version script to the linker call when
3625 dnl creating the shared library. The choice of version script is
3626 dnl controlled by 'style'.
3627 dnl --disable-symvers does not.
3628 dnl
3629 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3630 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
3631 dnl choose a default style based on linker characteristics. Passing
3632 dnl 'no' disables versioning.
3633 dnl
3634 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3636 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3637 [enables symbol versioning of the shared library],
3638 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3640 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3641 # don't know enough about $LD to do tricks...
3642 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3643 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3644 # with extern "C++" in version scripts.
3645 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3647 # Turn a 'yes' into a suitable default.
3648 if test x$enable_symvers = xyes ; then
3649 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3650 enable_symvers=no
3651 else
3652 if test $with_gnu_ld = yes ; then
3653 case ${target_os} in
3654 hpux*)
3655 enable_symvers=no ;;
3656 *)
3657 enable_symvers=gnu ;;
3658 esac
3659 else
3660 case ${target_os} in
3661 darwin*)
3662 enable_symvers=darwin ;;
3663 # Sun symbol versioning exists since Solaris 2.5.
3664 solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3665 # make_sunver.pl needs GNU c++filt to support extern "C++" in
3666 # version scripts, so disable symbol versioning if none can be
3667 # found.
3668 if test -z "$ac_cv_path_CXXFILT"; then
3669 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3670 AC_MSG_WARN([=== no GNU c++filt could be found.])
3671 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3672 enable_symvers=no
3673 else
3674 enable_symvers=sun
3675 fi
3676 ;;
3677 *)
3678 enable_symvers=no ;;
3679 esac
3680 fi
3681 fi
3682 fi
3684 # Check to see if 'darwin' or 'darwin-export' can win.
3685 if test x$enable_symvers = xdarwin-export ; then
3686 enable_symvers=darwin
3687 fi
3689 # Check if 'sun' was requested on non-Solaris 2 platforms.
3690 if test x$enable_symvers = xsun ; then
3691 case ${target_os} in
3692 solaris2*)
3693 # All fine.
3694 ;;
3695 *)
3696 # Unlikely to work.
3697 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3698 AC_MSG_WARN([=== you are not targetting Solaris 2.])
3699 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3700 enable_symvers=no
3701 ;;
3702 esac
3703 fi
3705 # Check to see if 'gnu' can win.
3706 if test $enable_symvers = gnu ||
3707 test $enable_symvers = gnu-versioned-namespace ||
3708 test $enable_symvers = sun; then
3709 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3710 AC_MSG_CHECKING([for shared libgcc])
3711 ac_save_CFLAGS="$CFLAGS"
3712 CFLAGS=' -lgcc_s'
3713 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3714 CFLAGS="$ac_save_CFLAGS"
3715 if test $glibcxx_shared_libgcc = no; then
3716 cat > conftest.c <<EOF
3717 int main (void) { return 0; }
3718 EOF
3719 changequote(,)dnl
3720 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3721 -shared -shared-libgcc -o conftest.so \
3722 conftest.c -v 2>&1 >/dev/null \
3723 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3724 changequote([,])dnl
3725 rm -f conftest.c conftest.so
3726 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3727 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3728 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3729 CFLAGS="$ac_save_CFLAGS"
3730 fi
3731 fi
3732 AC_MSG_RESULT($glibcxx_shared_libgcc)
3734 # For GNU ld, we need at least this version. The format is described in
3735 # GLIBCXX_CHECK_LINKER_FEATURES above.
3736 glibcxx_min_gnu_ld_version=21400
3738 # If no shared libgcc, can't win.
3739 if test $glibcxx_shared_libgcc != yes; then
3740 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3741 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3742 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3743 enable_symvers=no
3744 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3745 : All interesting versions of Sun ld support sun style symbol versioning.
3746 elif test $with_gnu_ld != yes ; then
3747 # just fail for now
3748 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3749 AC_MSG_WARN([=== you are not using the GNU linker.])
3750 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3751 enable_symvers=no
3752 elif test $glibcxx_ld_is_gold = yes ; then
3753 : All versions of gold support symbol versioning.
3754 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3755 # The right tools, the right setup, but too old. Fallbacks?
3756 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3757 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3758 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3759 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3760 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3761 enable_symvers=no
3762 fi
3763 fi
3765 # For libtool versioning info, format is CURRENT:REVISION:AGE
3766 libtool_VERSION=6:30:0
3768 # Everything parsed; figure out what files and settings to use.
3769 case $enable_symvers in
3770 no)
3771 SYMVER_FILE=config/abi/pre/none.ver
3772 ;;
3773 gnu)
3774 SYMVER_FILE=config/abi/pre/gnu.ver
3775 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3776 [Define to use GNU versioning in the shared library.])
3777 ;;
3778 gnu-versioned-namespace)
3779 libtool_VERSION=8:0:0
3780 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3781 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3782 [Define to use GNU namespace versioning in the shared library.])
3783 ;;
3784 darwin)
3785 SYMVER_FILE=config/abi/pre/gnu.ver
3786 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3787 [Define to use darwin versioning in the shared library.])
3788 ;;
3789 sun)
3790 SYMVER_FILE=config/abi/pre/gnu.ver
3791 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3792 [Define to use Sun versioning in the shared library.])
3793 ;;
3794 esac
3796 if test x$enable_symvers != xno ; then
3797 AC_DEFINE(_GLIBCXX_SYMVER, 1,
3798 [Define to use symbol versioning in the shared library.])
3799 fi
3801 AC_CACHE_CHECK([whether the target supports .symver directive],
3802 glibcxx_cv_have_as_symver_directive, [
3803 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3804 [], glibcxx_cv_have_as_symver_directive=yes,
3805 glibcxx_cv_have_as_symver_directive=no)])
3806 if test $glibcxx_cv_have_as_symver_directive = yes; then
3807 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3808 [Define to 1 if the target assembler supports .symver directive.])
3809 fi
3811 AC_SUBST(SYMVER_FILE)
3812 AC_SUBST(port_specific_symbol_files)
3813 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3814 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3815 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3816 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3817 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3818 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3820 if test $enable_symvers != no ; then
3821 case ${target_os} in
3822 # The Solaris 2 runtime linker doesn't support the GNU extension of
3823 # binding the same symbol to different versions
3824 solaris2*)
3825 ;;
3826 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3827 *)
3828 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3829 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3830 ;;
3831 esac
3832 fi
3834 # Now, set up compatibility support, if any.
3835 # In addition, need this to deal with std::size_t mangling in
3836 # src/compatibility.cc. In a perfect world, could use
3837 # typeid(std::size_t).name()[0] to do direct substitution.
3838 AC_MSG_CHECKING([for size_t as unsigned int])
3839 ac_save_CFLAGS="$CFLAGS"
3840 CFLAGS="-Werror"
3841 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3842 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3843 CFLAGS=$ac_save_CFLAGS
3844 if test "$glibcxx_size_t_is_i" = yes; then
3845 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3846 fi
3847 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3849 AC_MSG_CHECKING([for ptrdiff_t as int])
3850 ac_save_CFLAGS="$CFLAGS"
3851 CFLAGS="-Werror"
3852 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3853 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3854 CFLAGS=$ac_save_CFLAGS
3855 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3856 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3857 fi
3858 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3859 ])
3862 dnl
3863 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3864 dnl We must stage the required headers so that they will be installed
3865 dnl with the library (unlike libgcc, the STL implementation is provided
3866 dnl solely within headers). Since we must not inject random user-space
3867 dnl macro names into user-provided C++ code, we first stage into <file>-in
3868 dnl and process to <file> with an output command. The reason for a two-
3869 dnl stage process here is to correctly handle $srcdir!=$objdir without
3870 dnl having to write complex code (the sed commands to clean the macro
3871 dnl namespace are complex and fragile enough as it is). We must also
3872 dnl add a relative path so that -I- is supported properly.
3873 dnl
3874 dnl Substs:
3875 dnl thread_header
3876 dnl
3877 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3878 AC_MSG_CHECKING([for thread model used by GCC])
3879 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3880 AC_MSG_RESULT([$target_thread_file])
3881 GCC_AC_THREAD_HEADER([$target_thread_file])
3882 ])
3885 dnl
3886 dnl Check if gthread implementation defines the types and functions
3887 dnl required by the c++0x thread library. Conforming gthread
3888 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3889 dnl
3890 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3891 dnl
3892 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3893 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3895 if test x$enable_libstdcxx_threads = xauto ||
3896 test x$enable_libstdcxx_threads = xyes; then
3898 AC_LANG_SAVE
3899 AC_LANG_CPLUSPLUS
3901 ac_save_CXXFLAGS="$CXXFLAGS"
3902 CXXFLAGS="$CXXFLAGS -fno-exceptions \
3903 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3905 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3906 case $target_thread_file in
3907 posix)
3908 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3909 esac
3911 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3913 AC_TRY_COMPILE([#include <unistd.h>],
3914 [
3915 // In case of POSIX threads check _POSIX_TIMEOUTS.
3916 #if (defined(_PTHREADS) \
3917 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3918 #error
3919 #endif
3920 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3922 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3923 [Define to 1 if mutex_timedlock is available.])
3925 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3926 else res_mutex_timedlock=no ; fi
3927 AC_MSG_RESULT([$res_mutex_timedlock])
3929 AC_MSG_CHECKING([for gthreads library])
3931 AC_TRY_COMPILE([#include "gthr.h"],
3932 [
3933 #ifndef __GTHREADS_CXX0X
3934 #error
3935 #endif
3936 ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
3937 else
3938 ac_has_gthreads=no
3939 fi
3941 AC_MSG_RESULT([$ac_has_gthreads])
3943 if test x"$ac_has_gthreads" = x"yes"; then
3944 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3945 [Define if gthreads library is available.])
3947 # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14
3948 # but only do so if we're using pthread in the gthread library.
3949 # On VxWorks for example, pthread_rwlock_t is defined in sys/types.h
3950 # but the pthread library is not there by default and the gthread library
3951 # does not use it.
3952 AC_TRY_COMPILE([#include "gthr.h"],
3953 [
3954 #if (!defined(_PTHREADS))
3955 #error
3956 #endif
3957 ], [ac_gthread_use_pthreads=yes], [ac_gthread_use_pthreads=no])
3958 if test x"$ac_gthread_use_pthreads" = x"yes"; then
3959 AC_CHECK_TYPE([pthread_rwlock_t],
3960 [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1,
3961 [Define if POSIX read/write locks are available in <gthr.h>.])],
3962 [],
3963 [#include "gthr.h"])
3964 fi
3965 fi
3967 AC_CHECK_HEADER(semaphore.h, [
3968 AC_MSG_CHECKING([for POSIX Semaphores and sem_timedwait])
3969 AC_TRY_COMPILE([
3970 #include <unistd.h>
3971 #include <semaphore.h>
3972 #include <limits.h>
3973 ],
3974 [
3975 #if !defined _POSIX_TIMEOUTS || _POSIX_TIMEOUTS <= 0
3976 # error "POSIX Timeouts option not supported"
3977 #elif !defined _POSIX_SEMAPHORES || _POSIX_SEMAPHORES <= 0
3978 # error "POSIX Semaphores option not supported"
3979 #else
3980 #if defined SEM_VALUE_MAX
3981 constexpr int sem_value_max = SEM_VALUE_MAX;
3982 #elif defined _POSIX_SEM_VALUE_MAX
3983 constexpr int sem_value_max = _POSIX_SEM_VALUE_MAX;
3984 #else
3985 # error "SEM_VALUE_MAX not available"
3986 #endif
3987 sem_t sem;
3988 sem_init(&sem, 0, sem_value_max);
3989 struct timespec ts = { 0 };
3990 sem_timedwait(&sem, &ts);
3991 #endif
3992 ],
3993 [ac_have_posix_semaphore=yes],
3994 [ac_have_posix_semaphore=no])],
3995 [ac_have_posix_semaphore=no])
3997 if test $ac_have_posix_semaphore = yes ; then
3998 AC_DEFINE(HAVE_POSIX_SEMAPHORE,
3999 1,
4000 [Define to 1 if POSIX Semaphores with sem_timedwait are available in <semaphore.h>.])
4001 fi
4002 AC_MSG_RESULT([$ac_have_posix_semaphore])
4004 CXXFLAGS="$ac_save_CXXFLAGS"
4005 AC_LANG_RESTORE
4006 ])
4009 # Check whether LC_MESSAGES is available in <locale.h>.
4010 # Ulrich Drepper <drepper@cygnus.com>, 1995.
4011 #
4012 # This file file be copied and used freely without restrictions. It can
4013 # be used in projects which are not available under the GNU Public License
4014 # but which still want to provide support for the GNU gettext functionality.
4015 # Please note that the actual code is *not* freely available.
4016 AC_DEFUN([AC_LC_MESSAGES], [
4017 AC_CHECK_HEADER(locale.h, [
4018 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
4019 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
4020 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
4021 if test $ac_cv_val_LC_MESSAGES = yes; then
4022 AC_DEFINE(HAVE_LC_MESSAGES, 1,
4023 [Define if LC_MESSAGES is available in <locale.h>.])
4024 fi
4025 ])
4026 ])
4028 dnl
4029 dnl Check whether rdrand is supported in the assembler.
4030 AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [
4031 AC_CACHE_CHECK([for rdrand support in assembler],
4032 ac_cv_x86_rdrand, [
4033 ac_cv_x86_rdrand=no
4034 case "$target" in
4035 i?86-*-* | \
4036 x86_64-*-*)
4037 AC_TRY_COMPILE(, [asm("rdrand %eax");],
4038 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no])
4039 esac
4040 ])
4041 if test $ac_cv_x86_rdrand = yes; then
4042 AC_DEFINE(_GLIBCXX_X86_RDRAND, 1,
4043 [ Defined if as can handle rdrand. ])
4044 fi
4045 ])
4047 dnl
4048 dnl Check whether rdseed is supported in the assembler.
4049 AC_DEFUN([GLIBCXX_CHECK_X86_RDSEED], [
4050 AC_CACHE_CHECK([for rdseed support in assembler],
4051 ac_cv_x86_rdseed, [
4052 ac_cv_x86_rdseed=no
4053 case "$target" in
4054 i?86-*-* | \
4055 x86_64-*-*)
4056 AC_TRY_COMPILE(, [asm("rdseed %eax");],
4057 [ac_cv_x86_rdseed=yes], [ac_cv_x86_rdseed=no])
4058 esac
4059 ])
4060 if test $ac_cv_x86_rdseed = yes; then
4061 AC_DEFINE(_GLIBCXX_X86_RDSEED, 1,
4062 [ Defined if as can handle rdseed. ])
4063 fi
4064 ])
4066 dnl
4067 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
4068 dnl
4069 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
4071 AC_LANG_SAVE
4072 AC_LANG_CPLUSPLUS
4073 ac_save_CXXFLAGS="$CXXFLAGS"
4074 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4076 AC_CACHE_CHECK([for get_nprocs],
4077 glibcxx_cv_GET_NPROCS, [
4078 GCC_TRY_COMPILE_OR_LINK(
4079 [#include <sys/sysinfo.h>],
4080 [int n = get_nprocs();],
4081 [glibcxx_cv_GET_NPROCS=yes],
4082 [glibcxx_cv_GET_NPROCS=no])
4083 ])
4084 if test $glibcxx_cv_GET_NPROCS = yes; then
4085 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
4086 fi
4088 CXXFLAGS="$ac_save_CXXFLAGS"
4089 AC_LANG_RESTORE
4090 ])
4092 dnl
4093 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
4094 dnl
4095 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
4097 AC_LANG_SAVE
4098 AC_LANG_CPLUSPLUS
4099 ac_save_CXXFLAGS="$CXXFLAGS"
4100 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4102 AC_CACHE_CHECK([for _SC_NPROCESSORS_ONLN],
4103 glibcxx_cv_SC_NPROCESSORS_ONLN, [
4104 GCC_TRY_COMPILE_OR_LINK(
4105 [#include <unistd.h>],
4106 [int n = sysconf(_SC_NPROCESSORS_ONLN);],
4107 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
4108 [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
4109 ])
4110 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
4111 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.])
4112 fi
4114 CXXFLAGS="$ac_save_CXXFLAGS"
4115 AC_LANG_RESTORE
4116 ])
4118 dnl
4119 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
4120 dnl
4121 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
4123 AC_LANG_SAVE
4124 AC_LANG_CPLUSPLUS
4125 ac_save_CXXFLAGS="$CXXFLAGS"
4126 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4128 AC_CACHE_CHECK([for _SC_NPROC_ONLN],
4129 glibcxx_cv_SC_NPROC_ONLN, [
4130 GCC_TRY_COMPILE_OR_LINK(
4131 [#include <unistd.h>],
4132 [int n = sysconf(_SC_NPROC_ONLN);],
4133 [glibcxx_cv_SC_NPROC_ONLN=yes],
4134 [glibcxx_cv_SC_NPROC_ONLN=no])
4135 ])
4136 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
4137 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.])
4138 fi
4140 CXXFLAGS="$ac_save_CXXFLAGS"
4141 AC_LANG_RESTORE
4142 ])
4144 dnl
4145 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
4146 dnl
4147 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
4149 AC_LANG_SAVE
4150 AC_LANG_CPLUSPLUS
4151 ac_save_CXXFLAGS="$CXXFLAGS"
4152 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4154 AC_CACHE_CHECK([for pthreads_num_processors_np],
4155 glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
4156 GCC_TRY_COMPILE_OR_LINK(
4157 [#include <pthread.h>],
4158 [int n = pthread_num_processors_np();],
4159 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
4160 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
4161 ])
4162 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
4163 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
4164 fi
4166 CXXFLAGS="$ac_save_CXXFLAGS"
4167 AC_LANG_RESTORE
4168 ])
4170 dnl
4171 dnl Check whether pthread_cond_clockwait is available in <pthread.h> for std::condition_variable to use,
4172 dnl and define _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT.
4173 dnl
4174 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_COND_CLOCKWAIT], [
4176 AC_LANG_SAVE
4177 AC_LANG_CPLUSPLUS
4178 ac_save_CXXFLAGS="$CXXFLAGS"
4179 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4180 ac_save_LIBS="$LIBS"
4181 LIBS="$LIBS -lpthread"
4183 AC_CACHE_CHECK([for pthread_cond_clockwait],
4184 glibcxx_cv_PTHREAD_COND_CLOCKWAIT, [
4185 GCC_TRY_COMPILE_OR_LINK(
4186 [#include <pthread.h>],
4187 [pthread_mutex_t mutex; pthread_cond_t cond; struct timespec ts; int n = pthread_cond_clockwait(&cond, &mutex, 0, &ts);],
4188 [glibcxx_cv_PTHREAD_COND_CLOCKWAIT=yes],
4189 [glibcxx_cv_PTHREAD_COND_CLOCKWAIT=no])
4190 ])
4191 if test $glibcxx_cv_PTHREAD_COND_CLOCKWAIT = yes; then
4192 AC_DEFINE(_GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT, 1, [Define if pthread_cond_clockwait is available in <pthread.h>.])
4193 fi
4195 CXXFLAGS="$ac_save_CXXFLAGS"
4196 LIBS="$ac_save_LIBS"
4197 AC_LANG_RESTORE
4198 ])
4200 dnl
4201 dnl Check whether pthread_mutex_clocklock is available in <pthread.h> for std::timed_mutex to use,
4202 dnl and define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK.
4203 dnl
4204 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_MUTEX_CLOCKLOCK], [
4206 AC_LANG_SAVE
4207 AC_LANG_CPLUSPLUS
4208 ac_save_CXXFLAGS="$CXXFLAGS"
4209 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4210 ac_save_LIBS="$LIBS"
4211 LIBS="$LIBS -lpthread"
4213 AC_CACHE_CHECK([for pthread_mutex_clocklock],
4214 glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK, [
4215 GCC_TRY_COMPILE_OR_LINK(
4216 [#include <pthread.h>],
4217 [pthread_mutex_t mutex; struct timespec ts; int n = pthread_mutex_clocklock(&mutex, CLOCK_REALTIME, &ts);],
4218 [glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK=yes],
4219 [glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK=no])
4220 ])
4221 if test $glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK = yes; then
4222 AC_DEFINE(_GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK, 1, [Define if pthread_mutex_clocklock is available in <pthread.h>.])
4223 fi
4225 CXXFLAGS="$ac_save_CXXFLAGS"
4226 LIBS="$ac_save_LIBS"
4227 AC_LANG_RESTORE
4228 ])
4230 dnl
4231 dnl Check whether pthread_mutex_clocklock is available in <pthread.h> for std::timed_mutex to use,
4232 dnl and define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK.
4233 dnl
4234 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_RWLOCK_CLOCKLOCK], [
4236 AC_LANG_SAVE
4237 AC_LANG_CPLUSPLUS
4238 ac_save_CXXFLAGS="$CXXFLAGS"
4239 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4240 ac_save_LIBS="$LIBS"
4241 LIBS="$LIBS -lpthread"
4243 AC_CACHE_CHECK([for pthread_rwlock_clockrdlock, pthread_wlock_clockwrlock],
4244 glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK, [
4245 GCC_TRY_COMPILE_OR_LINK(
4246 [#include <pthread.h>],
4247 [pthread_rwlock_t rwl; struct timespec ts;]
4248 [int n = pthread_rwlock_clockrdlock(&rwl, CLOCK_REALTIME, &ts);]
4249 [int m = pthread_rwlock_clockwrlock(&rwl, CLOCK_REALTIME, &ts);],
4250 [glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK=yes],
4251 [glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK=no])
4252 ])
4253 if test $glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK = yes; then
4254 AC_DEFINE(_GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK, 1, [Define if pthread_rwlock_clockrdlock and pthread_rwlock_clockwrlock are available in <pthread.h>.])
4255 fi
4257 CXXFLAGS="$ac_save_CXXFLAGS"
4258 LIBS="$ac_save_LIBS"
4259 AC_LANG_RESTORE
4260 ])
4262 dnl
4263 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
4264 dnl
4265 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
4267 AC_LANG_SAVE
4268 AC_LANG_CPLUSPLUS
4269 ac_save_CXXFLAGS="$CXXFLAGS"
4270 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4272 AC_CACHE_CHECK([for hw.ncpu sysctl],
4273 glibcxx_cv_SYSCTL_HW_NCPU, [
4274 GCC_TRY_COMPILE_OR_LINK(
4275 [
4276 #include <stddef.h>
4277 #include <sys/sysctl.h>
4278 ],
4279 [
4280 int count;
4281 size_t size = sizeof(count);
4282 int mib[] = { CTL_HW, HW_NCPU };
4283 sysctl(mib, 2, &count, &size, NULL, 0);
4284 ],
4285 [glibcxx_cv_SYSCTL_HW_NCPU=yes],
4286 [glibcxx_cv_SYSCTL_HW_NCPU=no])
4287 ])
4288 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
4289 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
4290 fi
4292 CXXFLAGS="$ac_save_CXXFLAGS"
4293 AC_LANG_RESTORE
4294 ])
4296 dnl
4297 dnl Check to see if python pretty printing can be activated.
4298 dnl
4299 dnl --with-python-dir=dir
4300 dnl installs directory into $prefix/dir
4301 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
4303 AC_MSG_CHECKING([for custom python install directory])
4304 AC_ARG_WITH([python-dir],
4305 AS_HELP_STRING([--with-python-dir],
4306 [the location to install Python modules. This path is relative starting from the prefix.]),
4307 [with_python_dir=$withval], [with_python_dir="no"])
4308 AC_MSG_RESULT(${with_python_dir})
4310 # Needed for installing Python modules during make install.
4311 python_mod_dir="${with_python_dir}"
4312 AC_SUBST(python_mod_dir)
4313 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
4314 ])
4316 dnl
4317 dnl Check to see if -Werror is disabled.
4318 dnl
4319 dnl --enable-werror/--disable-werror
4320 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
4321 AC_MSG_CHECKING([for -Werror])
4322 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
4323 AC_MSG_RESULT($enable_werror)
4324 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
4325 ])
4327 dnl
4328 dnl Check whether obsolescent tmpnam is available in <stdio.h>,
4329 dnl and define _GLIBCXX_USE_TMPNAM.
4330 dnl
4331 AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl
4332 dnl
4333 AC_LANG_SAVE
4334 AC_LANG_CPLUSPLUS
4335 ac_save_CXXFLAGS="$CXXFLAGS"
4336 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4337 dnl
4338 AC_CACHE_CHECK([for tmpnam], glibcxx_cv_TMPNAM, [dnl
4339 GCC_TRY_COMPILE_OR_LINK(
4340 [#include <stdio.h>],
4341 [char *tmp = tmpnam(NULL);],
4342 [glibcxx_cv_TMPNAM=yes],
4343 [glibcxx_cv_TMPNAM=no])
4344 ])
4345 if test $glibcxx_cv_TMPNAM = yes; then
4346 AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.])
4347 fi
4348 dnl
4349 CXXFLAGS="$ac_save_CXXFLAGS"
4350 AC_LANG_RESTORE
4351 ])
4353 dnl
4354 dnl Check to see if sys/sdt.h exists and that it is suitable for use.
4355 dnl Some versions of sdt.h were not compatible with C++11.
4356 dnl
4357 AC_DEFUN([GLIBCXX_CHECK_SDT_H], [
4358 # Note that this test has to be run with the C language.
4359 # Otherwise, sdt.h will try to include some headers from
4360 # libstdc++ itself.
4361 AC_LANG_SAVE
4362 AC_LANG_C
4363 AC_CACHE_CHECK([for suitable sys/sdt.h],
4364 glibcxx_cv_sys_sdt_h, [
4365 # Because we have to run the test in C, we use grep rather
4366 # than the compiler to check for the bug. The bug is that
4367 # were strings without trailing whitespace, causing g++
4368 # to look for operator"". The pattern searches for the fixed
4369 # output.
4370 AC_EGREP_CPP([ \",\" ], [
4371 #include <sys/sdt.h>
4372 int f() { STAP_PROBE(hi, bob); }
4373 ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no])
4374 ])
4375 AC_LANG_RESTORE
4376 if test $glibcxx_cv_sys_sdt_h = yes; then
4377 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4378 [Define to 1 if you have a suitable <sys/sdt.h> header file])
4379 fi
4380 ])
4382 dnl
4383 dnl Control whether the library should define symbols for old and new ABIs.
4384 dnl This affects definitions of strings, stringstreams and locale facets.
4385 dnl
4386 dnl --disable-libstdcxx-dual-abi will use old ABI for all types.
4387 dnl
4388 dnl Defines:
4389 dnl _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0)
4390 dnl
4391 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [
4392 GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string])
4393 if test x$enable_symvers = xgnu-versioned-namespace; then
4394 # gnu-versioned-namespace is incompatible with the dual ABI.
4395 enable_libstdcxx_dual_abi="no"
4396 fi
4397 if test x"$enable_libstdcxx_dual_abi" != xyes; then
4398 AC_MSG_NOTICE([dual ABI is disabled])
4399 default_libstdcxx_abi="gcc4-compatible"
4400 fi
4401 GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes)
4402 ])
4404 dnl
4405 dnl Check to see which ABI should be enabled by default.
4406 dnl
4407 dnl --with-default-libstdcxx-abi={gcc4-compatible,new}
4408 dnl
4409 dnl Defines:
4410 dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
4411 dnl
4412 AC_DEFUN([GLIBCXX_DEFAULT_ABI], [
4413 if test x$enable_libstdcxx_dual_abi = xyes; then
4414 AC_MSG_CHECKING([for default std::string ABI to use])
4415 AC_ARG_WITH([default-libstdcxx-abi],
4416 AS_HELP_STRING([--with-default-libstdcxx-abi],
4417 [set the std::string ABI to use by default]),
4418 [case "$withval" in
4419 gcc4-compatible) default_libstdcxx_abi="gcc4-compatible" ;;
4420 new|cxx11) default_libstdcxx_abi="new" ;;
4421 c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;;
4422 *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
4423 esac
4424 ],
4425 [default_libstdcxx_abi="new"])
4426 AC_MSG_RESULT(${default_libstdcxx_abi})
4427 fi
4428 if test $default_libstdcxx_abi = "new"; then
4429 glibcxx_cxx11_abi=1
4430 glibcxx_cxx98_abi=0
4431 else
4432 glibcxx_cxx11_abi=0
4433 glibcxx_cxx98_abi=1
4434 fi
4435 AC_SUBST(glibcxx_cxx98_abi)
4436 GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1)
4437 ])
4439 dnl
4440 dnl Check to see whether to build libstdc++fs.a
4441 dnl
4442 dnl --enable-libstdcxx-filesystem-ts
4443 dnl
4444 AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [
4445 GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,,
4446 [turns on ISO/IEC TS 18822 support],
4447 [permit yes|no|auto])
4449 AC_MSG_CHECKING([whether to build Filesystem TS support])
4450 if test x"$ac_cv_header_dirent_h" != x"yes"; then
4451 enable_libstdcxx_filesystem_ts=no
4452 fi
4453 if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then
4454 case "${target_os}" in
4455 freebsd*|netbsd*|openbsd*|dragonfly*|darwin*)
4456 enable_libstdcxx_filesystem_ts=yes
4457 ;;
4458 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu | uclinux*)
4459 enable_libstdcxx_filesystem_ts=yes
4460 ;;
4461 rtems*)
4462 enable_libstdcxx_filesystem_ts=yes
4463 ;;
4464 solaris*)
4465 enable_libstdcxx_filesystem_ts=yes
4466 ;;
4467 mingw*)
4468 enable_libstdcxx_filesystem_ts=yes
4469 ;;
4470 *)
4471 enable_libstdcxx_filesystem_ts=no
4472 ;;
4473 esac
4474 fi
4475 AC_MSG_RESULT($enable_libstdcxx_filesystem_ts)
4476 GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes)
4477 ])
4479 dnl
4480 dnl Check whether the library calls required by the C++17 Filesystem library
4481 dnl and the Filesystem TS are present.
4482 dnl Defines:
4483 dnl HAVE_STRUCT_DIRENT_D_TYPE
4484 dnl _GLIBCXX_USE_REALPATH
4485 dnl _GLIBCXX_USE_UTIMENSAT
4486 dnl _GLIBCXX_USE_ST_MTIM
4487 dnl _GLIBCXX_USE_FCHMOD
4488 dnl _GLIBCXX_USE_FCHMODAT
4489 dnl _GLIBCXX_USE_SENDFILE
4490 dnl HAVE_LINK
4491 dnl HAVE_READLINK
4492 dnl HAVE_SYMLINK
4493 dnl
4494 AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
4495 dnl
4496 AC_LANG_SAVE
4497 AC_LANG_CPLUSPLUS
4498 ac_save_CXXFLAGS="$CXXFLAGS"
4499 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4500 dnl
4501 AC_CACHE_CHECK([for struct dirent.d_type], glibcxx_cv_dirent_d_type, [dnl
4502 GCC_TRY_COMPILE_OR_LINK(
4503 [#include <dirent.h>],
4504 [
4505 struct dirent d;
4506 if (sizeof d.d_type) return 0;
4507 ],
4508 [glibcxx_cv_dirent_d_type=yes],
4509 [glibcxx_cv_dirent_d_type=no])
4510 ])
4511 if test $glibcxx_cv_dirent_d_type = yes; then
4512 AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.])
4513 fi
4514 dnl
4515 AC_CACHE_CHECK([for realpath], glibcxx_cv_realpath, [dnl
4516 GCC_TRY_COMPILE_OR_LINK(
4517 [
4518 #include <limits.h>
4519 #include <stdlib.h>
4520 #include <unistd.h>
4521 ],
4522 [
4523 #if _XOPEN_VERSION < 500
4524 #error
4525 #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX)
4526 char *tmp = realpath((const char*)NULL, (char*)NULL);
4527 #else
4528 #error
4529 #endif
4530 ],
4531 [glibcxx_cv_realpath=yes],
4532 [glibcxx_cv_realpath=no])
4533 ])
4534 if test $glibcxx_cv_realpath = yes; then
4535 AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.])
4536 fi
4537 dnl
4538 AC_CACHE_CHECK([for utimensat], glibcxx_cv_utimensat, [dnl
4539 GCC_TRY_COMPILE_OR_LINK(
4540 [
4541 #include <fcntl.h>
4542 #include <sys/stat.h>
4543 ],
4544 [
4545 struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } };
4546 int i = utimensat(AT_FDCWD, "path", ts, 0);
4547 ],
4548 [glibcxx_cv_utimensat=yes],
4549 [glibcxx_cv_utimensat=no])
4550 ])
4551 if test $glibcxx_cv_utimensat = yes; then
4552 AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.])
4553 fi
4554 dnl
4555 AC_CACHE_CHECK([for utime], glibcxx_cv_utime, [dnl
4556 GCC_TRY_COMPILE_OR_LINK(
4557 [
4558 #include <utime.h>
4559 ],
4560 [
4561 struct utimbuf t = { 1, 1 };
4562 int i = utime("path", &t);
4563 ],
4564 [glibcxx_cv_utime=yes],
4565 [glibcxx_cv_utime=no])
4566 ])
4567 if test $glibcxx_cv_utime = yes; then
4568 AC_DEFINE(_GLIBCXX_USE_UTIME, 1, [Define if utime is available in <utime.h>.])
4569 fi
4570 dnl
4571 AC_CACHE_CHECK([for lstat], glibcxx_cv_lstat, [dnl
4572 GCC_TRY_COMPILE_OR_LINK(
4573 [ #include <sys/stat.h> ],
4574 [
4575 struct stat st;
4576 int i = lstat("path", &st);
4577 ],
4578 [glibcxx_cv_lstat=yes],
4579 [glibcxx_cv_lstat=no])
4580 ])
4581 if test $glibcxx_cv_lstat = yes; then
4582 AC_DEFINE(_GLIBCXX_USE_LSTAT, 1, [Define if lstat is available in <sys/stat.h>.])
4583 fi
4584 dnl
4585 AC_CACHE_CHECK([for struct stat.st_mtim.tv_nsec],
4586 glibcxx_cv_st_mtim, [dnl
4587 GCC_TRY_COMPILE_OR_LINK(
4588 [ #include <sys/stat.h> ],
4589 [
4590 struct stat st;
4591 return st.st_mtim.tv_nsec;
4592 ],
4593 [glibcxx_cv_st_mtim=yes],
4594 [glibcxx_cv_st_mtim=no])
4595 ])
4596 if test $glibcxx_cv_st_mtim = yes; then
4597 AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.])
4598 fi
4599 dnl
4600 AC_CACHE_CHECK([for fchmod],
4601 glibcxx_cv_fchmod, [dnl
4602 GCC_TRY_COMPILE_OR_LINK(
4603 [#include <sys/stat.h>],
4604 [fchmod(1, S_IWUSR);],
4605 [glibcxx_cv_fchmod=yes],
4606 [glibcxx_cv_fchmod=no])
4607 ])
4608 if test $glibcxx_cv_fchmod = yes; then
4609 AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.])
4610 fi
4611 dnl
4612 AC_CACHE_CHECK([for fchmodat],
4613 glibcxx_cv_fchmodat, [dnl
4614 GCC_TRY_COMPILE_OR_LINK(
4615 [
4616 #include <fcntl.h>
4617 #include <sys/stat.h>
4618 ],
4619 [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);],
4620 [glibcxx_cv_fchmodat=yes],
4621 [glibcxx_cv_fchmodat=no])
4622 ])
4623 if test $glibcxx_cv_fchmodat = yes; then
4624 AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.])
4625 fi
4626 dnl
4627 AC_CACHE_CHECK([for sendfile that can copy files],
4628 glibcxx_cv_sendfile, [dnl
4629 case "${target_os}" in
4630 gnu* | linux* | solaris* | uclinux*)
4631 GCC_TRY_COMPILE_OR_LINK(
4632 [#include <sys/sendfile.h>],
4633 [sendfile(1, 2, (off_t*)0, sizeof 1);],
4634 [glibcxx_cv_sendfile=yes],
4635 [glibcxx_cv_sendfile=no])
4636 ;;
4637 *)
4638 glibcxx_cv_sendfile=no
4639 ;;
4640 esac
4641 ])
4642 if test $glibcxx_cv_sendfile = yes; then
4643 AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.])
4644 fi
4645 dnl
4646 AC_CACHE_CHECK([for link],
4647 glibcxx_cv_link, [dnl
4648 GCC_TRY_COMPILE_OR_LINK(
4649 [#include <unistd.h>],
4650 [link("", "");],
4651 [glibcxx_cv_link=yes],
4652 [glibcxx_cv_link=no])
4653 ])
4654 if test $glibcxx_cv_link = yes; then
4655 AC_DEFINE(HAVE_LINK, 1, [Define if link is available in <unistd.h>.])
4656 fi
4657 dnl
4658 AC_CACHE_CHECK([for readlink],
4659 glibcxx_cv_readlink, [dnl
4660 GCC_TRY_COMPILE_OR_LINK(
4661 [#include <unistd.h>],
4662 [char buf[32]; readlink("", buf, sizeof(buf));],
4663 [glibcxx_cv_readlink=yes],
4664 [glibcxx_cv_readlink=no])
4665 ])
4666 if test $glibcxx_cv_readlink = yes; then
4667 AC_DEFINE(HAVE_READLINK, 1, [Define if readlink is available in <unistd.h>.])
4668 fi
4669 dnl
4670 AC_CACHE_CHECK([for symlink],
4671 glibcxx_cv_symlink, [dnl
4672 GCC_TRY_COMPILE_OR_LINK(
4673 [#include <unistd.h>],
4674 [symlink("", "");],
4675 [glibcxx_cv_symlink=yes],
4676 [glibcxx_cv_symlink=no])
4677 ])
4678 if test $glibcxx_cv_symlink = yes; then
4679 AC_DEFINE(HAVE_SYMLINK, 1, [Define if symlink is available in <unistd.h>.])
4680 fi
4681 dnl
4682 AC_CACHE_CHECK([for truncate],
4683 glibcxx_cv_truncate, [dnl
4684 GCC_TRY_COMPILE_OR_LINK(
4685 [#include <unistd.h>],
4686 [truncate("", 99);],
4687 [glibcxx_cv_truncate=yes],
4688 [glibcxx_cv_truncate=no])
4689 ])
4690 if test $glibcxx_cv_truncate = yes; then
4691 AC_DEFINE(HAVE_TRUNCATE, 1, [Define if truncate is available in <unistd.h>.])
4692 fi
4693 dnl
4694 CXXFLAGS="$ac_save_CXXFLAGS"
4695 AC_LANG_RESTORE
4696 ])
4698 dnl
4699 dnl Check how size_t is mangled. Copied from libitm.
4700 dnl
4701 AC_DEFUN([GLIBCXX_CHECK_SIZE_T_MANGLING], [
4702 AC_CACHE_CHECK([how size_t is mangled],
4703 glibcxx_cv_size_t_mangling, [
4704 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
4705 [glibcxx_cv_size_t_mangling=m], [
4706 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
4707 [glibcxx_cv_size_t_mangling=j], [
4708 AC_TRY_COMPILE([],
4709 [extern __SIZE_TYPE__ x; extern unsigned long long x;],
4710 [glibcxx_cv_size_t_mangling=y], [
4711 AC_TRY_COMPILE([],
4712 [extern __SIZE_TYPE__ x; extern unsigned short x;],
4713 [glibcxx_cv_size_t_mangling=t], [
4714 AC_TRY_COMPILE([],
4715 [extern __SIZE_TYPE__ x; extern __int20 unsigned x;],
4716 [glibcxx_cv_size_t_mangling=u6uint20],
4717 [glibcxx_cv_size_t_mangling=x])
4718 ])
4719 ])
4720 ])
4721 ])
4722 ])
4723 if test $glibcxx_cv_size_t_mangling = x; then
4724 AC_MSG_ERROR([Unknown underlying type for size_t])
4725 fi
4726 AC_DEFINE_UNQUOTED(_GLIBCXX_MANGLE_SIZE_T, [$glibcxx_cv_size_t_mangling],
4727 [Define to the letter to which size_t is mangled.])
4728 ])
4730 dnl
4731 dnl Determine whether std::exception_ptr symbols should be exported with
4732 dnl the symbol versions from GCC 4.6.0 or GCC 7.1.0, depending on which
4733 dnl release first added support for std::exception_ptr. Originally it was
4734 dnl only supported for targets with always-lock-free atomics for int, but
4735 dnl since GCC 7.1 it is supported for all targets.
4736 dnl
4737 AC_DEFUN([GLIBCXX_CHECK_EXCEPTION_PTR_SYMVER], [
4738 if test $enable_symvers != no; then
4739 AC_MSG_CHECKING([for first version to support std::exception_ptr])
4740 case ${target} in
4741 aarch64-*-* | alpha-*-* | hppa*-*-* | i?86-*-* | x86_64-*-* | \
4742 m68k-*-* | powerpc*-*-* | s390*-*-* | *-*-solaris* )
4743 ac_exception_ptr_since_gcc46=yes
4744 ;;
4745 *)
4746 # If the value of this macro changes then we will need to hardcode
4747 # yes/no here for additional targets based on the original value.
4748 AC_TRY_COMPILE([], [
4749 #if __GCC_ATOMIC_INT_LOCK_FREE <= 1
4750 # error atomic int not always lock free
4751 #endif
4752 ],
4753 [ac_exception_ptr_since_gcc46=yes],
4754 [ac_exception_ptr_since_gcc46=no])
4755 ;;
4756 esac
4757 if test x"$ac_exception_ptr_since_gcc46" = x"yes" ; then
4758 AC_DEFINE(HAVE_EXCEPTION_PTR_SINCE_GCC46, 1,
4759 [Define to 1 if GCC 4.6 supported std::exception_ptr for the target])
4760 AC_MSG_RESULT([4.6.0])
4761 else
4762 AC_MSG_RESULT([7.1.0])
4763 fi
4764 fi
4765 ])
4767 dnl
4768 dnl Check whether getentropy is present in <unistd.h>.
4769 dnl
4770 AC_DEFUN([GLIBCXX_CHECK_GETENTROPY], [
4772 AC_LANG_SAVE
4773 AC_LANG_CPLUSPLUS
4774 AC_CACHE_CHECK([for getentropy], glibcxx_cv_getentropy, [
4775 GCC_TRY_COMPILE_OR_LINK(
4776 [#include <unistd.h>],
4777 [unsigned i;
4778 ::getentropy(&i, sizeof(i));],
4779 [glibcxx_cv_getentropy=yes], [glibcxx_cv_getentropy=no])
4780 ])
4782 if test $glibcxx_cv_getentropy = yes; then
4783 AC_DEFINE(HAVE_GETENTROPY, 1, [Define if getentropy is available in <unistd.h>.])
4784 fi
4785 AC_LANG_RESTORE
4786 ])
4788 dnl
4789 dnl Check whether arc4random is present in <stdlib.h>.
4790 dnl
4791 AC_DEFUN([GLIBCXX_CHECK_ARC4RANDOM], [
4793 AC_LANG_SAVE
4794 AC_LANG_CPLUSPLUS
4795 AC_CACHE_CHECK([for arc4random], glibcxx_cv_arc4random, [
4796 GCC_TRY_COMPILE_OR_LINK(
4797 [#include <stdlib.h>],
4798 [unsigned i = ::arc4random();],
4799 [glibcxx_cv_arc4random=yes], [glibcxx_cv_arc4random=no])
4800 ])
4802 if test $glibcxx_cv_arc4random = yes; then
4803 AC_DEFINE(HAVE_ARC4RANDOM, 1, [Define if arc4random is available in <stdlib.h>.])
4804 fi
4805 AC_LANG_RESTORE
4806 ])
4809 # Macros from the top-level gcc directory.
4810 m4_include([../config/gc++filt.m4])
4811 m4_include([../config/tls.m4])
4812 m4_include([../config/gthr.m4])
4813 m4_include([../config/cet.m4])