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