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