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