| blob | 8129373e9dd7a1189895504ff379452de7873c1a |
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 src/libbacktrace src/experimental doc po testsuite python])
53 SUBDIRS='glibcxx_SUBDIRS'
55 # These need to be absolute paths, yet at the same time need to
56 # canonicalize only relative paths, because then amd will not unmount
57 # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
58 glibcxx_builddir=`${PWDCMD-pwd}`
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_ld_is_mold (set to "no" or "yes")
176 dnl glibcxx_gnu_ld_version (possibly)
177 dnl
178 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
179 dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
180 dnl
181 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
182 # If we're not using GNU ld, then there's no point in even trying these
183 # tests. Check for that first. We should have already tested for gld
184 # by now (in libtool), but require it now just to be safe...
185 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
186 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
187 AC_REQUIRE([AC_PROG_LD])
188 AC_REQUIRE([AC_PROG_AWK])
190 # The name set by libtool depends on the version of libtool. Shame on us
191 # for depending on an impl detail, but c'est la vie. Older versions used
192 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
193 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
194 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
195 # set (hence we're using an older libtool), then set it.
196 if test x${with_gnu_ld+set} != xset; then
197 if test x${ac_cv_prog_gnu_ld+set} != xset; then
198 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
199 with_gnu_ld=no
200 else
201 with_gnu_ld=$ac_cv_prog_gnu_ld
202 fi
203 fi
205 # Start by getting the version number. I think the libtool test already
206 # does some of this, but throws away the result.
207 glibcxx_ld_is_gold=no
208 glibcxx_ld_is_mold=no
209 if test x"$with_gnu_ld" = x"yes"; then
210 AC_MSG_CHECKING([for ld version])
211 changequote(,)
212 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
213 glibcxx_ld_is_gold=yes
214 elif $LD --version 2>/dev/null | grep 'mold' >/dev/null 2>&1; then
215 glibcxx_ld_is_mold=yes
216 fi
217 ldver=`$LD --version 2>/dev/null |
218 sed -e 's/[. ][0-9]\{8\}$//;s/.* \([^ ]\{1,\}\)$/\1/; q'`
219 changequote([,])
220 glibcxx_gnu_ld_version=`echo $ldver | \
221 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
222 AC_MSG_RESULT($glibcxx_gnu_ld_version)
223 fi
225 # Set --gc-sections.
226 glibcxx_have_gc_sections=no
227 if test "$glibcxx_ld_is_gold" = "yes" || test "$glibcxx_ld_is_mold" = "yes" ; then
228 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
229 glibcxx_have_gc_sections=yes
230 fi
231 else
232 glibcxx_gcsections_min_ld=21602
233 if test x"$with_gnu_ld" = x"yes" &&
234 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
235 glibcxx_have_gc_sections=yes
236 fi
237 fi
238 if test "$glibcxx_have_gc_sections" = "yes"; then
239 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
240 # NB: This flag only works reliably after 2.16.1. Configure tests
241 # for this are difficult, so hard wire a value that should work.
243 ac_test_CFLAGS="${CFLAGS+set}"
244 ac_save_CFLAGS="$CFLAGS"
245 CFLAGS='-Wl,--gc-sections'
247 # Check for -Wl,--gc-sections
248 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
249 AC_TRY_LINK([ int one(void) { return 1; }
250 int two(void) { return 2; }
251 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
252 if test "$ac_gcsections" = "yes"; then
253 rm -f conftest.c
254 touch conftest.c
255 if $CC -c conftest.c; then
256 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
257 grep "Warning: gc-sections option ignored" > /dev/null; then
258 ac_gcsections=no
259 fi
260 fi
261 rm -f conftest.c conftest.o conftest
262 fi
263 if test "$ac_gcsections" = "yes"; then
264 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
265 fi
266 AC_MSG_RESULT($ac_gcsections)
268 if test "$ac_test_CFLAGS" = set; then
269 CFLAGS="$ac_save_CFLAGS"
270 else
271 # this is the suspicious part
272 CFLAGS=''
273 fi
274 fi
276 # Set -z,relro.
277 # Note this is only for shared objects.
278 ac_ld_relro=no
279 if test x"$with_gnu_ld" = x"yes"; then
280 # cygwin and mingw uses PE, which has no ELF relro support,
281 # multi target ld may confuse configure machinery
282 case "$host" in
283 *-*-cygwin*)
284 ;;
285 *-*-mingw*)
286 ;;
287 *)
288 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
289 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
290 if test -n "$cxx_z_relo"; then
291 OPT_LDFLAGS="-Wl,-z,relro"
292 ac_ld_relro=yes
293 fi
294 AC_MSG_RESULT($ac_ld_relro)
295 esac
296 fi
298 # Set linker optimization flags.
299 if test x"$with_gnu_ld" = x"yes"; then
300 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
301 fi
303 AC_SUBST(SECTION_LDFLAGS)
304 AC_SUBST(OPT_LDFLAGS)
305 ])
308 dnl
309 dnl Check for headers for, and arguments to, the setrlimit() function.
310 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
311 dnl
312 dnl Defines:
313 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
314 dnl various HAVE_LIMIT_* for individual limit names
315 dnl
316 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
317 AC_MSG_CHECKING([for RLIMIT_$1])
318 AC_TRY_COMPILE(
319 [#include <unistd.h>
320 #include <sys/time.h>
321 #include <sys/resource.h>
322 ],
323 [ int f = RLIMIT_$1 ; ],
324 [glibcxx_mresult=1], [glibcxx_mresult=0])
325 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
326 [Only used in build directory testsuite_hooks.h.])
327 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
328 AC_MSG_RESULT($res)
329 ])
331 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
332 AC_LANG_SAVE
333 AC_LANG_CPLUSPLUS
334 setrlimit_have_headers=yes
335 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
336 [],
337 [setrlimit_have_headers=no])
338 # If don't have the headers, then we can't run the tests now, and we
339 # won't be seeing any of these during testsuite compilation.
340 if test $setrlimit_have_headers = yes; then
341 # Can't do these in a loop, else the resulting syntax is wrong.
342 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
343 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
344 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
345 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
346 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
348 # Check for rlimit, setrlimit.
349 AC_CACHE_CHECK([for testsuite resource limits support],
350 glibcxx_cv_setrlimit, [
351 AC_TRY_COMPILE(
352 [#include <unistd.h>
353 #include <sys/time.h>
354 #include <sys/resource.h>
355 ],
356 [struct rlimit r;
357 setrlimit(0, &r);],
358 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
359 ])
361 if test $glibcxx_cv_setrlimit = yes; then
362 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
363 [Define if using setrlimit to set resource limits during
364 "make check"])
365 fi
366 fi
367 AC_LANG_RESTORE
368 ])
371 dnl
372 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
373 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
374 dnl
375 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
377 AC_LANG_SAVE
378 AC_LANG_CPLUSPLUS
379 ac_save_CXXFLAGS="$CXXFLAGS"
380 CXXFLAGS="$CXXFLAGS -fno-exceptions"
382 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
383 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
384 GCC_TRY_COMPILE_OR_LINK(
385 [#include <sys/stat.h>],
386 [struct stat buffer;
387 fstat(0, &buffer);
388 S_ISREG(buffer.st_mode);],
389 [glibcxx_cv_S_ISREG=yes],
390 [glibcxx_cv_S_ISREG=no])
391 ])
392 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
393 GCC_TRY_COMPILE_OR_LINK(
394 [#include <sys/stat.h>],
395 [struct stat buffer;
396 fstat(0, &buffer);
397 S_IFREG & buffer.st_mode;],
398 [glibcxx_cv_S_IFREG=yes],
399 [glibcxx_cv_S_IFREG=no])
400 ])
401 res=no
402 if test $glibcxx_cv_S_ISREG = yes; then
403 AC_DEFINE(HAVE_S_ISREG, 1,
404 [Define if S_ISREG is available in <sys/stat.h>.])
405 res=S_ISREG
406 elif test $glibcxx_cv_S_IFREG = yes; then
407 AC_DEFINE(HAVE_S_IFREG, 1,
408 [Define if S_IFREG is available in <sys/stat.h>.])
409 res=S_IFREG
410 fi
411 AC_MSG_RESULT($res)
413 CXXFLAGS="$ac_save_CXXFLAGS"
414 AC_LANG_RESTORE
415 ])
418 dnl
419 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
420 dnl
421 AC_DEFUN([GLIBCXX_CHECK_POLL], [
423 AC_LANG_SAVE
424 AC_LANG_CPLUSPLUS
425 ac_save_CXXFLAGS="$CXXFLAGS"
426 CXXFLAGS="$CXXFLAGS -fno-exceptions"
428 AC_CACHE_CHECK([for poll], glibcxx_cv_POLL, [
429 GCC_TRY_COMPILE_OR_LINK(
430 [#include <poll.h>],
431 [struct pollfd pfd[1];
432 pfd[0].events = POLLIN;
433 poll(pfd, 1, 0);],
434 [glibcxx_cv_POLL=yes],
435 [glibcxx_cv_POLL=no])
436 ])
437 if test $glibcxx_cv_POLL = yes; then
438 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
439 fi
441 CXXFLAGS="$ac_save_CXXFLAGS"
442 AC_LANG_RESTORE
443 ])
446 dnl
447 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
448 dnl
449 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
451 AC_LANG_SAVE
452 AC_LANG_CPLUSPLUS
453 ac_save_CXXFLAGS="$CXXFLAGS"
454 CXXFLAGS="$CXXFLAGS -fno-exceptions"
456 AC_CACHE_CHECK([for writev], glibcxx_cv_WRITEV, [
457 GCC_TRY_COMPILE_OR_LINK(
458 [#include <sys/uio.h>],
459 [struct iovec iov[2];
460 writev(0, iov, 0);],
461 [glibcxx_cv_WRITEV=yes],
462 [glibcxx_cv_WRITEV=no])
463 ])
464 if test $glibcxx_cv_WRITEV = yes; then
465 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
466 fi
468 CXXFLAGS="$ac_save_CXXFLAGS"
469 AC_LANG_RESTORE
470 ])
473 dnl
474 dnl Check whether LFS support is available.
475 dnl
476 AC_DEFUN([GLIBCXX_CHECK_LFS], [
477 AC_LANG_SAVE
478 AC_LANG_CPLUSPLUS
479 ac_save_CXXFLAGS="$CXXFLAGS"
480 CXXFLAGS="$CXXFLAGS -fno-exceptions"
481 AC_CACHE_CHECK([for LFS support], glibcxx_cv_LFS, [
482 GCC_TRY_COMPILE_OR_LINK(
483 [#include <unistd.h>
484 #include <stdio.h>
485 #include <sys/stat.h>
486 ],
487 [FILE* fp;
488 fopen64("t", "w");
489 fseeko64(fp, 0, SEEK_CUR);
490 ftello64(fp);
491 lseek64(1, 0, SEEK_CUR);
492 struct stat64 buf;
493 fstat64(1, &buf);],
494 [glibcxx_cv_LFS=yes],
495 [glibcxx_cv_LFS=no])
496 ])
497 if test $glibcxx_cv_LFS = yes; then
498 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
499 fi
500 CXXFLAGS="$ac_save_CXXFLAGS"
501 AC_LANG_RESTORE
502 ])
505 dnl
506 dnl Check whether the old Copy-On-Write basic_string should allocate a new
507 dnl empty representation for every default-constructed basic_string. Without
508 dnl this option, COW strings share a single empty rep in static storage,
509 dnl but this only works if the linker can guarantee the static storage has
510 dnl a unique definition in the process. It also doesn't work if basic_string
511 dnl objects are stored in shared memory (see PR libstdc++/16612).
512 dnl When fully dynamic strings are enabled, the static storage is not used
513 dnl and a new empty string with reference-count == 1 is allocated each time.
514 dnl Enabling this changes the libstdc++.so ABI.
515 dnl
516 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
517 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
518 dnl otherwise the macro is not defined.
519 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
520 dnl Where DEFAULT is either `yes' or `no'.
521 dnl
522 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
523 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory], [permit yes|no])
524 if test $enable_fully_dynamic_string = yes; then
525 enable_fully_dynamic_string_def=1
526 else
527 enable_fully_dynamic_string_def=0
528 fi
529 AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
530 [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
531 ])
534 dnl
535 dnl Does any necessary configuration of the testsuite directory. Generates
536 dnl the testsuite_hooks.h header.
537 dnl
538 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
539 dnl
540 dnl Sets:
541 dnl enable_abi_check
542 dnl GLIBCXX_TEST_WCHAR_T
543 dnl GLIBCXX_TEST_THREAD
544 dnl Substs:
545 dnl baseline_dir
546 dnl baseline_subdir_switch
547 dnl
548 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
549 # Do checks for resource limit functions.
550 GLIBCXX_CHECK_SETRLIMIT
552 if $GLIBCXX_IS_NATIVE ; then
553 # Look for setenv, so that extended locale tests can be performed.
554 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
555 fi
557 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
558 test $enable_symvers != no; then
559 case "$host" in
560 *-*-cygwin*)
561 enable_abi_check=no ;;
562 *)
563 enable_abi_check=yes ;;
564 esac
565 else
566 # Only build this as native, since automake does not understand
567 # CXX_FOR_BUILD.
568 enable_abi_check=no
569 fi
571 # Export file names for ABI checking.
572 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
573 AC_SUBST(baseline_dir)
574 baseline_subdir_switch="$abi_baseline_subdir_switch"
575 AC_SUBST(baseline_subdir_switch)
576 ])
579 dnl
580 dnl Does any necessary configuration for docbook in the docs directory.
581 dnl
582 dnl XSLTPROC must be set before this
583 dnl
584 dnl Sets:
585 dnl glibcxx_stylesheets
586 dnl Substs:
587 dnl XSL_STYLE_DIR
588 dnl
589 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
591 glibcxx_docbook_url=http://docbook.sourceforge.net/release/xsl-ns/current/
593 AC_MSG_CHECKING([for local stylesheet directory])
594 glibcxx_local_stylesheets=no
595 if test x${XMLCATALOG} = xyes && xsl_style_dir=`xmlcatalog "" $glibcxx_docbook_url 2>/dev/null`
596 then
597 XSL_STYLE_DIR=`echo $xsl_style_dir | sed -n 's;^file://;;p'`
598 glibcxx_local_stylesheets=yes
599 else
600 for dir in \
601 /usr/share/sgml/docbook/xsl-ns-stylesheets \
602 /usr/share/xml/docbook/stylesheet/docbook-xsl-ns \
603 /usr/share/xml/docbook/stylesheet/nwalsh5/current \
604 /usr/share/xml/docbook/stylesheet/nwalsh/current
605 do
606 if test -d $dir; then
607 glibcxx_local_stylesheets=yes
608 XSL_STYLE_DIR=$dir
609 break
610 fi
611 done
612 fi
613 AC_MSG_RESULT($glibcxx_local_stylesheets)
615 if test x"$glibcxx_local_stylesheets" = x"yes"; then
616 AC_SUBST(XSL_STYLE_DIR)
617 AC_MSG_NOTICE($XSL_STYLE_DIR)
619 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
620 glibcxx_stylesheets=no
621 if test x${XMLCATALOG} = xno || xmlcatalog "" $glibcxx_docbook_url/xhtml/docbook.xsl >/dev/null 2>&1; then
622 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude $glibcxx_docbook_url/xhtml/docbook.xsl - 2>/dev/null; then
623 glibcxx_stylesheets=yes
624 fi
625 fi
626 AC_MSG_RESULT($glibcxx_stylesheets)
628 else
629 glibcxx_stylesheets=no
630 fi
632 # Check for epub3 dependencies.
633 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
634 glibcxx_epub_stylesheets=no
635 if test x"$glibcxx_local_stylesheets" = x"yes"; then
636 if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
637 glibcxx_epub_stylesheets=yes
638 fi
639 fi
640 AC_MSG_RESULT($glibcxx_epub_stylesheets)
641 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
643 ])
646 dnl
647 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
648 dnl
649 dnl Substs:
650 dnl GLIBCXX_INCLUDES
651 dnl TOPLEVEL_INCLUDES
652 dnl
653 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
654 # Used for every C++ compile we perform.
655 GLIBCXX_INCLUDES="\
656 -I$glibcxx_builddir/include/$host_alias \
657 -I$glibcxx_builddir/include \
658 -I$glibcxx_srcdir/libsupc++"
660 # For Canadian crosses, pick this up too.
661 if test $CANADIAN = yes; then
662 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
663 fi
665 # Stuff in the actual top level. Currently only used by libsupc++ to
666 # get unwind* headers from the libgcc dir.
667 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
668 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
670 # Now, export this to all the little Makefiles....
671 AC_SUBST(GLIBCXX_INCLUDES)
672 AC_SUBST(TOPLEVEL_INCLUDES)
673 ])
676 dnl
677 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
678 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
679 dnl
680 dnl Substs:
681 dnl CPPFLAGS
682 dnl OPTIMIZE_CXXFLAGS
683 dnl WARN_FLAGS
684 dnl
685 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
686 AC_SUBST(CPPFLAGS)
688 # Optimization flags that are probably a good idea for thrill-seekers. Just
689 # uncomment the lines below and make, everything else is ready to go...
690 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
691 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
692 AC_SUBST(OPTIMIZE_CXXFLAGS)
694 WARN_FLAGS="-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi=2"
695 AC_SUBST(WARN_FLAGS)
696 ])
699 dnl
700 dnl All installation directory information is determined here.
701 dnl
702 dnl Substs:
703 dnl gxx_install_dir
704 dnl glibcxx_prefixdir
705 dnl glibcxx_toolexecdir
706 dnl glibcxx_toolexeclibdir
707 dnl
708 dnl Assumes cross_compiling bits already done, and with_cross_host in
709 dnl particular.
710 dnl
711 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
712 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
713 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
714 glibcxx_toolexecdir=no
715 glibcxx_toolexeclibdir=no
716 glibcxx_prefixdir=$prefix
718 AC_MSG_CHECKING([for gxx-include-dir])
719 AC_ARG_WITH([gxx-include-dir],
720 AC_HELP_STRING([--with-gxx-include-dir=DIR],
721 [installation directory for include files]),
722 [case "$withval" in
723 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
724 no) gxx_include_dir=no ;;
725 *) gxx_include_dir=$withval ;;
726 esac],
727 [gxx_include_dir=no])
728 AC_MSG_RESULT($gxx_include_dir)
730 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
731 AC_ARG_ENABLE([version-specific-runtime-libs],
732 AC_HELP_STRING([--enable-version-specific-runtime-libs],
733 [Specify that runtime libraries should be installed in a compiler-specific directory]),
734 [case "$enableval" in
735 yes) version_specific_libs=yes ;;
736 no) version_specific_libs=no ;;
737 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
738 esac],
739 [version_specific_libs=no])
740 AC_MSG_RESULT($version_specific_libs)
742 GCC_WITH_TOOLEXECLIBDIR
744 # Default case for install directory for include files.
745 if test $version_specific_libs = no && test $gxx_include_dir = no; then
746 gxx_include_dir='include/c++/${gcc_version}'
747 if test -n "$with_cross_host" &&
748 test x"$with_cross_host" != x"no"; then
749 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
750 else
751 gxx_include_dir='${prefix}/'"$gxx_include_dir"
752 fi
753 fi
755 # Version-specific runtime libs processing.
756 if test $version_specific_libs = yes; then
757 # Need the gcc compiler version to know where to install libraries
758 # and header files if --enable-version-specific-runtime-libs option
759 # is selected. FIXME: these variables are misnamed, there are
760 # no executables installed in _toolexecdir or _toolexeclibdir.
761 if test x"$gxx_include_dir" = x"no"; then
762 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
763 fi
764 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
765 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
766 fi
768 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
769 # Install a library built with a cross compiler in tooldir, not libdir.
770 if test x"$glibcxx_toolexecdir" = x"no"; then
771 if test -n "$with_cross_host" &&
772 test x"$with_cross_host" != x"no"; then
773 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
774 case ${with_toolexeclibdir} in
775 no)
776 glibcxx_toolexeclibdir='${toolexecdir}/lib'
777 ;;
778 *)
779 glibcxx_toolexeclibdir=${with_toolexeclibdir}
780 ;;
781 esac
782 else
783 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
784 glibcxx_toolexeclibdir='${libdir}'
785 fi
786 multi_os_directory=`$CXX -print-multi-os-directory`
787 case $multi_os_directory in
788 .) ;; # Avoid trailing /.
789 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
790 esac
791 fi
793 AC_MSG_CHECKING([for install location])
794 AC_MSG_RESULT($gxx_include_dir)
796 AC_SUBST(glibcxx_prefixdir)
797 AC_SUBST(gxx_include_dir)
798 AC_SUBST(glibcxx_toolexecdir)
799 AC_SUBST(glibcxx_toolexeclibdir)
800 ])
803 dnl
804 dnl GLIBCXX_ENABLE
805 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
806 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
807 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
808 dnl
809 dnl See manual/appendix_porting.html#appendix.porting.build_hacking for
810 dnl documentation.
811 dnl
812 m4_define([GLIBCXX_ENABLE],[dnl
813 m4_define([_g_switch],[--enable-$1])dnl
814 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
815 AC_ARG_ENABLE([$1],m4_dquote(_g_help),
816 m4_bmatch([$5],
817 [^permit ],
818 [[
819 case "$enableval" in
820 m4_bpatsubst([$5],[permit ])) ;;
821 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
822 dnl Idea for future: generate a URL pointing to
823 dnl "onlinedocs/configopts.html#whatever"
824 esac
825 ]],
826 [^$],
827 [[
828 case "$enableval" in
829 yes|no) ;;
830 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
831 esac
832 ]],
833 [[$5]]),
834 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
835 m4_undefine([_g_switch])dnl
836 m4_undefine([_g_help])dnl
837 ])
840 dnl
841 dnl Check for ISO/IEC 9899:1999 "C99" support.
842 dnl
843 dnl --enable-c99 defines _GLIBCXX_USE_C99
844 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
845 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
846 dnl Where DEFAULT is either `yes' or `no'.
847 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
848 dnl
849 AC_DEFUN([GLIBCXX_ENABLE_C99], [
850 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
852 if test x"$enable_c99" = x"yes"; then
853 AC_LANG_SAVE
854 AC_LANG_CPLUSPLUS
856 # Use -std=c++98 (instead of -std=gnu++98) because leaving __STRICT_ANSI__
857 # undefined may cause fake C99 facilities, like pre-standard snprintf,
858 # to be spuriously enabled.
859 ac_save_CXXFLAGS="$CXXFLAGS"
860 CXXFLAGS="$CXXFLAGS -std=c++98"
861 ac_save_LIBS="$LIBS"
862 ac_save_gcc_no_link="$gcc_no_link"
864 if test x$gcc_no_link != xyes; then
865 # Use -fno-exceptions to that the C driver can link these tests without
866 # hitting undefined references to personality routines.
867 CXXFLAGS="$CXXFLAGS -fno-exceptions"
868 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
869 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
870 gcc_no_link=yes
871 ])
872 fi
874 # Check for the existence of <math.h> functions used if C99 is enabled.
875 AC_CACHE_CHECK([for ISO C99 support in <math.h> for C++98],
876 glibcxx_cv_c99_math_cxx98, [
877 GCC_TRY_COMPILE_OR_LINK(
878 [#include <math.h>
879 volatile double d1, d2;
880 volatile int i;],
881 [i = fpclassify(d1);
882 i = isfinite(d1);
883 i = isinf(d1);
884 i = isnan(d1);
885 i = isnormal(d1);
886 i = signbit(d1);
887 i = isgreater(d1, d2);
888 i = isgreaterequal(d1, d2);
889 i = isless(d1, d2);
890 i = islessequal(d1, d2);
891 i = islessgreater(d1, d2);
892 i = islessgreater(d1, d2);
893 i = isunordered(d1, d2);
894 ], [glibcxx_cv_c99_math_cxx98=yes], [glibcxx_cv_c99_math_cxx98=no])
895 ])
896 if test x"$glibcxx_cv_c99_math_cxx98" = x"yes"; then
897 AC_DEFINE(_GLIBCXX98_USE_C99_MATH, 1,
898 [Define if C99 functions or macros in <math.h> should be imported
899 in <cmath> in namespace std for C++98.])
900 fi
902 # Check for the existence of <complex.h> complex math functions.
903 # This is necessary even though libstdc++ uses the builtin versions
904 # of these functions, because if the builtin cannot be used, a reference
905 # to the library function is emitted.
906 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
907 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
908 if test x"$ac_has_complex_h" = x"yes"; then
909 AC_CACHE_CHECK([for ISO C99 support in <complex.h> for C++98],
910 glibcxx_cv_c99_complex_cxx98, [
911 GCC_TRY_COMPILE_OR_LINK(
912 [#include <complex.h>
913 typedef __complex__ float float_type;
914 typedef __complex__ double double_type;
915 typedef __complex__ long double ld_type;
916 volatile float_type tmpf;
917 volatile double_type tmpd;
918 volatile ld_type tmpld;
919 volatile float f;
920 volatile double d;
921 volatile long double ld;],
922 [f = cabsf(tmpf);
923 f = cargf(tmpf);
924 tmpf = ccosf(tmpf);
925 tmpf = ccoshf(tmpf);
926 tmpf = cexpf(tmpf);
927 tmpf = clogf(tmpf);
928 tmpf = csinf(tmpf);
929 tmpf = csinhf(tmpf);
930 tmpf = csqrtf(tmpf);
931 tmpf = ctanf(tmpf);
932 tmpf = ctanhf(tmpf);
933 tmpf = cpowf(tmpf, tmpf);
934 tmpf = cprojf(tmpf);
935 d = cabs(tmpd);
936 d = carg(tmpd);
937 tmpd = ccos(tmpd);
938 tmpd = ccosh(tmpd);
939 tmpd = cexp(tmpd);
940 tmpd = clog(tmpd);
941 tmpd = csin(tmpd);
942 tmpd = csinh(tmpd);
943 tmpd = csqrt(tmpd);
944 tmpd = ctan(tmpd);
945 tmpd = ctanh(tmpd);
946 tmpd = cpow(tmpd, tmpd);
947 tmpd = cproj(tmpd);
948 ld = cabsl(tmpld);
949 ld = cargl(tmpld);
950 tmpld = ccosl(tmpld);
951 tmpld = ccoshl(tmpld);
952 tmpld = cexpl(tmpld);
953 tmpld = clogl(tmpld);
954 tmpld = csinl(tmpld);
955 tmpld = csinhl(tmpld);
956 tmpld = csqrtl(tmpld);
957 tmpld = ctanl(tmpld);
958 tmpld = ctanhl(tmpld);
959 tmpld = cpowl(tmpld, tmpld);
960 tmpld = cprojl(tmpld);
961 ], [glibcxx_cv_c99_complex_cxx98=yes], [glibcxx_cv_c99_complex_cxx98=no])
962 ])
963 fi
964 if test x"$glibcxx_cv_c99_complex_cxx98" = x"yes"; then
965 AC_DEFINE(_GLIBCXX98_USE_C99_COMPLEX, 1,
966 [Define if C99 functions in <complex.h> should be used in
967 <complex> for C++98. Using compiler builtins for these functions
968 requires corresponding C99 library functions to be present.])
969 fi
971 # Check for the existence in <stdio.h> of vscanf, et. al.
972 AC_CACHE_CHECK([for ISO C99 support in <stdio.h> for C++98],
973 glibcxx_cv_c99_stdio_cxx98, [
974 GCC_TRY_COMPILE_OR_LINK(
975 [#include <stdio.h>
976 #include <stdarg.h>
977 void foo(char* fmt, ...)
978 {
979 va_list args; va_start(args, fmt);
980 vfscanf(stderr, "%i", args);
981 vscanf("%i", args);
982 vsnprintf(fmt, 0, "%i", args);
983 vsscanf(fmt, "%i", args);
984 snprintf(fmt, 0, "%i");
985 }], [],
986 [glibcxx_cv_c99_stdio_cxx98=yes], [glibcxx_cv_c99_stdio_cxx98=no])
987 ])
988 if test x"$glibcxx_cv_c99_stdio_cxx98" = x"yes"; then
989 AC_DEFINE(_GLIBCXX98_USE_C99_STDIO, 1,
990 [Define if C99 functions or macros in <stdio.h> should be imported
991 in <cstdio> in namespace std for C++98.])
992 fi
994 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
995 AC_CACHE_CHECK([for ISO C99 support in <stdlib.h> for C++98],
996 glibcxx_cv_c99_stdlib_cxx98, [
997 GCC_TRY_COMPILE_OR_LINK(
998 [#include <stdlib.h>
999 volatile float f;
1000 volatile long double ld;
1001 volatile unsigned long long ll;
1002 lldiv_t mydivt;],
1003 [char* tmp;
1004 f = strtof("gnu", &tmp);
1005 ld = strtold("gnu", &tmp);
1006 ll = strtoll("gnu", &tmp, 10);
1007 ll = strtoull("gnu", &tmp, 10);
1008 ll = llabs(10);
1009 mydivt = lldiv(10,1);
1010 ll = mydivt.quot;
1011 ll = mydivt.rem;
1012 ll = atoll("10");
1013 _Exit(0);
1014 ], [glibcxx_cv_c99_stdlib_cxx98=yes], [glibcxx_cv_c99_stdlib_cxx98=no])
1015 ])
1016 if test x"$glibcxx_cv_c99_stdlib_cxx98" = x"yes"; then
1017 AC_DEFINE(_GLIBCXX98_USE_C99_STDLIB, 1,
1018 [Define if C99 functions or macros in <stdlib.h> should be imported
1019 in <cstdlib> in namespace std for C++98.])
1020 fi
1022 # Check for the existence in <wchar.h> of wcstold, etc.
1023 if test x"$ac_has_wchar_h" = xyes &&
1024 test x"$ac_has_wctype_h" = xyes; then
1025 AC_CACHE_CHECK([for ISO C99 support in <wchar.h> for C++98],
1026 glibcxx_cv_c99_wchar_cxx98, [
1027 AC_TRY_COMPILE([#include <wchar.h>
1028 namespace test
1029 {
1030 using ::wcstold;
1031 using ::wcstoll;
1032 using ::wcstoull;
1033 }
1034 ], [], [glibcxx_cv_c99_wchar_cxx98=yes], [glibcxx_cv_c99_wchar_cxx98=no])
1035 ])
1037 # Checks for wide character functions that may not be present.
1038 # Injection of these is wrapped with guard macros.
1039 # NB: only put functions here, instead of immediately above, if
1040 # absolutely necessary.
1041 AC_TRY_COMPILE([#include <wchar.h>
1042 namespace test { using ::vfwscanf; }], [],
1043 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1045 AC_TRY_COMPILE([#include <wchar.h>
1046 namespace test { using ::vswscanf; }], [],
1047 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1049 AC_TRY_COMPILE([#include <wchar.h>
1050 namespace test { using ::vwscanf; }], [],
1051 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1053 AC_TRY_COMPILE([#include <wchar.h>
1054 namespace test { using ::wcstof; }], [],
1055 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1057 AC_TRY_COMPILE([#include <wctype.h>],
1058 [wint_t t; int i = iswblank(t);],
1059 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1061 if test x"$glibcxx_cv_c99_wchar_cxx98" = x"yes"; then
1062 AC_DEFINE(_GLIBCXX98_USE_C99_WCHAR, 1,
1063 [Define if C99 functions or macros in <wchar.h> should be imported
1064 in <cwchar> in namespace std for C++98.])
1065 fi
1066 fi
1068 # Option parsed, now set things appropriately.
1069 if test x"$glibcxx_cv_c99_math_cxx98" = x"no" ||
1070 test x"$glibcxx_cv_c99_complex_cxx98" = x"no" ||
1071 test x"$glibcxx_cv_c99_stdio_cxx98" = x"no" ||
1072 test x"$glibcxx_cv_c99_stdlib_cxx98" = x"no" ||
1073 test x"$glibcxx_cv_c99_wchar_cxx98" = x"no"; then
1074 enable_c99=no;
1075 else
1076 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1077 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1078 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1079 fi
1081 gcc_no_link="$ac_save_gcc_no_link"
1082 LIBS="$ac_save_LIBS"
1083 CXXFLAGS="$ac_save_CXXFLAGS"
1084 AC_LANG_RESTORE
1086 AC_LANG_SAVE
1087 AC_LANG_CPLUSPLUS
1089 # Use -std=c++11 and test again for C99 library feature in C++11 mode.
1090 # For the reasons given above we use -std=c++11 not -std=gnu++11.
1091 ac_save_CXXFLAGS="$CXXFLAGS"
1092 CXXFLAGS="$CXXFLAGS -std=c++11"
1093 ac_save_LIBS="$LIBS"
1094 ac_save_gcc_no_link="$gcc_no_link"
1096 if test x$gcc_no_link != xyes; then
1097 # Use -fno-exceptions to that the C driver can link these tests without
1098 # hitting undefined references to personality routines.
1099 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1100 AC_CHECK_LIB(m, sin, [LIBS="$LIBS -lm"], [
1101 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
1102 gcc_no_link=yes
1103 ])
1104 fi
1106 # Check for the existence of <stdint.h> types.
1107 AC_CACHE_CHECK([for ISO C99 support in <stdint.h> for C++11],
1108 glibcxx_cv_c99_stdint, [
1109 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1110 #define __STDC_CONSTANT_MACROS
1111 #include <stdint.h>],
1112 [typedef int8_t my_int8_t;
1113 my_int8_t i8 = INT8_MIN;
1114 i8 = INT8_MAX;
1115 typedef int16_t my_int16_t;
1116 my_int16_t i16 = INT16_MIN;
1117 i16 = INT16_MAX;
1118 typedef int32_t my_int32_t;
1119 my_int32_t i32 = INT32_MIN;
1120 i32 = INT32_MAX;
1121 typedef int64_t my_int64_t;
1122 my_int64_t i64 = INT64_MIN;
1123 i64 = INT64_MAX;
1124 typedef int_fast8_t my_int_fast8_t;
1125 my_int_fast8_t if8 = INT_FAST8_MIN;
1126 if8 = INT_FAST8_MAX;
1127 typedef int_fast16_t my_int_fast16_t;
1128 my_int_fast16_t if16 = INT_FAST16_MIN;
1129 if16 = INT_FAST16_MAX;
1130 typedef int_fast32_t my_int_fast32_t;
1131 my_int_fast32_t if32 = INT_FAST32_MIN;
1132 if32 = INT_FAST32_MAX;
1133 typedef int_fast64_t my_int_fast64_t;
1134 my_int_fast64_t if64 = INT_FAST64_MIN;
1135 if64 = INT_FAST64_MAX;
1136 typedef int_least8_t my_int_least8_t;
1137 my_int_least8_t il8 = INT_LEAST8_MIN;
1138 il8 = INT_LEAST8_MAX;
1139 typedef int_least16_t my_int_least16_t;
1140 my_int_least16_t il16 = INT_LEAST16_MIN;
1141 il16 = INT_LEAST16_MAX;
1142 typedef int_least32_t my_int_least32_t;
1143 my_int_least32_t il32 = INT_LEAST32_MIN;
1144 il32 = INT_LEAST32_MAX;
1145 typedef int_least64_t my_int_least64_t;
1146 my_int_least64_t il64 = INT_LEAST64_MIN;
1147 il64 = INT_LEAST64_MAX;
1148 typedef intmax_t my_intmax_t;
1149 my_intmax_t im = INTMAX_MAX;
1150 im = INTMAX_MIN;
1151 typedef intptr_t my_intptr_t;
1152 my_intptr_t ip = INTPTR_MAX;
1153 ip = INTPTR_MIN;
1154 typedef uint8_t my_uint8_t;
1155 my_uint8_t ui8 = UINT8_MAX;
1156 ui8 = UINT8_MAX;
1157 typedef uint16_t my_uint16_t;
1158 my_uint16_t ui16 = UINT16_MAX;
1159 ui16 = UINT16_MAX;
1160 typedef uint32_t my_uint32_t;
1161 my_uint32_t ui32 = UINT32_MAX;
1162 ui32 = UINT32_MAX;
1163 typedef uint64_t my_uint64_t;
1164 my_uint64_t ui64 = UINT64_MAX;
1165 ui64 = UINT64_MAX;
1166 typedef uint_fast8_t my_uint_fast8_t;
1167 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1168 uif8 = UINT_FAST8_MAX;
1169 typedef uint_fast16_t my_uint_fast16_t;
1170 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1171 uif16 = UINT_FAST16_MAX;
1172 typedef uint_fast32_t my_uint_fast32_t;
1173 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1174 uif32 = UINT_FAST32_MAX;
1175 typedef uint_fast64_t my_uint_fast64_t;
1176 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1177 uif64 = UINT_FAST64_MAX;
1178 typedef uint_least8_t my_uint_least8_t;
1179 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1180 uil8 = UINT_LEAST8_MAX;
1181 typedef uint_least16_t my_uint_least16_t;
1182 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1183 uil16 = UINT_LEAST16_MAX;
1184 typedef uint_least32_t my_uint_least32_t;
1185 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1186 uil32 = UINT_LEAST32_MAX;
1187 typedef uint_least64_t my_uint_least64_t;
1188 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1189 uil64 = UINT_LEAST64_MAX;
1190 typedef uintmax_t my_uintmax_t;
1191 my_uintmax_t uim = UINTMAX_MAX;
1192 uim = UINTMAX_MAX;
1193 typedef uintptr_t my_uintptr_t;
1194 my_uintptr_t uip = UINTPTR_MAX;
1195 uip = UINTPTR_MAX;
1196 ],[glibcxx_cv_c99_stdint=yes],
1197 [glibcxx_cv_c99_stdint=no])
1198 ])
1199 if test x"$glibcxx_cv_c99_stdint" = x"yes"; then
1200 AC_DEFINE(_GLIBCXX_USE_C99_STDINT, 1,
1201 [Define if C99 types in <stdint.h> should be imported in
1202 <cstdint> in namespace std for C++11.])
1203 fi
1205 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1206 # sense if the glibcxx_cv_c99_stdint check fails, per C99, 7.8/1).
1207 ac_c99_inttypes=no;
1208 if test x"$glibcxx_cv_c99_stdint" = x"yes"; then
1209 AC_MSG_CHECKING([for ISO C99 support for C++11 in <inttypes.h>])
1210 AC_TRY_COMPILE([#include <inttypes.h>],
1211 [intmax_t i, numer, denom, base;
1212 const char* s;
1213 char** endptr;
1214 intmax_t ret = imaxabs(i);
1215 imaxdiv_t dret = imaxdiv(numer, denom);
1216 ret = strtoimax(s, endptr, base);
1217 uintmax_t uret = strtoumax(s, endptr, base);
1218 ],[ac_c99_inttypes=yes], [ac_c99_inttypes=no])
1219 AC_MSG_RESULT($ac_c99_inttypes)
1220 fi
1221 if test x"$ac_c99_inttypes" = x"yes"; then
1222 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES, 1,
1223 [Define if C99 functions in <inttypes.h> should be imported in
1224 <cinttypes> in namespace std in C++11.])
1225 fi
1227 # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
1228 # make sense if the glibcxx_cv_c99_stdint check fails, per C99, 7.8/1).
1229 ac_c99_inttypes_wchar_t=no;
1230 if test x"$glibcxx_cv_c99_stdint" = x"yes"; then
1231 AC_MSG_CHECKING([for wchar_t ISO C99 support for C++11 in <inttypes.h>])
1232 AC_TRY_COMPILE([#include <inttypes.h>],
1233 [intmax_t base;
1234 const wchar_t* s;
1235 wchar_t** endptr;
1236 intmax_t ret = wcstoimax(s, endptr, base);
1237 uintmax_t uret = wcstoumax(s, endptr, base);
1238 ],[ac_c99_inttypes_wchar_t=yes],
1239 [ac_c99_inttypes_wchar_t=no])
1240 AC_MSG_RESULT($ac_c99_inttypes_wchar_t)
1241 fi
1242 if test x"$ac_c99_inttypes_wchar_t" = x"yes"; then
1243 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T, 1,
1244 [Define if wchar_t C99 functions in <inttypes.h> should be
1245 imported in <cinttypes> in namespace std in C++11.])
1246 fi
1248 # Check for the existence of <math.h> functions used if C99 is enabled.
1249 AC_CACHE_CHECK([for ISO C99 support in <math.h> for C++11],
1250 glibcxx_cv_c99_math_cxx11, [
1251 GCC_TRY_COMPILE_OR_LINK(
1252 [#include <math.h>
1253 volatile double d1, d2;
1254 volatile int i;],
1255 [i = fpclassify(d1);
1256 i = isfinite(d1);
1257 i = isinf(d1);
1258 i = isnan(d1);
1259 i = isnormal(d1);
1260 i = signbit(d1);
1261 i = isgreater(d1, d2);
1262 i = isgreaterequal(d1, d2);
1263 i = isless(d1, d2);
1264 i = islessequal(d1, d2);
1265 i = islessgreater(d1, d2);
1266 i = islessgreater(d1, d2);
1267 i = isunordered(d1, d2);
1268 ], [glibcxx_cv_c99_math_cxx11=yes], [glibcxx_cv_c99_math_cxx11=no])
1269 ])
1270 if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
1271 AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
1272 [Define if C99 functions or macros in <math.h> should be imported
1273 in <cmath> in namespace std for C++11.])
1274 fi
1276 # Check for the existence of <complex.h> complex math functions.
1277 # This is necessary even though libstdc++ uses the builtin versions
1278 # of these functions, because if the builtin cannot be used, a reference
1279 # to the library function is emitted.
1280 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
1281 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1282 if test x"$ac_has_complex_h" = x"yes"; then
1283 AC_CACHE_CHECK([for ISO C99 support in <complex.h> for C++11],
1284 glibcxx_cv_c99_complex_cxx11, [
1285 GCC_TRY_COMPILE_OR_LINK(
1286 [#include <complex.h>
1287 typedef __complex__ float float_type;
1288 typedef __complex__ double double_type;
1289 typedef __complex__ long double ld_type;
1290 volatile float_type tmpf;
1291 volatile double_type tmpd;
1292 volatile ld_type tmpld;
1293 volatile float f;
1294 volatile double d;
1295 volatile long double ld;],
1296 [f = cabsf(tmpf);
1297 f = cargf(tmpf);
1298 tmpf = ccosf(tmpf);
1299 tmpf = ccoshf(tmpf);
1300 tmpf = cexpf(tmpf);
1301 tmpf = clogf(tmpf);
1302 tmpf = csinf(tmpf);
1303 tmpf = csinhf(tmpf);
1304 tmpf = csqrtf(tmpf);
1305 tmpf = ctanf(tmpf);
1306 tmpf = ctanhf(tmpf);
1307 tmpf = cpowf(tmpf, tmpf);
1308 tmpf = cprojf(tmpf);
1309 d = cabs(tmpd);
1310 d = carg(tmpd);
1311 tmpd = ccos(tmpd);
1312 tmpd = ccosh(tmpd);
1313 tmpd = cexp(tmpd);
1314 tmpd = clog(tmpd);
1315 tmpd = csin(tmpd);
1316 tmpd = csinh(tmpd);
1317 tmpd = csqrt(tmpd);
1318 tmpd = ctan(tmpd);
1319 tmpd = ctanh(tmpd);
1320 tmpd = cpow(tmpd, tmpd);
1321 tmpd = cproj(tmpd);
1322 ld = cabsl(tmpld);
1323 ld = cargl(tmpld);
1324 tmpld = ccosl(tmpld);
1325 tmpld = ccoshl(tmpld);
1326 tmpld = cexpl(tmpld);
1327 tmpld = clogl(tmpld);
1328 tmpld = csinl(tmpld);
1329 tmpld = csinhl(tmpld);
1330 tmpld = csqrtl(tmpld);
1331 tmpld = ctanl(tmpld);
1332 tmpld = ctanhl(tmpld);
1333 tmpld = cpowl(tmpld, tmpld);
1334 tmpld = cprojl(tmpld);
1335 ], [glibcxx_cv_c99_complex_cxx11=yes], [glibcxx_cv_c99_complex_cxx11=no])
1336 ])
1337 fi
1338 if test x"$glibcxx_cv_c99_complex_cxx11" = x"yes"; then
1339 AC_DEFINE(_GLIBCXX11_USE_C99_COMPLEX, 1,
1340 [Define if C99 functions in <complex.h> should be used in
1341 <complex> for C++11. Using compiler builtins for these functions
1342 requires corresponding C99 library functions to be present.])
1343 fi
1345 # Check for the existence of <complex.h> complex inverse trigonometric
1346 # math functions used by <complex> for C++11 and later.
1347 ac_c99_complex_arc=no;
1348 if test x"$ac_has_complex_h" = x"yes"; then
1349 AC_MSG_CHECKING([for ISO C99 support for inverse trig functions in <complex.h>])
1350 AC_TRY_COMPILE([#include <complex.h>],
1351 [typedef __complex__ float float_type; float_type tmpf;
1352 cacosf(tmpf);
1353 casinf(tmpf);
1354 catanf(tmpf);
1355 cacoshf(tmpf);
1356 casinhf(tmpf);
1357 catanhf(tmpf);
1358 typedef __complex__ double double_type; double_type tmpd;
1359 cacos(tmpd);
1360 casin(tmpd);
1361 catan(tmpd);
1362 cacosh(tmpd);
1363 casinh(tmpd);
1364 catanh(tmpd);
1365 typedef __complex__ long double ld_type; ld_type tmpld;
1366 cacosl(tmpld);
1367 casinl(tmpld);
1368 catanl(tmpld);
1369 cacoshl(tmpld);
1370 casinhl(tmpld);
1371 catanhl(tmpld);
1372 ],[ac_c99_complex_arc=yes], [ac_c99_complex_arc=no])
1373 fi
1374 AC_MSG_RESULT($ac_c99_complex_arc)
1375 if test x"$ac_c99_complex_arc" = x"yes"; then
1376 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_ARC, 1,
1377 [Define if C99 inverse trig functions in <complex.h> should be
1378 used in <complex>. Using compiler builtins for these functions
1379 requires corresponding C99 library functions to be present.])
1380 fi
1382 # Check for the existence in <stdio.h> of vscanf, et. al.
1383 AC_CACHE_CHECK([for ISO C99 support in <stdio.h> for C++11],
1384 glibcxx_cv_c99_stdio_cxx11, [
1385 GCC_TRY_COMPILE_OR_LINK(
1386 [#include <stdio.h>
1387 #include <stdarg.h>
1388 void foo(char* fmt, ...)
1389 {
1390 va_list args; va_start(args, fmt);
1391 vfscanf(stderr, "%i", args);
1392 vscanf("%i", args);
1393 vsnprintf(fmt, 0, "%i", args);
1394 vsscanf(fmt, "%i", args);
1395 snprintf(fmt, 0, "%i");
1396 }], [],
1397 [glibcxx_cv_c99_stdio_cxx11=yes], [glibcxx_cv_c99_stdio_cxx11=no])
1398 ])
1399 if test x"$glibcxx_cv_c99_stdio_cxx11" = x"yes"; then
1400 AC_DEFINE(_GLIBCXX11_USE_C99_STDIO, 1,
1401 [Define if C99 functions or macros in <stdio.h> should be imported
1402 in <cstdio> in namespace std for C++11.])
1403 fi
1405 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1406 AC_CACHE_CHECK([for ISO C99 support in <stdlib.h> for C++11],
1407 glibcxx_cv_c99_stdlib_cxx11, [
1408 GCC_TRY_COMPILE_OR_LINK(
1409 [#include <stdlib.h>
1410 volatile float f;
1411 volatile long double ld;
1412 volatile unsigned long long ll;
1413 lldiv_t mydivt;],
1414 [char* tmp;
1415 f = strtof("gnu", &tmp);
1416 ld = strtold("gnu", &tmp);
1417 ll = strtoll("gnu", &tmp, 10);
1418 ll = strtoull("gnu", &tmp, 10);
1419 ll = llabs(10);
1420 mydivt = lldiv(10,1);
1421 ll = mydivt.quot;
1422 ll = mydivt.rem;
1423 ll = atoll("10");
1424 _Exit(0);
1425 ], [glibcxx_cv_c99_stdlib_cxx11=yes], [glibcxx_cv_c99_stdlib_cxx11=no])
1426 ])
1427 if test x"$glibcxx_cv_c99_stdlib_cxx11" = x"yes"; then
1428 AC_DEFINE(_GLIBCXX11_USE_C99_STDLIB, 1,
1429 [Define if C99 functions or macros in <stdlib.h> should be imported
1430 in <cstdlib> in namespace std for C++11.])
1431 fi
1433 # Check for the existence in <wchar.h> of wcstold, etc.
1434 if test x"$ac_has_wchar_h" = xyes &&
1435 test x"$ac_has_wctype_h" = xyes; then
1436 AC_CACHE_CHECK([for ISO C99 support in <wchar.h> for C++11],
1437 glibcxx_cv_c99_wchar_cxx11, [
1438 AC_TRY_COMPILE([#include <wchar.h>
1439 namespace test
1440 {
1441 using ::wcstold;
1442 using ::wcstoll;
1443 using ::wcstoull;
1444 }
1445 ], [], [glibcxx_cv_c99_wchar_cxx11=yes], [glibcxx_cv_c99_wchar_cxx11=no])
1446 ])
1448 # Checks for wide character functions that may not be present.
1449 # Injection of these is wrapped with guard macros.
1450 # NB: only put functions here, instead of immediately above, if
1451 # absolutely necessary.
1452 AC_TRY_COMPILE([#include <wchar.h>
1453 namespace test { using ::vfwscanf; }], [],
1454 [AC_DEFINE(HAVE_VFWSCANF, 1, [Defined if vfwscanf exists.])], [])
1456 AC_TRY_COMPILE([#include <wchar.h>
1457 namespace test { using ::vswscanf; }], [],
1458 [AC_DEFINE(HAVE_VSWSCANF, 1, [Defined if vswscanf exists.])], [])
1460 AC_TRY_COMPILE([#include <wchar.h>
1461 namespace test { using ::vwscanf; }], [],
1462 [AC_DEFINE(HAVE_VWSCANF, 1, [Defined if vwscanf exists.])], [])
1464 AC_TRY_COMPILE([#include <wchar.h>
1465 namespace test { using ::wcstof; }], [],
1466 [AC_DEFINE(HAVE_WCSTOF, 1, [Defined if wcstof exists.])], [])
1468 AC_TRY_COMPILE([#include <wctype.h>],
1469 [wint_t t; int i = iswblank(t);],
1470 [AC_DEFINE(HAVE_ISWBLANK, 1, [Defined if iswblank exists.])], [])
1472 if test x"$glibcxx_cv_c99_wchar_cxx11" = x"yes"; then
1473 AC_DEFINE(_GLIBCXX11_USE_C99_WCHAR, 1,
1474 [Define if C99 functions or macros in <wchar.h> should be imported
1475 in <cwchar> in namespace std for C++11.])
1476 fi
1477 fi
1479 # Check for the existence of <ctype.h> functions.
1480 AC_CACHE_CHECK([for ISO C99 support for C++11 in <ctype.h>],
1481 glibcxx_cv_c99_ctype, [
1482 AC_TRY_COMPILE([#include <ctype.h>],
1483 [int ch;
1484 int ret;
1485 ret = isblank(ch);
1486 ],[glibcxx_cv_c99_ctype=yes],
1487 [glibcxx_cv_c99_ctype=no])
1488 ])
1489 if test x"$glibcxx_cv_c99_ctype" = x"yes"; then
1490 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE, 1,
1491 [Define if C99 functions in <ctype.h> should be imported in
1492 <cctype> in namespace std for C++11.])
1493 fi
1495 # Check for the existence of <fenv.h> functions.
1496 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1497 ac_c99_fenv=no;
1498 if test x"$ac_has_fenv_h" = x"yes"; then
1499 AC_MSG_CHECKING([for ISO C99 support for C++11 in <fenv.h>])
1500 AC_TRY_COMPILE([#include <fenv.h>],
1501 [int except, mode;
1502 fexcept_t* pflag;
1503 fenv_t* penv;
1504 int ret;
1505 ret = feclearexcept(except);
1506 ret = fegetexceptflag(pflag, except);
1507 ret = feraiseexcept(except);
1508 ret = fesetexceptflag(pflag, except);
1509 ret = fetestexcept(except);
1510 ret = fegetround();
1511 ret = fesetround(mode);
1512 ret = fegetenv(penv);
1513 ret = feholdexcept(penv);
1514 ret = fesetenv(penv);
1515 ret = feupdateenv(penv);
1516 ],[ac_c99_fenv=yes], [ac_c99_fenv=no])
1517 AC_MSG_RESULT($ac_c99_fenv)
1518 fi
1519 if test x"$ac_c99_fenv" = x"yes"; then
1520 AC_DEFINE(_GLIBCXX_USE_C99_FENV, 1,
1521 [Define if C99 functions in <fenv.h> should be imported in
1522 <cfenv> in namespace std for C++11.])
1523 fi
1525 gcc_no_link="$ac_save_gcc_no_link"
1526 LIBS="$ac_save_LIBS"
1527 CXXFLAGS="$ac_save_CXXFLAGS"
1528 AC_LANG_RESTORE
1529 fi
1531 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1532 AC_MSG_RESULT($enable_c99)
1533 ])
1536 dnl
1537 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1538 dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this]
1539 dnl in the C++11 standard.
1540 dnl
1541 dnl --enable-libstdcxx-time
1542 dnl --enable-libstdcxx-time=yes
1543 dnl checks for the availability of monotonic and realtime clocks,
1544 dnl nanosleep and sched_yield in libc.
1545 dnl --enable-libstdcxx-time=rt
1546 dnl also searches (and, if needed, links) librt. Note that this is
1547 dnl not always desirable because, in glibc 2.16 and earlier, for
1548 dnl example, in turn it triggers the linking of libpthread too,
1549 dnl which activates locking,
1550 dnl a large overhead for single-thread programs.
1551 dnl --enable-libstdcxx-time=no
1552 dnl --disable-libstdcxx-time
1553 dnl disables the checks completely
1554 dnl
1555 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1556 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1557 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1558 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1559 dnl
1560 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1562 GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]],
1563 [use KIND for check type],
1564 [permit yes|no|rt])
1566 AC_LANG_SAVE
1567 AC_LANG_CPLUSPLUS
1568 ac_save_CXXFLAGS="$CXXFLAGS"
1569 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1570 ac_save_LIBS="$LIBS"
1572 ac_has_clock_monotonic=no
1573 ac_has_clock_realtime=no
1574 ac_has_nanosleep=no
1575 ac_has_sched_yield=no
1577 if test x"$enable_libstdcxx_time" = x"auto"; then
1579 case "${target_os}" in
1580 cygwin*)
1581 ac_has_nanosleep=yes
1582 ;;
1583 mingw*)
1584 ac_has_win32_sleep=yes
1585 ac_has_sched_yield=yes
1586 ;;
1587 darwin*)
1588 ac_has_nanosleep=yes
1589 ac_has_sched_yield=yes
1590 ;;
1591 # VxWorks has nanosleep as soon as the kernel is configured with
1592 # INCLUDE_POSIX_TIMERS, which is normally/most-often the case.
1593 vxworks*)
1594 ac_has_nanosleep=yes
1595 ;;
1596 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
1597 # Don't use link test for freestanding library, in case gcc_no_link=yes
1598 if test x"$is_hosted" = xyes; then
1599 # Versions of glibc before 2.17 needed -lrt for clock_gettime.
1600 AC_SEARCH_LIBS(clock_gettime, [rt])
1601 if test x"$ac_cv_search_clock_gettime" = x"none required"; then
1602 ac_has_clock_monotonic=yes
1603 ac_has_clock_realtime=yes
1604 fi
1605 fi
1606 ac_has_nanosleep=yes
1607 ac_has_sched_yield=yes
1608 ;;
1609 freebsd*|netbsd*|dragonfly*|rtems*)
1610 ac_has_clock_monotonic=yes
1611 ac_has_clock_realtime=yes
1612 ac_has_nanosleep=yes
1613 ac_has_sched_yield=yes
1614 ;;
1615 openbsd*)
1616 ac_has_clock_monotonic=yes
1617 ac_has_clock_realtime=yes
1618 ac_has_nanosleep=yes
1619 ;;
1620 solaris*)
1621 ac_has_clock_monotonic=yes
1622 ac_has_clock_realtime=yes
1623 ac_has_nanosleep=yes
1624 ac_has_sched_yield=yes
1625 ;;
1626 uclinux*)
1627 ac_has_nanosleep=yes
1628 ac_has_sched_yield=yes
1629 esac
1631 elif test x"$enable_libstdcxx_time" != x"no"; then
1633 if test x"$enable_libstdcxx_time" = x"rt"; then
1634 AC_SEARCH_LIBS(clock_gettime, [rt])
1635 AC_SEARCH_LIBS(nanosleep, [rt])
1636 else
1637 AC_CHECK_FUNC(clock_gettime)
1638 AC_CHECK_FUNC(nanosleep)
1639 fi
1641 case "$ac_cv_search_clock_gettime" in
1642 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1643 ;;
1644 esac
1645 case "$ac_cv_search_nanosleep" in
1646 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1647 ;;
1648 esac
1650 AC_SEARCH_LIBS(sched_yield, [rt])
1652 case "$ac_cv_search_sched_yield" in
1653 -lrt*)
1654 if test x"$enable_libstdcxx_time" = x"rt"; then
1655 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1656 ac_has_sched_yield=yes
1657 fi
1658 ;;
1659 *)
1660 ac_has_sched_yield=yes
1661 ;;
1662 esac
1664 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1666 if test x"$ac_has_unistd_h" = x"yes"; then
1667 AC_MSG_CHECKING([for monotonic clock])
1668 AC_TRY_LINK(
1669 [#include <unistd.h>
1670 #include <time.h>
1671 ],
1672 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1673 timespec tp;
1674 #endif
1675 clock_gettime(CLOCK_MONOTONIC, &tp);
1676 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1678 AC_MSG_RESULT($ac_has_clock_monotonic)
1680 AC_MSG_CHECKING([for realtime clock])
1681 AC_TRY_LINK(
1682 [#include <unistd.h>
1683 #include <time.h>
1684 ],
1685 [#if _POSIX_TIMERS > 0
1686 timespec tp;
1687 #endif
1688 clock_gettime(CLOCK_REALTIME, &tp);
1689 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1691 AC_MSG_RESULT($ac_has_clock_realtime)
1693 AC_MSG_CHECKING([for nanosleep])
1694 AC_TRY_LINK(
1695 [#include <unistd.h>
1696 #include <time.h>
1697 ],
1698 [#if _POSIX_TIMERS > 0
1699 timespec tp;
1700 #endif
1701 nanosleep(&tp, 0);
1702 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1704 AC_MSG_RESULT($ac_has_nanosleep)
1705 fi
1706 fi
1708 if test x"$ac_has_clock_monotonic" != x"yes"; then
1709 case ${target_os} in
1710 linux* | uclinux*)
1711 AC_MSG_CHECKING([for clock_gettime syscall])
1712 AC_TRY_COMPILE(
1713 [#include <unistd.h>
1714 #include <time.h>
1715 #include <sys/syscall.h>
1716 ],
1717 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1718 timespec tp;
1719 #endif
1720 syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp);
1721 syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp);
1722 ], [ac_has_clock_gettime_syscall=yes], [ac_has_clock_gettime_syscall=no])
1723 AC_MSG_RESULT($ac_has_clock_gettime_syscall)
1724 if test x"$ac_has_clock_gettime_syscall" = x"yes"; then
1725 AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1,
1726 [Defined if clock_gettime syscall has monotonic and realtime clock support. ])
1727 ac_has_clock_monotonic=yes
1728 ac_has_clock_realtime=yes
1729 AC_MSG_CHECKING([for struct timespec that matches syscall])
1730 AC_TRY_COMPILE(
1731 [#include <time.h>
1732 #include <sys/syscall.h>
1733 ],
1734 [#ifdef SYS_clock_gettime64
1735 #if SYS_clock_gettime64 != SYS_clock_gettime
1736 // We need to use SYS_clock_gettime and libc appears to
1737 // also know about the SYS_clock_gettime64 syscall.
1738 // Check that userspace doesn't use time64 version of timespec.
1739 static_assert(sizeof(timespec::tv_sec) == sizeof(long),
1740 "struct timespec must be compatible with SYS_clock_gettime");
1741 #endif
1742 #endif
1743 ],
1744 [ac_timespec_matches_syscall=yes],
1745 [ac_timespec_matches_syscall=no])
1746 AC_MSG_RESULT($ac_timespec_matches_syscall)
1747 if test x"$ac_timespec_matches_syscall" = no; then
1748 AC_MSG_ERROR([struct timespec is not compatible with SYS_clock_gettime, please report a bug to http://gcc.gnu.org/bugzilla])
1749 fi
1750 fi;;
1751 esac
1752 fi
1754 if test x"$ac_has_clock_monotonic" = x"yes"; then
1755 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1756 [ Defined if clock_gettime has monotonic clock support. ])
1757 fi
1759 if test x"$ac_has_clock_realtime" = x"yes"; then
1760 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1761 [ Defined if clock_gettime has realtime clock support. ])
1762 fi
1764 if test x"$ac_has_sched_yield" = x"yes"; then
1765 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1766 [ Defined if sched_yield is available. ])
1767 fi
1769 if test x"$ac_has_nanosleep" = x"yes"; then
1770 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1771 [ Defined if nanosleep is available. ])
1772 elif test x"$ac_has_win32_sleep" = x"yes"; then
1773 AC_DEFINE(_GLIBCXX_USE_WIN32_SLEEP, 1,
1774 [Defined if Sleep exists.])
1775 else
1776 AC_MSG_CHECKING([for sleep])
1777 AC_TRY_COMPILE([#include <unistd.h>],
1778 [sleep(1)],
1779 [ac_has_sleep=yes],[ac_has_sleep=no])
1780 if test x"$ac_has_sleep" = x"yes"; then
1781 AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.])
1782 fi
1783 AC_MSG_RESULT($ac_has_sleep)
1784 AC_MSG_CHECKING([for usleep])
1785 AC_TRY_COMPILE([#include <unistd.h>],
1786 [sleep(1);
1787 usleep(100);],
1788 [ac_has_usleep=yes],[ac_has_usleep=no])
1789 if test x"$ac_has_usleep" = x"yes"; then
1790 AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.])
1791 fi
1792 AC_MSG_RESULT($ac_has_usleep)
1793 fi
1795 if test x"$ac_has_nanosleep$ac_has_win32_sleep$ac_has_sleep" = x"nonono"; then
1796 AC_DEFINE(_GLIBCXX_NO_SLEEP,1, [Defined if no way to sleep is available.])
1797 fi
1799 AC_SUBST(GLIBCXX_LIBS)
1801 CXXFLAGS="$ac_save_CXXFLAGS"
1802 LIBS="$ac_save_LIBS"
1803 AC_LANG_RESTORE
1804 ])
1806 dnl
1807 dnl Check for gettimeofday, used in the implementation of 20.11.7
1808 dnl [time.clock] in the C++11 standard.
1809 dnl
1810 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1812 AC_MSG_CHECKING([for gettimeofday])
1814 AC_LANG_SAVE
1815 AC_LANG_CPLUSPLUS
1816 ac_save_CXXFLAGS="$CXXFLAGS"
1817 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1819 ac_has_gettimeofday=no;
1820 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1821 if test x"$ac_has_sys_time_h" = x"yes"; then
1822 AC_MSG_CHECKING([for gettimeofday])
1823 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1824 [timeval tv; gettimeofday(&tv, 0);],
1825 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1827 AC_MSG_RESULT($ac_has_gettimeofday)
1828 fi
1830 if test x"$ac_has_gettimeofday" = x"yes"; then
1831 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1832 [ Defined if gettimeofday is available. ])
1833 fi
1835 CXXFLAGS="$ac_save_CXXFLAGS"
1836 AC_LANG_RESTORE
1837 ])
1839 dnl
1840 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1841 dnl facilities in Chapter 8, "C compatibility".
1842 dnl
1843 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1845 AC_LANG_SAVE
1846 AC_LANG_CPLUSPLUS
1848 # Use -std=c++98 because -std=gnu++98 leaves __STRICT_ANSI__
1849 # undefined and fake C99 facilities may be spuriously enabled.
1850 ac_save_CXXFLAGS="$CXXFLAGS"
1851 CXXFLAGS="$CXXFLAGS -std=c++98"
1853 # Check for the existence of <complex.h> complex math functions used
1854 # by tr1/complex.
1855 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1856 ac_c99_complex_tr1=no;
1857 if test x"$ac_has_complex_h" = x"yes"; then
1858 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1859 AC_TRY_COMPILE([#include <complex.h>],
1860 [typedef __complex__ float float_type; float_type tmpf;
1861 cacosf(tmpf);
1862 casinf(tmpf);
1863 catanf(tmpf);
1864 cacoshf(tmpf);
1865 casinhf(tmpf);
1866 catanhf(tmpf);
1867 typedef __complex__ double double_type; double_type tmpd;
1868 cacos(tmpd);
1869 casin(tmpd);
1870 catan(tmpd);
1871 cacosh(tmpd);
1872 casinh(tmpd);
1873 catanh(tmpd);
1874 typedef __complex__ long double ld_type; ld_type tmpld;
1875 cacosl(tmpld);
1876 casinl(tmpld);
1877 catanl(tmpld);
1878 cacoshl(tmpld);
1879 casinhl(tmpld);
1880 catanhl(tmpld);
1881 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1882 fi
1883 AC_MSG_RESULT($ac_c99_complex_tr1)
1884 if test x"$ac_c99_complex_tr1" = x"yes"; then
1885 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1886 [Define if C99 functions in <complex.h> should be used in
1887 <tr1/complex>. Using compiler builtins for these functions
1888 requires corresponding C99 library functions to be present.])
1889 fi
1891 # Check for the existence of <ctype.h> functions.
1892 AC_CACHE_CHECK([for ISO C99 support to TR1 in <ctype.h>],
1893 glibcxx_cv_c99_ctype_tr1, [
1894 AC_TRY_COMPILE([#include <ctype.h>],
1895 [int ch;
1896 int ret;
1897 ret = isblank(ch);
1898 ],[glibcxx_cv_c99_ctype_tr1=yes],
1899 [glibcxx_cv_c99_ctype_tr1=no])
1900 ])
1901 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1902 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1903 [Define if C99 functions in <ctype.h> should be imported in
1904 <tr1/cctype> in namespace std::tr1.])
1905 fi
1907 # Check for the existence of <fenv.h> functions.
1908 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1909 ac_c99_fenv_tr1=no;
1910 if test x"$ac_has_fenv_h" = x"yes"; then
1911 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1912 AC_TRY_COMPILE([#include <fenv.h>],
1913 [int except, mode;
1914 fexcept_t* pflag;
1915 fenv_t* penv;
1916 int ret;
1917 ret = feclearexcept(except);
1918 ret = fegetexceptflag(pflag, except);
1919 ret = feraiseexcept(except);
1920 ret = fesetexceptflag(pflag, except);
1921 ret = fetestexcept(except);
1922 ret = fegetround();
1923 ret = fesetround(mode);
1924 ret = fegetenv(penv);
1925 ret = feholdexcept(penv);
1926 ret = fesetenv(penv);
1927 ret = feupdateenv(penv);
1928 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1929 AC_MSG_RESULT($ac_c99_fenv_tr1)
1930 fi
1931 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1932 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1933 [Define if C99 functions in <fenv.h> should be imported in
1934 <tr1/cfenv> in namespace std::tr1.])
1935 fi
1937 # Check for the existence of <stdint.h> types.
1938 AC_CACHE_CHECK([for ISO C99 support to TR1 in <stdint.h>],
1939 glibcxx_cv_c99_stdint_tr1, [
1940 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1941 #define __STDC_CONSTANT_MACROS
1942 #include <stdint.h>],
1943 [typedef int8_t my_int8_t;
1944 my_int8_t i8 = INT8_MIN;
1945 i8 = INT8_MAX;
1946 typedef int16_t my_int16_t;
1947 my_int16_t i16 = INT16_MIN;
1948 i16 = INT16_MAX;
1949 typedef int32_t my_int32_t;
1950 my_int32_t i32 = INT32_MIN;
1951 i32 = INT32_MAX;
1952 typedef int64_t my_int64_t;
1953 my_int64_t i64 = INT64_MIN;
1954 i64 = INT64_MAX;
1955 typedef int_fast8_t my_int_fast8_t;
1956 my_int_fast8_t if8 = INT_FAST8_MIN;
1957 if8 = INT_FAST8_MAX;
1958 typedef int_fast16_t my_int_fast16_t;
1959 my_int_fast16_t if16 = INT_FAST16_MIN;
1960 if16 = INT_FAST16_MAX;
1961 typedef int_fast32_t my_int_fast32_t;
1962 my_int_fast32_t if32 = INT_FAST32_MIN;
1963 if32 = INT_FAST32_MAX;
1964 typedef int_fast64_t my_int_fast64_t;
1965 my_int_fast64_t if64 = INT_FAST64_MIN;
1966 if64 = INT_FAST64_MAX;
1967 typedef int_least8_t my_int_least8_t;
1968 my_int_least8_t il8 = INT_LEAST8_MIN;
1969 il8 = INT_LEAST8_MAX;
1970 typedef int_least16_t my_int_least16_t;
1971 my_int_least16_t il16 = INT_LEAST16_MIN;
1972 il16 = INT_LEAST16_MAX;
1973 typedef int_least32_t my_int_least32_t;
1974 my_int_least32_t il32 = INT_LEAST32_MIN;
1975 il32 = INT_LEAST32_MAX;
1976 typedef int_least64_t my_int_least64_t;
1977 my_int_least64_t il64 = INT_LEAST64_MIN;
1978 il64 = INT_LEAST64_MAX;
1979 typedef intmax_t my_intmax_t;
1980 my_intmax_t im = INTMAX_MAX;
1981 im = INTMAX_MIN;
1982 typedef intptr_t my_intptr_t;
1983 my_intptr_t ip = INTPTR_MAX;
1984 ip = INTPTR_MIN;
1985 typedef uint8_t my_uint8_t;
1986 my_uint8_t ui8 = UINT8_MAX;
1987 ui8 = UINT8_MAX;
1988 typedef uint16_t my_uint16_t;
1989 my_uint16_t ui16 = UINT16_MAX;
1990 ui16 = UINT16_MAX;
1991 typedef uint32_t my_uint32_t;
1992 my_uint32_t ui32 = UINT32_MAX;
1993 ui32 = UINT32_MAX;
1994 typedef uint64_t my_uint64_t;
1995 my_uint64_t ui64 = UINT64_MAX;
1996 ui64 = UINT64_MAX;
1997 typedef uint_fast8_t my_uint_fast8_t;
1998 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1999 uif8 = UINT_FAST8_MAX;
2000 typedef uint_fast16_t my_uint_fast16_t;
2001 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
2002 uif16 = UINT_FAST16_MAX;
2003 typedef uint_fast32_t my_uint_fast32_t;
2004 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
2005 uif32 = UINT_FAST32_MAX;
2006 typedef uint_fast64_t my_uint_fast64_t;
2007 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
2008 uif64 = UINT_FAST64_MAX;
2009 typedef uint_least8_t my_uint_least8_t;
2010 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
2011 uil8 = UINT_LEAST8_MAX;
2012 typedef uint_least16_t my_uint_least16_t;
2013 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
2014 uil16 = UINT_LEAST16_MAX;
2015 typedef uint_least32_t my_uint_least32_t;
2016 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
2017 uil32 = UINT_LEAST32_MAX;
2018 typedef uint_least64_t my_uint_least64_t;
2019 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
2020 uil64 = UINT_LEAST64_MAX;
2021 typedef uintmax_t my_uintmax_t;
2022 my_uintmax_t uim = UINTMAX_MAX;
2023 uim = UINTMAX_MAX;
2024 typedef uintptr_t my_uintptr_t;
2025 my_uintptr_t uip = UINTPTR_MAX;
2026 uip = UINTPTR_MAX;
2027 ],[glibcxx_cv_c99_stdint_tr1=yes],
2028 [glibcxx_cv_c99_stdint_tr1=no])
2029 ])
2030 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2031 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
2032 [Define if C99 types in <stdint.h> should be imported in
2033 <tr1/cstdint> in namespace std::tr1.])
2034 fi
2036 # Check for the existence of <math.h> functions.
2037 AC_CACHE_CHECK([for ISO C99 support to TR1 in <math.h>],
2038 glibcxx_cv_c99_math_tr1, [
2039 AC_TRY_COMPILE([#include <math.h>],
2040 [typedef double_t my_double_t;
2041 typedef float_t my_float_t;
2042 acosh(0.0);
2043 acoshf(0.0f);
2044 acoshl(0.0l);
2045 asinh(0.0);
2046 asinhf(0.0f);
2047 asinhl(0.0l);
2048 atanh(0.0);
2049 atanhf(0.0f);
2050 atanhl(0.0l);
2051 cbrt(0.0);
2052 cbrtf(0.0f);
2053 cbrtl(0.0l);
2054 copysign(0.0, 0.0);
2055 copysignf(0.0f, 0.0f);
2056 copysignl(0.0l, 0.0l);
2057 erf(0.0);
2058 erff(0.0f);
2059 erfl(0.0l);
2060 erfc(0.0);
2061 erfcf(0.0f);
2062 erfcl(0.0l);
2063 exp2(0.0);
2064 exp2f(0.0f);
2065 exp2l(0.0l);
2066 expm1(0.0);
2067 expm1f(0.0f);
2068 expm1l(0.0l);
2069 fdim(0.0, 0.0);
2070 fdimf(0.0f, 0.0f);
2071 fdiml(0.0l, 0.0l);
2072 fma(0.0, 0.0, 0.0);
2073 fmaf(0.0f, 0.0f, 0.0f);
2074 fmal(0.0l, 0.0l, 0.0l);
2075 fmax(0.0, 0.0);
2076 fmaxf(0.0f, 0.0f);
2077 fmaxl(0.0l, 0.0l);
2078 fmin(0.0, 0.0);
2079 fminf(0.0f, 0.0f);
2080 fminl(0.0l, 0.0l);
2081 hypot(0.0, 0.0);
2082 hypotf(0.0f, 0.0f);
2083 hypotl(0.0l, 0.0l);
2084 ilogb(0.0);
2085 ilogbf(0.0f);
2086 ilogbl(0.0l);
2087 lgamma(0.0);
2088 lgammaf(0.0f);
2089 lgammal(0.0l);
2090 #ifndef __APPLE__ /* see below */
2091 llrint(0.0);
2092 llrintf(0.0f);
2093 llrintl(0.0l);
2094 llround(0.0);
2095 llroundf(0.0f);
2096 llroundl(0.0l);
2097 #endif
2098 log1p(0.0);
2099 log1pf(0.0f);
2100 log1pl(0.0l);
2101 log2(0.0);
2102 log2f(0.0f);
2103 log2l(0.0l);
2104 logb(0.0);
2105 logbf(0.0f);
2106 logbl(0.0l);
2107 lrint(0.0);
2108 lrintf(0.0f);
2109 lrintl(0.0l);
2110 lround(0.0);
2111 lroundf(0.0f);
2112 lroundl(0.0l);
2113 nan("");
2114 nanf("");
2115 nanl("");
2116 nearbyint(0.0);
2117 nearbyintf(0.0f);
2118 nearbyintl(0.0l);
2119 nextafter(0.0, 0.0);
2120 nextafterf(0.0f, 0.0f);
2121 nextafterl(0.0l, 0.0l);
2122 nexttoward(0.0, 0.0);
2123 nexttowardf(0.0f, 0.0f);
2124 nexttowardl(0.0l, 0.0l);
2125 remainder(0.0, 0.0);
2126 remainderf(0.0f, 0.0f);
2127 remainderl(0.0l, 0.0l);
2128 remquo(0.0, 0.0, 0);
2129 remquof(0.0f, 0.0f, 0);
2130 remquol(0.0l, 0.0l, 0);
2131 rint(0.0);
2132 rintf(0.0f);
2133 rintl(0.0l);
2134 round(0.0);
2135 roundf(0.0f);
2136 roundl(0.0l);
2137 scalbln(0.0, 0l);
2138 scalblnf(0.0f, 0l);
2139 scalblnl(0.0l, 0l);
2140 scalbn(0.0, 0);
2141 scalbnf(0.0f, 0);
2142 scalbnl(0.0l, 0);
2143 tgamma(0.0);
2144 tgammaf(0.0f);
2145 tgammal(0.0l);
2146 trunc(0.0);
2147 truncf(0.0f);
2148 truncl(0.0l);
2149 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
2150 ])
2151 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
2152 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
2153 [Define if C99 functions or macros in <math.h> should be imported
2154 in <tr1/cmath> in namespace std::tr1.])
2156 case "${target_os}" in
2157 darwin*)
2158 AC_CACHE_CHECK([for ISO C99 rounding functions in <math.h>],
2159 glibcxx_cv_c99_math_llround, [
2160 AC_TRY_COMPILE([#include <math.h>],
2161 [llrint(0.0);
2162 llrintf(0.0f);
2163 llrintl(0.0l);
2164 llround(0.0);
2165 llroundf(0.0f);
2166 llroundl(0.0l);
2167 ],
2168 [glibcxx_cv_c99_math_llround=yes],
2169 [glibcxx_cv_c99_math_llround=no])
2170 ])
2171 ;;
2172 esac
2173 if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
2174 AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
2175 [Define if C99 llrint and llround functions are missing from <math.h>.])
2176 fi
2177 fi
2179 # Check for the existence of <inttypes.h> functions (NB: doesn't make
2180 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
2181 ac_c99_inttypes_tr1=no;
2182 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2183 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
2184 AC_TRY_COMPILE([#include <inttypes.h>],
2185 [intmax_t i, numer, denom, base;
2186 const char* s;
2187 char** endptr;
2188 intmax_t ret = imaxabs(i);
2189 imaxdiv_t dret = imaxdiv(numer, denom);
2190 ret = strtoimax(s, endptr, base);
2191 uintmax_t uret = strtoumax(s, endptr, base);
2192 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
2193 AC_MSG_RESULT($ac_c99_inttypes_tr1)
2194 fi
2195 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
2196 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
2197 [Define if C99 functions in <inttypes.h> should be imported in
2198 <tr1/cinttypes> in namespace std::tr1.])
2199 fi
2201 # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't
2202 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
2203 ac_c99_inttypes_wchar_t_tr1=no;
2204 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2205 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
2206 AC_TRY_COMPILE([#include <inttypes.h>],
2207 [intmax_t base;
2208 const wchar_t* s;
2209 wchar_t** endptr;
2210 intmax_t ret = wcstoimax(s, endptr, base);
2211 uintmax_t uret = wcstoumax(s, endptr, base);
2212 ],[ac_c99_inttypes_wchar_t_tr1=yes],
2213 [ac_c99_inttypes_wchar_t_tr1=no])
2214 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
2215 fi
2216 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
2217 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
2218 [Define if wchar_t C99 functions in <inttypes.h> should be
2219 imported in <tr1/cinttypes> in namespace std::tr1.])
2220 fi
2222 # Check for the existence of the <stdbool.h> header.
2223 AC_CHECK_HEADERS(stdbool.h)
2225 # Check for the existence of the <stdalign.h> header.
2226 AC_CHECK_HEADERS(stdalign.h)
2228 CXXFLAGS="$ac_save_CXXFLAGS"
2229 AC_LANG_RESTORE
2230 ])
2232 dnl
2233 dnl Check for uchar.h and usability.
2234 dnl
2235 AC_DEFUN([GLIBCXX_CHECK_UCHAR_H], [
2237 # Test uchar.h.
2238 AC_CHECK_HEADERS(uchar.h, ac_has_uchar_h=yes, ac_has_uchar_h=no)
2240 AC_LANG_SAVE
2241 AC_LANG_CPLUSPLUS
2242 ac_save_CXXFLAGS="$CXXFLAGS"
2243 CXXFLAGS="$CXXFLAGS -std=c++11"
2245 if test x"$ac_has_uchar_h" = x"yes"; then
2246 AC_MSG_CHECKING([for ISO C11 support for <uchar.h>])
2247 AC_TRY_COMPILE([#include <uchar.h>
2248 #ifdef __STDC_UTF_16__
2249 long i = __STDC_UTF_16__;
2250 #endif
2251 #ifdef __STDC_UTF_32__
2252 long j = __STDC_UTF_32__;
2253 #endif
2254 namespace test
2255 {
2256 using ::c16rtomb;
2257 using ::c32rtomb;
2258 using ::mbrtoc16;
2259 using ::mbrtoc32;
2260 }
2261 ],
2262 [], [ac_c11_uchar_cxx11=yes], [ac_c11_uchar_cxx11=no])
2263 AC_MSG_RESULT($ac_c11_uchar_cxx11)
2264 else
2265 ac_c11_uchar_cxx11=no
2266 fi
2267 if test x"$ac_c11_uchar_cxx11" = x"yes"; then
2268 AC_DEFINE(_GLIBCXX_USE_C11_UCHAR_CXX11, 1,
2269 [Define if C11 functions in <uchar.h> should be imported into
2270 namespace std in <cuchar>.])
2271 fi
2273 CXXFLAGS="$CXXFLAGS -fchar8_t"
2274 if test x"$ac_has_uchar_h" = x"yes"; then
2275 AC_MSG_CHECKING([for c8rtomb and mbrtoc8 in <uchar.h> with -fchar8_t])
2276 AC_TRY_COMPILE([#include <uchar.h>
2277 namespace test
2278 {
2279 using ::c8rtomb;
2280 using ::mbrtoc8;
2281 }
2282 ],
2283 [], [ac_uchar_c8rtomb_mbrtoc8_fchar8_t=yes],
2284 [ac_uchar_c8rtomb_mbrtoc8_fchar8_t=no])
2285 AC_MSG_RESULT($ac_uchar_c8rtomb_mbrtoc8_fchar8_t)
2286 else
2287 ac_uchar_c8rtomb_mbrtoc8_fchar8_t=no
2288 fi
2289 if test x"$ac_uchar_c8rtomb_mbrtoc8_fchar8_t" = x"yes"; then
2290 AC_DEFINE(_GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_FCHAR8_T, 1,
2291 [Define if c8rtomb and mbrtoc8 functions in <uchar.h> should be
2292 imported into namespace std in <cuchar> for -fchar8_t.])
2293 fi
2295 CXXFLAGS="$CXXFLAGS -std=c++20"
2296 if test x"$ac_has_uchar_h" = x"yes"; then
2297 AC_MSG_CHECKING([for c8rtomb and mbrtoc8 in <uchar.h> with -std=c++20])
2298 AC_TRY_COMPILE([#include <uchar.h>
2299 namespace test
2300 {
2301 using ::c8rtomb;
2302 using ::mbrtoc8;
2303 }
2304 ],
2305 [], [ac_uchar_c8rtomb_mbrtoc8_cxx20=yes],
2306 [ac_uchar_c8rtomb_mbrtoc8_cxx20=no])
2307 AC_MSG_RESULT($ac_uchar_c8rtomb_mbrtoc8_cxx20)
2308 else
2309 ac_uchar_c8rtomb_mbrtoc8_cxx20=no
2310 fi
2311 if test x"$ac_uchar_c8rtomb_mbrtoc8_cxx20" = x"yes"; then
2312 AC_DEFINE(_GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_CXX20, 1,
2313 [Define if c8rtomb and mbrtoc8 functions in <uchar.h> should be
2314 imported into namespace std in <cuchar> for C++20.])
2315 fi
2317 CXXFLAGS="$ac_save_CXXFLAGS"
2318 AC_LANG_RESTORE
2319 ])
2322 dnl
2323 dnl Check whether "/dev/random" and "/dev/urandom" are available for
2324 dnl class std::random_device from C++ 2011 [rand.device], and
2325 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
2326 dnl
2327 AC_DEFUN([GLIBCXX_CHECK_DEV_RANDOM], [
2329 AC_CACHE_CHECK([for "/dev/random" and "/dev/urandom" for std::random_device],
2330 glibcxx_cv_dev_random, [
2331 if test -r /dev/random && test -r /dev/urandom; then
2332 ## For MSys environment the test above is detected as false-positive
2333 ## on mingw-targets. So disable it explicitly for them.
2334 case ${target_os} in
2335 *mingw*) glibcxx_cv_dev_random=no ;;
2336 *) glibcxx_cv_dev_random=yes ;;
2337 esac
2338 else
2339 glibcxx_cv_dev_random=no;
2340 fi
2341 ])
2343 if test x"$glibcxx_cv_dev_random" = x"yes"; then
2344 AC_DEFINE(_GLIBCXX_USE_DEV_RANDOM, 1,
2345 [Define if /dev/random and /dev/urandom are available for
2346 std::random_device.])
2347 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
2348 [Define if /dev/random and /dev/urandom are available for
2349 the random_device of TR1 (Chapter 5.1).])
2350 fi
2352 ])
2354 dnl
2355 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
2356 dnl
2357 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
2359 if test "$is_hosted" = yes; then
2360 AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
2361 AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
2362 [#include <stdio.h>],
2363 [AC_MSG_ERROR([computing EOF failed])])
2364 ])
2365 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
2366 [Define to the value of the EOF integer constant.])
2368 AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
2369 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
2370 [#include <stdio.h>],
2371 [AC_MSG_ERROR([computing SEEK_CUR failed])])
2372 ])
2373 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
2374 [Define to the value of the SEEK_CUR integer constant.])
2376 AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
2377 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
2378 [#include <stdio.h>],
2379 [AC_MSG_ERROR([computing SEEK_END failed])])
2380 ])
2381 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
2382 [Define to the value of the SEEK_END integer constant.])
2383 fi
2384 ])
2386 dnl
2387 dnl Check whether required C++ overloads are present in <stdio.h>.
2388 dnl
2389 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
2391 AC_LANG_SAVE
2392 AC_LANG_CPLUSPLUS
2393 # Use C++11 because a conforming <stdio.h> won't define gets for C++14,
2394 # and we don't need a declaration for C++14 anyway.
2395 ac_save_CXXFLAGS="$CXXFLAGS"
2396 CXXFLAGS="$CXXFLAGS -std=gnu++11"
2398 AC_CACHE_CHECK([for gets declaration], glibcxx_cv_gets, [
2399 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2400 [#include <stdio.h>
2401 namespace test
2402 {
2403 using ::gets;
2404 }
2405 ])],
2406 [glibcxx_cv_gets=yes],
2407 [glibcxx_cv_gets=no]
2408 )])
2410 if test $glibcxx_cv_gets = yes; then
2411 AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h> before C++14.])
2412 fi
2414 CXXFLAGS="$ac_save_CXXFLAGS"
2415 AC_LANG_RESTORE
2416 ])
2418 dnl
2419 dnl Check whether required C++11 overloads for floating point and integral
2420 dnl types are present in <math.h>.
2421 dnl
2422 AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
2424 AC_LANG_SAVE
2425 AC_LANG_CPLUSPLUS
2426 ac_save_CXXFLAGS="$CXXFLAGS"
2427 CXXFLAGS="$CXXFLAGS -std=c++11"
2429 case "$host" in
2430 *-*-solaris2.*)
2431 # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
2432 # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
2433 AC_CACHE_CHECK([for C++11 <math.h> floating point overloads],
2434 glibcxx_cv_math11_fp_overload, [
2435 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2436 [#include <math.h>
2437 #undef isfinite
2438 namespace std {
2439 inline bool isfinite(float __x)
2440 { return __builtin_isfinite(__x); }
2441 }
2442 ])],
2443 [glibcxx_cv_math11_fp_overload=no],
2444 [glibcxx_cv_math11_fp_overload=yes]
2445 )])
2447 # autoheader cannot handle indented templates.
2448 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP],
2449 [/* Define if all C++11 floating point overloads are available in <math.h>. */
2450 #if __cplusplus >= 201103L
2451 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2452 #endif])
2454 if test $glibcxx_cv_math11_fp_overload = yes; then
2455 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP)
2456 fi
2458 # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
2459 # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
2460 AC_CACHE_CHECK([for C++11 <math.h> integral type overloads],
2461 glibcxx_cv_math11_int_overload, [
2462 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2463 [#include <math.h>
2464 namespace std {
2465 template<typename _Tp>
2466 struct __is_integer;
2467 template<>
2468 struct __is_integer<int>
2469 {
2470 enum { __value = 1 };
2471 };
2472 }
2473 namespace __gnu_cxx {
2474 template<bool, typename>
2475 struct __enable_if;
2476 template<typename _Tp>
2477 struct __enable_if<true, _Tp>
2478 { typedef _Tp __type; };
2479 }
2480 namespace std {
2481 template<typename _Tp>
2482 constexpr typename __gnu_cxx::__enable_if
2483 <__is_integer<_Tp>::__value, double>::__type
2484 log2(_Tp __x)
2485 { return __builtin_log2(__x); }
2486 }
2487 int
2488 main (void)
2489 {
2490 int i = 1000;
2491 return std::log2(i);
2492 }
2493 ])],
2494 [glibcxx_cv_math11_int_overload=no],
2495 [glibcxx_cv_math11_int_overload=yes]
2496 )])
2498 # autoheader cannot handle indented templates.
2499 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT],
2500 [/* Define if all C++11 integral type overloads are available in <math.h>. */
2501 #if __cplusplus >= 201103L
2502 #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2503 #endif])
2505 if test $glibcxx_cv_math11_int_overload = yes; then
2506 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT)
2507 fi
2508 ;;
2509 *)
2510 # If <math.h> defines the obsolete isinf(double) and isnan(double)
2511 # functions (instead of or as well as the C99 generic macros) then we
2512 # can't define std::isinf(double) and std::isnan(double) in <cmath>
2513 # and must use the ones from <math.h> instead.
2514 AC_CACHE_CHECK([for obsolete isinf function in <math.h>],
2515 glibcxx_cv_obsolete_isinf, [
2516 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2517 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2518 #include <math.h>
2519 #undef isinf
2520 namespace std {
2521 using ::isinf;
2522 bool isinf(float);
2523 bool isinf(long double);
2524 }
2525 using std::isinf;
2526 bool b = isinf(0.0);
2527 ])],
2528 [glibcxx_cv_obsolete_isinf=yes],
2529 [glibcxx_cv_obsolete_isinf=no]
2530 )])
2531 if test $glibcxx_cv_obsolete_isinf = yes; then
2532 AC_DEFINE(HAVE_OBSOLETE_ISINF, 1,
2533 [Define if <math.h> defines obsolete isinf function.])
2534 fi
2536 AC_CACHE_CHECK([for obsolete isnan function in <math.h>],
2537 glibcxx_cv_obsolete_isnan, [
2538 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
2539 [#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
2540 #include <math.h>
2541 #undef isnan
2542 namespace std {
2543 using ::isnan;
2544 bool isnan(float);
2545 bool isnan(long double);
2546 }
2547 using std::isnan;
2548 bool b = isnan(0.0);
2549 ])],
2550 [glibcxx_cv_obsolete_isnan=yes],
2551 [glibcxx_cv_obsolete_isnan=no]
2552 )])
2553 if test $glibcxx_cv_obsolete_isnan = yes; then
2554 AC_DEFINE(HAVE_OBSOLETE_ISNAN, 1,
2555 [Define if <math.h> defines obsolete isnan function.])
2556 fi
2557 ;;
2558 esac
2560 CXXFLAGS="$ac_save_CXXFLAGS"
2561 AC_LANG_RESTORE
2562 ])
2564 dnl
2565 dnl Check for what type of C headers to use.
2566 dnl
2567 dnl --enable-cheaders= [does stuff].
2568 dnl --disable-cheaders [does not do anything, really].
2569 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
2570 dnl Where DEFAULT is either 'c' or 'c_global' or 'c_std'.
2571 dnl
2572 dnl To use the obsolete 'c_std' headers use --enable-cheaders-obsolete as
2573 dnl well as --enable-cheaders=c_std, otherwise configure will fail.
2574 dnl
2575 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
2576 GLIBCXX_ENABLE(cheaders-obsolete,no,,
2577 [allow use of obsolete "C" headers for g++])
2578 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
2579 [construct "C" headers for g++], [permit c|c_global|c_std])
2580 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
2581 if test $enable_cheaders = c_std ; then
2582 AC_MSG_WARN([the --enable-cheaders=c_std configuration is obsolete, c_global should be used instead])
2583 AC_MSG_WARN([if you are unable to use c_global please report a bug or inform libstdc++@gcc.gnu.org])
2584 if test $enable_cheaders_obsolete != yes ; then
2585 AC_MSG_ERROR(use --enable-cheaders-obsolete to use c_std "C" headers)
2586 fi
2587 fi
2589 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
2591 # Allow overrides to configure.host here.
2592 if test $enable_cheaders = c_global; then
2593 c_compatibility=yes
2594 fi
2596 AC_SUBST(C_INCLUDE_DIR)
2597 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
2598 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
2599 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
2600 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
2601 ])
2604 dnl
2605 dnl Check for which locale library to use. The choice is mapped to
2606 dnl a subdirectory of config/locale.
2607 dnl
2608 dnl Default is generic.
2609 dnl
2610 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
2611 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
2612 [use MODEL for target locale package],
2613 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
2615 # Deal with gettext issues. Default to not using it (=no) until we detect
2616 # support for it later. Let the user turn it off via --e/d, but let that
2617 # default to on for easier handling.
2618 USE_NLS=no
2619 AC_ARG_ENABLE(nls,
2620 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
2621 [],
2622 [enable_nls=yes])
2624 # Either a known package, or "auto"
2625 if test $enable_clocale = no || test $enable_clocale = yes; then
2626 enable_clocale=auto
2627 fi
2628 enable_clocale_flag=$enable_clocale
2630 # Probe for locale model to use if none specified.
2631 # Default to "generic".
2632 if test $enable_clocale_flag = auto; then
2633 case ${target_os} in
2634 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2635 enable_clocale_flag=gnu
2636 ;;
2637 darwin*)
2638 enable_clocale_flag=darwin
2639 ;;
2640 vxworks*)
2641 enable_clocale_flag=vxworks
2642 ;;
2643 dragonfly* | freebsd*)
2644 enable_clocale_flag=dragonfly
2645 ;;
2646 openbsd*)
2647 enable_clocale_flag=newlib
2648 ;;
2649 *)
2650 if test x"$with_newlib" = x"yes"; then
2651 enable_clocale_flag=newlib
2652 else
2653 enable_clocale_flag=generic
2654 fi
2655 ;;
2656 esac
2657 fi
2659 # Sanity check model, and test for special functionality.
2660 if test $enable_clocale_flag = gnu; then
2661 AC_EGREP_CPP([_GLIBCXX_ok], [
2662 #include <features.h>
2663 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
2664 _GLIBCXX_ok
2665 #endif
2666 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
2668 # Set it to scream when it hurts.
2669 ac_save_CFLAGS="$CFLAGS"
2670 CFLAGS="-Wimplicit-function-declaration -Werror"
2672 # Use strxfrm_l if available.
2673 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2674 #include <string.h>
2675 #include <locale.h>],
2676 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
2677 AC_DEFINE(HAVE_STRXFRM_L, 1,
2678 [Define if strxfrm_l is available in <string.h>.]),)
2680 # Use strerror_l if available.
2681 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2682 #include <string.h>
2683 #include <locale.h>],
2684 [__locale_t loc; strerror_l(5, loc);],
2685 AC_DEFINE(HAVE_STRERROR_L, 1,
2686 [Define if strerror_l is available in <string.h>.]),)
2688 CFLAGS="$ac_save_CFLAGS"
2689 fi
2691 # Perhaps use strerror_r if available, and strerror_l isn't.
2692 ac_save_CFLAGS="$CFLAGS"
2693 CFLAGS="-Wimplicit-function-declaration -Werror"
2694 AC_TRY_COMPILE([#define _GNU_SOURCE 1
2695 #include <string.h>
2696 #include <locale.h>],
2697 [char s[128]; strerror_r(5, s, 128);],
2698 AC_DEFINE(HAVE_STRERROR_R, 1,
2699 [Define if strerror_r is available in <string.h>.]),)
2700 CFLAGS="$ac_save_CFLAGS"
2702 # Set configure bits for specified locale package
2703 AC_MSG_CHECKING([for C locale to use])
2704 case ${enable_clocale_flag} in
2705 generic)
2706 AC_MSG_RESULT(generic)
2708 CLOCALE_H=config/locale/generic/c_locale.h
2709 CLOCALE_CC=config/locale/generic/c_locale.cc
2710 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2711 CCOLLATE_CC=config/locale/generic/collate_members.cc
2712 CCTYPE_CC=config/locale/generic/ctype_members.cc
2713 CMESSAGES_H=config/locale/generic/messages_members.h
2714 CMESSAGES_CC=config/locale/generic/messages_members.cc
2715 CMONEY_CC=config/locale/generic/monetary_members.cc
2716 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2717 CTIME_H=config/locale/generic/time_members.h
2718 CTIME_CC=config/locale/generic/time_members.cc
2719 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2720 ;;
2721 darwin)
2722 AC_MSG_RESULT(darwin)
2724 CLOCALE_H=config/locale/generic/c_locale.h
2725 CLOCALE_CC=config/locale/generic/c_locale.cc
2726 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2727 CCOLLATE_CC=config/locale/generic/collate_members.cc
2728 CCTYPE_CC=config/locale/darwin/ctype_members.cc
2729 CMESSAGES_H=config/locale/generic/messages_members.h
2730 CMESSAGES_CC=config/locale/generic/messages_members.cc
2731 CMONEY_CC=config/locale/generic/monetary_members.cc
2732 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2733 CTIME_H=config/locale/generic/time_members.h
2734 CTIME_CC=config/locale/generic/time_members.cc
2735 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2736 ;;
2737 vxworks)
2738 AC_MSG_RESULT(vxworks)
2740 CLOCALE_H=config/locale/generic/c_locale.h
2741 CLOCALE_CC=config/locale/generic/c_locale.cc
2742 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2743 CCOLLATE_CC=config/locale/generic/collate_members.cc
2744 CCTYPE_CC=config/locale/vxworks/ctype_members.cc
2745 CMESSAGES_H=config/locale/generic/messages_members.h
2746 CMESSAGES_CC=config/locale/generic/messages_members.cc
2747 CMONEY_CC=config/locale/generic/monetary_members.cc
2748 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2749 CTIME_H=config/locale/generic/time_members.h
2750 CTIME_CC=config/locale/generic/time_members.cc
2751 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2752 ;;
2753 dragonfly)
2754 AC_MSG_RESULT(dragonfly or freebsd)
2756 CLOCALE_H=config/locale/dragonfly/c_locale.h
2757 CLOCALE_CC=config/locale/dragonfly/c_locale.cc
2758 CCODECVT_CC=config/locale/dragonfly/codecvt_members.cc
2759 CCOLLATE_CC=config/locale/dragonfly/collate_members.cc
2760 CCTYPE_CC=config/locale/dragonfly/ctype_members.cc
2761 CMESSAGES_H=config/locale/generic/messages_members.h
2762 CMESSAGES_CC=config/locale/generic/messages_members.cc
2763 CMONEY_CC=config/locale/dragonfly/monetary_members.cc
2764 CNUMERIC_CC=config/locale/dragonfly/numeric_members.cc
2765 CTIME_H=config/locale/dragonfly/time_members.h
2766 CTIME_CC=config/locale/dragonfly/time_members.cc
2767 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2768 ;;
2770 gnu)
2771 AC_MSG_RESULT(gnu)
2773 # Declare intention to use gettext, and add support for specific
2774 # languages.
2775 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2776 ALL_LINGUAS="de fr"
2778 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2779 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2780 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2781 USE_NLS=yes
2782 fi
2783 # Export the build objects.
2784 for ling in $ALL_LINGUAS; do \
2785 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2786 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2787 done
2788 AC_SUBST(glibcxx_MOFILES)
2789 AC_SUBST(glibcxx_POFILES)
2791 CLOCALE_H=config/locale/gnu/c_locale.h
2792 CLOCALE_CC=config/locale/gnu/c_locale.cc
2793 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2794 CCOLLATE_CC=config/locale/gnu/collate_members.cc
2795 CCTYPE_CC=config/locale/gnu/ctype_members.cc
2796 CMESSAGES_H=config/locale/gnu/messages_members.h
2797 CMESSAGES_CC=config/locale/gnu/messages_members.cc
2798 CMONEY_CC=config/locale/gnu/monetary_members.cc
2799 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2800 CTIME_H=config/locale/gnu/time_members.h
2801 CTIME_CC=config/locale/gnu/time_members.cc
2802 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2803 ;;
2804 ieee_1003.1-2001)
2805 AC_MSG_RESULT(IEEE 1003.1)
2807 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2808 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2809 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2810 CCOLLATE_CC=config/locale/generic/collate_members.cc
2811 CCTYPE_CC=config/locale/generic/ctype_members.cc
2812 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2813 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2814 CMONEY_CC=config/locale/generic/monetary_members.cc
2815 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2816 CTIME_H=config/locale/generic/time_members.h
2817 CTIME_CC=config/locale/generic/time_members.cc
2818 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2819 ;;
2820 newlib)
2821 AC_MSG_RESULT(newlib)
2823 CLOCALE_H=config/locale/generic/c_locale.h
2824 CLOCALE_CC=config/locale/generic/c_locale.cc
2825 CCODECVT_CC=config/locale/generic/codecvt_members.cc
2826 CCOLLATE_CC=config/locale/generic/collate_members.cc
2827 CCTYPE_CC=config/locale/newlib/ctype_members.cc
2828 CMESSAGES_H=config/locale/generic/messages_members.h
2829 CMESSAGES_CC=config/locale/generic/messages_members.cc
2830 CMONEY_CC=config/locale/generic/monetary_members.cc
2831 CNUMERIC_CC=config/locale/generic/numeric_members.cc
2832 CTIME_H=config/locale/generic/time_members.h
2833 CTIME_CC=config/locale/generic/time_members.cc
2834 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2835 ;;
2836 esac
2838 # This is where the testsuite looks for locale catalogs, using the
2839 # -DLOCALEDIR define during testsuite compilation.
2840 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2841 AC_SUBST(glibcxx_localedir)
2843 # A standalone libintl (e.g., GNU libintl) may be in use.
2844 if test $USE_NLS = yes; then
2845 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2846 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2847 fi
2848 if test $USE_NLS = yes; then
2849 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2850 [Define if NLS translations are to be used.])
2851 fi
2853 AC_SUBST(USE_NLS)
2854 AC_SUBST(CLOCALE_H)
2855 AC_SUBST(CMESSAGES_H)
2856 AC_SUBST(CCODECVT_CC)
2857 AC_SUBST(CCOLLATE_CC)
2858 AC_SUBST(CCTYPE_CC)
2859 AC_SUBST(CMESSAGES_CC)
2860 AC_SUBST(CMONEY_CC)
2861 AC_SUBST(CNUMERIC_CC)
2862 AC_SUBST(CTIME_H)
2863 AC_SUBST(CTIME_CC)
2864 AC_SUBST(CLOCALE_CC)
2865 AC_SUBST(CLOCALE_INTERNAL_H)
2866 ])
2869 dnl
2870 dnl Check for which std::allocator base class to use. The choice is
2871 dnl mapped from a subdirectory of include/ext.
2872 dnl
2873 dnl Default is new.
2874 dnl
2875 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2876 AC_MSG_CHECKING([for std::allocator base class])
2877 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2878 [use KIND for target std::allocator base],
2879 [permit new|malloc|yes|no|auto])
2881 # If they didn't use this option switch, or if they specified --enable
2882 # with no specific model, we'll have to look for one. If they
2883 # specified --disable (???), do likewise.
2884 if test $enable_libstdcxx_allocator = no ||
2885 test $enable_libstdcxx_allocator = yes;
2886 then
2887 enable_libstdcxx_allocator=auto
2888 fi
2890 # Either a known package, or "auto". Auto implies the default choice
2891 # for a particular platform.
2892 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2894 # Probe for host-specific support if no specific model is specified.
2895 # Default to "new".
2896 if test $enable_libstdcxx_allocator_flag = auto; then
2897 case ${target_os} in
2898 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2899 enable_libstdcxx_allocator_flag=new
2900 ;;
2901 *)
2902 enable_libstdcxx_allocator_flag=new
2903 ;;
2904 esac
2905 fi
2906 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2909 # Set configure bits for specified locale package
2910 case ${enable_libstdcxx_allocator_flag} in
2911 malloc)
2912 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2913 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2914 ;;
2915 new)
2916 ALLOCATOR_H=config/allocator/new_allocator_base.h
2917 ALLOCATOR_NAME=__gnu_cxx::new_allocator
2918 ;;
2919 esac
2921 GLIBCXX_CONDITIONAL(ENABLE_ALLOCATOR_NEW,
2922 test $enable_libstdcxx_allocator_flag = new)
2923 AC_SUBST(ALLOCATOR_H)
2924 AC_SUBST(ALLOCATOR_NAME)
2925 ])
2928 dnl
2929 dnl Check for whether the Boost-derived checks should be turned on.
2930 dnl
2931 dnl --enable-concept-checks turns them on.
2932 dnl --disable-concept-checks leaves them off.
2933 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2934 dnl Where DEFAULT is either `yes' or `no'.
2935 dnl
2936 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2937 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2938 if test $enable_concept_checks = yes; then
2939 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2940 [Define to use concept checking code from the boost libraries.])
2941 fi
2942 ])
2944 dnl
2945 dnl Use extern templates.
2946 dnl
2947 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2948 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2950 dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2951 dnl Where DEFAULT is `yes' or `no'.
2952 dnl
2953 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2955 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2957 AC_MSG_CHECKING([for extern template support])
2958 AC_MSG_RESULT([$enable_extern_template])
2960 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2961 ])
2963 dnl
2964 dnl Use vtable verification.
2965 dnl
2966 dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1
2967 dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0
2969 dnl + Usage: GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)]
2970 dnl Where DEFAULT is `yes' or `no'.
2971 dnl
2972 AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [
2974 GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify])
2976 AC_MSG_CHECKING([for vtable verify support])
2977 AC_MSG_RESULT([$enable_vtable_verify])
2979 vtv_cygmin=no
2980 if test $enable_vtable_verify = yes; then
2981 case ${target_os} in
2982 cygwin*|mingw32*)
2983 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2984 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2985 vtv_cygmin=yes
2986 ;;
2987 darwin*)
2988 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u,_vtable_map_vars_start -Wl,-u,_vtable_map_vars_end"
2989 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-rpath,${toplevel_builddir}/libvtv/.libs"
2990 ;;
2991 solaris2*)
2992 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2993 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,-R -Wl,${toplevel_builddir}/libvtv/.libs"
2994 ;;
2995 *)
2996 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end"
2997 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs"
2998 ;;
2999 esac
3000 VTV_PCH_CXXFLAGS="-fvtable-verify=std"
3001 else
3002 VTV_CXXFLAGS=
3003 VTV_PCH_CXXFLAGS=
3004 VTV_CXXLINKFLAGS=
3005 fi
3007 AC_SUBST(VTV_CXXFLAGS)
3008 AC_SUBST(VTV_PCH_CXXFLAGS)
3009 AC_SUBST(VTV_CXXLINKFLAGS)
3010 AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes)
3011 GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes)
3012 ])
3014 dnl
3015 dnl Check for parallel mode pre-requisites, including OpenMP support.
3016 dnl
3017 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
3018 dnl
3019 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
3021 enable_parallel=no;
3023 # See if configured libgomp/omp.h exists. (libgomp may be in
3024 # noconfigdirs but not explicitly disabled.)
3025 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
3026 enable_parallel=yes;
3027 else
3028 AC_MSG_NOTICE([target-libgomp not built])
3029 fi
3031 AC_MSG_CHECKING([for parallel mode support])
3032 AC_MSG_RESULT([$enable_parallel])
3033 ])
3036 dnl
3037 dnl Check for which I/O library to use: stdio and POSIX, or pure stdio.
3038 dnl
3039 dnl Default is stdio_posix.
3040 dnl
3041 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
3042 AC_MSG_CHECKING([for underlying I/O to use])
3043 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
3044 [use target-specific I/O package], [permit stdio|stdio_posix|stdio_pure])
3046 # The only available I/O model is based on stdio, via basic_file_stdio.
3047 # The default "stdio" is actually "stdio + POSIX" because it uses fdopen(3)
3048 # to get a file descriptor and then uses read(3) and write(3) with it.
3049 # The "stdio_pure" model doesn't use fdopen and only uses FILE* for I/O.
3050 case ${enable_cstdio} in
3051 stdio*)
3052 CSTDIO_H=config/io/c_io_stdio.h
3053 BASIC_FILE_H=config/io/basic_file_stdio.h
3054 BASIC_FILE_CC=config/io/basic_file_stdio.cc
3056 if test "x$enable_cstdio" = "xstdio_pure" ; then
3057 AC_MSG_RESULT([stdio (without POSIX read/write)])
3058 AC_DEFINE(_GLIBCXX_USE_STDIO_PURE, 1,
3059 [Define to restrict std::__basic_file<> to stdio APIs.])
3060 else
3061 AC_MSG_RESULT([stdio (with POSIX read/write)])
3062 fi
3063 ;;
3064 esac
3066 AC_SUBST(CSTDIO_H)
3067 AC_SUBST(BASIC_FILE_H)
3068 AC_SUBST(BASIC_FILE_CC)
3069 ])
3072 dnl
3073 dnl Check for "unusual" flags to pass to the compiler while building.
3074 dnl
3075 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
3076 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
3077 dnl --disable-cxx-flags passes nothing.
3078 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
3079 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
3080 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
3081 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
3082 dnl If "default flags" is an empty string, the effect is the same
3083 dnl as --disable or --enable=no.
3084 dnl
3085 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
3086 AC_MSG_CHECKING([for extra compiler flags for building])
3087 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
3088 [pass compiler FLAGS when building library],
3089 [case "x$enable_cxx_flags" in
3090 xno | x) enable_cxx_flags= ;;
3091 x-*) ;;
3092 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
3093 esac])
3095 # Run through flags (either default or command-line) and set anything
3096 # extra (e.g., #defines) that must accompany particular g++ options.
3097 if test -n "$enable_cxx_flags"; then
3098 for f in $enable_cxx_flags; do
3099 case "$f" in
3100 -fhonor-std) ;;
3101 -*) ;;
3102 *) # and we're trying to pass /what/ exactly?
3103 AC_MSG_ERROR([compiler flags start with a -]) ;;
3104 esac
3105 done
3106 fi
3108 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3109 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
3110 AC_SUBST(EXTRA_CXX_FLAGS)
3111 ])
3114 dnl
3115 dnl Check to see if debugging libraries are to be built.
3116 dnl
3117 dnl --enable-libstdcxx-debug
3118 dnl builds a separate set of debugging libraries in addition to the
3119 dnl normal (shared, static) libstdc++ binaries.
3120 dnl
3121 dnl --disable-libstdcxx-debug
3122 dnl builds only one (non-debug) version of libstdc++.
3123 dnl
3124 dnl --enable-libstdcxx-debug-flags=FLAGS
3125 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
3126 dnl
3127 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
3128 dnl Where DEFAULT is either `yes' or `no'.
3129 dnl
3130 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
3131 AC_MSG_CHECKING([for additional debug build])
3132 skip_debug_build=
3133 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
3134 if test x$enable_libstdcxx_debug = xyes; then
3135 if test -f $toplevel_builddir/../stage_final \
3136 && test -f $toplevel_builddir/../stage_current; then
3137 stage_final=`cat $toplevel_builddir/../stage_final`
3138 stage_current=`cat $toplevel_builddir/../stage_current`
3139 if test x$stage_current != x$stage_final ; then
3140 skip_debug_build=" (skipped for bootstrap stage $stage_current)"
3141 enable_libstdcxx_debug=no
3142 fi
3143 fi
3144 fi
3145 AC_MSG_RESULT($enable_libstdcxx_debug$skip_debug_build)
3146 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
3147 ])
3150 dnl
3151 dnl Check for explicit debug flags.
3152 dnl
3153 dnl --enable-libstdcxx-debug-flags='-O1'
3154 dnl is a general method for passing flags to be used when
3155 dnl building debug libraries with --enable-libstdcxx-debug.
3156 dnl
3157 dnl --disable-libstdcxx-debug-flags does nothing.
3158 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
3159 dnl If "default flags" is an empty string, the effect is the same
3160 dnl as --disable or --enable=no.
3161 dnl
3162 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
3163 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
3164 [pass compiler FLAGS when building debug library],
3165 [case "x$enable_libstdcxx_debug_flags" in
3166 xno | x) enable_libstdcxx_debug_flags= ;;
3167 x-*) ;;
3168 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
3169 esac])
3171 # Option parsed, now set things appropriately
3172 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
3173 AC_SUBST(DEBUG_FLAGS)
3175 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
3176 ])
3179 dnl
3180 dnl Check if the user only wants a freestanding library implementation.
3181 dnl
3182 dnl --disable-hosted-libstdcxx will turn off most of the library build,
3183 dnl installing only the headers required by [17.4.1.3] and the language
3184 dnl support library. More than that will be built (to keep the Makefiles
3185 dnl conveniently clean), but not installed.
3186 dnl
3187 dnl Also define --disable-libstdcxx-hosted as an alias for
3188 dnl --disable-hosted-libstdcxx but fail if both are given
3189 dnl and their values do not agree.
3190 dnl
3191 dnl Sets:
3192 dnl is_hosted (yes/no)
3193 dnl
3194 dnl Defines:
3195 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
3196 dnl
3197 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
3198 AC_ARG_ENABLE([hosted-libstdcxx],
3199 AC_HELP_STRING([--disable-hosted-libstdcxx],
3200 [only build freestanding C++ runtime support]),
3201 [enable_hosted_libstdcxx_was_given=yes],
3202 [case "$host" in
3203 arm*-*-symbianelf*)
3204 enable_hosted_libstdcxx=no
3205 ;;
3206 *)
3207 case "${with_newlib}-${with_headers}" in
3208 no-no) enable_hosted_libstdcxx=no ;;
3209 *) enable_hosted_libstdcxx=yes ;;
3210 esac
3211 ;;
3212 esac])
3214 # Because most configure args are --enable-libstdcxx-foo add an alias
3215 # of that form for --enable-hosted-libstdcxx.
3216 AC_ARG_ENABLE([libstdcxx-hosted],
3217 AC_HELP_STRING([--disable-libstdcxx-hosted],
3218 [alias for --disable-hosted-libstdcxx]),
3219 [if test "$enable_hosted_libstdcxx_was_given" = yes; then
3220 if test "$enable_hosted_libstdcxx" != "$enableval"; then
3221 AC_MSG_ERROR([--enable-libstdcxx-hosted=$enableval conflicts with --enable-hosted-libstdcxx=$enable_hosted_libstdcxx])
3222 fi
3223 else
3224 enable_hosted_libstdcxx=${enableval}
3225 fi
3226 ],)
3228 freestanding_flags=
3229 if test "$enable_hosted_libstdcxx" = no; then
3230 AC_MSG_NOTICE([Only freestanding libraries will be built])
3231 is_hosted=no
3232 hosted_define=0
3233 enable_abi_check=no
3234 enable_libstdcxx_pch=no
3235 if test "x$with_headers" = xno; then
3236 freestanding_flags="-ffreestanding"
3237 fi
3238 else
3239 is_hosted=yes
3240 hosted_define=__STDC_HOSTED__
3241 fi
3242 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
3243 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
3244 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
3245 FREESTANDING_FLAGS="$freestanding_flags"
3246 AC_SUBST(FREESTANDING_FLAGS)
3247 ])
3250 dnl
3251 dnl Check if the user wants a non-verbose library implementation.
3252 dnl
3253 dnl --disable-libstdcxx-verbose will turn off descriptive messages to
3254 dnl standard error on termination.
3255 dnl
3256 dnl Defines:
3257 dnl _GLIBCXX_VERBOSE (always defined, either to 1 or 0)
3258 dnl
3259 AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [
3260 AC_ARG_ENABLE([libstdcxx-verbose],
3261 AC_HELP_STRING([--disable-libstdcxx-verbose],
3262 [disable termination messages to standard error]),,
3263 [enable_libstdcxx_verbose=yes])
3264 if test x"$enable_libstdcxx_verbose" = xyes; then
3265 verbose_define=1
3266 else
3267 AC_MSG_NOTICE([verbose termination messages are disabled])
3268 verbose_define=0
3269 fi
3270 AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define,
3271 [Define to 1 if a verbose library is built, or 0 otherwise.])
3272 ])
3275 dnl
3276 dnl Check for template specializations for the 'long long' type.
3277 dnl The result determines only whether 'long long' I/O is enabled; things
3278 dnl like numeric_limits<> specializations are always available.
3279 dnl
3280 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
3281 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
3282 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
3283 dnl Where DEFAULT is either `yes' or `no'.
3284 dnl
3285 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
3286 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
3287 if test $enable_long_long = yes; then
3288 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
3289 [Define if code specialized for long long should be used.])
3290 fi
3291 AC_MSG_CHECKING([for enabled long long specializations])
3292 AC_MSG_RESULT([$enable_long_long])
3293 ])
3296 dnl
3297 dnl Check for decimal floating point.
3298 dnl See:
3299 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
3300 dnl
3301 dnl This checks to see if the host supports decimal floating point types.
3302 dnl
3303 dnl Defines:
3304 dnl _GLIBCXX_USE_DECIMAL_FLOAT
3305 dnl
3306 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
3308 # Fake what AC_TRY_COMPILE does, without linking as this is
3309 # unnecessary for this test.
3311 cat > conftest.$ac_ext << EOF
3312 [#]line __oline__ "configure"
3313 int main()
3314 {
3315 _Decimal32 d1;
3316 _Decimal64 d2;
3317 _Decimal128 d3;
3318 return 0;
3319 }
3320 EOF
3322 AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
3323 if AC_TRY_EVAL(ac_compile); then
3324 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
3325 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
3326 enable_dfp=yes
3327 else
3328 enable_dfp=no
3329 fi
3330 AC_MSG_RESULT($enable_dfp)
3331 rm -f conftest*
3332 ])
3334 dnl
3335 dnl Check for GNU 128-bit floating point type.
3336 dnl
3337 dnl Note: also checks that the type isn't a standard types.
3338 dnl
3339 dnl Defines:
3340 dnl ENABLE_FLOAT128
3341 dnl
3342 AC_DEFUN([GLIBCXX_ENABLE_FLOAT128], [
3344 AC_LANG_SAVE
3345 AC_LANG_CPLUSPLUS
3347 # Fake what AC_TRY_COMPILE does, without linking as this is
3348 # unnecessary for this test.
3350 cat > conftest.$ac_ext << EOF
3351 [#]line __oline__ "configure"
3352 template<typename T1, typename T2>
3353 struct same
3354 { typedef T2 type; };
3356 template<typename T>
3357 struct same<T, T>;
3359 int main()
3360 {
3361 typename same<double, __float128>::type f1;
3362 typename same<long double, __float128>::type f2;
3363 }
3364 EOF
3366 AC_MSG_CHECKING([for __float128])
3367 if AC_TRY_EVAL(ac_compile); then
3368 enable_float128=yes
3369 else
3370 enable_float128=no
3371 fi
3372 AC_MSG_RESULT($enable_float128)
3373 GLIBCXX_CONDITIONAL(ENABLE_FLOAT128, test $enable_float128 = yes)
3374 rm -f conftest*
3376 AC_LANG_RESTORE
3377 ])
3379 dnl
3380 dnl Check for template specializations for the 'wchar_t' type.
3381 dnl
3382 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
3383 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
3384 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
3385 dnl Where DEFAULT is either `yes' or `no'.
3386 dnl
3387 dnl Necessary support must also be present.
3388 dnl
3389 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
3390 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
3392 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
3393 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
3394 AC_MSG_CHECKING([for mbstate_t])
3395 AC_TRY_COMPILE([#include <wchar.h>],
3396 [mbstate_t teststate;],
3397 have_mbstate_t=yes, have_mbstate_t=no)
3398 AC_MSG_RESULT($have_mbstate_t)
3399 if test x"$have_mbstate_t" = xyes; then
3400 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
3401 fi
3403 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
3404 # ac_has_wchar_h.
3405 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
3407 if test x"$enable_wchar_t" = x"yes"; then
3409 AC_LANG_SAVE
3410 AC_LANG_CPLUSPLUS
3412 if test x"$ac_has_wchar_h" = xyes &&
3413 test x"$ac_has_wctype_h" = xyes; then
3414 AC_TRY_COMPILE([#include <wchar.h>
3415 #include <stddef.h>
3416 wint_t i;
3417 long l = WEOF;
3418 long j = WCHAR_MIN;
3419 long k = WCHAR_MAX;
3420 namespace test
3421 {
3422 using ::btowc;
3423 using ::fgetwc;
3424 using ::fgetws;
3425 using ::fputwc;
3426 using ::fputws;
3427 using ::fwide;
3428 using ::fwprintf;
3429 using ::fwscanf;
3430 using ::getwc;
3431 using ::getwchar;
3432 using ::mbrlen;
3433 using ::mbrtowc;
3434 using ::mbsinit;
3435 using ::mbsrtowcs;
3436 using ::putwc;
3437 using ::putwchar;
3438 using ::swprintf;
3439 using ::swscanf;
3440 using ::ungetwc;
3441 using ::vfwprintf;
3442 using ::vswprintf;
3443 using ::vwprintf;
3444 using ::wcrtomb;
3445 using ::wcscat;
3446 using ::wcschr;
3447 using ::wcscmp;
3448 using ::wcscoll;
3449 using ::wcscpy;
3450 using ::wcscspn;
3451 using ::wcsftime;
3452 using ::wcslen;
3453 using ::wcsncat;
3454 using ::wcsncmp;
3455 using ::wcsncpy;
3456 using ::wcspbrk;
3457 using ::wcsrchr;
3458 using ::wcsrtombs;
3459 using ::wcsspn;
3460 using ::wcsstr;
3461 using ::wcstod;
3462 using ::wcstok;
3463 using ::wcstol;
3464 using ::wcstoul;
3465 using ::wcsxfrm;
3466 using ::wctob;
3467 using ::wmemchr;
3468 using ::wmemcmp;
3469 using ::wmemcpy;
3470 using ::wmemmove;
3471 using ::wmemset;
3472 using ::wprintf;
3473 using ::wscanf;
3474 }
3475 ],[],[], [enable_wchar_t=no])
3476 else
3477 enable_wchar_t=no
3478 fi
3480 AC_LANG_RESTORE
3481 fi
3483 if test x"$enable_wchar_t" = x"yes"; then
3484 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
3485 [Define if code specialized for wchar_t should be used.])
3486 fi
3488 AC_MSG_CHECKING([for enabled wchar_t specializations])
3489 AC_MSG_RESULT([$enable_wchar_t])
3490 ])
3493 dnl
3494 dnl Check to see if building and using a C++ precompiled header can be done.
3495 dnl
3496 dnl --enable-libstdcxx-pch=yes
3497 dnl default, this shows intent to use stdc++.h.gch If it looks like it
3498 dnl may work, after some light-hearted attempts to puzzle out compiler
3499 dnl support, flip bits on in include/Makefile.am
3500 dnl
3501 dnl --disable-libstdcxx-pch
3502 dnl turns off attempts to use or build stdc++.h.gch.
3503 dnl
3504 dnl Substs:
3505 dnl glibcxx_PCHFLAGS
3506 dnl
3507 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
3508 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
3509 if test $enable_libstdcxx_pch = yes; then
3510 AC_CACHE_CHECK([for compiler with PCH support],
3511 [glibcxx_cv_prog_CXX_pch],
3512 [ac_save_CXXFLAGS="$CXXFLAGS"
3513 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
3514 AC_LANG_SAVE
3515 AC_LANG_CPLUSPLUS
3516 echo '#include <math.h>' > conftest.h
3517 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
3518 -o conftest.h.gch 1>&5 2>&1 &&
3519 echo '#error "pch failed"' > conftest.h &&
3520 echo '#include "conftest.h"' > conftest.cc &&
3521 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
3522 then
3523 glibcxx_cv_prog_CXX_pch=yes
3524 else
3525 glibcxx_cv_prog_CXX_pch=no
3526 fi
3527 rm -f conftest*
3528 CXXFLAGS=$ac_save_CXXFLAGS
3529 AC_LANG_RESTORE
3530 ])
3531 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
3532 fi
3534 AC_MSG_CHECKING([for enabled PCH])
3535 AC_MSG_RESULT([$enable_libstdcxx_pch])
3537 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
3538 if test $enable_libstdcxx_pch = yes; then
3539 glibcxx_PCHFLAGS="-include bits/stdc++.h"
3540 else
3541 glibcxx_PCHFLAGS=""
3542 fi
3543 AC_SUBST(glibcxx_PCHFLAGS)
3544 ])
3547 dnl
3548 dnl Check for atomic builtins.
3549 dnl See:
3550 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
3551 dnl
3552 dnl This checks to see if the host supports the compiler-generated
3553 dnl builtins for atomic operations for various integral sizes. Note, this
3554 dnl is intended to be an all-or-nothing switch, so all the atomic operations
3555 dnl that are used should be checked.
3556 dnl
3557 dnl Note:
3558 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
3559 dnl
3560 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
3561 AC_LANG_SAVE
3562 AC_LANG_CPLUSPLUS
3563 old_CXXFLAGS="$CXXFLAGS"
3565 # Do link tests if possible, instead asm tests, limited to some platforms
3566 # see discussion in PR target/40134, PR libstdc++/40133 and the thread
3567 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
3568 atomic_builtins_link_tests=no
3569 if test x$gcc_no_link != xyes; then
3570 # Can do link tests. Limit to some tested platforms
3571 case "$host" in
3572 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
3573 atomic_builtins_link_tests=yes
3574 ;;
3575 esac
3576 fi
3578 if test x$atomic_builtins_link_tests = xyes; then
3580 # Do link tests.
3582 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3584 AC_CACHE_CHECK([for atomic builtins for bool],
3585 glibcxx_cv_atomic_bool, [
3586 AC_TRY_LINK(
3587 [ ],
3588 [typedef bool atomic_type;
3589 atomic_type c1;
3590 atomic_type c2;
3591 atomic_type c3(0);
3592 // N.B. __atomic_fetch_add is not supported for bool.
3593 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3594 __ATOMIC_RELAXED);
3595 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3596 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3597 ],
3598 [glibcxx_cv_atomic_bool=yes],
3599 [glibcxx_cv_atomic_bool=no])
3600 ])
3602 AC_CACHE_CHECK([for atomic builtins for short],
3603 glibcxx_cv_atomic_short, [
3604 AC_TRY_LINK(
3605 [ ],
3606 [typedef short atomic_type;
3607 atomic_type c1;
3608 atomic_type c2;
3609 atomic_type c3(0);
3610 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3611 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3612 __ATOMIC_RELAXED);
3613 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3614 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3615 ],
3616 [glibcxx_cv_atomic_short=yes],
3617 [glibcxx_cv_atomic_short=no])
3618 ])
3620 AC_CACHE_CHECK([for atomic builtins for int],
3621 glibcxx_cv_atomic_int, [
3622 AC_TRY_LINK(
3623 [ ],
3624 [typedef int atomic_type;
3625 atomic_type c1;
3626 atomic_type c2;
3627 atomic_type c3(0);
3628 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3629 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3630 __ATOMIC_RELAXED);
3631 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3632 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3633 ],
3634 [glibcxx_cv_atomic_int=yes],
3635 [glibcxx_cv_atomic_int=no])
3636 ])
3638 AC_CACHE_CHECK([for atomic builtins for long long],
3639 glibcxx_cv_atomic_long_long, [
3640 AC_TRY_LINK(
3641 [ ],
3642 [typedef long long atomic_type;
3643 atomic_type c1;
3644 atomic_type c2;
3645 atomic_type c3(0);
3646 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3647 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3648 __ATOMIC_RELAXED);
3649 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3650 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3651 ],
3652 [glibcxx_cv_atomic_long_long=yes],
3653 [glibcxx_cv_atomic_long_long=no])
3654 ])
3656 else
3658 # Do asm tests.
3660 # Compile unoptimized.
3661 CXXFLAGS='-O0 -S'
3663 # Fake what AC_TRY_COMPILE does.
3665 cat > conftest.$ac_ext << EOF
3666 [#]line __oline__ "configure"
3667 int main()
3668 {
3669 typedef bool atomic_type;
3670 atomic_type c1;
3671 atomic_type c2;
3672 atomic_type c3(0);
3673 // N.B. __atomic_fetch_add is not supported for bool.
3674 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3675 __ATOMIC_RELAXED);
3676 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3677 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3679 return 0;
3680 }
3681 EOF
3683 AC_MSG_CHECKING([for atomic builtins for bool])
3684 if AC_TRY_EVAL(ac_compile); then
3685 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3686 glibcxx_cv_atomic_bool=no
3687 else
3688 glibcxx_cv_atomic_bool=yes
3689 fi
3690 fi
3691 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
3692 rm -f conftest*
3694 cat > conftest.$ac_ext << EOF
3695 [#]line __oline__ "configure"
3696 int main()
3697 {
3698 typedef short atomic_type;
3699 atomic_type c1;
3700 atomic_type c2;
3701 atomic_type c3(0);
3702 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3703 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3704 __ATOMIC_RELAXED);
3705 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3706 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3708 return 0;
3709 }
3710 EOF
3712 AC_MSG_CHECKING([for atomic builtins for short])
3713 if AC_TRY_EVAL(ac_compile); then
3714 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3715 glibcxx_cv_atomic_short=no
3716 else
3717 glibcxx_cv_atomic_short=yes
3718 fi
3719 fi
3720 AC_MSG_RESULT($glibcxx_cv_atomic_short)
3721 rm -f conftest*
3723 cat > conftest.$ac_ext << EOF
3724 [#]line __oline__ "configure"
3725 int main()
3726 {
3727 // NB: _Atomic_word not necessarily int.
3728 typedef int atomic_type;
3729 atomic_type c1;
3730 atomic_type c2;
3731 atomic_type c3(0);
3732 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3733 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3734 __ATOMIC_RELAXED);
3735 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3736 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3738 return 0;
3739 }
3740 EOF
3742 AC_MSG_CHECKING([for atomic builtins for int])
3743 if AC_TRY_EVAL(ac_compile); then
3744 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3745 glibcxx_cv_atomic_int=no
3746 else
3747 glibcxx_cv_atomic_int=yes
3748 fi
3749 fi
3750 AC_MSG_RESULT($glibcxx_cv_atomic_int)
3751 rm -f conftest*
3753 cat > conftest.$ac_ext << EOF
3754 [#]line __oline__ "configure"
3755 int main()
3756 {
3757 typedef long long atomic_type;
3758 atomic_type c1;
3759 atomic_type c2;
3760 atomic_type c3(0);
3761 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
3762 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
3763 __ATOMIC_RELAXED);
3764 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
3765 __atomic_load_n(&c1, __ATOMIC_RELAXED);
3767 return 0;
3768 }
3769 EOF
3771 AC_MSG_CHECKING([for atomic builtins for long long])
3772 if AC_TRY_EVAL(ac_compile); then
3773 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
3774 glibcxx_cv_atomic_long_long=no
3775 else
3776 glibcxx_cv_atomic_long_long=yes
3777 fi
3778 fi
3779 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
3780 rm -f conftest*
3782 fi
3784 CXXFLAGS="$old_CXXFLAGS"
3785 AC_LANG_RESTORE
3787 # Set atomicity_dir to builtins if all but the long long test above passes,
3788 # or if the builtins were already chosen (e.g. by configure.host).
3789 if { test "$glibcxx_cv_atomic_bool" = yes \
3790 && test "$glibcxx_cv_atomic_short" = yes \
3791 && test "$glibcxx_cv_atomic_int" = yes; } \
3792 || test "$atomicity_dir" = "cpu/generic/atomicity_builtins"; then
3793 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
3794 [Define if the compiler supports C++11 atomics.])
3795 atomicity_dir=cpu/generic/atomicity_builtins
3796 fi
3798 # If still generic, set to mutex.
3799 if test $atomicity_dir = "cpu/generic" ; then
3800 atomicity_dir=cpu/generic/atomicity_mutex
3801 AC_MSG_WARN([No native atomic operations are provided for this platform.])
3802 if test "x$target_thread_file" = xsingle; then
3803 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
3804 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
3805 else
3806 AC_MSG_WARN([They will be faked using a mutex.])
3807 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
3808 fi
3809 fi
3811 ])
3813 dnl
3814 dnl Set default lock policy for synchronizing shared_ptr reference counting.
3815 dnl
3816 dnl --with-libstdcxx-lock-policy=auto
3817 dnl Use atomic operations for shared_ptr reference counting only if
3818 dnl the default target supports atomic compare-and-swap.
3819 dnl --with-libstdcxx-lock-policy=atomic
3820 dnl Use atomic operations for shared_ptr reference counting.
3821 dnl --with-libstdcxx-lock-policy=mutex
3822 dnl Use a mutex to synchronize shared_ptr reference counting.
3823 dnl
3824 dnl This controls the value of __gnu_cxx::__default_lock_policy, which
3825 dnl determines how shared_ptr reference counts are synchronized.
3826 dnl The option "atomic" means that atomic operations should be used,
3827 dnl "mutex" means that a mutex will be used. The default option, "auto",
3828 dnl will check if the target supports the compiler-generated builtins
3829 dnl for atomic compare-and-swap operations for 2-byte and 4-byte integers,
3830 dnl and will use "atomic" if supported, "mutex" otherwise.
3831 dnl This option is ignored if the thread model used by GCC is "single",
3832 dnl as no synchronization is used at all in that case.
3833 dnl This option affects the library ABI (except in the "single" thread model).
3834 dnl
3835 dnl Defines _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY to 1 if atomics should be used.
3836 dnl
3837 AC_DEFUN([GLIBCXX_ENABLE_LOCK_POLICY], [
3839 AC_ARG_WITH([libstdcxx-lock-policy],
3840 AC_HELP_STRING([--with-libstdcxx-lock-policy={atomic,mutex,auto}],
3841 [synchronization policy for shared_ptr reference counting [default=auto]]),
3842 [libstdcxx_atomic_lock_policy=$withval],
3843 [libstdcxx_atomic_lock_policy=auto])
3845 case "$libstdcxx_atomic_lock_policy" in
3846 atomic|mutex|auto) ;;
3847 *) AC_MSG_ERROR([Invalid argument for --with-libstdcxx-lock-policy]) ;;
3848 esac
3849 AC_MSG_CHECKING([for lock policy for shared_ptr reference counts])
3851 if test x"$libstdcxx_atomic_lock_policy" = x"auto"; then
3852 AC_LANG_SAVE
3853 AC_LANG_CPLUSPLUS
3854 ac_save_CXXFLAGS="$CXXFLAGS"
3856 dnl Why do we care about 2-byte CAS on targets with 4-byte _Atomic_word?!
3857 dnl Why don't we check 8-byte CAS for sparc64, where _Atomic_word is long?!
3858 dnl New targets should only check for CAS for the _Atomic_word type.
3859 AC_TRY_COMPILE([
3860 #if defined __riscv
3861 # error "Defaulting to mutex-based locks for ABI compatibility"
3862 #endif
3863 #if ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
3864 # error "No 2-byte compare-and-swap"
3865 #elif ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
3866 # error "No 4-byte compare-and-swap"
3867 #endif
3868 ],,
3869 [libstdcxx_atomic_lock_policy=atomic],
3870 [libstdcxx_atomic_lock_policy=mutex])
3871 AC_LANG_RESTORE
3872 CXXFLAGS="$ac_save_CXXFLAGS"
3873 fi
3875 if test x"$libstdcxx_atomic_lock_policy" = x"atomic"; then
3876 AC_MSG_RESULT(atomic)
3877 AC_DEFINE(HAVE_ATOMIC_LOCK_POLICY,1,
3878 [Defined if shared_ptr reference counting should use atomic operations.])
3879 else
3880 AC_MSG_RESULT(mutex)
3881 fi
3883 ])
3885 dnl
3886 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3887 dnl
3888 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3889 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3890 dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3891 dnl Where DEFAULT is 'yes'.
3892 dnl
3893 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3894 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3896 if test x$enable_libstdcxx_visibility = xyes ; then
3897 dnl all hail libgfortran
3898 dnl Check whether the target supports hidden visibility.
3899 AC_CACHE_CHECK([whether the target supports hidden visibility],
3900 glibcxx_cv_have_attribute_visibility, [
3901 save_CFLAGS="$CFLAGS"
3902 CFLAGS="$CFLAGS -Werror"
3903 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3904 [], glibcxx_cv_have_attribute_visibility=yes,
3905 glibcxx_cv_have_attribute_visibility=no)
3906 CFLAGS="$save_CFLAGS"])
3907 if test $glibcxx_cv_have_attribute_visibility = no; then
3908 enable_libstdcxx_visibility=no
3909 fi
3910 fi
3912 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3913 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3914 ])
3917 dnl
3918 dnl Add version tags to symbols in shared library (or not), additionally
3919 dnl marking other symbols as private/local (or not).
3920 dnl
3921 dnl Sets libtool_VERSION, and determines shared library SONAME.
3922 dnl
3923 dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3924 dnl
3925 dnl --enable-symvers=style adds a version script to the linker call when
3926 dnl creating the shared library. The choice of version script is
3927 dnl controlled by 'style'.
3928 dnl --disable-symvers does not.
3929 dnl
3930 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3931 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
3932 dnl choose a default style based on linker characteristics. Passing
3933 dnl 'no' disables versioning.
3934 dnl
3935 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3937 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3938 [enables symbol versioning of the shared library],
3939 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3941 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3942 # don't know enough about $LD to do tricks...
3943 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3944 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3945 # with extern "C++" in version scripts.
3946 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3948 # Turn a 'yes' into a suitable default.
3949 if test x$enable_symvers = xyes ; then
3950 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3951 enable_symvers=no
3952 else
3953 if test $with_gnu_ld = yes ; then
3954 case ${target_os} in
3955 hpux*)
3956 enable_symvers=no ;;
3957 *)
3958 enable_symvers=gnu ;;
3959 esac
3960 else
3961 case ${target_os} in
3962 darwin*)
3963 enable_symvers=darwin ;;
3964 # Sun symbol versioning exists since Solaris 2.5.
3965 solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3966 # make_sunver.pl needs GNU c++filt to support extern "C++" in
3967 # version scripts, so disable symbol versioning if none can be
3968 # found.
3969 if test -z "$ac_cv_path_CXXFILT"; then
3970 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3971 AC_MSG_WARN([=== no GNU c++filt could be found.])
3972 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3973 enable_symvers=no
3974 else
3975 enable_symvers=sun
3976 fi
3977 ;;
3978 *)
3979 enable_symvers=no ;;
3980 esac
3981 fi
3982 fi
3983 fi
3985 # Check to see if 'darwin' or 'darwin-export' can win.
3986 if test x$enable_symvers = xdarwin-export ; then
3987 enable_symvers=darwin
3988 fi
3990 # Check if 'sun' was requested on non-Solaris 2 platforms.
3991 if test x$enable_symvers = xsun ; then
3992 case ${target_os} in
3993 solaris2*)
3994 # All fine.
3995 ;;
3996 *)
3997 # Unlikely to work.
3998 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3999 AC_MSG_WARN([=== you are not targetting Solaris 2.])
4000 AC_MSG_WARN([=== Symbol versioning will be disabled.])
4001 enable_symvers=no
4002 ;;
4003 esac
4004 fi
4006 # Check to see if 'gnu' can win.
4007 if test $enable_symvers = gnu ||
4008 test $enable_symvers = gnu-versioned-namespace ||
4009 test $enable_symvers = sun; then
4010 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
4011 AC_MSG_CHECKING([for shared libgcc])
4012 ac_save_CFLAGS="$CFLAGS"
4013 CFLAGS=' -lgcc_s'
4014 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
4015 CFLAGS="$ac_save_CFLAGS"
4016 if test $glibcxx_shared_libgcc = no; then
4017 cat > conftest.c <<EOF
4018 int main (void) { return 0; }
4019 EOF
4020 changequote(,)dnl
4021 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
4022 -shared -shared-libgcc -o conftest.so \
4023 conftest.c -v 2>&1 >/dev/null \
4024 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
4025 changequote([,])dnl
4026 rm -f conftest.c conftest.so
4027 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
4028 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
4029 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
4030 CFLAGS="$ac_save_CFLAGS"
4031 fi
4032 fi
4033 AC_MSG_RESULT($glibcxx_shared_libgcc)
4035 # For GNU ld, we need at least this version. The format is described in
4036 # GLIBCXX_CHECK_LINKER_FEATURES above.
4037 glibcxx_min_gnu_ld_version=21400
4039 # If no shared libgcc, can't win.
4040 if test $glibcxx_shared_libgcc != yes; then
4041 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
4042 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
4043 AC_MSG_WARN([=== Symbol versioning will be disabled.])
4044 enable_symvers=no
4045 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
4046 : All interesting versions of Sun ld support sun style symbol versioning.
4047 elif test $with_gnu_ld != yes ; then
4048 # just fail for now
4049 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
4050 AC_MSG_WARN([=== you are not using the GNU linker.])
4051 AC_MSG_WARN([=== Symbol versioning will be disabled.])
4052 enable_symvers=no
4053 elif test $glibcxx_ld_is_gold = yes ; then
4054 : All versions of gold support symbol versioning.
4055 elif test $glibcxx_ld_is_mold = yes ; then
4056 : All versions of mold support symbol versioning.
4057 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
4058 # The right tools, the right setup, but too old. Fallbacks?
4059 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
4060 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
4061 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
4062 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
4063 AC_MSG_WARN([=== Symbol versioning will be disabled.])
4064 enable_symvers=no
4065 fi
4066 fi
4068 # For libtool versioning info, format is CURRENT:REVISION:AGE
4069 libtool_VERSION=6:32:0
4071 # Everything parsed; figure out what files and settings to use.
4072 case $enable_symvers in
4073 no)
4074 SYMVER_FILE=config/abi/pre/none.ver
4075 ;;
4076 gnu)
4077 SYMVER_FILE=config/abi/pre/gnu.ver
4078 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
4079 [Define to use GNU versioning in the shared library.])
4080 ;;
4081 gnu-versioned-namespace)
4082 libtool_VERSION=8:0:0
4083 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
4084 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
4085 [Define to use GNU namespace versioning in the shared library.])
4086 ;;
4087 darwin)
4088 SYMVER_FILE=config/abi/pre/gnu.ver
4089 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
4090 [Define to use darwin versioning in the shared library.])
4091 ;;
4092 sun)
4093 SYMVER_FILE=config/abi/pre/gnu.ver
4094 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
4095 [Define to use Sun versioning in the shared library.])
4096 ;;
4097 esac
4099 if test x$enable_symvers != xno ; then
4100 AC_DEFINE(_GLIBCXX_SYMVER, 1,
4101 [Define to use symbol versioning in the shared library.])
4102 fi
4104 AC_CACHE_CHECK([whether the target supports .symver directive],
4105 glibcxx_cv_have_as_symver_directive, [
4106 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
4107 [], glibcxx_cv_have_as_symver_directive=yes,
4108 glibcxx_cv_have_as_symver_directive=no)])
4109 if test $glibcxx_cv_have_as_symver_directive = yes; then
4110 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
4111 [Define to 1 if the target assembler supports .symver directive.])
4112 fi
4114 AC_SUBST(SYMVER_FILE)
4115 AC_SUBST(port_specific_symbol_files)
4116 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
4117 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
4118 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
4119 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
4120 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
4121 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
4123 if test $enable_symvers != no ; then
4124 case ${target_os} in
4125 # The Solaris 2 runtime linker doesn't support the GNU extension of
4126 # binding the same symbol to different versions
4127 solaris2*)
4128 ;;
4129 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
4130 *)
4131 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
4132 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
4133 ;;
4134 esac
4135 fi
4137 # Now, set up compatibility support, if any.
4138 # In addition, need this to deal with std::size_t mangling in
4139 # src/compatibility.cc. In a perfect world, could use
4140 # typeid(std::size_t).name()[0] to do direct substitution.
4141 AC_MSG_CHECKING([for size_t as unsigned int])
4142 ac_save_CFLAGS="$CFLAGS"
4143 CFLAGS="-Werror"
4144 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
4145 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
4146 CFLAGS=$ac_save_CFLAGS
4147 if test "$glibcxx_size_t_is_i" = yes; then
4148 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
4149 fi
4150 AC_MSG_RESULT([$glibcxx_size_t_is_i])
4152 AC_MSG_CHECKING([for ptrdiff_t as int])
4153 ac_save_CFLAGS="$CFLAGS"
4154 CFLAGS="-Werror"
4155 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
4156 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
4157 CFLAGS=$ac_save_CFLAGS
4158 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
4159 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
4160 fi
4161 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
4162 ])
4165 dnl
4166 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
4167 dnl We must stage the required headers so that they will be installed
4168 dnl with the library (unlike libgcc, the STL implementation is provided
4169 dnl solely within headers). Since we must not inject random user-space
4170 dnl macro names into user-provided C++ code, we first stage into <file>-in
4171 dnl and process to <file> with an output command. The reason for a two-
4172 dnl stage process here is to correctly handle $srcdir!=$objdir without
4173 dnl having to write complex code (the sed commands to clean the macro
4174 dnl namespace are complex and fragile enough as it is). We must also
4175 dnl add a relative path so that -I- is supported properly.
4176 dnl
4177 dnl Substs:
4178 dnl thread_header
4179 dnl
4180 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
4181 AC_MSG_CHECKING([for thread model used by GCC])
4182 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
4183 AC_MSG_RESULT([$target_thread_file])
4184 GCC_AC_THREAD_HEADER([$target_thread_file])
4185 ])
4188 dnl
4189 dnl Check if gthread implementation defines the types and functions
4190 dnl required by the c++0x thread library. Conforming gthread
4191 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
4192 dnl
4193 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
4194 dnl
4195 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
4196 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
4198 if test x$enable_libstdcxx_threads = xauto ||
4199 test x$enable_libstdcxx_threads = xyes; then
4201 AC_LANG_SAVE
4202 AC_LANG_CPLUSPLUS
4204 ac_save_CXXFLAGS="$CXXFLAGS"
4205 CXXFLAGS="$CXXFLAGS -fno-exceptions \
4206 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
4208 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
4209 case $target_thread_file in
4210 posix)
4211 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
4212 ;;
4213 win32)
4214 CXXFLAGS="$CXXFLAGS -D_WIN32_THREADS"
4215 # The support of condition variables is disabled by default in
4216 # the Win32 gthreads library, so enable it on explicit request.
4217 if test x$enable_libstdcxx_threads = xyes; then
4218 CXXFLAGS="$CXXFLAGS -D_WIN32_WINNT=0x0600"
4219 fi
4220 ;;
4221 esac
4223 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
4225 AC_TRY_COMPILE([#include <unistd.h>],
4226 [
4227 // In case of POSIX threads check _POSIX_TIMEOUTS.
4228 #if (defined(_PTHREADS) \
4229 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
4230 #error
4231 // In case of Win32 threads there is no support.
4232 #elif defined(_WIN32_THREADS)
4233 #error
4234 #endif
4235 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
4237 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
4238 [Define to 1 if mutex_timedlock is available.])
4240 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
4241 else res_mutex_timedlock=no ; fi
4242 AC_MSG_RESULT([$res_mutex_timedlock])
4244 AC_MSG_CHECKING([for gthreads library])
4246 AC_TRY_COMPILE([#include "gthr.h"],
4247 [
4248 #ifndef __GTHREADS_CXX0X
4249 #error
4250 #endif
4251 ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
4252 else
4253 ac_has_gthreads=no
4254 fi
4256 AC_MSG_RESULT([$ac_has_gthreads])
4258 if test x"$ac_has_gthreads" = x"yes"; then
4259 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
4260 [Define if gthreads library is available.])
4262 # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14
4263 # but only do so if we're using pthread in the gthread library.
4264 # On VxWorks for example, pthread_rwlock_t is defined in sys/types.h
4265 # but the pthread library is not there by default and the gthread library
4266 # does not use it.
4267 AC_TRY_COMPILE([#include "gthr.h"],
4268 [
4269 #if (!defined(_PTHREADS))
4270 #error
4271 #endif
4272 ], [ac_gthread_use_pthreads=yes], [ac_gthread_use_pthreads=no])
4273 if test x"$ac_gthread_use_pthreads" = x"yes"; then
4274 AC_CHECK_TYPE([pthread_rwlock_t],
4275 [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1,
4276 [Define if POSIX read/write locks are available in <gthr.h>.])],
4277 [],
4278 [#include "gthr.h"])
4279 fi
4281 # See above for the rationale.
4282 if test $target_thread_file = win32; then
4283 CPPFLAGS="$CPPFLAGS -D_WIN32_WINNT=0x0600"
4284 fi
4285 fi
4287 AC_CHECK_HEADER(semaphore.h, [
4288 AC_MSG_CHECKING([for POSIX Semaphores and sem_timedwait])
4289 AC_TRY_COMPILE([
4290 #include <unistd.h>
4291 #include <semaphore.h>
4292 #include <limits.h>
4293 ],
4294 [
4295 #if !defined _POSIX_TIMEOUTS || _POSIX_TIMEOUTS <= 0
4296 # error "POSIX Timeouts option not supported"
4297 #elif !defined _POSIX_SEMAPHORES || _POSIX_SEMAPHORES <= 0
4298 # error "POSIX Semaphores option not supported"
4299 #else
4300 #if defined SEM_VALUE_MAX
4301 constexpr int sem_value_max = SEM_VALUE_MAX;
4302 #elif defined _POSIX_SEM_VALUE_MAX
4303 constexpr int sem_value_max = _POSIX_SEM_VALUE_MAX;
4304 #else
4305 # error "SEM_VALUE_MAX not available"
4306 #endif
4307 sem_t sem;
4308 sem_init(&sem, 0, sem_value_max);
4309 struct timespec ts = { 0 };
4310 sem_timedwait(&sem, &ts);
4311 #endif
4312 ],
4313 [ac_have_posix_semaphore=yes],
4314 [ac_have_posix_semaphore=no])],
4315 [ac_have_posix_semaphore=no])
4317 if test $ac_have_posix_semaphore = yes ; then
4318 AC_DEFINE(HAVE_POSIX_SEMAPHORE,
4319 1,
4320 [Define to 1 if POSIX Semaphores with sem_timedwait are available in <semaphore.h>.])
4321 fi
4322 AC_MSG_RESULT([$ac_have_posix_semaphore])
4324 CXXFLAGS="$ac_save_CXXFLAGS"
4325 AC_LANG_RESTORE
4326 ])
4329 # Check whether LC_MESSAGES is available in <locale.h>.
4330 # Ulrich Drepper <drepper@cygnus.com>, 1995.
4331 #
4332 # This file file be copied and used freely without restrictions. It can
4333 # be used in projects which are not available under the GNU Public License
4334 # but which still want to provide support for the GNU gettext functionality.
4335 # Please note that the actual code is *not* freely available.
4336 AC_DEFUN([AC_LC_MESSAGES], [
4337 AC_CHECK_HEADER(locale.h, [
4338 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
4339 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
4340 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
4341 if test $ac_cv_val_LC_MESSAGES = yes; then
4342 AC_DEFINE(HAVE_LC_MESSAGES, 1,
4343 [Define if LC_MESSAGES is available in <locale.h>.])
4344 fi
4345 ])
4346 ])
4348 dnl
4349 dnl Check whether rdrand is supported in the assembler.
4350 AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [
4351 AC_CACHE_CHECK([for rdrand support in assembler],
4352 ac_cv_x86_rdrand, [
4353 ac_cv_x86_rdrand=no
4354 case "$target" in
4355 i?86-*-* | \
4356 x86_64-*-*)
4357 AC_TRY_COMPILE(, [asm("rdrand %eax");],
4358 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no])
4359 esac
4360 ])
4361 if test $ac_cv_x86_rdrand = yes; then
4362 AC_DEFINE(_GLIBCXX_X86_RDRAND, 1,
4363 [ Defined if as can handle rdrand. ])
4364 fi
4365 ])
4367 dnl
4368 dnl Check whether rdseed is supported in the assembler.
4369 AC_DEFUN([GLIBCXX_CHECK_X86_RDSEED], [
4370 AC_CACHE_CHECK([for rdseed support in assembler],
4371 ac_cv_x86_rdseed, [
4372 ac_cv_x86_rdseed=no
4373 case "$target" in
4374 i?86-*-* | \
4375 x86_64-*-*)
4376 AC_TRY_COMPILE(, [asm("rdseed %eax");],
4377 [ac_cv_x86_rdseed=yes], [ac_cv_x86_rdseed=no])
4378 esac
4379 ])
4380 if test $ac_cv_x86_rdseed = yes; then
4381 AC_DEFINE(_GLIBCXX_X86_RDSEED, 1,
4382 [ Defined if as can handle rdseed. ])
4383 fi
4384 ])
4386 dnl
4387 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
4388 dnl
4389 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
4391 AC_LANG_SAVE
4392 AC_LANG_CPLUSPLUS
4393 ac_save_CXXFLAGS="$CXXFLAGS"
4394 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4396 AC_CACHE_CHECK([for get_nprocs],
4397 glibcxx_cv_GET_NPROCS, [
4398 GCC_TRY_COMPILE_OR_LINK(
4399 [#include <sys/sysinfo.h>],
4400 [int n = get_nprocs();],
4401 [glibcxx_cv_GET_NPROCS=yes],
4402 [glibcxx_cv_GET_NPROCS=no])
4403 ])
4404 if test $glibcxx_cv_GET_NPROCS = yes; then
4405 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
4406 fi
4408 CXXFLAGS="$ac_save_CXXFLAGS"
4409 AC_LANG_RESTORE
4410 ])
4412 dnl
4413 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
4414 dnl
4415 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
4417 AC_LANG_SAVE
4418 AC_LANG_CPLUSPLUS
4419 ac_save_CXXFLAGS="$CXXFLAGS"
4420 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4422 AC_CACHE_CHECK([for _SC_NPROCESSORS_ONLN],
4423 glibcxx_cv_SC_NPROCESSORS_ONLN, [
4424 GCC_TRY_COMPILE_OR_LINK(
4425 [#include <unistd.h>],
4426 [int n = sysconf(_SC_NPROCESSORS_ONLN);],
4427 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
4428 [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
4429 ])
4430 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
4431 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.])
4432 fi
4434 CXXFLAGS="$ac_save_CXXFLAGS"
4435 AC_LANG_RESTORE
4436 ])
4438 dnl
4439 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
4440 dnl
4441 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
4443 AC_LANG_SAVE
4444 AC_LANG_CPLUSPLUS
4445 ac_save_CXXFLAGS="$CXXFLAGS"
4446 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4448 AC_CACHE_CHECK([for _SC_NPROC_ONLN],
4449 glibcxx_cv_SC_NPROC_ONLN, [
4450 GCC_TRY_COMPILE_OR_LINK(
4451 [#include <unistd.h>],
4452 [int n = sysconf(_SC_NPROC_ONLN);],
4453 [glibcxx_cv_SC_NPROC_ONLN=yes],
4454 [glibcxx_cv_SC_NPROC_ONLN=no])
4455 ])
4456 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
4457 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.])
4458 fi
4460 CXXFLAGS="$ac_save_CXXFLAGS"
4461 AC_LANG_RESTORE
4462 ])
4464 dnl
4465 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
4466 dnl
4467 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
4469 AC_LANG_SAVE
4470 AC_LANG_CPLUSPLUS
4471 ac_save_CXXFLAGS="$CXXFLAGS"
4472 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4474 AC_CACHE_CHECK([for pthreads_num_processors_np],
4475 glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
4476 GCC_TRY_COMPILE_OR_LINK(
4477 [#include <pthread.h>],
4478 [int n = pthread_num_processors_np();],
4479 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
4480 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
4481 ])
4482 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
4483 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
4484 fi
4486 CXXFLAGS="$ac_save_CXXFLAGS"
4487 AC_LANG_RESTORE
4488 ])
4490 dnl
4491 dnl Check whether pthread_cond_clockwait is available in <pthread.h> for std::condition_variable to use,
4492 dnl and define _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT.
4493 dnl
4494 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_COND_CLOCKWAIT], [
4496 AC_LANG_SAVE
4497 AC_LANG_CPLUSPLUS
4498 ac_save_CXXFLAGS="$CXXFLAGS"
4499 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4500 ac_save_LIBS="$LIBS"
4501 LIBS="$LIBS -lpthread"
4503 AC_CACHE_CHECK([for pthread_cond_clockwait],
4504 glibcxx_cv_PTHREAD_COND_CLOCKWAIT, [
4505 GCC_TRY_COMPILE_OR_LINK(
4506 [#include <pthread.h>],
4507 [pthread_mutex_t mutex; pthread_cond_t cond; struct timespec ts; int n = pthread_cond_clockwait(&cond, &mutex, 0, &ts);],
4508 [glibcxx_cv_PTHREAD_COND_CLOCKWAIT=yes],
4509 [glibcxx_cv_PTHREAD_COND_CLOCKWAIT=no])
4510 ])
4511 if test $glibcxx_cv_PTHREAD_COND_CLOCKWAIT = yes; then
4512 AC_DEFINE(_GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT, 1, [Define if pthread_cond_clockwait is available in <pthread.h>.])
4513 fi
4515 CXXFLAGS="$ac_save_CXXFLAGS"
4516 LIBS="$ac_save_LIBS"
4517 AC_LANG_RESTORE
4518 ])
4520 dnl
4521 dnl Check whether pthread_mutex_clocklock is available in <pthread.h> for std::timed_mutex to use,
4522 dnl and define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK.
4523 dnl
4524 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_MUTEX_CLOCKLOCK], [
4526 AC_LANG_SAVE
4527 AC_LANG_CPLUSPLUS
4528 ac_save_CXXFLAGS="$CXXFLAGS"
4529 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4530 ac_save_LIBS="$LIBS"
4531 LIBS="$LIBS -lpthread"
4533 AC_CACHE_CHECK([for pthread_mutex_clocklock],
4534 glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK, [
4535 GCC_TRY_COMPILE_OR_LINK(
4536 [#include <pthread.h>],
4537 [pthread_mutex_t mutex; struct timespec ts; int n = pthread_mutex_clocklock(&mutex, CLOCK_REALTIME, &ts);],
4538 [glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK=yes],
4539 [glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK=no])
4540 ])
4541 if test $glibcxx_cv_PTHREAD_MUTEX_CLOCKLOCK = yes; then
4542 AC_DEFINE(_GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK, (_GLIBCXX_TSAN==0), [Define if pthread_mutex_clocklock is available in <pthread.h>.])
4543 fi
4545 CXXFLAGS="$ac_save_CXXFLAGS"
4546 LIBS="$ac_save_LIBS"
4547 AC_LANG_RESTORE
4548 ])
4550 dnl
4551 dnl Check whether pthread_mutex_clocklock is available in <pthread.h> for std::timed_mutex to use,
4552 dnl and define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK.
4553 dnl
4554 AC_DEFUN([GLIBCXX_CHECK_PTHREAD_RWLOCK_CLOCKLOCK], [
4556 AC_LANG_SAVE
4557 AC_LANG_CPLUSPLUS
4558 ac_save_CXXFLAGS="$CXXFLAGS"
4559 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4560 ac_save_LIBS="$LIBS"
4561 LIBS="$LIBS -lpthread"
4563 AC_CACHE_CHECK([for pthread_rwlock_clockrdlock, pthread_wlock_clockwrlock],
4564 glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK, [
4565 GCC_TRY_COMPILE_OR_LINK(
4566 [#include <pthread.h>],
4567 [pthread_rwlock_t rwl; struct timespec ts;]
4568 [int n = pthread_rwlock_clockrdlock(&rwl, CLOCK_REALTIME, &ts);]
4569 [int m = pthread_rwlock_clockwrlock(&rwl, CLOCK_REALTIME, &ts);],
4570 [glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK=yes],
4571 [glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK=no])
4572 ])
4573 if test $glibcxx_cv_PTHREAD_RWLOCK_CLOCKLOCK = yes; then
4574 AC_DEFINE(_GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK, 1, [Define if pthread_rwlock_clockrdlock and pthread_rwlock_clockwrlock are available in <pthread.h>.])
4575 fi
4577 CXXFLAGS="$ac_save_CXXFLAGS"
4578 LIBS="$ac_save_LIBS"
4579 AC_LANG_RESTORE
4580 ])
4582 dnl
4583 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
4584 dnl
4585 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
4587 AC_LANG_SAVE
4588 AC_LANG_CPLUSPLUS
4589 ac_save_CXXFLAGS="$CXXFLAGS"
4590 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4592 AC_CACHE_CHECK([for hw.ncpu sysctl],
4593 glibcxx_cv_SYSCTL_HW_NCPU, [
4594 GCC_TRY_COMPILE_OR_LINK(
4595 [
4596 #include <stddef.h>
4597 #include <sys/sysctl.h>
4598 ],
4599 [
4600 int count;
4601 size_t size = sizeof(count);
4602 int mib[] = { CTL_HW, HW_NCPU };
4603 sysctl(mib, 2, &count, &size, NULL, 0);
4604 ],
4605 [glibcxx_cv_SYSCTL_HW_NCPU=yes],
4606 [glibcxx_cv_SYSCTL_HW_NCPU=no])
4607 ])
4608 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
4609 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
4610 fi
4612 CXXFLAGS="$ac_save_CXXFLAGS"
4613 AC_LANG_RESTORE
4614 ])
4616 dnl
4617 dnl Check to see if python pretty printing can be activated.
4618 dnl
4619 dnl --with-python-dir=dir
4620 dnl installs directory into $prefix/dir
4621 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
4623 AC_MSG_CHECKING([for custom python install directory])
4624 AC_ARG_WITH([python-dir],
4625 AS_HELP_STRING([--with-python-dir],
4626 [the location to install Python modules. This path is relative starting from the prefix.]),
4627 [with_python_dir=$withval], [with_python_dir="no"])
4628 AC_MSG_RESULT(${with_python_dir})
4630 # Needed for installing Python modules during make install.
4631 python_mod_dir="${with_python_dir}"
4632 AC_SUBST(python_mod_dir)
4633 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
4634 ])
4636 dnl
4637 dnl Check to see if -Werror is disabled.
4638 dnl
4639 dnl --enable-werror/--disable-werror
4640 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
4641 AC_MSG_CHECKING([for -Werror])
4642 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
4643 AC_MSG_RESULT($enable_werror)
4644 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
4645 ])
4647 dnl
4648 dnl Check whether obsolescent tmpnam is available in <stdio.h>,
4649 dnl and define _GLIBCXX_USE_TMPNAM.
4650 dnl
4651 AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl
4652 dnl
4653 AC_LANG_SAVE
4654 AC_LANG_CPLUSPLUS
4655 ac_save_CXXFLAGS="$CXXFLAGS"
4656 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4657 dnl
4658 AC_CACHE_CHECK([for tmpnam], glibcxx_cv_TMPNAM, [dnl
4659 GCC_TRY_COMPILE_OR_LINK(
4660 [#include <stdio.h>],
4661 [char *tmp = tmpnam(NULL);],
4662 [glibcxx_cv_TMPNAM=yes],
4663 [glibcxx_cv_TMPNAM=no])
4664 ])
4665 if test $glibcxx_cv_TMPNAM = yes; then
4666 AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.])
4667 fi
4668 dnl
4669 CXXFLAGS="$ac_save_CXXFLAGS"
4670 AC_LANG_RESTORE
4671 ])
4673 dnl
4674 dnl Check to see if sys/sdt.h exists and that it is suitable for use.
4675 dnl Some versions of sdt.h were not compatible with C++11.
4676 dnl
4677 AC_DEFUN([GLIBCXX_CHECK_SDT_H], [
4678 # Note that this test has to be run with the C language.
4679 # Otherwise, sdt.h will try to include some headers from
4680 # libstdc++ itself.
4681 AC_LANG_SAVE
4682 AC_LANG_C
4683 AC_CACHE_CHECK([for suitable sys/sdt.h],
4684 glibcxx_cv_sys_sdt_h, [
4685 # Because we have to run the test in C, we use grep rather
4686 # than the compiler to check for the bug. The bug is that
4687 # were strings without trailing whitespace, causing g++
4688 # to look for operator"". The pattern searches for the fixed
4689 # output.
4690 AC_EGREP_CPP([ \",\" ], [
4691 #include <sys/sdt.h>
4692 int f() { STAP_PROBE(hi, bob); }
4693 ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no])
4694 ])
4695 AC_LANG_RESTORE
4696 if test $glibcxx_cv_sys_sdt_h = yes; then
4697 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4698 [Define to 1 if you have a suitable <sys/sdt.h> header file])
4699 fi
4700 ])
4702 dnl
4703 dnl Control whether the library should define symbols for old and new ABIs.
4704 dnl This affects definitions of strings, stringstreams and locale facets.
4705 dnl
4706 dnl --disable-libstdcxx-dual-abi will use old ABI for all types.
4707 dnl
4708 dnl Defines:
4709 dnl _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0)
4710 dnl
4711 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [
4712 GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string])
4713 if test x$enable_symvers = xgnu-versioned-namespace; then
4714 # gnu-versioned-namespace is incompatible with the dual ABI.
4715 enable_libstdcxx_dual_abi="no"
4716 fi
4717 if test x"$enable_libstdcxx_dual_abi" != xyes; then
4718 AC_MSG_NOTICE([dual ABI is disabled])
4719 default_libstdcxx_abi="gcc4-compatible"
4720 fi
4721 GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes)
4722 ])
4724 dnl
4725 dnl Check to see which ABI should be enabled by default.
4726 dnl
4727 dnl --with-default-libstdcxx-abi={gcc4-compatible,new}
4728 dnl
4729 dnl Defines:
4730 dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0)
4731 dnl
4732 AC_DEFUN([GLIBCXX_DEFAULT_ABI], [
4733 if test x$enable_libstdcxx_dual_abi = xyes; then
4734 AC_MSG_CHECKING([for default std::string ABI to use])
4735 AC_ARG_WITH([default-libstdcxx-abi],
4736 AS_HELP_STRING([--with-default-libstdcxx-abi],
4737 [set the std::string ABI to use by default]),
4738 [case "$withval" in
4739 gcc4-compatible) default_libstdcxx_abi="gcc4-compatible" ;;
4740 new|cxx11) default_libstdcxx_abi="new" ;;
4741 c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;;
4742 *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;;
4743 esac
4744 ],
4745 [default_libstdcxx_abi="new"])
4746 AC_MSG_RESULT(${default_libstdcxx_abi})
4747 fi
4748 if test $default_libstdcxx_abi = "new"; then
4749 glibcxx_cxx11_abi=1
4750 glibcxx_cxx98_abi=0
4751 else
4752 glibcxx_cxx11_abi=0
4753 glibcxx_cxx98_abi=1
4754 fi
4755 AC_SUBST(glibcxx_cxx98_abi)
4756 GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1)
4757 ])
4759 dnl
4760 dnl Check to see whether to build libstdc++fs.a
4761 dnl
4762 dnl --enable-libstdcxx-filesystem-ts
4763 dnl
4764 AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [
4765 GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,,
4766 [turns on ISO/IEC TS 18822 support],
4767 [permit yes|no|auto])
4769 AC_MSG_CHECKING([whether to build Filesystem TS support])
4770 if test x"$ac_cv_header_dirent_h" != x"yes"; then
4771 enable_libstdcxx_filesystem_ts=no
4772 fi
4773 if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then
4774 case "${target_os}" in
4775 freebsd*|netbsd*|openbsd*|dragonfly*|darwin*)
4776 enable_libstdcxx_filesystem_ts=yes
4777 ;;
4778 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu | uclinux*)
4779 enable_libstdcxx_filesystem_ts=yes
4780 ;;
4781 rtems*)
4782 enable_libstdcxx_filesystem_ts=yes
4783 ;;
4784 solaris*)
4785 enable_libstdcxx_filesystem_ts=yes
4786 ;;
4787 mingw*)
4788 enable_libstdcxx_filesystem_ts=yes
4789 ;;
4790 *)
4791 enable_libstdcxx_filesystem_ts=no
4792 ;;
4793 esac
4794 fi
4795 AC_MSG_RESULT($enable_libstdcxx_filesystem_ts)
4796 GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes)
4797 ])
4799 dnl
4800 dnl Check whether the library calls required by the C++17 Filesystem library
4801 dnl and the Filesystem TS are present.
4802 dnl Defines:
4803 dnl HAVE_STRUCT_DIRENT_D_TYPE
4804 dnl _GLIBCXX_USE_REALPATH
4805 dnl _GLIBCXX_USE_UTIMENSAT
4806 dnl _GLIBCXX_USE_ST_MTIM
4807 dnl _GLIBCXX_USE_FCHMOD
4808 dnl _GLIBCXX_USE_FCHMODAT
4809 dnl _GLIBCXX_USE_SENDFILE
4810 dnl HAVE_LINK
4811 dnl HAVE_READLINK
4812 dnl HAVE_SYMLINK
4813 dnl
4814 AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl
4815 dnl
4816 AC_LANG_SAVE
4817 AC_LANG_CPLUSPLUS
4818 ac_save_CXXFLAGS="$CXXFLAGS"
4819 CXXFLAGS="$CXXFLAGS -fno-exceptions"
4820 dnl
4821 AC_CACHE_CHECK([for struct dirent.d_type], glibcxx_cv_dirent_d_type, [dnl
4822 GCC_TRY_COMPILE_OR_LINK(
4823 [#include <dirent.h>],
4824 [
4825 struct dirent d;
4826 if (sizeof d.d_type) return 0;
4827 ],
4828 [glibcxx_cv_dirent_d_type=yes],
4829 [glibcxx_cv_dirent_d_type=no])
4830 ])
4831 if test $glibcxx_cv_dirent_d_type = yes; then
4832 AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.])
4833 fi
4834 dnl
4835 AC_CACHE_CHECK([for realpath], glibcxx_cv_realpath, [dnl
4836 GCC_TRY_COMPILE_OR_LINK(
4837 [
4838 #include <limits.h>
4839 #include <stdlib.h>
4840 #include <unistd.h>
4841 ],
4842 [
4843 #if _XOPEN_VERSION < 500
4844 #error
4845 #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX)
4846 char *tmp = realpath((const char*)NULL, (char*)NULL);
4847 #else
4848 #error
4849 #endif
4850 ],
4851 [glibcxx_cv_realpath=yes],
4852 [glibcxx_cv_realpath=no])
4853 ])
4854 if test $glibcxx_cv_realpath = yes; then
4855 AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.])
4856 fi
4857 dnl
4858 AC_CACHE_CHECK([for utimensat], glibcxx_cv_utimensat, [dnl
4859 GCC_TRY_COMPILE_OR_LINK(
4860 [
4861 #include <fcntl.h>
4862 #include <sys/stat.h>
4863 ],
4864 [
4865 struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } };
4866 int i = utimensat(AT_FDCWD, "path", ts, 0);
4867 ],
4868 [glibcxx_cv_utimensat=yes],
4869 [glibcxx_cv_utimensat=no])
4870 ])
4871 if test $glibcxx_cv_utimensat = yes; then
4872 AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.])
4873 fi
4874 dnl
4875 AC_CACHE_CHECK([for utime], glibcxx_cv_utime, [dnl
4876 GCC_TRY_COMPILE_OR_LINK(
4877 [
4878 #include <utime.h>
4879 ],
4880 [
4881 struct utimbuf t = { 1, 1 };
4882 int i = utime("path", &t);
4883 ],
4884 [glibcxx_cv_utime=yes],
4885 [glibcxx_cv_utime=no])
4886 ])
4887 if test $glibcxx_cv_utime = yes; then
4888 AC_DEFINE(_GLIBCXX_USE_UTIME, 1, [Define if utime is available in <utime.h>.])
4889 fi
4890 dnl
4891 AC_CACHE_CHECK([for lstat], glibcxx_cv_lstat, [dnl
4892 GCC_TRY_COMPILE_OR_LINK(
4893 [ #include <sys/stat.h> ],
4894 [
4895 struct stat st;
4896 int i = lstat("path", &st);
4897 ],
4898 [glibcxx_cv_lstat=yes],
4899 [glibcxx_cv_lstat=no])
4900 ])
4901 if test $glibcxx_cv_lstat = yes; then
4902 AC_DEFINE(_GLIBCXX_USE_LSTAT, 1, [Define if lstat is available in <sys/stat.h>.])
4903 fi
4904 dnl
4905 AC_CACHE_CHECK([for struct stat.st_mtim.tv_nsec],
4906 glibcxx_cv_st_mtim, [dnl
4907 GCC_TRY_COMPILE_OR_LINK(
4908 [ #include <sys/stat.h> ],
4909 [
4910 struct stat st;
4911 return st.st_mtim.tv_nsec;
4912 ],
4913 [glibcxx_cv_st_mtim=yes],
4914 [glibcxx_cv_st_mtim=no])
4915 ])
4916 if test $glibcxx_cv_st_mtim = yes; then
4917 AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.])
4918 fi
4919 dnl
4920 AC_CACHE_CHECK([for fchmod],
4921 glibcxx_cv_fchmod, [dnl
4922 GCC_TRY_COMPILE_OR_LINK(
4923 [#include <sys/stat.h>],
4924 [fchmod(1, S_IWUSR);],
4925 [glibcxx_cv_fchmod=yes],
4926 [glibcxx_cv_fchmod=no])
4927 ])
4928 if test $glibcxx_cv_fchmod = yes; then
4929 AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.])
4930 fi
4931 dnl
4932 AC_CACHE_CHECK([for fchmodat],
4933 glibcxx_cv_fchmodat, [dnl
4934 GCC_TRY_COMPILE_OR_LINK(
4935 [
4936 #include <fcntl.h>
4937 #include <sys/stat.h>
4938 ],
4939 [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);],
4940 [glibcxx_cv_fchmodat=yes],
4941 [glibcxx_cv_fchmodat=no])
4942 ])
4943 if test $glibcxx_cv_fchmodat = yes; then
4944 AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.])
4945 fi
4946 dnl
4947 AC_CACHE_CHECK([for sendfile that can copy files],
4948 glibcxx_cv_sendfile, [dnl
4949 case "${target_os}" in
4950 gnu* | linux* | solaris* | uclinux*)
4951 GCC_TRY_COMPILE_OR_LINK(
4952 [#include <sys/sendfile.h>],
4953 [sendfile(1, 2, (off_t*)0, sizeof 1);],
4954 [glibcxx_cv_sendfile=yes],
4955 [glibcxx_cv_sendfile=no])
4956 ;;
4957 *)
4958 glibcxx_cv_sendfile=no
4959 ;;
4960 esac
4961 ])
4962 if test $glibcxx_cv_sendfile = yes; then
4963 AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.])
4964 fi
4965 dnl
4966 AC_CACHE_CHECK([for link],
4967 glibcxx_cv_link, [dnl
4968 GCC_TRY_COMPILE_OR_LINK(
4969 [#include <unistd.h>],
4970 [link("", "");],
4971 [glibcxx_cv_link=yes],
4972 [glibcxx_cv_link=no])
4973 ])
4974 if test $glibcxx_cv_link = yes; then
4975 AC_DEFINE(HAVE_LINK, 1, [Define if link is available in <unistd.h>.])
4976 fi
4977 dnl
4978 AC_CACHE_CHECK([for readlink],
4979 glibcxx_cv_readlink, [dnl
4980 GCC_TRY_COMPILE_OR_LINK(
4981 [#include <unistd.h>],
4982 [char buf[32]; readlink("", buf, sizeof(buf));],
4983 [glibcxx_cv_readlink=yes],
4984 [glibcxx_cv_readlink=no])
4985 ])
4986 if test $glibcxx_cv_readlink = yes; then
4987 AC_DEFINE(HAVE_READLINK, 1, [Define if readlink is available in <unistd.h>.])
4988 fi
4989 dnl
4990 AC_CACHE_CHECK([for symlink],
4991 glibcxx_cv_symlink, [dnl
4992 GCC_TRY_COMPILE_OR_LINK(
4993 [#include <unistd.h>],
4994 [symlink("", "");],
4995 [glibcxx_cv_symlink=yes],
4996 [glibcxx_cv_symlink=no])
4997 ])
4998 if test $glibcxx_cv_symlink = yes; then
4999 AC_DEFINE(HAVE_SYMLINK, 1, [Define if symlink is available in <unistd.h>.])
5000 fi
5001 dnl
5002 AC_CACHE_CHECK([for truncate],
5003 glibcxx_cv_truncate, [dnl
5004 GCC_TRY_COMPILE_OR_LINK(
5005 [#include <unistd.h>],
5006 [truncate("", 99);],
5007 [glibcxx_cv_truncate=yes],
5008 [glibcxx_cv_truncate=no])
5009 ])
5010 if test $glibcxx_cv_truncate = yes; then
5011 AC_DEFINE(HAVE_TRUNCATE, 1, [Define if truncate is available in <unistd.h>.])
5012 fi
5013 dnl
5014 AC_CACHE_CHECK([for fdopendir],
5015 glibcxx_cv_fdopendir, [dnl
5016 GCC_TRY_COMPILE_OR_LINK(
5017 [#include <dirent.h>],
5018 [::DIR* dir = ::fdopendir(1);],
5019 [glibcxx_cv_fdopendir=yes],
5020 [glibcxx_cv_fdopendir=no])
5021 ])
5022 if test $glibcxx_cv_fdopendir = yes; then
5023 AC_DEFINE(HAVE_FDOPENDIR, 1, [Define if fdopendir is available in <dirent.h>.])
5024 fi
5025 dnl
5026 AC_CACHE_CHECK([for dirfd],
5027 glibcxx_cv_dirfd, [dnl
5028 GCC_TRY_COMPILE_OR_LINK(
5029 [#include <dirent.h>],
5030 [int fd = ::dirfd((::DIR*)0);],
5031 [glibcxx_cv_dirfd=yes],
5032 [glibcxx_cv_dirfd=no])
5033 ])
5034 if test $glibcxx_cv_dirfd = yes; then
5035 AC_DEFINE(HAVE_DIRFD, 1, [Define if dirfd is available in <dirent.h>.])
5036 fi
5037 dnl
5038 AC_CACHE_CHECK([for openat],
5039 glibcxx_cv_openat, [dnl
5040 GCC_TRY_COMPILE_OR_LINK(
5041 [#include <fcntl.h>],
5042 [int fd = ::openat(AT_FDCWD, "", 0);],
5043 [glibcxx_cv_openat=yes],
5044 [glibcxx_cv_openat=no])
5045 ])
5046 if test $glibcxx_cv_openat = yes; then
5047 AC_DEFINE(HAVE_OPENAT, 1, [Define if openat is available in <fcntl.h>.])
5048 fi
5049 dnl
5050 AC_CACHE_CHECK([for unlinkat],
5051 glibcxx_cv_unlinkat, [dnl
5052 GCC_TRY_COMPILE_OR_LINK(
5053 [#include <fcntl.h>
5054 #include <unistd.h>],
5055 [::unlinkat(AT_FDCWD, "", AT_REMOVEDIR);],
5056 [glibcxx_cv_unlinkat=yes],
5057 [glibcxx_cv_unlinkat=no])
5058 ])
5059 if test $glibcxx_cv_unlinkat = yes; then
5060 AC_DEFINE(HAVE_UNLINKAT, 1, [Define if unlinkat is available in <fcntl.h>.])
5061 fi
5062 dnl
5063 CXXFLAGS="$ac_save_CXXFLAGS"
5064 AC_LANG_RESTORE
5065 ])
5067 dnl
5068 dnl Check how size_t is mangled. Copied from libitm.
5069 dnl
5070 AC_DEFUN([GLIBCXX_CHECK_SIZE_T_MANGLING], [
5071 AC_CACHE_CHECK([how size_t is mangled],
5072 glibcxx_cv_size_t_mangling, [
5073 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
5074 [glibcxx_cv_size_t_mangling=m], [
5075 AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
5076 [glibcxx_cv_size_t_mangling=j], [
5077 AC_TRY_COMPILE([],
5078 [extern __SIZE_TYPE__ x; extern unsigned long long x;],
5079 [glibcxx_cv_size_t_mangling=y], [
5080 AC_TRY_COMPILE([],
5081 [extern __SIZE_TYPE__ x; extern unsigned short x;],
5082 [glibcxx_cv_size_t_mangling=t], [
5083 AC_TRY_COMPILE([],
5084 [extern __SIZE_TYPE__ x; extern __int20 unsigned x;],
5085 [glibcxx_cv_size_t_mangling=u6uint20],
5086 [glibcxx_cv_size_t_mangling=x])
5087 ])
5088 ])
5089 ])
5090 ])
5091 ])
5092 if test $glibcxx_cv_size_t_mangling = x; then
5093 AC_MSG_ERROR([Unknown underlying type for size_t])
5094 fi
5095 AC_DEFINE_UNQUOTED(_GLIBCXX_MANGLE_SIZE_T, [$glibcxx_cv_size_t_mangling],
5096 [Define to the letter to which size_t is mangled.])
5097 ])
5099 dnl
5100 dnl Determine whether std::exception_ptr symbols should be exported with
5101 dnl the symbol versions from GCC 4.6.0 or GCC 7.1.0, depending on which
5102 dnl release first added support for std::exception_ptr. Originally it was
5103 dnl only supported for targets with always-lock-free atomics for int, but
5104 dnl since GCC 7.1 it is supported for all targets.
5105 dnl
5106 AC_DEFUN([GLIBCXX_CHECK_EXCEPTION_PTR_SYMVER], [
5107 if test $enable_symvers != no; then
5108 AC_MSG_CHECKING([for first version to support std::exception_ptr])
5109 case ${target} in
5110 aarch64-*-* | alpha-*-* | hppa*-*-* | i?86-*-* | x86_64-*-* | \
5111 m68k-*-* | powerpc*-*-* | s390*-*-* | *-*-solaris* )
5112 ac_exception_ptr_since_gcc46=yes
5113 ;;
5114 *)
5115 # If the value of this macro changes then we will need to hardcode
5116 # yes/no here for additional targets based on the original value.
5117 AC_TRY_COMPILE([], [
5118 #if __GCC_ATOMIC_INT_LOCK_FREE <= 1
5119 # error atomic int not always lock free
5120 #endif
5121 ],
5122 [ac_exception_ptr_since_gcc46=yes],
5123 [ac_exception_ptr_since_gcc46=no])
5124 ;;
5125 esac
5126 if test x"$ac_exception_ptr_since_gcc46" = x"yes" ; then
5127 AC_DEFINE(HAVE_EXCEPTION_PTR_SINCE_GCC46, 1,
5128 [Define to 1 if GCC 4.6 supported std::exception_ptr for the target])
5129 AC_MSG_RESULT([4.6.0])
5130 else
5131 AC_MSG_RESULT([7.1.0])
5132 fi
5133 fi
5134 ])
5136 dnl
5137 dnl Check whether getentropy is present in <unistd.h>.
5138 dnl
5139 AC_DEFUN([GLIBCXX_CHECK_GETENTROPY], [
5141 AC_LANG_SAVE
5142 AC_LANG_CPLUSPLUS
5143 AC_CACHE_CHECK([for getentropy], glibcxx_cv_getentropy, [
5144 GCC_TRY_COMPILE_OR_LINK(
5145 [#include <unistd.h>],
5146 [unsigned i;
5147 ::getentropy(&i, sizeof(i));],
5148 [glibcxx_cv_getentropy=yes], [glibcxx_cv_getentropy=no])
5149 ])
5151 if test $glibcxx_cv_getentropy = yes; then
5152 AC_DEFINE(HAVE_GETENTROPY, 1, [Define if getentropy is available in <unistd.h>.])
5153 fi
5154 AC_LANG_RESTORE
5155 ])
5157 dnl
5158 dnl Check whether arc4random is present in <stdlib.h>.
5159 dnl
5160 AC_DEFUN([GLIBCXX_CHECK_ARC4RANDOM], [
5162 AC_LANG_SAVE
5163 AC_LANG_CPLUSPLUS
5164 AC_CACHE_CHECK([for arc4random], glibcxx_cv_arc4random, [
5165 GCC_TRY_COMPILE_OR_LINK(
5166 [#include <stdlib.h>],
5167 [unsigned i = ::arc4random();],
5168 [glibcxx_cv_arc4random=yes], [glibcxx_cv_arc4random=no])
5169 ])
5171 if test $glibcxx_cv_arc4random = yes; then
5172 AC_DEFINE(HAVE_ARC4RANDOM, 1, [Define if arc4random is available in <stdlib.h>.])
5173 fi
5174 AC_LANG_RESTORE
5175 ])
5177 dnl
5178 dnl Check to see whether to build libstdc++_libbacktrace.a
5179 dnl
5180 dnl --enable-libstdcxx-backtrace
5181 dnl
5182 AC_DEFUN([GLIBCXX_ENABLE_BACKTRACE], [
5183 GLIBCXX_ENABLE(libstdcxx-backtrace,auto,,
5184 [turns on libbacktrace support],
5185 [permit yes|no|auto])
5187 # Most of this is adapted from libsanitizer/configure.ac
5189 BACKTRACE_CPPFLAGS=
5191 # libbacktrace only needs atomics for int, which we've already tested
5192 if test "$glibcxx_cv_atomic_int" = "yes"; then
5193 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_ATOMIC_FUNCTIONS=1"
5194 fi
5196 # Test for __sync support.
5197 AC_CACHE_CHECK([__sync extensions],
5198 [glibcxx_cv_sys_sync],
5199 [GCC_TRY_COMPILE_OR_LINK(
5200 [int i;],
5201 [__sync_bool_compare_and_swap (&i, i, i);
5202 __sync_lock_test_and_set (&i, 1);
5203 __sync_lock_release (&i);],
5204 [glibcxx_cv_sys_sync=yes],
5205 [glibcxx_cv_sys_sync=no])
5206 ])
5207 if test "$glibcxx_cv_sys_sync" = "yes"; then
5208 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_SYNC_FUNCTIONS=1"
5209 fi
5211 # Check for dl_iterate_phdr.
5212 AC_CHECK_HEADERS(link.h)
5213 if test "$ac_cv_header_link_h" = "no"; then
5214 have_dl_iterate_phdr=no
5215 else
5216 # When built as a GCC target library, we can't do a link test.
5217 AC_EGREP_HEADER([dl_iterate_phdr], [link.h], [have_dl_iterate_phdr=yes],
5218 [have_dl_iterate_phdr=no])
5219 fi
5220 if test "$have_dl_iterate_phdr" = "yes"; then
5221 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_DL_ITERATE_PHDR=1"
5222 fi
5223 AC_CHECK_HEADERS(windows.h)
5225 # Check for the fcntl function.
5226 if test -n "${with_target_subdir}"; then
5227 case "${host}" in
5228 *-*-mingw*) have_fcntl=no ;;
5229 *) have_fcntl=yes ;;
5230 esac
5231 else
5232 AC_CHECK_FUNC(fcntl, [have_fcntl=yes], [have_fcntl=no])
5233 fi
5234 if test "$have_fcntl" = "yes"; then
5235 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_FCNTL=1"
5236 fi
5238 AC_CHECK_DECLS(strnlen)
5240 # Check for getexecname function.
5241 if test -n "${with_target_subdir}"; then
5242 case "${host}" in
5243 *-*-solaris2*) have_getexecname=yes ;;
5244 *) have_getexecname=no ;;
5245 esac
5246 else
5247 AC_CHECK_FUNC(getexecname, [have_getexecname=yes], [have_getexecname=no])
5248 fi
5249 if test "$have_getexecname" = "yes"; then
5250 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DHAVE_GETEXECNAME=1"
5251 fi
5253 # The library needs to be able to read the executable itself. Compile
5254 # a file to determine the executable format. The awk script
5255 # filetype.awk prints out the file type.
5256 AC_CACHE_CHECK([output filetype],
5257 [glibcxx_cv_sys_filetype],
5258 [filetype=
5259 AC_COMPILE_IFELSE(
5260 [AC_LANG_PROGRAM([int i;], [int j;])],
5261 [filetype=`${AWK} -f $srcdir/../libbacktrace/filetype.awk conftest.$ac_objext`],
5262 [AC_MSG_FAILURE([compiler failed])])
5263 glibcxx_cv_sys_filetype=$filetype])
5265 # Match the file type to decide what files to compile.
5266 FORMAT_FILE=
5267 case "$glibcxx_cv_sys_filetype" in
5268 elf*) FORMAT_FILE="elf.lo" ;;
5269 pecoff*) FORMAT_FILE="pecoff.lo" ;;
5270 *) AC_MSG_WARN([could not determine output file type])
5271 FORMAT_FILE="unknown.lo"
5272 enable_libstdcxx_backtrace=no
5273 ;;
5274 esac
5275 AC_SUBST(FORMAT_FILE)
5277 # ELF defines.
5278 elfsize=
5279 case "$glibcxx_cv_sys_filetype" in
5280 elf32) elfsize=32 ;;
5281 elf64) elfsize=64 ;;
5282 esac
5283 BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DBACKTRACE_ELF_SIZE=$elfsize"
5285 AC_MSG_CHECKING([whether to build libbacktrace support])
5286 if test "$enable_libstdcxx_backtrace" = "auto"; then
5287 enable_libstdcxx_backtrace=no
5288 fi
5289 AC_MSG_RESULT($enable_libstdcxx_backtrace)
5290 if test "$enable_libstdcxx_backtrace" = "yes"; then
5291 BACKTRACE_SUPPORTED=1
5293 AC_CHECK_HEADERS(sys/mman.h)
5294 case "${host}" in
5295 *-*-msdosdjgpp) # DJGPP has sys/man.h, but no mmap
5296 have_mmap=no ;;
5297 *-*-*)
5298 have_mmap="$ac_cv_header_sys_mman_h" ;;
5299 esac
5301 if test "$have_mmap" = "no"; then
5302 VIEW_FILE=read.lo
5303 ALLOC_FILE=alloc.lo
5304 else
5305 VIEW_FILE=mmapio.lo
5306 AC_PREPROC_IFELSE([AC_LANG_SOURCE([
5307 #include <sys/mman.h>
5308 #if !defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
5309 #error no MAP_ANONYMOUS
5310 #endif
5311 ])], [ALLOC_FILE=mmap.lo], [ALLOC_FILE=alloc.lo])
5312 fi
5313 AC_SUBST(VIEW_FILE)
5314 AC_SUBST(ALLOC_FILE)
5316 BACKTRACE_USES_MALLOC=0
5317 if test "$ALLOC_FILE" = "alloc.lo"; then
5318 BACKTRACE_USES_MALLOC=1
5319 fi
5321 if test "$ac_has_gthreads" = "yes"; then
5322 BACKTRACE_SUPPORTS_THREADS=1
5323 else
5324 BACKTRACE_SUPPORTS_THREADS=0
5325 fi
5326 AC_SUBST(BACKTRACE_CPPFLAGS)
5327 AC_SUBST(BACKTRACE_SUPPORTED)
5328 AC_SUBST(BACKTRACE_USES_MALLOC)
5329 AC_SUBST(BACKTRACE_SUPPORTS_THREADS)
5330 AC_DEFINE(HAVE_STACKTRACE, 1, [Define if the <stacktrace> header is supported.])
5331 else
5332 BACKTRACE_SUPPORTED=0
5333 BACKTRACE_USES_MALLOC=0
5334 BACKTRACE_SUPPORTS_THREADS=0
5335 fi
5336 GLIBCXX_CONDITIONAL(ENABLE_BACKTRACE, [test "$enable_libstdcxx_backtrace" = yes])
5337 ])
5339 dnl
5340 dnl Allow the emergency EH pool to be configured.
5341 dnl
5342 dnl --enable-libstdcxx-static-eh-pool will cause a fixed-size static buffer
5343 dnl to be used for allocating exceptions after malloc fails. The default is
5344 dnl to allocate a buffer using malloc
5345 dnl
5346 dnl --with-libstdcxx-eh-pool-obj-count=N will set the default size for the
5347 dnl buffer. For a static buffer that size is fixed permanently. For a dynamic
5348 dnl buffer it's the default, but it can be overridden from the environment.
5349 dnl
5350 dnl To set the default to approximately the same values as GCC 12,
5351 dnl use --with-libstdcxx-eh-pool-obj-count=94 for 32-bit targets,
5352 dnl and --with-libstdcxx-eh-pool-obj-count=252 for 64-bit targets.
5353 dnl
5354 dnl Defines:
5355 dnl _GLIBCXX_EH_POOL_STATIC if a fixed-size static buffer should be used
5356 dnl instead of allocating a buffer on startup.
5357 dnl _GLIBCXX_EH_POOL_NOBJS to override the default EMERGENCY_OBJ_COUNT value.
5358 dnl
5359 AC_DEFUN([GLIBCXX_EMERGENCY_EH_ALLOC], [
5360 eh_pool_static=
5361 eh_pool_nobjs=
5362 AC_ARG_ENABLE([libstdcxx-static-eh-pool],
5363 AC_HELP_STRING([--enable-libstdcxx-static-eh-pool],
5364 [use a fixed-size static buffer for allocating exceptions if malloc fails]),
5365 [if test "${enableval}" = yes; then
5366 eh_pool_static="-D_GLIBCXX_EH_POOL_STATIC"
5367 AC_MSG_NOTICE([EH pool using static buffer])
5368 fi],)
5370 AC_ARG_WITH([libstdcxx-eh-pool-obj-count],
5371 AC_HELP_STRING([--with-libstdcxx-eh-pool-obj-count],
5372 [the number of exceptions that can be allocated from the pool if malloc fails]),
5373 [if test "${withval}" -ge 0 2>/dev/null; then
5374 eh_pool_obj_count="-D_GLIBCXX_EH_POOL_NOBJS=${withval}"
5375 AC_MSG_NOTICE([EH pool object count: ${withval}])
5376 else
5377 AC_MSG_ERROR([EH pool obj count must be a non-negative integer: $withval])
5378 fi],)
5380 EH_POOL_FLAGS="$eh_pool_static $eh_pool_obj_count"
5381 AC_SUBST(EH_POOL_FLAGS)
5382 ])
5384 dnl
5385 dnl Allow the location of tzdata files to be configured.
5386 dnl
5387 dnl --with-libstdcxx-zoneinfo=ARG where ARG can be:
5388 dnl DIR - use DIR/tzdata.zi and DIR/leapseconds files.
5389 dnl static - use static copy of tzdata.zi embedded in the library.
5390 dnl DIR,static - use DIR, but use embedded static copy as fallback.
5391 dnl yes - equivalent to DIR,static with a system-specific value for DIR.
5392 dnl no - disable most tzdb functionality.
5393 dnl
5394 dnl Defines:
5395 dnl _GLIBCXX_ZONEINFO_DIR if std::chrono::tzdb should use the specified
5396 dnl directory for the tzdata.zi and leapseconds files.
5397 dnl _GLIBCXX_STATIC_TZDATA if std::chrono::tzdb should use an embedded
5398 dnl static copy of the tzdata.zi file.
5399 dnl
5400 AC_DEFUN([GLIBCXX_ZONEINFO_DIR], [
5401 AC_ARG_WITH([libstdcxx-zoneinfo],
5402 AC_HELP_STRING([--with-libstdcxx-zoneinfo],
5403 [the location to use for tzdata]),
5404 [],[with_libstdcxx_zoneinfo=yes])
5406 if test "x${with_libstdcxx_zoneinfo}" = xyes; then
5407 # Pick a default when no specific path is set.
5408 case "$target_os" in
5409 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
5410 # Not all distros ship tzdata.zi in this dir.
5411 zoneinfo_dir="/usr/share/zoneinfo"
5412 ;;
5413 aix*)
5414 # Binary tzfile files are in /usr/share/lib/zoneinfo
5415 # but tzdata.zi is not present there.
5416 zoneinfo_dir=none
5417 ;;
5418 darwin2*)
5419 # Binary tzfile files are in /usr/share/lib/zoneinfo.default
5420 # but tzdata.zi is not present there.
5421 zoneinfo_dir=none
5422 ;;
5423 *)
5424 # Binary tzfile files are commonly found in /usr/share/zoneinfo
5425 # but tzdata.zi is not present there.
5426 zoneinfo_dir=none
5427 ;;
5428 esac
5429 case "$host" in
5430 avr-*-* | msp430-*-* ) embed_zoneinfo=no ;;
5431 *)
5432 # Also embed a copy of the tzdata.zi file as a static string.
5433 embed_zoneinfo=yes ;;
5434 esac
5435 elif test "x${with_libstdcxx_zoneinfo}" = xno; then
5436 # Disable tzdb support completely.
5437 zoneinfo_dir=none
5438 embed_zoneinfo=no
5439 else
5440 case "${with_libstdcxx_zoneinfo}" in
5441 static)
5442 # Do not attempt to read from disk, always use embedded data.
5443 zoneinfo_dir=none
5444 embed_zoneinfo=yes
5445 ;;
5446 static,* | *,static)
5447 # Try to read from disk, use embedded data as fallback.
5448 zoneinfo_dir="${with_libstdcxx_zoneinfo#static,}"
5449 zoneinfo_dir="${with_libstdcxx_zoneinfo%,static}"
5450 embed_zoneinfo=yes
5451 ;;
5452 *)
5453 zoneinfo_dir="${with_libstdcxx_zoneinfo}"
5454 embed_zoneinfo=no
5455 ;;
5456 esac
5457 fi
5458 AC_MSG_NOTICE([zoneinfo data directory: ${zoneinfo_dir}])
5459 if test "x${zoneinfo_dir}" != xnone; then
5460 AC_DEFINE_UNQUOTED(_GLIBCXX_ZONEINFO_DIR, "${zoneinfo_dir}",
5461 [Define if a directory should be searched for tzdata files.])
5462 if $GLIBCXX_IS_NATIVE && ! test -f "$zoneinfo_dir/tzdata.zi"; then
5463 AC_MSG_WARN("$zoneinfo_dir does not contain tzdata.zi file")
5464 fi
5465 fi
5466 GLIBCXX_CONDITIONAL(USE_STATIC_TZDATA, test "${embed_zoneinfo}" = yes)
5467 if test "x${embed_zoneinfo}" = xyes; then
5468 AC_MSG_NOTICE([static tzdata.zi file will be compiled into the library])
5469 AC_DEFINE_UNQUOTED(_GLIBCXX_STATIC_TZDATA, 1,
5470 [Define if static tzdata should be compiled into the library.])
5471 fi
5472 ])
5474 dnl
5475 dnl Check whether lock tables can be aligned to avoid false sharing.
5476 dnl
5477 dnl Defines:
5478 dnl _GLIBCXX_CAN_ALIGNAS_DESTRUCTIVE_SIZE if objects with static storage
5479 dnl duration can be aligned to std::hardware_destructive_interference_size.
5480 dnl
5481 AC_DEFUN([GLIBCXX_CHECK_ALIGNAS_CACHELINE], [
5482 AC_LANG_SAVE
5483 AC_LANG_CPLUSPLUS
5485 AC_MSG_CHECKING([whether static objects can be aligned to the cacheline size])
5486 AC_TRY_COMPILE(, [struct alignas(__GCC_DESTRUCTIVE_SIZE) Aligned { };
5487 alignas(Aligned) static char buf[sizeof(Aligned) * 16];
5488 ], [ac_alignas_cacheline=yes], [ac_alignas_cacheline=no])
5489 if test "$ac_alignas_cacheline" = yes; then
5490 AC_DEFINE_UNQUOTED(_GLIBCXX_CAN_ALIGNAS_DESTRUCTIVE_SIZE, 1,
5491 [Define if global objects can be aligned to
5492 std::hardware_destructive_interference_size.])
5493 fi
5494 AC_MSG_RESULT($ac_alignas_cacheline)
5496 AC_LANG_RESTORE
5497 ])
5499 # Macros from the top-level gcc directory.
5500 m4_include([../config/gc++filt.m4])
5501 m4_include([../config/tls.m4])
5502 m4_include([../config/gthr.m4])
5503 m4_include([../config/cet.m4])