3 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
5 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
6 dnl end of configure. This lets tested variables be reassigned, and the
7 dnl conditional will depend on the final state of the variable. For a simple
8 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
10 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
11 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
12 m4_divert_text([glibcxx_diversion],dnl
13 AM_CONDITIONAL([$1],[$2])
16 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
20 dnl Check to see what architecture and operating system we are compiling
21 dnl for. Also, if architecture- or OS-specific flags are required for
22 dnl compilation, pick them up here.
24 AC_DEFUN([GLIBCXX_CHECK_HOST], [
25 . $glibcxx_srcdir/configure.host
26 AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
27 AC_MSG_NOTICE([OS config directory is $os_include_dir])
31 dnl Initialize the rest of the library configury. At this point we have
32 dnl variables like $host.
37 dnl glibcxx_builddir (absolute path)
38 dnl glibcxx_srcdir (absolute path)
39 dnl toplevel_srcdir (absolute path)
42 dnl with_target_subdir
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
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++ python src doc po testsuite])
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}`
60 [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
61 *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
63 toplevel_srcdir=${glibcxx_srcdir}/..
64 AC_SUBST(glibcxx_builddir)
65 AC_SUBST(glibcxx_srcdir)
66 AC_SUBST(toplevel_srcdir)
68 # We use these options to decide which functions to include. They are
69 # set from the top level.
70 AC_ARG_WITH([target-subdir],
71 AC_HELP_STRING([--with-target-subdir=SUBDIR],
72 [configuring in a subdirectory]))
74 AC_ARG_WITH([cross-host],
75 AC_HELP_STRING([--with-cross-host=HOST],
76 [configuring with a cross compiler]))
79 AC_HELP_STRING([--with-newlib],
80 [assume newlib as a system C library]))
82 # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
83 # available). Uncomment the next line to force a particular method.
89 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
93 # Set up safe default values for all subsequent AM_CONDITIONAL tests
94 # which are themselves conditionally expanded.
95 ## (Right now, this only matters for enable_wchar_t, but nothing prevents
96 ## other macros from doing the same. This should be automated.) -pme
98 # Check for C library flavor since Linux platforms use different configuration
99 # directories depending on the C library in use.
100 AC_EGREP_CPP([_using_uclibc], [
105 ], uclibc=yes, uclibc=no)
107 AC_EGREP_CPP([_using_bionic], [
112 ], bionic=yes, bionic=no)
114 # Find platform-specific directories containing configuration info.
115 # Also possibly modify flags used elsewhere, as needed by the platform.
121 dnl Tests for newer compiler features, or features that are present in newer
122 dnl compiler versions but not older compiler versions still in use, should
126 dnl WERROR='-Werror' if requested and possible; g++'s that lack the
127 dnl new inlining code or the new system_header pragma will die on -Werror.
128 dnl Leave it out by default and use maint-mode to use it.
129 dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if
130 dnl compiler supports it and the user has not requested debug mode.
132 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
133 # All these tests are for C++; save the language and the compiler flags.
134 # The CXXFLAGS thing is suspicious, but based on similar bits previously
135 # found in GLIBCXX_CONFIGURE.
138 ac_test_CXXFLAGS="${CXXFLAGS+set}"
139 ac_save_CXXFLAGS="$CXXFLAGS"
141 # Check for maintainer-mode bits.
142 if test x"$USE_MAINTAINER_MODE" = xno; then
148 # Check for -ffunction-sections -fdata-sections
149 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
150 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
151 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
152 if test "$ac_test_CXXFLAGS" = set; then
153 CXXFLAGS="$ac_save_CXXFLAGS"
155 # this is the suspicious part
158 if test x"$ac_fdsections" = x"yes"; then
159 SECTION_FLAGS='-ffunction-sections -fdata-sections'
161 AC_MSG_RESULT($ac_fdsections)
165 AC_SUBST(SECTION_FLAGS)
170 dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
171 dnl the native linker is in use, all variables will be defined to something
172 dnl safe (like an empty string).
175 dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
176 dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
177 dnl LD (as a side effect of testing)
180 dnl glibcxx_ld_is_gold (set to "no" or "yes")
181 dnl glibcxx_gnu_ld_version (possibly)
183 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
184 dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
186 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
187 # If we're not using GNU ld, then there's no point in even trying these
188 # tests. Check for that first. We should have already tested for gld
189 # by now (in libtool), but require it now just to be safe...
190 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
191 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
192 AC_REQUIRE([AC_PROG_LD])
193 AC_REQUIRE([AC_PROG_AWK])
195 # The name set by libtool depends on the version of libtool. Shame on us
196 # for depending on an impl detail, but c'est la vie. Older versions used
197 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
198 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
199 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
200 # set (hence we're using an older libtool), then set it.
201 if test x${with_gnu_ld+set} != xset; then
202 if test x${ac_cv_prog_gnu_ld+set} != xset; then
203 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
206 with_gnu_ld=$ac_cv_prog_gnu_ld
210 # Start by getting the version number. I think the libtool test already
211 # does some of this, but throws away the result.
212 glibcxx_ld_is_gold=no
213 if test x"$with_gnu_ld" = x"yes"; then
214 AC_MSG_CHECKING([for ld version])
216 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
217 glibcxx_ld_is_gold=yes
219 ldver=`$LD --version 2>/dev/null |
220 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'`
222 glibcxx_gnu_ld_version=`echo $ldver | \
223 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
224 AC_MSG_RESULT($glibcxx_gnu_ld_version)
228 glibcxx_have_gc_sections=no
229 if test "$glibcxx_ld_is_gold" = "yes"; then
230 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
231 glibcxx_have_gc_sections=yes
234 glibcxx_gcsections_min_ld=21602
235 if test x"$with_gnu_ld" = x"yes" &&
236 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
237 glibcxx_have_gc_sections=yes
240 if test "$glibcxx_have_gc_sections" = "yes"; then
241 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
242 # NB: This flag only works reliably after 2.16.1. Configure tests
243 # for this are difficult, so hard wire a value that should work.
245 ac_test_CFLAGS="${CFLAGS+set}"
246 ac_save_CFLAGS="$CFLAGS"
247 CFLAGS='-Wl,--gc-sections'
249 # Check for -Wl,--gc-sections
250 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
251 AC_TRY_LINK([ int one(void) { return 1; }
252 int two(void) { return 2; }
253 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
254 if test "$ac_gcsections" = "yes"; then
257 if $CC -c conftest.c; then
258 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
259 grep "Warning: gc-sections option ignored" > /dev/null; then
263 rm -f conftest.c conftest.o conftest
265 if test "$ac_gcsections" = "yes"; then
266 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
268 AC_MSG_RESULT($ac_gcsections)
270 if test "$ac_test_CFLAGS" = set; then
271 CFLAGS="$ac_save_CFLAGS"
273 # this is the suspicious part
279 # Note this is only for shared objects.
281 if test x"$with_gnu_ld" = x"yes"; then
282 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
283 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
284 if test -n "$cxx_z_relo"; then
285 OPT_LDFLAGS="-Wl,-z,relro"
288 AC_MSG_RESULT($ac_ld_relro)
291 # Set linker optimization flags.
292 if test x"$with_gnu_ld" = x"yes"; then
293 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
296 AC_SUBST(SECTION_LDFLAGS)
297 AC_SUBST(OPT_LDFLAGS)
302 dnl Check for headers for, and arguments to, the setrlimit() function.
303 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
306 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
307 dnl various HAVE_LIMIT_* for individual limit names
309 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
310 AC_MSG_CHECKING([for RLIMIT_$1])
313 #include <sys/time.h>
314 #include <sys/resource.h>
316 [ int f = RLIMIT_$1 ; ],
317 [glibcxx_mresult=1], [glibcxx_mresult=0])
318 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
319 [Only used in build directory testsuite_hooks.h.])
320 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
324 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
325 setrlimit_have_headers=yes
326 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
328 [setrlimit_have_headers=no])
329 # If don't have the headers, then we can't run the tests now, and we
330 # won't be seeing any of these during testsuite compilation.
331 if test $setrlimit_have_headers = yes; then
332 # Can't do these in a loop, else the resulting syntax is wrong.
333 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
334 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
335 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
336 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
337 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
339 # Check for rlimit, setrlimit.
340 AC_CACHE_VAL(glibcxx_cv_setrlimit, [
343 #include <sys/time.h>
344 #include <sys/resource.h>
348 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
352 AC_MSG_CHECKING([for testsuite resource limits support])
353 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
355 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
356 [Define if using setrlimit to set resource limits during
361 AC_MSG_RESULT($ac_res_limits)
366 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
367 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
369 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
373 ac_save_CXXFLAGS="$CXXFLAGS"
374 CXXFLAGS="$CXXFLAGS -fno-exceptions"
376 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
377 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
378 GCC_TRY_COMPILE_OR_LINK(
379 [#include <sys/stat.h>],
382 S_ISREG(buffer.st_mode);],
383 [glibcxx_cv_S_ISREG=yes],
384 [glibcxx_cv_S_ISREG=no])
386 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
387 GCC_TRY_COMPILE_OR_LINK(
388 [#include <sys/stat.h>],
391 S_IFREG & buffer.st_mode;],
392 [glibcxx_cv_S_IFREG=yes],
393 [glibcxx_cv_S_IFREG=no])
396 if test $glibcxx_cv_S_ISREG = yes; then
397 AC_DEFINE(HAVE_S_ISREG, 1,
398 [Define if S_IFREG is available in <sys/stat.h>.])
400 elif test $glibcxx_cv_S_IFREG = yes; then
401 AC_DEFINE(HAVE_S_IFREG, 1,
402 [Define if S_IFREG is available in <sys/stat.h>.])
407 CXXFLAGS="$ac_save_CXXFLAGS"
413 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
415 AC_DEFUN([GLIBCXX_CHECK_POLL], [
419 ac_save_CXXFLAGS="$CXXFLAGS"
420 CXXFLAGS="$CXXFLAGS -fno-exceptions"
422 AC_MSG_CHECKING([for poll])
423 AC_CACHE_VAL(glibcxx_cv_POLL, [
424 GCC_TRY_COMPILE_OR_LINK(
426 [struct pollfd pfd[1];
427 pfd[0].events = POLLIN;
429 [glibcxx_cv_POLL=yes],
430 [glibcxx_cv_POLL=no])
432 if test $glibcxx_cv_POLL = yes; then
433 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
435 AC_MSG_RESULT($glibcxx_cv_POLL)
437 CXXFLAGS="$ac_save_CXXFLAGS"
443 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
445 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
449 ac_save_CXXFLAGS="$CXXFLAGS"
450 CXXFLAGS="$CXXFLAGS -fno-exceptions"
452 AC_MSG_CHECKING([for writev])
453 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
454 GCC_TRY_COMPILE_OR_LINK(
455 [#include <sys/uio.h>],
456 [struct iovec iov[2];
458 [glibcxx_cv_WRITEV=yes],
459 [glibcxx_cv_WRITEV=no])
461 if test $glibcxx_cv_WRITEV = yes; then
462 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
464 AC_MSG_RESULT($glibcxx_cv_WRITEV)
466 CXXFLAGS="$ac_save_CXXFLAGS"
472 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
473 dnl Also check whether int64_t is actually a typedef to long or long long.
475 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
480 AC_MSG_CHECKING([for int64_t])
481 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
483 [#include <stdint.h>],
485 [glibcxx_cv_INT64_T=yes],
486 [glibcxx_cv_INT64_T=no])
489 if test $glibcxx_cv_INT64_T = yes; then
490 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
491 AC_MSG_RESULT($glibcxx_cv_INT64_T)
493 AC_MSG_CHECKING([for int64_t as long])
494 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
497 template<typename, typename> struct same { enum { value = -1 }; };
498 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
499 int array[same<int64_t, long>::value];], [],
500 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
503 if test $glibcxx_cv_int64_t_long = yes; then
504 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
505 AC_MSG_RESULT($glibcxx_cv_int64_t_long)
508 AC_MSG_CHECKING([for int64_t as long long])
509 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
512 template<typename, typename> struct same { enum { value = -1 }; };
513 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
514 int array[same<int64_t, long long>::value];], [],
515 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
518 if test $glibcxx_cv_int64_t_long_long = yes; then
519 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
520 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
529 dnl Check whether LFS support is available.
531 AC_DEFUN([GLIBCXX_CHECK_LFS], [
534 ac_save_CXXFLAGS="$CXXFLAGS"
535 CXXFLAGS="$CXXFLAGS -fno-exceptions"
536 AC_MSG_CHECKING([for LFS support])
537 AC_CACHE_VAL(glibcxx_cv_LFS, [
538 GCC_TRY_COMPILE_OR_LINK(
541 #include <sys/stat.h>
545 fseeko64(fp, 0, SEEK_CUR);
547 lseek64(1, 0, SEEK_CUR);
550 [glibcxx_cv_LFS=yes],
553 if test $glibcxx_cv_LFS = yes; then
554 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
556 AC_MSG_RESULT($glibcxx_cv_LFS)
557 CXXFLAGS="$ac_save_CXXFLAGS"
563 dnl Check for whether a fully dynamic basic_string implementation should
564 dnl be turned on, that does not put empty objects in per-process static
565 dnl memory (mostly useful together with shared memory allocators, see PR
566 dnl libstdc++/16612 for details).
568 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
569 dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
570 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
571 dnl Where DEFAULT is either `yes' or `no'.
573 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
574 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
575 if test $enable_fully_dynamic_string = yes; then
576 AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
577 [Define if a fully dynamic basic_string is wanted.])
583 dnl Does any necessary configuration of the testsuite directory. Generates
584 dnl the testsuite_hooks.h header.
586 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
590 dnl GLIBCXX_TEST_WCHAR_T
591 dnl GLIBCXX_TEST_THREAD
595 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
596 if $GLIBCXX_IS_NATIVE ; then
597 # Do checks for resource limit functions.
598 GLIBCXX_CHECK_SETRLIMIT
600 # Look for setenv, so that extended locale tests can be performed.
601 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
604 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
605 test $enable_symvers != no; then
608 enable_abi_check=no ;;
610 enable_abi_check=yes ;;
613 # Only build this as native, since automake does not understand
618 # Export file names for ABI checking.
619 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
620 AC_SUBST(baseline_dir)
625 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
629 dnl TOPLEVEL_INCLUDES
631 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
632 # Used for every C++ compile we perform.
634 -I$glibcxx_builddir/include/$host_alias \
635 -I$glibcxx_builddir/include \
636 -I$glibcxx_srcdir/libsupc++"
638 # For Canadian crosses, pick this up too.
639 if test $CANADIAN = yes; then
640 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
643 # Stuff in the actual top level. Currently only used by libsupc++ to
644 # get unwind* headers from the gcc dir.
645 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
646 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
648 # Now, export this to all the little Makefiles....
649 AC_SUBST(GLIBCXX_INCLUDES)
650 AC_SUBST(TOPLEVEL_INCLUDES)
655 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
656 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
659 dnl OPTIMIZE_CXXFLAGS
662 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
663 # Optimization flags that are probably a good idea for thrill-seekers. Just
664 # uncomment the lines below and make, everything else is ready to go...
665 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
666 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
667 AC_SUBST(OPTIMIZE_CXXFLAGS)
669 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
675 dnl All installation directory information is determined here.
679 dnl glibcxx_prefixdir
680 dnl glibcxx_toolexecdir
681 dnl glibcxx_toolexeclibdir
683 dnl Assumes cross_compiling bits already done, and with_cross_host in
686 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
687 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
688 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
689 glibcxx_toolexecdir=no
690 glibcxx_toolexeclibdir=no
691 glibcxx_prefixdir=$prefix
693 AC_MSG_CHECKING([for gxx-include-dir])
694 AC_ARG_WITH([gxx-include-dir],
695 AC_HELP_STRING([--with-gxx-include-dir=DIR],
696 [installation directory for include files]),
698 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
699 no) gxx_include_dir=no ;;
700 *) gxx_include_dir=$withval ;;
702 [gxx_include_dir=no])
703 AC_MSG_RESULT($gxx_include_dir)
705 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
706 AC_ARG_ENABLE([version-specific-runtime-libs],
707 AC_HELP_STRING([--enable-version-specific-runtime-libs],
708 [Specify that runtime libraries should be installed in a compiler-specific directory]),
709 [case "$enableval" in
710 yes) version_specific_libs=yes ;;
711 no) version_specific_libs=no ;;
712 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
714 [version_specific_libs=no])
715 AC_MSG_RESULT($version_specific_libs)
717 # Default case for install directory for include files.
718 if test $version_specific_libs = no && test $gxx_include_dir = no; then
719 gxx_include_dir='include/c++/${gcc_version}'
720 if test -n "$with_cross_host" &&
721 test x"$with_cross_host" != x"no"; then
722 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
724 gxx_include_dir='${prefix}/'"$gxx_include_dir"
728 # Version-specific runtime libs processing.
729 if test $version_specific_libs = yes; then
730 # Need the gcc compiler version to know where to install libraries
731 # and header files if --enable-version-specific-runtime-libs option
732 # is selected. FIXME: these variables are misnamed, there are
733 # no executables installed in _toolexecdir or _toolexeclibdir.
734 if test x"$gxx_include_dir" = x"no"; then
735 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
737 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
738 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
741 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
742 # Install a library built with a cross compiler in tooldir, not libdir.
743 if test x"$glibcxx_toolexecdir" = x"no"; then
744 if test -n "$with_cross_host" &&
745 test x"$with_cross_host" != x"no"; then
746 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
747 glibcxx_toolexeclibdir='${toolexecdir}/lib'
749 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
750 glibcxx_toolexeclibdir='${libdir}'
752 multi_os_directory=`$CXX -print-multi-os-directory`
753 case $multi_os_directory in
754 .) ;; # Avoid trailing /.
755 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
759 AC_MSG_CHECKING([for install location])
760 AC_MSG_RESULT($gxx_include_dir)
762 AC_SUBST(glibcxx_prefixdir)
763 AC_SUBST(gxx_include_dir)
764 AC_SUBST(glibcxx_toolexecdir)
765 AC_SUBST(glibcxx_toolexeclibdir)
771 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
772 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
773 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
775 dnl See docs/html/17_intro/configury.html#enable for documentation.
777 m4_define([GLIBCXX_ENABLE],[dnl
778 m4_define([_g_switch],[--enable-$1])dnl
779 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
780 AC_ARG_ENABLE($1,_g_help,
785 m4_bpatsubst([$5],[permit ])) ;;
786 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
787 dnl Idea for future: generate a URL pointing to
788 dnl "onlinedocs/configopts.html#whatever"
795 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
799 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
800 m4_undefine([_g_switch])dnl
801 m4_undefine([_g_help])dnl
806 dnl Check for ISO/IEC 9899:1999 "C99" support.
808 dnl --enable-c99 defines _GLIBCXX_USE_C99
809 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
810 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
811 dnl Where DEFAULT is either `yes' or `no'.
812 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
814 AC_DEFUN([GLIBCXX_ENABLE_C99], [
815 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
817 if test x"$enable_c99" = x"yes"; then
822 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
823 # undefined and fake C99 facilities - like pre-standard snprintf - may be
824 # spuriously enabled.
825 # Long term, -std=c++0x could be even better, could manage to explicitely
826 # request C99 facilities to the underlying C headers.
827 ac_save_CXXFLAGS="$CXXFLAGS"
828 CXXFLAGS="$CXXFLAGS -std=c++98"
830 ac_save_gcc_no_link="$gcc_no_link"
832 if test x$gcc_no_link != xyes; then
833 # Use -fno-exceptions to that the C driver can link these tests without
834 # hitting undefined references to personality routines.
835 CXXFLAGS="$CXXFLAGS -fno-exceptions"
836 AC_CHECK_LIB(m, sin, [
839 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
844 # Check for the existence of <math.h> functions used if C99 is enabled.
845 AC_MSG_CHECKING([for ISO C99 support in <math.h>])
846 AC_CACHE_VAL(glibcxx_cv_c99_math, [
847 GCC_TRY_COMPILE_OR_LINK(
849 volatile double d1, d2;
857 i = isgreater(d1, d2);
858 i = isgreaterequal(d1, d2);
860 i = islessequal(d1, d2);
861 i = islessgreater(d1, d2);
862 i = islessgreater(d1, d2);
863 i = isunordered(d1, d2);
864 ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
866 AC_MSG_RESULT($glibcxx_cv_c99_math)
867 if test x"$glibcxx_cv_c99_math" = x"yes"; then
868 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
869 [Define if C99 functions or macros in <math.h> should be imported
870 in <cmath> in namespace std.])
873 # Check for the existence of <complex.h> complex math functions.
874 # This is necessary even though libstdc++ uses the builtin versions
875 # of these functions, because if the builtin cannot be used, a reference
876 # to the library function is emitted.
877 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
878 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
879 glibcxx_cv_c99_complex=no;
880 if test x"$ac_has_complex_h" = x"yes"; then
881 AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
882 GCC_TRY_COMPILE_OR_LINK(
883 [#include <complex.h>
884 typedef __complex__ float float_type;
885 typedef __complex__ double double_type;
886 typedef __complex__ long double ld_type;
887 volatile float_type tmpf;
888 volatile double_type tmpd;
889 volatile ld_type tmpld;
892 volatile long double ld;],
904 tmpf = cpowf(tmpf, tmpf);
917 tmpd = cpow(tmpd, tmpd);
921 tmpld = ccosl(tmpld);
922 tmpld = ccoshl(tmpld);
923 tmpld = cexpl(tmpld);
924 tmpld = clogl(tmpld);
925 tmpld = csinl(tmpld);
926 tmpld = csinhl(tmpld);
927 tmpld = csqrtl(tmpld);
928 tmpld = ctanl(tmpld);
929 tmpld = ctanhl(tmpld);
930 tmpld = cpowl(tmpld, tmpld);
931 tmpld = cprojl(tmpld);
932 ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
934 AC_MSG_RESULT($glibcxx_cv_c99_complex)
935 if test x"$glibcxx_cv_c99_complex" = x"yes"; then
936 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
937 [Define if C99 functions in <complex.h> should be used in
938 <complex>. Using compiler builtins for these functions requires
939 corresponding C99 library functions to be present.])
942 # Check for the existence in <stdio.h> of vscanf, et. al.
943 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
944 AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
945 GCC_TRY_COMPILE_OR_LINK(
948 void foo(char* fmt, ...)
950 va_list args; va_start(args, fmt);
951 vfscanf(stderr, "%i", args);
953 vsnprintf(fmt, 0, "%i", args);
954 vsscanf(fmt, "%i", args);
956 [snprintf("12", 0, "%i");],
957 [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
959 AC_MSG_RESULT($glibcxx_cv_c99_stdio)
961 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
962 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
963 AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
964 GCC_TRY_COMPILE_OR_LINK(
967 volatile long double ld;
968 volatile unsigned long long ll;
971 f = strtof("gnu", &tmp);
972 ld = strtold("gnu", &tmp);
973 ll = strtoll("gnu", &tmp, 10);
974 ll = strtoull("gnu", &tmp, 10);
976 mydivt = lldiv(10,1);
981 ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
983 AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
985 # Check for the existence in <wchar.h> of wcstold, etc.
986 glibcxx_cv_c99_wchar=no;
987 if test x"$ac_has_wchar_h" = xyes &&
988 test x"$ac_has_wctype_h" = xyes; then
989 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
990 AC_TRY_COMPILE([#include <wchar.h>
997 ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
999 # Checks for wide character functions that may not be present.
1000 # Injection of these is wrapped with guard macros.
1001 # NB: only put functions here, instead of immediately above, if
1002 # absolutely necessary.
1003 AC_TRY_COMPILE([#include <wchar.h>
1004 namespace test { using ::vfwscanf; } ], [],
1005 [AC_DEFINE(HAVE_VFWSCANF,1,
1006 [Defined if vfwscanf exists.])],[])
1008 AC_TRY_COMPILE([#include <wchar.h>
1009 namespace test { using ::vswscanf; } ], [],
1010 [AC_DEFINE(HAVE_VSWSCANF,1,
1011 [Defined if vswscanf exists.])],[])
1013 AC_TRY_COMPILE([#include <wchar.h>
1014 namespace test { using ::vwscanf; } ], [],
1015 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1017 AC_TRY_COMPILE([#include <wchar.h>
1018 namespace test { using ::wcstof; } ], [],
1019 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1021 AC_TRY_COMPILE([#include <wctype.h>],
1022 [ wint_t t; int i = iswblank(t);],
1023 [AC_DEFINE(HAVE_ISWBLANK,1,
1024 [Defined if iswblank exists.])],[])
1026 AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1029 # Option parsed, now set things appropriately.
1030 if test x"$glibcxx_cv_c99_math" = x"no" ||
1031 test x"$glibcxx_cv_c99_complex" = x"no" ||
1032 test x"$glibcxx_cv_c99_stdio" = x"no" ||
1033 test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1034 test x"$glibcxx_cv_c99_wchar" = x"no"; then
1037 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1038 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1039 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1042 gcc_no_link="$ac_save_gcc_no_link"
1043 LIBS="$ac_save_LIBS"
1044 CXXFLAGS="$ac_save_CXXFLAGS"
1048 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1049 AC_MSG_RESULT($enable_c99)
1054 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1055 dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this]
1056 dnl in the current C++0x working draft.
1058 dnl --enable-libstdcxx-time
1059 dnl --enable-libstdcxx-time=yes
1060 dnl checks for the availability of monotonic and realtime clocks,
1061 dnl nanosleep and sched_yield in libc and libposix4 and, in case, links
1063 dnl --enable-libstdcxx-time=rt
1064 dnl also searches (and, in case, links) librt. Note that this is
1065 dnl not always desirable because, in glibc, for example, in turn it
1066 dnl triggers the linking of libpthread too, which activates locking,
1067 dnl a large overhead for single-thread programs.
1068 dnl --enable-libstdcxx-time=no
1069 dnl --disable-libstdcxx-time
1070 dnl disables the checks completely
1072 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1074 AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1075 GLIBCXX_ENABLE(libstdcxx-time,$1,[=KIND],
1076 [use KIND for check type],
1081 ac_save_CXXFLAGS="$CXXFLAGS"
1082 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1083 ac_save_LIBS="$LIBS"
1085 ac_has_clock_monotonic=no
1086 ac_has_clock_realtime=no
1087 AC_MSG_RESULT($enable_libstdcxx_time)
1089 if test x"$enable_libstdcxx_time" != x"no"; then
1091 if test x"$enable_libstdcxx_time" = x"rt"; then
1092 AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1093 AC_SEARCH_LIBS(nanosleep, [rt posix4])
1095 AC_SEARCH_LIBS(clock_gettime, [posix4])
1096 AC_SEARCH_LIBS(nanosleep, [posix4])
1099 case "$ac_cv_search_clock_gettime" in
1100 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1103 case "$ac_cv_search_nanosleep" in
1104 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1108 AC_SEARCH_LIBS(sched_yield, [rt posix4])
1110 case "$ac_cv_search_sched_yield" in
1112 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1113 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1114 [ Defined if sched_yield is available. ])
1117 if test x"$enable_libstdcxx_time" = x"rt"; then
1118 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1119 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1120 [ Defined if sched_yield is available. ])
1124 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1125 [ Defined if sched_yield is available. ])
1129 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1131 if test x"$ac_has_unistd_h" = x"yes"; then
1132 AC_MSG_CHECKING([for monotonic clock])
1134 [#include <unistd.h>
1137 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1140 clock_gettime(CLOCK_MONOTONIC, &tp);
1141 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1143 AC_MSG_RESULT($ac_has_clock_monotonic)
1145 AC_MSG_CHECKING([for realtime clock])
1147 [#include <unistd.h>
1150 [#if _POSIX_TIMERS > 0
1153 clock_gettime(CLOCK_REALTIME, &tp);
1154 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1156 AC_MSG_RESULT($ac_has_clock_realtime)
1158 AC_MSG_CHECKING([for nanosleep])
1160 [#include <unistd.h>
1163 [#if _POSIX_TIMERS > 0
1167 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1169 AC_MSG_RESULT($ac_has_nanosleep)
1173 if test x"$ac_has_clock_monotonic" = x"yes"; then
1174 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1175 [ Defined if clock_gettime has monotonic clock support. ])
1178 if test x"$ac_has_clock_realtime" = x"yes"; then
1179 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1180 [ Defined if clock_gettime has realtime clock support. ])
1183 if test x"$ac_has_nanosleep" = x"yes"; then
1184 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1185 [ Defined if nanosleep is available. ])
1188 AC_SUBST(GLIBCXX_LIBS)
1190 CXXFLAGS="$ac_save_CXXFLAGS"
1191 LIBS="$ac_save_LIBS"
1196 dnl Check for gettimeofday, used in the implementation of 20.8.5
1197 dnl [time.clock] in the current C++0x working draft.
1199 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1201 AC_MSG_CHECKING([for gettimeofday])
1205 ac_save_CXXFLAGS="$CXXFLAGS"
1206 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1208 ac_has_gettimeofday=no;
1209 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1210 if test x"$ac_has_sys_time_h" = x"yes"; then
1211 AC_MSG_CHECKING([for gettimeofday])
1212 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1213 [timeval tv; gettimeofday(&tv, 0);],
1214 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1216 AC_MSG_RESULT($ac_has_gettimeofday)
1219 if test x"$ac_has_gettimeofday" = x"yes"; then
1220 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1221 [ Defined if gettimeofday is available. ])
1224 CXXFLAGS="$ac_save_CXXFLAGS"
1229 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1230 dnl facilities in Chapter 8, "C compatibility".
1232 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1237 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1238 # undefined and fake C99 facilities may be spuriously enabled.
1239 ac_save_CXXFLAGS="$CXXFLAGS"
1240 CXXFLAGS="$CXXFLAGS -std=c++98"
1242 # Check for the existence of <complex.h> complex math functions used
1244 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1245 ac_c99_complex_tr1=no;
1246 if test x"$ac_has_complex_h" = x"yes"; then
1247 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1248 AC_TRY_COMPILE([#include <complex.h>],
1249 [typedef __complex__ float float_type; float_type tmpf;
1256 typedef __complex__ double double_type; double_type tmpd;
1263 typedef __complex__ long double ld_type; ld_type tmpld;
1270 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1272 AC_MSG_RESULT($ac_c99_complex_tr1)
1273 if test x"$ac_c99_complex_tr1" = x"yes"; then
1274 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1275 [Define if C99 functions in <complex.h> should be used in
1276 <tr1/complex>. Using compiler builtins for these functions
1277 requires corresponding C99 library functions to be present.])
1280 # Check for the existence of <ctype.h> functions.
1281 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1282 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1283 AC_TRY_COMPILE([#include <ctype.h>],
1287 ],[glibcxx_cv_c99_ctype_tr1=yes],
1288 [glibcxx_cv_c99_ctype_tr1=no])
1290 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1291 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1292 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1293 [Define if C99 functions in <ctype.h> should be imported in
1294 <tr1/cctype> in namespace std::tr1.])
1297 # Check for the existence of <fenv.h> functions.
1298 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1300 if test x"$ac_has_fenv_h" = x"yes"; then
1301 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1302 AC_TRY_COMPILE([#include <fenv.h>],
1307 ret = feclearexcept(except);
1308 ret = fegetexceptflag(pflag, except);
1309 ret = feraiseexcept(except);
1310 ret = fesetexceptflag(pflag, except);
1311 ret = fetestexcept(except);
1313 ret = fesetround(mode);
1314 ret = fegetenv(penv);
1315 ret = feholdexcept(penv);
1316 ret = fesetenv(penv);
1317 ret = feupdateenv(penv);
1318 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1320 AC_MSG_RESULT($ac_c99_fenv_tr1)
1321 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1322 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1323 [Define if C99 functions in <fenv.h> should be imported in
1324 <tr1/cfenv> in namespace std::tr1.])
1327 # Check for the existence of <stdint.h> types.
1328 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1329 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1330 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1331 #define __STDC_CONSTANT_MACROS
1332 #include <stdint.h>],
1333 [typedef int8_t my_int8_t;
1334 my_int8_t i8 = INT8_MIN;
1336 typedef int16_t my_int16_t;
1337 my_int16_t i16 = INT16_MIN;
1339 typedef int32_t my_int32_t;
1340 my_int32_t i32 = INT32_MIN;
1342 typedef int64_t my_int64_t;
1343 my_int64_t i64 = INT64_MIN;
1345 typedef int_fast8_t my_int_fast8_t;
1346 my_int_fast8_t if8 = INT_FAST8_MIN;
1347 if8 = INT_FAST8_MAX;
1348 typedef int_fast16_t my_int_fast16_t;
1349 my_int_fast16_t if16 = INT_FAST16_MIN;
1350 if16 = INT_FAST16_MAX;
1351 typedef int_fast32_t my_int_fast32_t;
1352 my_int_fast32_t if32 = INT_FAST32_MIN;
1353 if32 = INT_FAST32_MAX;
1354 typedef int_fast64_t my_int_fast64_t;
1355 my_int_fast64_t if64 = INT_FAST64_MIN;
1356 if64 = INT_FAST64_MAX;
1357 typedef int_least8_t my_int_least8_t;
1358 my_int_least8_t il8 = INT_LEAST8_MIN;
1359 il8 = INT_LEAST8_MAX;
1360 typedef int_least16_t my_int_least16_t;
1361 my_int_least16_t il16 = INT_LEAST16_MIN;
1362 il16 = INT_LEAST16_MAX;
1363 typedef int_least32_t my_int_least32_t;
1364 my_int_least32_t il32 = INT_LEAST32_MIN;
1365 il32 = INT_LEAST32_MAX;
1366 typedef int_least64_t my_int_least64_t;
1367 my_int_least64_t il64 = INT_LEAST64_MIN;
1368 il64 = INT_LEAST64_MAX;
1369 typedef intmax_t my_intmax_t;
1370 my_intmax_t im = INTMAX_MAX;
1372 typedef intptr_t my_intptr_t;
1373 my_intptr_t ip = INTPTR_MAX;
1375 typedef uint8_t my_uint8_t;
1376 my_uint8_t ui8 = UINT8_MAX;
1378 typedef uint16_t my_uint16_t;
1379 my_uint16_t ui16 = UINT16_MAX;
1381 typedef uint32_t my_uint32_t;
1382 my_uint32_t ui32 = UINT32_MAX;
1384 typedef uint64_t my_uint64_t;
1385 my_uint64_t ui64 = UINT64_MAX;
1387 typedef uint_fast8_t my_uint_fast8_t;
1388 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1389 uif8 = UINT_FAST8_MAX;
1390 typedef uint_fast16_t my_uint_fast16_t;
1391 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1392 uif16 = UINT_FAST16_MAX;
1393 typedef uint_fast32_t my_uint_fast32_t;
1394 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1395 uif32 = UINT_FAST32_MAX;
1396 typedef uint_fast64_t my_uint_fast64_t;
1397 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1398 uif64 = UINT_FAST64_MAX;
1399 typedef uint_least8_t my_uint_least8_t;
1400 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1401 uil8 = UINT_LEAST8_MAX;
1402 typedef uint_least16_t my_uint_least16_t;
1403 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1404 uil16 = UINT_LEAST16_MAX;
1405 typedef uint_least32_t my_uint_least32_t;
1406 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1407 uil32 = UINT_LEAST32_MAX;
1408 typedef uint_least64_t my_uint_least64_t;
1409 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1410 uil64 = UINT_LEAST64_MAX;
1411 typedef uintmax_t my_uintmax_t;
1412 my_uintmax_t uim = UINTMAX_MAX;
1414 typedef uintptr_t my_uintptr_t;
1415 my_uintptr_t uip = UINTPTR_MAX;
1417 ],[glibcxx_cv_c99_stdint_tr1=yes],
1418 [glibcxx_cv_c99_stdint_tr1=no])
1420 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1421 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1422 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1423 [Define if C99 types in <stdint.h> should be imported in
1424 <tr1/cstdint> in namespace std::tr1.])
1427 # Check for the existence of <math.h> functions.
1428 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1429 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1430 AC_TRY_COMPILE([#include <math.h>],
1431 [typedef double_t my_double_t;
1432 typedef float_t my_float_t;
1446 copysignf(0.0f, 0.0f);
1447 copysignl(0.0l, 0.0l);
1464 fmaf(0.0f, 0.0f, 0.0f);
1465 fmal(0.0l, 0.0l, 0.0l);
1508 nextafter(0.0, 0.0);
1509 nextafterf(0.0f, 0.0f);
1510 nextafterl(0.0l, 0.0l);
1511 nexttoward(0.0, 0.0);
1512 nexttowardf(0.0f, 0.0f);
1513 nexttowardl(0.0l, 0.0l);
1514 remainder(0.0, 0.0);
1515 remainderf(0.0f, 0.0f);
1516 remainderl(0.0l, 0.0l);
1517 remquo(0.0, 0.0, 0);
1518 remquof(0.0f, 0.0f, 0);
1519 remquol(0.0l, 0.0l, 0);
1538 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1540 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1541 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1542 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1543 [Define if C99 functions or macros in <math.h> should be imported
1544 in <tr1/cmath> in namespace std::tr1.])
1547 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1548 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1549 ac_c99_inttypes_tr1=no;
1550 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1551 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1552 AC_TRY_COMPILE([#include <inttypes.h>],
1553 [intmax_t i, numer, denom, base;
1556 intmax_t ret = imaxabs(i);
1557 imaxdiv_t dret = imaxdiv(numer, denom);
1558 ret = strtoimax(s, endptr, base);
1559 uintmax_t uret = strtoumax(s, endptr, base);
1560 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1562 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1563 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1564 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1565 [Define if C99 functions in <inttypes.h> should be imported in
1566 <tr1/cinttypes> in namespace std::tr1.])
1569 # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1570 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1571 ac_c99_inttypes_wchar_t_tr1=no;
1572 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1573 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1574 AC_TRY_COMPILE([#include <inttypes.h>],
1578 intmax_t ret = wcstoimax(s, endptr, base);
1579 uintmax_t uret = wcstoumax(s, endptr, base);
1580 ],[ac_c99_inttypes_wchar_t_tr1=yes],
1581 [ac_c99_inttypes_wchar_t_tr1=no])
1583 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1584 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1585 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1586 [Define if wchar_t C99 functions in <inttypes.h> should be
1587 imported in <tr1/cinttypes> in namespace std::tr1.])
1590 # Check for the existence of the <stdbool.h> header.
1591 AC_CHECK_HEADERS(stdbool.h)
1593 CXXFLAGS="$ac_save_CXXFLAGS"
1598 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1599 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1601 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1603 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1604 AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1605 if test -r /dev/random && test -r /dev/urandom; then
1606 glibcxx_cv_random_tr1=yes;
1608 glibcxx_cv_random_tr1=no;
1611 AC_MSG_RESULT($glibcxx_cv_random_tr1)
1613 if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1614 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1615 [Define if /dev/random and /dev/urandom are available for
1616 the random_device of TR1 (Chapter 5.1).])
1622 dnl Check whether EOF, SEEK_CUR, and SEEK_END have the most common values:
1623 dnl in that case including <cstdio> in some C++ headers can be avoided.
1625 AC_DEFUN([GLIBCXX_CHECK_STDIO_MACROS], [
1627 AC_MSG_CHECKING([for EOF == -1, SEEK_CUR == 1, SEEK_END == 2])
1628 AC_CACHE_VAL(glibcxx_cv_stdio_macros, [
1629 AC_TRY_COMPILE([#include <stdio.h>],
1630 [#if ((EOF != -1) || (SEEK_CUR != 1) || (SEEK_END != 2))
1633 ], [glibcxx_cv_stdio_macros=yes],
1634 [glibcxx_cv_stdio_macros=no])
1636 AC_MSG_RESULT($glibcxx_cv_stdio_macros)
1637 if test x"$glibcxx_cv_stdio_macros" = x"yes"; then
1638 AC_DEFINE(_GLIBCXX_STDIO_MACROS, 1,
1639 [Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2.])
1645 dnl Check whether macros, etc are present for <system_error>
1647 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1649 m4_pushdef([n_syserr], [1])dnl
1650 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1651 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1652 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY],
1653 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1654 AC_MSG_CHECKING([for syserr])
1655 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1656 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1657 [int i = syserr;])],
1658 [glibcxx_cv_system_error[]n_syserr=yes],
1659 [glibcxx_cv_system_error[]n_syserr=no])
1661 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1662 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1663 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1665 m4_define([n_syserr], m4_incr(n_syserr))dnl
1666 m4_popdef([SYSERR])dnl
1668 m4_popdef([n_syserr])dnl
1672 dnl Check for what type of C headers to use.
1674 dnl --enable-cheaders= [does stuff].
1675 dnl --disable-cheaders [does not do anything, really].
1676 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1677 dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1679 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1680 GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1681 [construct "C" headers for g++], [permit c|c_std|c_global])
1682 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1684 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1686 # Allow overrides to configure.host here.
1687 if test $enable_cheaders = c_global; then
1691 if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1695 AC_SUBST(C_INCLUDE_DIR)
1696 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1697 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1698 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1699 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1700 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1705 dnl Check for which locale library to use. The choice is mapped to
1706 dnl a subdirectory of config/locale.
1708 dnl Default is generic.
1710 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1711 GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1712 [use MODEL for target locale package],
1713 [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1715 # Deal with gettext issues. Default to not using it (=no) until we detect
1716 # support for it later. Let the user turn it off via --e/d, but let that
1717 # default to on for easier handling.
1720 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1724 # Either a known packaage, or "auto"
1725 if test $enable_clocale = no || test $enable_clocale = yes; then
1728 enable_clocale_flag=$enable_clocale
1730 # Probe for locale model to use if none specified.
1731 # Default to "generic".
1732 if test $enable_clocale_flag = auto; then
1733 case ${target_os} in
1734 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1735 enable_clocale_flag=gnu
1738 enable_clocale_flag=darwin
1741 enable_clocale_flag=generic
1746 # Sanity check model, and test for special functionality.
1747 if test $enable_clocale_flag = gnu; then
1748 AC_EGREP_CPP([_GLIBCXX_ok], [
1749 #include <features.h>
1750 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1753 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1755 # Set it to scream when it hurts.
1756 ac_save_CFLAGS="$CFLAGS"
1757 CFLAGS="-Wimplicit-function-declaration -Werror"
1759 # Use strxfrm_l if available.
1760 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1762 #include <locale.h>],
1763 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1764 AC_DEFINE(HAVE_STRXFRM_L, 1,
1765 [Define if strxfrm_l is available in <string.h>.]),)
1767 # Use strerror_l if available.
1768 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1770 #include <locale.h>],
1771 [__locale_t loc; strerror_l(5, loc);],
1772 AC_DEFINE(HAVE_STRERROR_L, 1,
1773 [Define if strerror_l is available in <string.h>.]),)
1775 CFLAGS="$ac_save_CFLAGS"
1778 # Perhaps use strerror_r if available, and strerror_l isn't.
1779 ac_save_CFLAGS="$CFLAGS"
1780 CFLAGS="-Wimplicit-function-declaration -Werror"
1781 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1783 #include <locale.h>],
1784 [char s[128]; strerror_r(5, s, 128);],
1785 AC_DEFINE(HAVE_STRERROR_R, 1,
1786 [Define if strerror_r is available in <string.h>.]),)
1787 CFLAGS="$ac_save_CFLAGS"
1789 # Set configure bits for specified locale package
1790 AC_MSG_CHECKING([for C locale to use])
1791 case ${enable_clocale_flag} in
1793 AC_MSG_RESULT(generic)
1795 CLOCALE_H=config/locale/generic/c_locale.h
1796 CLOCALE_CC=config/locale/generic/c_locale.cc
1797 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1798 CCOLLATE_CC=config/locale/generic/collate_members.cc
1799 CCTYPE_CC=config/locale/generic/ctype_members.cc
1800 CMESSAGES_H=config/locale/generic/messages_members.h
1801 CMESSAGES_CC=config/locale/generic/messages_members.cc
1802 CMONEY_CC=config/locale/generic/monetary_members.cc
1803 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1804 CTIME_H=config/locale/generic/time_members.h
1805 CTIME_CC=config/locale/generic/time_members.cc
1806 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1809 AC_MSG_RESULT(darwin or freebsd)
1811 CLOCALE_H=config/locale/generic/c_locale.h
1812 CLOCALE_CC=config/locale/generic/c_locale.cc
1813 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1814 CCOLLATE_CC=config/locale/generic/collate_members.cc
1815 CCTYPE_CC=config/locale/darwin/ctype_members.cc
1816 CMESSAGES_H=config/locale/generic/messages_members.h
1817 CMESSAGES_CC=config/locale/generic/messages_members.cc
1818 CMONEY_CC=config/locale/generic/monetary_members.cc
1819 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1820 CTIME_H=config/locale/generic/time_members.h
1821 CTIME_CC=config/locale/generic/time_members.cc
1822 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1828 # Declare intention to use gettext, and add support for specific
1830 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1833 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1834 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1835 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1838 # Export the build objects.
1839 for ling in $ALL_LINGUAS; do \
1840 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1841 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1843 AC_SUBST(glibcxx_MOFILES)
1844 AC_SUBST(glibcxx_POFILES)
1846 CLOCALE_H=config/locale/gnu/c_locale.h
1847 CLOCALE_CC=config/locale/gnu/c_locale.cc
1848 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1849 CCOLLATE_CC=config/locale/gnu/collate_members.cc
1850 CCTYPE_CC=config/locale/gnu/ctype_members.cc
1851 CMESSAGES_H=config/locale/gnu/messages_members.h
1852 CMESSAGES_CC=config/locale/gnu/messages_members.cc
1853 CMONEY_CC=config/locale/gnu/monetary_members.cc
1854 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1855 CTIME_H=config/locale/gnu/time_members.h
1856 CTIME_CC=config/locale/gnu/time_members.cc
1857 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1860 AC_MSG_RESULT(IEEE 1003.1)
1862 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1863 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1864 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1865 CCOLLATE_CC=config/locale/generic/collate_members.cc
1866 CCTYPE_CC=config/locale/generic/ctype_members.cc
1867 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1868 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1869 CMONEY_CC=config/locale/generic/monetary_members.cc
1870 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1871 CTIME_H=config/locale/generic/time_members.h
1872 CTIME_CC=config/locale/generic/time_members.cc
1873 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1877 # This is where the testsuite looks for locale catalogs, using the
1878 # -DLOCALEDIR define during testsuite compilation.
1879 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1880 AC_SUBST(glibcxx_localedir)
1882 # A standalone libintl (e.g., GNU libintl) may be in use.
1883 if test $USE_NLS = yes; then
1884 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1885 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1887 if test $USE_NLS = yes; then
1888 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1889 [Define if NLS translations are to be used.])
1894 AC_SUBST(CMESSAGES_H)
1895 AC_SUBST(CCODECVT_CC)
1896 AC_SUBST(CCOLLATE_CC)
1898 AC_SUBST(CMESSAGES_CC)
1900 AC_SUBST(CNUMERIC_CC)
1903 AC_SUBST(CLOCALE_CC)
1904 AC_SUBST(CLOCALE_INTERNAL_H)
1909 dnl Check for which std::allocator base class to use. The choice is
1910 dnl mapped from a subdirectory of include/ext.
1914 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1915 AC_MSG_CHECKING([for std::allocator base class])
1916 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1917 [use KIND for target std::allocator base],
1918 [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1920 # If they didn't use this option switch, or if they specified --enable
1921 # with no specific model, we'll have to look for one. If they
1922 # specified --disable (???), do likewise.
1923 if test $enable_libstdcxx_allocator = no ||
1924 test $enable_libstdcxx_allocator = yes;
1926 enable_libstdcxx_allocator=auto
1929 # Either a known package, or "auto". Auto implies the default choice
1930 # for a particular platform.
1931 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1933 # Probe for host-specific support if no specific model is specified.
1935 if test $enable_libstdcxx_allocator_flag = auto; then
1936 case ${target_os} in
1937 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1938 enable_libstdcxx_allocator_flag=new
1941 enable_libstdcxx_allocator_flag=new
1945 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1948 # Set configure bits for specified locale package
1949 case ${enable_libstdcxx_allocator_flag} in
1951 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1952 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1955 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1956 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1959 ALLOCATOR_H=config/allocator/mt_allocator_base.h
1960 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1963 ALLOCATOR_H=config/allocator/new_allocator_base.h
1964 ALLOCATOR_NAME=__gnu_cxx::new_allocator
1967 ALLOCATOR_H=config/allocator/pool_allocator_base.h
1968 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1972 AC_SUBST(ALLOCATOR_H)
1973 AC_SUBST(ALLOCATOR_NAME)
1978 dnl Check for whether the Boost-derived checks should be turned on.
1980 dnl --enable-concept-checks turns them on.
1981 dnl --disable-concept-checks leaves them off.
1982 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1983 dnl Where DEFAULT is either `yes' or `no'.
1985 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1986 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1987 if test $enable_concept_checks = yes; then
1988 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1989 [Define to use concept checking code from the boost libraries.])
1994 dnl Check for parallel mode pre-requisites, including OpenMP support.
1996 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
1998 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2002 # See if configured libgomp/omp.h exists. (libgomp may be in
2003 # noconfigdirs but not explicitly disabled.)
2004 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2005 enable_parallel=yes;
2007 AC_MSG_NOTICE([target-libgomp not built])
2010 AC_MSG_CHECKING([for parallel mode support])
2011 AC_MSG_RESULT([$enable_parallel])
2012 GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2017 dnl Check for which I/O library to use: stdio, or something specific.
2019 dnl Default is stdio.
2021 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2022 AC_MSG_CHECKING([for underlying I/O to use])
2023 GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
2024 [use target-specific I/O package], [permit stdio])
2026 # Now that libio has been removed, you can have any color you want as long
2027 # as it's black. This is one big no-op until other packages are added, but
2028 # showing the framework never hurts.
2029 case ${enable_cstdio} in
2031 CSTDIO_H=config/io/c_io_stdio.h
2032 BASIC_FILE_H=config/io/basic_file_stdio.h
2033 BASIC_FILE_CC=config/io/basic_file_stdio.cc
2034 AC_MSG_RESULT(stdio)
2039 AC_SUBST(BASIC_FILE_H)
2040 AC_SUBST(BASIC_FILE_CC)
2045 dnl Check for "unusual" flags to pass to the compiler while building.
2047 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2048 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2049 dnl --disable-cxx-flags passes nothing.
2050 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2051 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2052 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2053 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2054 dnl If "default flags" is an empty string, the effect is the same
2055 dnl as --disable or --enable=no.
2057 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2058 AC_MSG_CHECKING([for extra compiler flags for building])
2059 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2060 [pass compiler FLAGS when building library],
2061 [case "x$enable_cxx_flags" in
2062 xno | x) enable_cxx_flags= ;;
2064 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2067 # Run through flags (either default or command-line) and set anything
2068 # extra (e.g., #defines) that must accompany particular g++ options.
2069 if test -n "$enable_cxx_flags"; then
2070 for f in $enable_cxx_flags; do
2074 *) # and we're trying to pass /what/ exactly?
2075 AC_MSG_ERROR([compiler flags start with a -]) ;;
2080 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2081 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2082 AC_SUBST(EXTRA_CXX_FLAGS)
2087 dnl Check to see if debugging libraries are to be built.
2089 dnl --enable-libstdcxx-debug
2090 dnl builds a separate set of debugging libraries in addition to the
2091 dnl normal (shared, static) libstdc++ binaries.
2093 dnl --disable-libstdcxx-debug
2094 dnl builds only one (non-debug) version of libstdc++.
2096 dnl --enable-libstdcxx-debug-flags=FLAGS
2097 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2099 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2100 dnl Where DEFAULT is either `yes' or `no'.
2102 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2103 AC_MSG_CHECKING([for additional debug build])
2104 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2105 AC_MSG_RESULT($enable_libstdcxx_debug)
2106 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2111 dnl Check for explicit debug flags.
2113 dnl --enable-libstdcxx-debug-flags='-O1'
2114 dnl is a general method for passing flags to be used when
2115 dnl building debug libraries with --enable-debug.
2117 dnl --disable-libstdcxx-debug-flags does nothing.
2118 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2119 dnl If "default flags" is an empty string, the effect is the same
2120 dnl as --disable or --enable=no.
2122 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2123 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2124 [pass compiler FLAGS when building debug library],
2125 [case "x$enable_libstdcxx_debug_flags" in
2126 xno | x) enable_libstdcxx_debug_flags= ;;
2128 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2131 # Option parsed, now set things appropriately
2132 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2133 AC_SUBST(DEBUG_FLAGS)
2135 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2140 dnl Check if the user only wants a freestanding library implementation.
2142 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2143 dnl installing only the headers required by [17.4.1.3] and the language
2144 dnl support library. More than that will be built (to keep the Makefiles
2145 dnl conveniently clean), but not installed.
2148 dnl is_hosted (yes/no)
2151 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
2153 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2154 AC_ARG_ENABLE([hosted-libstdcxx],
2155 AC_HELP_STRING([--disable-hosted-libstdcxx],
2156 [only build freestanding C++ runtime support]),,
2159 enable_hosted_libstdcxx=no
2162 enable_hosted_libstdcxx=yes
2165 if test "$enable_hosted_libstdcxx" = no; then
2166 AC_MSG_NOTICE([Only freestanding libraries will be built])
2170 enable_libstdcxx_pch=no
2175 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2176 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2177 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2182 dnl Check for template specializations for the 'long long' type.
2183 dnl The result determines only whether 'long long' I/O is enabled; things
2184 dnl like numeric_limits<> specializations are always available.
2186 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2187 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2188 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2189 dnl Where DEFAULT is either `yes' or `no'.
2191 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2192 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2193 if test $enable_long_long = yes; then
2194 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2195 [Define if code specialized for long long should be used.])
2197 AC_MSG_CHECKING([for enabled long long specializations])
2198 AC_MSG_RESULT([$enable_long_long])
2203 dnl Check for decimal floating point.
2205 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2207 dnl This checks to see if the host supports decimal floating point types.
2210 dnl _GLIBCXX_USE_DECIMAL_FLOAT
2212 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2214 # Fake what AC_TRY_COMPILE does, without linking as this is
2215 # unnecessary for this test.
2217 cat > conftest.$ac_ext << EOF
2218 [#]line __oline__ "configure"
2228 AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2229 if AC_TRY_EVAL(ac_compile); then
2230 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2231 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2236 AC_MSG_RESULT($enable_dfp)
2241 dnl Check for template specializations for the 'wchar_t' type.
2243 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2244 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2245 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2246 dnl Where DEFAULT is either `yes' or `no'.
2248 dnl Necessary support must also be present.
2250 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2251 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2253 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2254 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2255 AC_MSG_CHECKING([for mbstate_t])
2256 AC_TRY_COMPILE([#include <wchar.h>],
2257 [mbstate_t teststate;],
2258 have_mbstate_t=yes, have_mbstate_t=no)
2259 AC_MSG_RESULT($have_mbstate_t)
2260 if test x"$have_mbstate_t" = xyes; then
2261 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2264 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2266 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2268 if test x"$enable_wchar_t" = x"yes"; then
2273 if test x"$ac_has_wchar_h" = xyes &&
2274 test x"$ac_has_wctype_h" = xyes; then
2275 AC_TRY_COMPILE([#include <wchar.h>
2336 ],[],[], [enable_wchar_t=no])
2344 if test x"$enable_wchar_t" = x"yes"; then
2345 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2346 [Define if code specialized for wchar_t should be used.])
2349 AC_MSG_CHECKING([for enabled wchar_t specializations])
2350 AC_MSG_RESULT([$enable_wchar_t])
2355 dnl Check to see if building and using a C++ precompiled header can be done.
2357 dnl --enable-libstdcxx-pch=yes
2358 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2359 dnl may work, after some light-hearted attempts to puzzle out compiler
2360 dnl support, flip bits on in include/Makefile.am
2362 dnl --disable-libstdcxx-pch
2363 dnl turns off attempts to use or build stdc++.h.gch.
2366 dnl glibcxx_PCHFLAGS
2368 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2369 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2370 if test $enable_libstdcxx_pch = yes; then
2371 AC_CACHE_CHECK([for compiler with PCH support],
2372 [glibcxx_cv_prog_CXX_pch],
2373 [ac_save_CXXFLAGS="$CXXFLAGS"
2374 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2377 echo '#include <math.h>' > conftest.h
2378 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2379 -o conftest.h.gch 1>&5 2>&1 &&
2380 echo '#error "pch failed"' > conftest.h &&
2381 echo '#include "conftest.h"' > conftest.cc &&
2382 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2384 glibcxx_cv_prog_CXX_pch=yes
2386 glibcxx_cv_prog_CXX_pch=no
2389 CXXFLAGS=$ac_save_CXXFLAGS
2392 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2395 AC_MSG_CHECKING([for enabled PCH])
2396 AC_MSG_RESULT([$enable_libstdcxx_pch])
2398 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2399 if test $enable_libstdcxx_pch = yes; then
2400 glibcxx_PCHFLAGS="-include bits/stdc++.h"
2404 AC_SUBST(glibcxx_PCHFLAGS)
2409 dnl Check for atomic builtins.
2411 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2413 dnl This checks to see if the host supports the compiler-generated
2414 dnl builtins for atomic operations for various integral sizes. Note, this
2415 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2416 dnl that are used should be checked.
2419 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2422 dnl _GLIBCXX_ATOMIC_BUILTINS_1
2423 dnl _GLIBCXX_ATOMIC_BUILTINS_2
2424 dnl _GLIBCXX_ATOMIC_BUILTINS_4
2425 dnl _GLIBCXX_ATOMIC_BUILTINS_8
2427 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2430 old_CXXFLAGS="$CXXFLAGS"
2432 # Do link tests if possible, instead asm tests, limited to some platforms
2433 # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2434 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2435 atomic_builtins_link_tests=no
2436 if test x$gcc_no_link != xyes; then
2437 # Can do link tests. Limit to some tested platforms
2439 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2440 atomic_builtins_link_tests=yes
2445 if test x$atomic_builtins_link_tests = xyes; then
2449 CXXFLAGS="$CXXFLAGS -fno-exceptions"
2451 AC_MSG_CHECKING([for atomic builtins for bool])
2452 AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2455 [typedef bool atomic_type;
2458 const atomic_type c3(0);
2459 __sync_fetch_and_add(&c1, c2);
2460 __sync_val_compare_and_swap(&c1, c3, c2);
2461 __sync_lock_test_and_set(&c1, c3);
2462 __sync_lock_release(&c1);
2463 __sync_synchronize();],
2464 [glibcxx_cv_atomic_bool=yes],
2465 [glibcxx_cv_atomic_bool=no])
2467 if test $glibcxx_cv_atomic_bool = yes; then
2468 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2469 [Define if builtin atomic operations for bool are supported on this host.])
2471 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2473 AC_MSG_CHECKING([for atomic builtins for short])
2474 AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2477 [typedef short atomic_type;
2480 const atomic_type c3(0);
2481 __sync_fetch_and_add(&c1, c2);
2482 __sync_val_compare_and_swap(&c1, c3, c2);
2483 __sync_lock_test_and_set(&c1, c3);
2484 __sync_lock_release(&c1);
2485 __sync_synchronize();],
2486 [glibcxx_cv_atomic_short=yes],
2487 [glibcxx_cv_atomic_short=no])
2489 if test $glibcxx_cv_atomic_short = yes; then
2490 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2491 [Define if builtin atomic operations for short are supported on this host.])
2493 AC_MSG_RESULT($glibcxx_cv_atomic_short)
2495 AC_MSG_CHECKING([for atomic builtins for int])
2496 AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2499 [typedef int atomic_type;
2502 const atomic_type c3(0);
2503 __sync_fetch_and_add(&c1, c2);
2504 __sync_val_compare_and_swap(&c1, c3, c2);
2505 __sync_lock_test_and_set(&c1, c3);
2506 __sync_lock_release(&c1);
2507 __sync_synchronize();],
2508 [glibcxx_cv_atomic_int=yes],
2509 [glibcxx_cv_atomic_int=no])
2511 if test $glibcxx_cv_atomic_int = yes; then
2512 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2513 [Define if builtin atomic operations for int are supported on this host.])
2515 AC_MSG_RESULT($glibcxx_cv_atomic_int)
2517 AC_MSG_CHECKING([for atomic builtins for long long])
2518 AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2521 [typedef long long atomic_type;
2524 const atomic_type c3(0);
2525 __sync_fetch_and_add(&c1, c2);
2526 __sync_val_compare_and_swap(&c1, c3, c2);
2527 __sync_lock_test_and_set(&c1, c3);
2528 __sync_lock_release(&c1);
2529 __sync_synchronize();],
2530 [glibcxx_cv_atomic_long_long=yes],
2531 [glibcxx_cv_atomic_long_long=no])
2533 if test $glibcxx_cv_atomic_long_long = yes; then
2534 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2535 [Define if builtin atomic operations for long long are supported on this host.])
2537 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2543 # Compile unoptimized.
2546 # Fake what AC_TRY_COMPILE does.
2548 cat > conftest.$ac_ext << EOF
2549 [#]line __oline__ "configure"
2552 typedef bool atomic_type;
2555 const atomic_type c3(0);
2556 __sync_fetch_and_add(&c1, c2);
2557 __sync_val_compare_and_swap(&c1, c3, c2);
2558 __sync_lock_test_and_set(&c1, c3);
2559 __sync_lock_release(&c1);
2560 __sync_synchronize();
2565 AC_MSG_CHECKING([for atomic builtins for bool])
2566 if AC_TRY_EVAL(ac_compile); then
2567 if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2568 glibcxx_cv_atomic_bool=no
2570 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2571 [Define if builtin atomic operations for bool are supported on this host.])
2572 glibcxx_cv_atomic_bool=yes
2575 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2578 cat > conftest.$ac_ext << EOF
2579 [#]line __oline__ "configure"
2582 typedef short atomic_type;
2585 const atomic_type c3(0);
2586 __sync_fetch_and_add(&c1, c2);
2587 __sync_val_compare_and_swap(&c1, c3, c2);
2588 __sync_lock_test_and_set(&c1, c3);
2589 __sync_lock_release(&c1);
2590 __sync_synchronize();
2595 AC_MSG_CHECKING([for atomic builtins for short])
2596 if AC_TRY_EVAL(ac_compile); then
2597 if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2598 glibcxx_cv_atomic_short=no
2600 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2601 [Define if builtin atomic operations for short are supported on this host.])
2602 glibcxx_cv_atomic_short=yes
2605 AC_MSG_RESULT($glibcxx_cv_atomic_short)
2608 cat > conftest.$ac_ext << EOF
2609 [#]line __oline__ "configure"
2612 // NB: _Atomic_word not necessarily int.
2613 typedef int atomic_type;
2616 const atomic_type c3(0);
2617 __sync_fetch_and_add(&c1, c2);
2618 __sync_val_compare_and_swap(&c1, c3, c2);
2619 __sync_lock_test_and_set(&c1, c3);
2620 __sync_lock_release(&c1);
2621 __sync_synchronize();
2626 AC_MSG_CHECKING([for atomic builtins for int])
2627 if AC_TRY_EVAL(ac_compile); then
2628 if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2629 glibcxx_cv_atomic_int=no
2631 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2632 [Define if builtin atomic operations for int are supported on this host.])
2633 glibcxx_cv_atomic_int=yes
2636 AC_MSG_RESULT($glibcxx_cv_atomic_int)
2639 cat > conftest.$ac_ext << EOF
2640 [#]line __oline__ "configure"
2643 typedef long long atomic_type;
2646 const atomic_type c3(0);
2647 __sync_fetch_and_add(&c1, c2);
2648 __sync_val_compare_and_swap(&c1, c3, c2);
2649 __sync_lock_test_and_set(&c1, c3);
2650 __sync_lock_release(&c1);
2651 __sync_synchronize();
2656 AC_MSG_CHECKING([for atomic builtins for long long])
2657 if AC_TRY_EVAL(ac_compile); then
2658 if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2659 glibcxx_cv_atomic_long_long=no
2661 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2662 [Define if builtin atomic operations for long long are supported on this host.])
2663 glibcxx_cv_atomic_long_long=yes
2666 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2671 CXXFLAGS="$old_CXXFLAGS"
2674 # Set atomicity_dir to builtins if either of above tests pass.
2675 if test $glibcxx_cv_atomic_int = yes || test $glibcxx_cv_atomic_bool = yes ; then
2676 atomicity_dir=cpu/generic/atomicity_builtins
2679 # If still generic, set to mutex.
2680 if test $atomicity_dir = "cpu/generic" ; then
2681 atomicity_dir=cpu/generic/atomicity_mutex
2682 AC_MSG_WARN([No native atomic operations are provided for this platform.])
2683 if test "x$target_thread_file" = xsingle; then
2684 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2685 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2687 AC_MSG_WARN([They will be faked using a mutex.])
2688 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2696 dnl Check for exception handling support. If an explicit enable/disable
2697 dnl sjlj exceptions is given, we don't have to detect. Otherwise the
2698 dnl target may or may not support call frame exceptions.
2700 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2701 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2702 dnl Neither one forces an attempt at detection.
2705 dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2707 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2708 AC_MSG_CHECKING([for exception model to use])
2711 GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2712 [force use of builtin_setjmp for exceptions],
2713 [permit yes|no|auto])
2715 if test $enable_sjlj_exceptions = auto; then
2716 # Botheration. Now we've got to detect the exception model. Link tests
2717 # against libgcc.a are problematic since we've not been given proper -L
2718 # bits for single-tree newlib and libgloss.
2720 # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style.
2721 cat > conftest.$ac_ext << EOF
2722 [#]line __oline__ "configure"
2731 old_CXXFLAGS="$CXXFLAGS"
2733 if AC_TRY_EVAL(ac_compile); then
2734 if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2735 enable_sjlj_exceptions=yes
2736 elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2737 enable_sjlj_exceptions=no
2738 elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2739 enable_sjlj_exceptions=no
2742 CXXFLAGS="$old_CXXFLAGS"
2746 # This is a tad weird, for hysterical raisins. We have to map
2747 # enable/disable to two different models.
2748 case $enable_sjlj_exceptions in
2750 AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2751 [Define if the compiler is configured for setjmp/longjmp exceptions.])
2752 ac_exception_model_name=sjlj
2755 ac_exception_model_name="call frame"
2758 AC_MSG_ERROR([unable to detect exception model])
2762 AC_MSG_RESULT($ac_exception_model_name)
2767 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2769 dnl --enable-visibility enables attempt to use visibility attributes.
2770 dnl --disable-visibility turns off all use of visibility attributes.
2771 dnl + Usage: GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2772 dnl Where DEFAULT is 'yes'.
2774 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2775 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2777 if test x$enable_visibility = xyes ; then
2778 dnl all hail libgfortran
2779 dnl Check whether the target supports hidden visibility.
2780 AC_CACHE_CHECK([whether the target supports hidden visibility],
2781 glibcxx_cv_have_attribute_visibility, [
2782 save_CFLAGS="$CFLAGS"
2783 CFLAGS="$CFLAGS -Werror"
2784 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2785 [], glibcxx_cv_have_attribute_visibility=yes,
2786 glibcxx_cv_have_attribute_visibility=no)
2787 CFLAGS="$save_CFLAGS"])
2788 if test $glibcxx_cv_have_attribute_visibility = no; then
2789 enable_visibility=no
2793 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2794 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2799 dnl Add version tags to symbols in shared library (or not), additionally
2800 dnl marking other symbols as private/local (or not).
2802 dnl --enable-symvers=style adds a version script to the linker call when
2803 dnl creating the shared library. The choice of version script is
2804 dnl controlled by 'style'.
2805 dnl --disable-symvers does not.
2806 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2807 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
2808 dnl choose a default style based on linker characteristics. Passing
2809 dnl 'no' disables versioning.
2811 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2813 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2814 [enables symbol versioning of the shared library],
2815 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2817 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2818 # don't know enough about $LD to do tricks...
2819 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2821 # Turn a 'yes' into a suitable default.
2822 if test x$enable_symvers = xyes ; then
2823 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2826 if test $with_gnu_ld = yes ; then
2827 case ${target_os} in
2829 enable_symvers=no ;;
2831 enable_symvers=gnu ;;
2834 case ${target_os} in
2836 enable_symvers=darwin ;;
2838 enable_symvers=no ;;
2844 # Check to see if 'darwin' or 'darwin-export' can win.
2845 if test x$enable_symvers = xdarwin-export ; then
2846 enable_symvers=darwin
2849 # Check to see if 'gnu' can win.
2850 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2851 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2852 AC_MSG_CHECKING([for shared libgcc])
2853 ac_save_CFLAGS="$CFLAGS"
2855 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2856 CFLAGS="$ac_save_CFLAGS"
2857 if test $glibcxx_shared_libgcc = no; then
2858 cat > conftest.c <<EOF
2859 int main (void) { return 0; }
2862 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2863 -shared -shared-libgcc -o conftest.so \
2864 conftest.c -v 2>&1 >/dev/null \
2865 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2867 rm -f conftest.c conftest.so
2868 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2869 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2870 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2871 CFLAGS="$ac_save_CFLAGS"
2874 AC_MSG_RESULT($glibcxx_shared_libgcc)
2876 # For GNU ld, we need at least this version. The format is described in
2877 # GLIBCXX_CHECK_LINKER_FEATURES above.
2878 glibcxx_min_gnu_ld_version=21400
2880 # If no shared libgcc, can't win.
2881 if test $glibcxx_shared_libgcc != yes; then
2882 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2883 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2884 AC_MSG_WARN([=== Symbol versioning will be disabled.])
2886 elif test $with_gnu_ld != yes ; then
2888 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2889 AC_MSG_WARN([=== you are not using the GNU linker.])
2890 AC_MSG_WARN([=== Symbol versioning will be disabled.])
2892 elif test $glibcxx_ld_is_gold = yes ; then
2893 : All versions of gold support symbol versioning.
2894 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2895 # The right tools, the right setup, but too old. Fallbacks?
2896 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2897 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2898 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2899 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2900 AC_MSG_WARN([=== Symbol versioning will be disabled.])
2905 # Everything parsed; figure out what file to use.
2906 case $enable_symvers in
2908 SYMVER_FILE=config/abi/pre/none.ver
2911 SYMVER_FILE=config/abi/pre/gnu.ver
2912 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2913 [Define to use GNU versioning in the shared library.])
2915 gnu-versioned-namespace)
2916 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2917 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2918 [Define to use GNU namespace versioning in the shared library.])
2921 SYMVER_FILE=config/abi/pre/gnu.ver
2922 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2923 [Define to use darwin versioning in the shared library.])
2927 if test x$enable_symvers != xno ; then
2928 AC_DEFINE(_GLIBCXX_SYMVER, 1,
2929 [Define to use symbol versioning in the shared library.])
2932 AC_CACHE_CHECK([whether the target supports .symver directive],
2933 glibcxx_cv_have_as_symver_directive, [
2934 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
2935 [], glibcxx_cv_have_as_symver_directive=yes,
2936 glibcxx_cv_have_as_symver_directive=no)])
2937 if test $glibcxx_cv_have_as_symver_directive = yes; then
2938 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
2939 [Define to 1 if the target assembler supports .symver directive.])
2942 AC_SUBST(SYMVER_FILE)
2943 AC_SUBST(port_specific_symbol_files)
2944 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2945 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2946 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2947 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2948 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2950 # Now, set up compatibility support, if any.
2951 # In addition, need this to deal with std::size_t mangling in
2952 # src/compatibility.cc. In a perfect world, could use
2953 # typeid(std::size_t).name()[0] to do direct substitution.
2954 AC_MSG_CHECKING([for size_t as unsigned int])
2955 ac_save_CFLAGS="$CFLAGS"
2957 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2958 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2959 CFLAGS=$ac_save_CFLAGS
2960 if test "$glibcxx_size_t_is_i" = yes; then
2961 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2963 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2965 AC_MSG_CHECKING([for ptrdiff_t as int])
2966 ac_save_CFLAGS="$CFLAGS"
2968 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2969 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2970 CFLAGS=$ac_save_CFLAGS
2971 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2972 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2974 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2979 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2980 dnl We must stage the required headers so that they will be installed
2981 dnl with the library (unlike libgcc, the STL implementation is provided
2982 dnl solely within headers). Since we must not inject random user-space
2983 dnl macro names into user-provided C++ code, we first stage into <file>-in
2984 dnl and process to <file> with an output command. The reason for a two-
2985 dnl stage process here is to correctly handle $srcdir!=$objdir without
2986 dnl having to write complex code (the sed commands to clean the macro
2987 dnl namespace are complex and fragile enough as it is). We must also
2988 dnl add a relative path so that -I- is supported properly.
2991 dnl glibcxx_thread_h
2994 dnl HAVE_GTHR_DEFAULT
2996 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2997 AC_MSG_CHECKING([for thread model used by GCC])
2998 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2999 AC_MSG_RESULT([$target_thread_file])
3001 if test $target_thread_file != single; then
3002 AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
3003 [Define if gthr-default.h exists
3004 (meaning that threading support is enabled).])
3007 glibcxx_thread_h=gthr-$target_thread_file.h
3009 dnl Check for __GTHREADS define.
3010 gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
3011 if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
3017 AC_SUBST(glibcxx_thread_h)
3022 dnl Check if gthread implementation defines the types and functions
3023 dnl required by the c++0x thread library. Conforming gthread
3024 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3026 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3030 ac_save_CXXFLAGS="$CXXFLAGS"
3031 CXXFLAGS="$CXXFLAGS -fno-exceptions -I${toplevel_srcdir}/gcc"
3033 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3034 case $target_thread_file in
3036 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3039 AC_MSG_CHECKING([for gthreads library])
3041 AC_TRY_COMPILE([#include "gthr.h"],
3043 #ifndef __GTHREADS_CXX0X
3047 // In case of POSIX threads check _POSIX_TIMEOUTS too.
3048 #if (defined(_PTHREADS) \
3049 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3052 ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
3054 AC_MSG_RESULT([$ac_has_gthreads])
3056 if test x"$ac_has_gthreads" = x"yes"; then
3057 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3058 [Define if gthreads library is available.])
3061 CXXFLAGS="$ac_save_CXXFLAGS"
3066 # Check whether LC_MESSAGES is available in <locale.h>.
3067 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3069 # This file file be copied and used freely without restrictions. It can
3070 # be used in projects which are not available under the GNU Public License
3071 # but which still want to provide support for the GNU gettext functionality.
3072 # Please note that the actual code is *not* freely available.
3073 AC_DEFUN([AC_LC_MESSAGES], [
3074 AC_CHECK_HEADER(locale.h, [
3075 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3076 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3077 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3078 if test $ac_cv_val_LC_MESSAGES = yes; then
3079 AC_DEFINE(HAVE_LC_MESSAGES, 1,
3080 [Define if LC_MESSAGES is available in <locale.h>.])
3085 # Macros from the top-level gcc directory.
3086 m4_include([../config/tls.m4])