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