| blob | 186916c2e47e75b5c9ee07a35c2981414934e147 |
2 dnl
3 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
4 dnl
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.
9 dnl
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])
14 )dnl
15 ])dnl
16 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
19 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.
23 dnl
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])
28 ])
30 dnl
31 dnl Initialize the rest of the library configury. At this point we have
32 dnl variables like $host.
33 dnl
34 dnl Sets:
35 dnl SUBDIRS
36 dnl Substs:
37 dnl glibcxx_builddir (absolute path)
38 dnl glibcxx_srcdir (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 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}`
59 case $srcdir in
60 [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
61 *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
62 esac
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]))
78 AC_ARG_WITH([newlib],
79 AC_HELP_STRING([--with-newlib],
80 [assume newlib as a system C library]))
82 # We're almost certainly being configured before anything else which uses
83 # C++, so all of our AC_PROG_* discoveries will be cached. It's vital that
84 # we not cache the value of CXX that we "discover" here, because it's set
85 # to something unique for us and libjava. Other target libraries need to
86 # find CXX for themselves. We yank the rug out from under the normal AC_*
87 # process by sneakily renaming the cache variable. This also lets us debug
88 # the value of "our" CXX in postmortems.
89 #
90 # We must also force CXX to /not/ be a precious variable, otherwise the
91 # wrong (non-multilib-adjusted) value will be used in multilibs. This
92 # little trick also affects CPPFLAGS, CXXFLAGS, and LDFLAGS. And as a side
93 # effect, CXXFLAGS is no longer automagically subst'd, so we have to do
94 # that ourselves. Un-preciousing AC_PROG_CC also affects CC and CFLAGS.
95 #
96 # -fno-builtin must be present here so that a non-conflicting form of
97 # std::exit can be guessed by AC_PROG_CXX, and used in later tests.
99 m4_define([ac_cv_prog_CXX],[glibcxx_cv_prog_CXX])
100 m4_rename([_AC_ARG_VAR_PRECIOUS],[glibcxx_PRECIOUS])
101 m4_define([_AC_ARG_VAR_PRECIOUS],[])
102 save_CXXFLAGS="$CXXFLAGS"
103 CXXFLAGS="$CXXFLAGS -fno-builtin"
104 AC_PROG_CC
105 AC_PROG_CXX
106 CXXFLAGS="$save_CXXFLAGS"
107 m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
108 AC_SUBST(CFLAGS)
109 AC_SUBST(CXXFLAGS)
111 # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
112 # available). Uncomment the next line to force a particular method.
113 AC_PROG_LN_S
114 #LN_S='cp -p'
116 AC_CHECK_TOOL(AS, as)
117 AC_CHECK_TOOL(AR, ar)
118 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
120 AM_MAINTAINER_MODE
122 # Set up safe default values for all subsequent AM_CONDITIONAL tests
123 # which are themselves conditionally expanded.
124 ## (Right now, this only matters for enable_wchar_t, but nothing prevents
125 ## other macros from doing the same. This should be automated.) -pme
127 # Check for uClibc since Linux platforms use different configuration
128 # directories depending on the C library in use.
129 AC_EGREP_CPP([_using_uclibc], [
130 #include <stdio.h>
131 #if __UCLIBC__
132 _using_uclibc
133 #endif
134 ], uclibc=yes, uclibc=no)
136 # Find platform-specific directories containing configuration info.
137 # Also possibly modify flags used elsewhere, as needed by the platform.
138 GLIBCXX_CHECK_HOST
139 ])
142 dnl
143 dnl Tests for newer compiler features, or features that are present in newer
144 dnl compiler versions but not older compiler versions still in use, should
145 dnl be placed here.
146 dnl
147 dnl Defines:
148 dnl WERROR='-Werror' if requested and possible; g++'s that lack the
149 dnl new inlining code or the new system_header pragma will die on -Werror.
150 dnl Leave it out by default and use maint-mode to use it.
151 dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if
152 dnl compiler supports it and the user has not requested debug mode.
153 dnl
154 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
155 # All these tests are for C++; save the language and the compiler flags.
156 # The CXXFLAGS thing is suspicious, but based on similar bits previously
157 # found in GLIBCXX_CONFIGURE.
158 AC_LANG_SAVE
159 AC_LANG_CPLUSPLUS
160 ac_test_CXXFLAGS="${CXXFLAGS+set}"
161 ac_save_CXXFLAGS="$CXXFLAGS"
163 # Check for maintainer-mode bits.
164 if test x"$USE_MAINTAINER_MODE" = xno; then
165 WERROR=''
166 else
167 WERROR='-Werror'
168 fi
170 # Check for -ffunction-sections -fdata-sections
171 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
172 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
173 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
174 if test "$ac_test_CXXFLAGS" = set; then
175 CXXFLAGS="$ac_save_CXXFLAGS"
176 else
177 # this is the suspicious part
178 CXXFLAGS=''
179 fi
180 if test x"$ac_fdsections" = x"yes"; then
181 SECTION_FLAGS='-ffunction-sections -fdata-sections'
182 fi
183 AC_MSG_RESULT($ac_fdsections)
185 AC_LANG_RESTORE
186 AC_SUBST(WERROR)
187 AC_SUBST(SECTION_FLAGS)
188 ])
191 dnl
192 dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
193 dnl the native linker is in use, all variables will be defined to something
194 dnl safe (like an empty string).
195 dnl
196 dnl Defines:
197 dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
198 dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
199 dnl LD (as a side effect of testing)
200 dnl Sets:
201 dnl with_gnu_ld
202 dnl glibcxx_ld_is_gold (set to "no" or "yes")
203 dnl glibcxx_gnu_ld_version (possibly)
204 dnl
205 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
206 dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
207 dnl
208 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
209 # If we're not using GNU ld, then there's no point in even trying these
210 # tests. Check for that first. We should have already tested for gld
211 # by now (in libtool), but require it now just to be safe...
212 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
213 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
214 AC_REQUIRE([AC_PROG_LD])
215 AC_REQUIRE([AC_PROG_AWK])
217 # The name set by libtool depends on the version of libtool. Shame on us
218 # for depending on an impl detail, but c'est la vie. Older versions used
219 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
220 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
221 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
222 # set (hence we're using an older libtool), then set it.
223 if test x${with_gnu_ld+set} != xset; then
224 if test x${ac_cv_prog_gnu_ld+set} != xset; then
225 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
226 with_gnu_ld=no
227 else
228 with_gnu_ld=$ac_cv_prog_gnu_ld
229 fi
230 fi
232 # Start by getting the version number. I think the libtool test already
233 # does some of this, but throws away the result.
234 glibcxx_ld_is_gold=no
235 if test x"$with_gnu_ld" = x"yes"; then
236 AC_MSG_CHECKING([for ld version])
237 changequote(,)
238 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
239 glibcxx_ld_is_gold=yes
240 fi
241 ldver=`$LD --version 2>/dev/null | head -1 | \
242 sed -e 's/GNU \(go\)\{0,1\}ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\4/'`
243 changequote([,])
244 glibcxx_gnu_ld_version=`echo $ldver | \
245 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
246 AC_MSG_RESULT($glibcxx_gnu_ld_version)
247 fi
249 # Set --gc-sections.
250 glibcxx_have_gc_sections=no
251 if test "$glibcxx_ld_is_gold" = "yes"; then
252 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
253 glibcxx_have_gc_sections=yes
254 fi
255 else
256 glibcxx_gcsections_min_ld=21602
257 if test x"$with_gnu_ld" = x"yes" &&
258 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
259 glibcxx_have_gc_sections=yes
260 fi
261 fi
262 if test "$glibcxx_have_gc_sections" = "yes"; then
263 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
264 # NB: This flag only works reliably after 2.16.1. Configure tests
265 # for this are difficult, so hard wire a value that should work.
267 ac_test_CFLAGS="${CFLAGS+set}"
268 ac_save_CFLAGS="$CFLAGS"
269 CFLAGS='-Wl,--gc-sections'
271 # Check for -Wl,--gc-sections
272 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
273 AC_TRY_LINK([ int one(void) { return 1; }
274 int two(void) { return 2; }
275 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
276 if test "$ac_gcsections" = "yes"; then
277 rm -f conftest.c
278 touch conftest.c
279 if $CC -c conftest.c; then
280 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
281 grep "Warning: gc-sections option ignored" > /dev/null; then
282 ac_gcsections=no
283 fi
284 fi
285 rm -f conftest.c conftest.o conftest
286 fi
287 if test "$ac_gcsections" = "yes"; then
288 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
289 fi
290 AC_MSG_RESULT($ac_gcsections)
292 if test "$ac_test_CFLAGS" = set; then
293 CFLAGS="$ac_save_CFLAGS"
294 else
295 # this is the suspicious part
296 CFLAGS=''
297 fi
298 fi
300 # Set -z,relro.
301 # Note this is only for shared objects.
302 ac_ld_relro=no
303 if test x"$with_gnu_ld" = x"yes"; then
304 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
305 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
306 if test -n "$cxx_z_relo"; then
307 OPT_LDFLAGS="-Wl,-z,relro"
308 ac_ld_relro=yes
309 fi
310 AC_MSG_RESULT($ac_ld_relro)
311 fi
313 # Set linker optimization flags.
314 if test x"$with_gnu_ld" = x"yes"; then
315 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
316 fi
318 AC_SUBST(SECTION_LDFLAGS)
319 AC_SUBST(OPT_LDFLAGS)
320 ])
323 dnl
324 dnl Check for headers for, and arguments to, the setrlimit() function.
325 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
326 dnl
327 dnl Defines:
328 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
329 dnl various HAVE_LIMIT_* for individual limit names
330 dnl
331 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
332 AC_MSG_CHECKING([for RLIMIT_$1])
333 AC_TRY_COMPILE(
334 [#include <unistd.h>
335 #include <sys/time.h>
336 #include <sys/resource.h>
337 ],
338 [ int f = RLIMIT_$1 ; ],
339 [glibcxx_mresult=1], [glibcxx_mresult=0])
340 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
341 [Only used in build directory testsuite_hooks.h.])
342 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
343 AC_MSG_RESULT($res)
344 ])
346 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
347 setrlimit_have_headers=yes
348 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
349 [],
350 [setrlimit_have_headers=no])
351 # If don't have the headers, then we can't run the tests now, and we
352 # won't be seeing any of these during testsuite compilation.
353 if test $setrlimit_have_headers = yes; then
354 # Can't do these in a loop, else the resulting syntax is wrong.
355 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
356 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
357 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
358 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
359 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
361 # Check for rlimit, setrlimit.
362 AC_CACHE_VAL(glibcxx_cv_setrlimit, [
363 AC_TRY_COMPILE(
364 [#include <unistd.h>
365 #include <sys/time.h>
366 #include <sys/resource.h>
367 ],
368 [struct rlimit r;
369 setrlimit(0, &r);],
370 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
371 ])
372 fi
374 AC_MSG_CHECKING([for testsuite resource limits support])
375 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
376 ac_res_limits=yes
377 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
378 [Define if using setrlimit to set resource limits during
379 "make check"])
380 else
381 ac_res_limits=no
382 fi
383 AC_MSG_RESULT($ac_res_limits)
384 ])
387 dnl
388 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
389 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
390 dnl
391 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
393 AC_LANG_SAVE
394 AC_LANG_CPLUSPLUS
395 ac_save_CXXFLAGS="$CXXFLAGS"
396 CXXFLAGS="$CXXFLAGS -fno-exceptions"
398 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
399 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
400 GCC_TRY_COMPILE_OR_LINK(
401 [#include <sys/stat.h>],
402 [struct stat buffer;
403 fstat(0, &buffer);
404 S_ISREG(buffer.st_mode);],
405 [glibcxx_cv_S_ISREG=yes],
406 [glibcxx_cv_S_ISREG=no])
407 ])
408 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
409 GCC_TRY_COMPILE_OR_LINK(
410 [#include <sys/stat.h>],
411 [struct stat buffer;
412 fstat(0, &buffer);
413 S_IFREG & buffer.st_mode;],
414 [glibcxx_cv_S_IFREG=yes],
415 [glibcxx_cv_S_IFREG=no])
416 ])
417 res=no
418 if test $glibcxx_cv_S_ISREG = yes; then
419 AC_DEFINE(HAVE_S_ISREG, 1,
420 [Define if S_IFREG is available in <sys/stat.h>.])
421 res=S_ISREG
422 elif test $glibcxx_cv_S_IFREG = yes; then
423 AC_DEFINE(HAVE_S_IFREG, 1,
424 [Define if S_IFREG is available in <sys/stat.h>.])
425 res=S_IFREG
426 fi
427 AC_MSG_RESULT($res)
429 CXXFLAGS="$ac_save_CXXFLAGS"
430 AC_LANG_RESTORE
431 ])
434 dnl
435 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
436 dnl
437 AC_DEFUN([GLIBCXX_CHECK_POLL], [
439 AC_LANG_SAVE
440 AC_LANG_CPLUSPLUS
441 ac_save_CXXFLAGS="$CXXFLAGS"
442 CXXFLAGS="$CXXFLAGS -fno-exceptions"
444 AC_MSG_CHECKING([for poll])
445 AC_CACHE_VAL(glibcxx_cv_POLL, [
446 GCC_TRY_COMPILE_OR_LINK(
447 [#include <poll.h>],
448 [struct pollfd pfd[1];
449 pfd[0].events = POLLIN;
450 poll(pfd, 1, 0);],
451 [glibcxx_cv_POLL=yes],
452 [glibcxx_cv_POLL=no])
453 ])
454 if test $glibcxx_cv_POLL = yes; then
455 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
456 fi
457 AC_MSG_RESULT($glibcxx_cv_POLL)
459 CXXFLAGS="$ac_save_CXXFLAGS"
460 AC_LANG_RESTORE
461 ])
464 dnl
465 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
466 dnl
467 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
469 AC_LANG_SAVE
470 AC_LANG_CPLUSPLUS
471 ac_save_CXXFLAGS="$CXXFLAGS"
472 CXXFLAGS="$CXXFLAGS -fno-exceptions"
474 AC_MSG_CHECKING([for writev])
475 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
476 GCC_TRY_COMPILE_OR_LINK(
477 [#include <sys/uio.h>],
478 [struct iovec iov[2];
479 writev(0, iov, 0);],
480 [glibcxx_cv_WRITEV=yes],
481 [glibcxx_cv_WRITEV=no])
482 ])
483 if test $glibcxx_cv_WRITEV = yes; then
484 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
485 fi
486 AC_MSG_RESULT($glibcxx_cv_WRITEV)
488 CXXFLAGS="$ac_save_CXXFLAGS"
489 AC_LANG_RESTORE
490 ])
493 dnl
494 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
495 dnl Also check whether int64_t is actually a typedef to long or long long.
496 dnl
497 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
499 AC_LANG_SAVE
500 AC_LANG_CPLUSPLUS
502 AC_MSG_CHECKING([for int64_t])
503 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
504 AC_TRY_COMPILE(
505 [#include <stdint.h>],
506 [int64_t var;],
507 [glibcxx_cv_INT64_T=yes],
508 [glibcxx_cv_INT64_T=no])
509 ])
511 if test $glibcxx_cv_INT64_T = yes; then
512 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
513 AC_MSG_RESULT($glibcxx_cv_INT64_T)
515 AC_MSG_CHECKING([for int64_t as long])
516 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
517 AC_TRY_COMPILE(
518 [#include <stdint.h>
519 template<typename, typename> struct same { enum { value = -1 }; };
520 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
521 int array[same<int64_t, long>::value];], [],
522 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
523 ])
525 if test $glibcxx_cv_int64_t_long = yes; then
526 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
527 AC_MSG_RESULT($glibcxx_cv_int64_t_long)
528 fi
530 AC_MSG_CHECKING([for int64_t as long long])
531 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
532 AC_TRY_COMPILE(
533 [#include <stdint.h>
534 template<typename, typename> struct same { enum { value = -1 }; };
535 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
536 int array[same<int64_t, long long>::value];], [],
537 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
538 ])
540 if test $glibcxx_cv_int64_t_long_long = yes; then
541 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
542 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
543 fi
544 fi
546 AC_LANG_RESTORE
547 ])
550 dnl
551 dnl Check whether LFS support is available.
552 dnl
553 AC_DEFUN([GLIBCXX_CHECK_LFS], [
554 AC_LANG_SAVE
555 AC_LANG_CPLUSPLUS
556 ac_save_CXXFLAGS="$CXXFLAGS"
557 CXXFLAGS="$CXXFLAGS -fno-exceptions"
558 AC_MSG_CHECKING([for LFS support])
559 AC_CACHE_VAL(glibcxx_cv_LFS, [
560 GCC_TRY_COMPILE_OR_LINK(
561 [#include <unistd.h>
562 #include <stdio.h>
563 #include <sys/stat.h>
564 ],
565 [FILE* fp;
566 fopen64("t", "w");
567 fseeko64(fp, 0, SEEK_CUR);
568 ftello64(fp);
569 lseek64(1, 0, SEEK_CUR);
570 struct stat64 buf;
571 fstat64(1, &buf);],
572 [glibcxx_cv_LFS=yes],
573 [glibcxx_cv_LFS=no])
574 ])
575 if test $glibcxx_cv_LFS = yes; then
576 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
577 fi
578 AC_MSG_RESULT($glibcxx_cv_LFS)
579 CXXFLAGS="$ac_save_CXXFLAGS"
580 AC_LANG_RESTORE
581 ])
584 dnl
585 dnl Check for whether a fully dynamic basic_string implementation should
586 dnl be turned on, that does not put empty objects in per-process static
587 dnl memory (mostly useful together with shared memory allocators, see PR
588 dnl libstdc++/16612 for details).
589 dnl
590 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
591 dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
592 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
593 dnl Where DEFAULT is either `yes' or `no'.
594 dnl
595 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
596 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
597 if test $enable_fully_dynamic_string = yes; then
598 AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
599 [Define if a fully dynamic basic_string is wanted.])
600 fi
601 ])
604 dnl
605 dnl Does any necessary configuration of the testsuite directory. Generates
606 dnl the testsuite_hooks.h header.
607 dnl
608 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
609 dnl
610 dnl Sets:
611 dnl enable_abi_check
612 dnl GLIBCXX_TEST_WCHAR_T
613 dnl GLIBCXX_TEST_THREAD
614 dnl Substs:
615 dnl baseline_dir
616 dnl
617 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
618 if $GLIBCXX_IS_NATIVE ; then
619 # Do checks for resource limit functions.
620 GLIBCXX_CHECK_SETRLIMIT
622 # Look for setenv, so that extended locale tests can be performed.
623 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
624 fi
626 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
627 test $enable_symvers != no; then
628 case "$host" in
629 *-*-cygwin*)
630 enable_abi_check=no ;;
631 *)
632 enable_abi_check=yes ;;
633 esac
634 else
635 # Only build this as native, since automake does not understand
636 # CXX_FOR_BUILD.
637 enable_abi_check=no
638 fi
640 # Export file names for ABI checking.
641 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
642 AC_SUBST(baseline_dir)
643 ])
646 dnl
647 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
648 dnl
649 dnl Substs:
650 dnl GLIBCXX_INCLUDES
651 dnl TOPLEVEL_INCLUDES
652 dnl
653 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
654 # Used for every C++ compile we perform.
655 GLIBCXX_INCLUDES="\
656 -I$glibcxx_builddir/include/$host_alias \
657 -I$glibcxx_builddir/include \
658 -I$glibcxx_srcdir/libsupc++"
660 # For Canadian crosses, pick this up too.
661 if test $CANADIAN = yes; then
662 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
663 fi
665 # Stuff in the actual top level. Currently only used by libsupc++ to
666 # get unwind* headers from the gcc dir.
667 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
668 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
670 # Now, export this to all the little Makefiles....
671 AC_SUBST(GLIBCXX_INCLUDES)
672 AC_SUBST(TOPLEVEL_INCLUDES)
673 ])
676 dnl
677 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
678 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
679 dnl
680 dnl Substs:
681 dnl OPTIMIZE_CXXFLAGS
682 dnl WARN_FLAGS
683 dnl
684 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
685 # Optimization flags that are probably a good idea for thrill-seekers. Just
686 # uncomment the lines below and make, everything else is ready to go...
687 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
688 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
689 AC_SUBST(OPTIMIZE_CXXFLAGS)
691 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
692 AC_SUBST(WARN_FLAGS)
693 ])
696 dnl
697 dnl All installation directory information is determined here.
698 dnl
699 dnl Substs:
700 dnl gxx_install_dir
701 dnl glibcxx_prefixdir
702 dnl glibcxx_toolexecdir
703 dnl glibcxx_toolexeclibdir
704 dnl
705 dnl Assumes cross_compiling bits already done, and with_cross_host in
706 dnl particular.
707 dnl
708 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
709 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
710 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
711 glibcxx_toolexecdir=no
712 glibcxx_toolexeclibdir=no
713 glibcxx_prefixdir=$prefix
715 AC_MSG_CHECKING([for gxx-include-dir])
716 AC_ARG_WITH([gxx-include-dir],
717 AC_HELP_STRING([--with-gxx-include-dir=DIR],
718 [installation directory for include files]),
719 [case "$withval" in
720 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
721 no) gxx_include_dir=no ;;
722 *) gxx_include_dir=$withval ;;
723 esac],
724 [gxx_include_dir=no])
725 AC_MSG_RESULT($gxx_include_dir)
727 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
728 AC_ARG_ENABLE([version-specific-runtime-libs],
729 AC_HELP_STRING([--enable-version-specific-runtime-libs],
730 [Specify that runtime libraries should be installed in a compiler-specific directory]),
731 [case "$enableval" in
732 yes) version_specific_libs=yes ;;
733 no) version_specific_libs=no ;;
734 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
735 esac],
736 [version_specific_libs=no])
737 AC_MSG_RESULT($version_specific_libs)
739 # Default case for install directory for include files.
740 if test $version_specific_libs = no && test $gxx_include_dir = no; then
741 gxx_include_dir='include/c++/${gcc_version}'
742 if test -n "$with_cross_host" &&
743 test x"$with_cross_host" != x"no"; then
744 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
745 else
746 gxx_include_dir='${prefix}/'"$gxx_include_dir"
747 fi
748 fi
750 # Version-specific runtime libs processing.
751 if test $version_specific_libs = yes; then
752 # Need the gcc compiler version to know where to install libraries
753 # and header files if --enable-version-specific-runtime-libs option
754 # is selected. FIXME: these variables are misnamed, there are
755 # no executables installed in _toolexecdir or _toolexeclibdir.
756 if test x"$gxx_include_dir" = x"no"; then
757 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
758 fi
759 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
760 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
761 fi
763 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
764 # Install a library built with a cross compiler in tooldir, not libdir.
765 if test x"$glibcxx_toolexecdir" = x"no"; then
766 if test -n "$with_cross_host" &&
767 test x"$with_cross_host" != x"no"; then
768 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
769 glibcxx_toolexeclibdir='${toolexecdir}/lib'
770 else
771 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
772 glibcxx_toolexeclibdir='${libdir}'
773 fi
774 multi_os_directory=`$CXX -print-multi-os-directory`
775 case $multi_os_directory in
776 .) ;; # Avoid trailing /.
777 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
778 esac
779 fi
781 AC_MSG_CHECKING([for install location])
782 AC_MSG_RESULT($gxx_include_dir)
784 AC_SUBST(glibcxx_prefixdir)
785 AC_SUBST(gxx_include_dir)
786 AC_SUBST(glibcxx_toolexecdir)
787 AC_SUBST(glibcxx_toolexeclibdir)
788 ])
791 dnl
792 dnl GLIBCXX_ENABLE
793 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
794 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
795 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
796 dnl
797 dnl See docs/html/17_intro/configury.html#enable for documentation.
798 dnl
799 m4_define([GLIBCXX_ENABLE],[dnl
800 m4_define([_g_switch],[--enable-$1])dnl
801 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
802 AC_ARG_ENABLE($1,_g_help,
803 m4_bmatch([$5],
804 [^permit ],
805 [[
806 case "$enableval" in
807 m4_bpatsubst([$5],[permit ])) ;;
808 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
809 dnl Idea for future: generate a URL pointing to
810 dnl "onlinedocs/configopts.html#whatever"
811 esac
812 ]],
813 [^$],
814 [[
815 case "$enableval" in
816 yes|no) ;;
817 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
818 esac
819 ]],
820 [[$5]]),
821 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
822 m4_undefine([_g_switch])dnl
823 m4_undefine([_g_help])dnl
824 ])
827 dnl
828 dnl Check for ISO/IEC 9899:1999 "C99" support.
829 dnl
830 dnl --enable-c99 defines _GLIBCXX_USE_C99
831 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
832 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
833 dnl Where DEFAULT is either `yes' or `no'.
834 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
835 dnl
836 AC_DEFUN([GLIBCXX_ENABLE_C99], [
837 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
839 if test x"$enable_c99" = x"yes"; then
841 AC_LANG_SAVE
842 AC_LANG_CPLUSPLUS
844 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
845 # undefined and fake C99 facilities - like pre-standard snprintf - may be
846 # spuriously enabled.
847 # Long term, -std=c++0x could be even better, could manage to explicitely
848 # request C99 facilities to the underlying C headers.
849 ac_save_CXXFLAGS="$CXXFLAGS"
850 CXXFLAGS="$CXXFLAGS -std=c++98"
851 ac_save_LIBS="$LIBS"
852 ac_save_gcc_no_link="$gcc_no_link"
854 if test x$gcc_no_link != xyes; then
855 # Use -fno-exceptions to that the C driver can link these tests without
856 # hitting undefined references to personality routines.
857 CXXFLAGS="$CXXFLAGS -fno-exceptions"
858 AC_CHECK_LIB(m, sin, [
859 LIBS="$LIBS -lm"
860 ], [
861 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
862 gcc_no_link=yes
863 ])
864 fi
866 # Check for the existence of <math.h> functions used if C99 is enabled.
867 AC_MSG_CHECKING([for ISO C99 support in <math.h>])
868 AC_CACHE_VAL(glibcxx_cv_c99_math, [
869 GCC_TRY_COMPILE_OR_LINK(
870 [#include <math.h>
871 volatile double d1, d2;
872 volatile int i;],
873 [i = fpclassify(d1);
874 i = isfinite(d1);
875 i = isinf(d1);
876 i = isnan(d1);
877 i = isnormal(d1);
878 i = signbit(d1);
879 i = isgreater(d1, d2);
880 i = isgreaterequal(d1, d2);
881 i = isless(d1, d2);
882 i = islessequal(d1, d2);
883 i = islessgreater(d1, d2);
884 i = islessgreater(d1, d2);
885 i = isunordered(d1, d2);
886 ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
887 ])
888 AC_MSG_RESULT($glibcxx_cv_c99_math)
889 if test x"$glibcxx_cv_c99_math" = x"yes"; then
890 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
891 [Define if C99 functions or macros in <math.h> should be imported
892 in <cmath> in namespace std.])
893 fi
895 # Check for the existence of <complex.h> complex math functions.
896 # This is necessary even though libstdc++ uses the builtin versions
897 # of these functions, because if the builtin cannot be used, a reference
898 # to the library function is emitted.
899 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
900 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
901 glibcxx_cv_c99_complex=no;
902 if test x"$ac_has_complex_h" = x"yes"; then
903 AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
904 GCC_TRY_COMPILE_OR_LINK(
905 [#include <complex.h>
906 typedef __complex__ float float_type;
907 typedef __complex__ double double_type;
908 typedef __complex__ long double ld_type;
909 volatile float_type tmpf;
910 volatile double_type tmpd;
911 volatile ld_type tmpld;
912 volatile float f;
913 volatile double d;
914 volatile long double ld;],
915 [f = cabsf(tmpf);
916 f = cargf(tmpf);
917 tmpf = ccosf(tmpf);
918 tmpf = ccoshf(tmpf);
919 tmpf = cexpf(tmpf);
920 tmpf = clogf(tmpf);
921 tmpf = csinf(tmpf);
922 tmpf = csinhf(tmpf);
923 tmpf = csqrtf(tmpf);
924 tmpf = ctanf(tmpf);
925 tmpf = ctanhf(tmpf);
926 tmpf = cpowf(tmpf, tmpf);
927 tmpf = cprojf(tmpf);
928 d = cabs(tmpd);
929 d = carg(tmpd);
930 tmpd = ccos(tmpd);
931 tmpd = ccosh(tmpd);
932 tmpd = cexp(tmpd);
933 tmpd = clog(tmpd);
934 tmpd = csin(tmpd);
935 tmpd = csinh(tmpd);
936 tmpd = csqrt(tmpd);
937 tmpd = ctan(tmpd);
938 tmpd = ctanh(tmpd);
939 tmpd = cpow(tmpd, tmpd);
940 tmpd = cproj(tmpd);
941 ld = cabsl(tmpld);
942 ld = cargl(tmpld);
943 tmpld = ccosl(tmpld);
944 tmpld = ccoshl(tmpld);
945 tmpld = cexpl(tmpld);
946 tmpld = clogl(tmpld);
947 tmpld = csinl(tmpld);
948 tmpld = csinhl(tmpld);
949 tmpld = csqrtl(tmpld);
950 tmpld = ctanl(tmpld);
951 tmpld = ctanhl(tmpld);
952 tmpld = cpowl(tmpld, tmpld);
953 tmpld = cprojl(tmpld);
954 ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
955 fi
956 AC_MSG_RESULT($glibcxx_cv_c99_complex)
957 if test x"$glibcxx_cv_c99_complex" = x"yes"; then
958 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
959 [Define if C99 functions in <complex.h> should be used in
960 <complex>. Using compiler builtins for these functions requires
961 corresponding C99 library functions to be present.])
962 fi
964 # Check for the existence in <stdio.h> of vscanf, et. al.
965 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
966 AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
967 GCC_TRY_COMPILE_OR_LINK(
968 [#include <stdio.h>
969 #include <stdarg.h>
970 void foo(char* fmt, ...)
971 {
972 va_list args; va_start(args, fmt);
973 vfscanf(stderr, "%i", args);
974 vscanf("%i", args);
975 vsnprintf(fmt, 0, "%i", args);
976 vsscanf(fmt, "%i", args);
977 }],
978 [snprintf("12", 0, "%i");],
979 [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
980 ])
981 AC_MSG_RESULT($glibcxx_cv_c99_stdio)
983 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
984 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
985 AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
986 GCC_TRY_COMPILE_OR_LINK(
987 [#include <stdlib.h>
988 volatile float f;
989 volatile long double ld;
990 volatile unsigned long long ll;
991 lldiv_t mydivt;],
992 [char* tmp;
993 f = strtof("gnu", &tmp);
994 ld = strtold("gnu", &tmp);
995 ll = strtoll("gnu", &tmp, 10);
996 ll = strtoull("gnu", &tmp, 10);
997 ll = llabs(10);
998 mydivt = lldiv(10,1);
999 ll = mydivt.quot;
1000 ll = mydivt.rem;
1001 ll = atoll("10");
1002 _Exit(0);
1003 ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
1004 ])
1005 AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
1007 # Check for the existence in <wchar.h> of wcstold, etc.
1008 glibcxx_cv_c99_wchar=no;
1009 if test x"$ac_has_wchar_h" = xyes &&
1010 test x"$ac_has_wctype_h" = xyes; then
1011 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1012 AC_TRY_COMPILE([#include <wchar.h>
1013 namespace test
1014 {
1015 using ::wcstold;
1016 using ::wcstoll;
1017 using ::wcstoull;
1018 }
1019 ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
1021 # Checks for wide character functions that may not be present.
1022 # Injection of these is wrapped with guard macros.
1023 # NB: only put functions here, instead of immediately above, if
1024 # absolutely necessary.
1025 AC_TRY_COMPILE([#include <wchar.h>
1026 namespace test { using ::vfwscanf; } ], [],
1027 [AC_DEFINE(HAVE_VFWSCANF,1,
1028 [Defined if vfwscanf exists.])],[])
1030 AC_TRY_COMPILE([#include <wchar.h>
1031 namespace test { using ::vswscanf; } ], [],
1032 [AC_DEFINE(HAVE_VSWSCANF,1,
1033 [Defined if vswscanf exists.])],[])
1035 AC_TRY_COMPILE([#include <wchar.h>
1036 namespace test { using ::vwscanf; } ], [],
1037 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1039 AC_TRY_COMPILE([#include <wchar.h>
1040 namespace test { using ::wcstof; } ], [],
1041 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1043 AC_TRY_COMPILE([#include <wctype.h>],
1044 [ wint_t t; int i = iswblank(t);],
1045 [AC_DEFINE(HAVE_ISWBLANK,1,
1046 [Defined if iswblank exists.])],[])
1048 AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1049 fi
1051 # Option parsed, now set things appropriately.
1052 if test x"$glibcxx_cv_c99_math" = x"no" ||
1053 test x"$glibcxx_cv_c99_complex" = x"no" ||
1054 test x"$glibcxx_cv_c99_stdio" = x"no" ||
1055 test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1056 test x"$glibcxx_cv_c99_wchar" = x"no"; then
1057 enable_c99=no;
1058 else
1059 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1060 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1061 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1062 fi
1064 gcc_no_link="$ac_save_gcc_no_link"
1065 LIBS="$ac_save_LIBS"
1066 CXXFLAGS="$ac_save_CXXFLAGS"
1067 AC_LANG_RESTORE
1068 fi
1070 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1071 AC_MSG_RESULT($enable_c99)
1072 ])
1075 dnl
1076 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1077 dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this]
1078 dnl in the current C++0x working draft.
1079 dnl
1080 dnl --enable-libstdcxx-time
1081 dnl --enable-libstdcxx-time=yes
1082 dnl checks for the availability of monotonic and realtime clocks,
1083 dnl nanosleep and sched_yield in libc and libposix4 and, in case, links
1084 dnl the latter
1085 dnl --enable-libstdcxx-time=rt
1086 dnl also searches (and, in case, links) librt. Note that this is
1087 dnl not always desirable because, in glibc, for example, in turn it
1088 dnl triggers the linking of libpthread too, which activates locking,
1089 dnl a large overhead for single-thread programs.
1090 dnl --enable-libstdcxx-time=no
1091 dnl --disable-libstdcxx-time
1092 dnl disables the checks completely
1093 dnl
1094 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1096 AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1097 GLIBCXX_ENABLE(libstdcxx-time,$1,[=KIND],
1098 [use KIND for check type],
1099 [permit yes|no|rt])
1101 AC_LANG_SAVE
1102 AC_LANG_CPLUSPLUS
1103 ac_save_CXXFLAGS="$CXXFLAGS"
1104 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1105 ac_save_LIBS="$LIBS"
1107 ac_has_clock_monotonic=no;
1108 ac_has_clock_realtime=no;
1110 if test x"$enable_libstdcxx_time" != x"no"; then
1112 if test x"$enable_libstdcxx_time" = x"rt"; then
1113 AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1114 AC_SEARCH_LIBS(nanosleep, [rt posix4])
1115 else
1116 AC_SEARCH_LIBS(clock_gettime, [posix4])
1117 AC_SEARCH_LIBS(nanosleep, [posix4])
1118 fi
1120 case "$ac_cv_search_clock_gettime" in
1121 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1122 ;;
1123 esac
1124 case "$ac_cv_search_nanosleep" in
1125 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1126 ;;
1127 esac
1129 AC_SEARCH_LIBS(sched_yield, [rt posix4])
1131 case "$ac_cv_search_sched_yield" in
1132 -lposix4*)
1133 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1134 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1135 [ Defined if sched_yield is available. ])
1136 ;;
1137 -lrt*)
1138 if test x"$enable_libstdcxx_time" = x"rt"; then
1139 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1140 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1141 [ Defined if sched_yield is available. ])
1142 fi
1143 ;;
1144 *)
1145 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1146 [ Defined if sched_yield is available. ])
1147 ;;
1148 esac
1150 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1152 if test x"$ac_has_unistd_h" = x"yes"; then
1153 AC_MSG_CHECKING([for monotonic clock])
1154 AC_TRY_LINK(
1155 [#include <unistd.h>
1156 #include <time.h>
1157 ],
1158 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1159 timespec tp;
1160 #endif
1161 clock_gettime(CLOCK_MONOTONIC, &tp);
1162 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1164 AC_MSG_RESULT($ac_has_clock_monotonic)
1166 AC_MSG_CHECKING([for realtime clock])
1167 AC_TRY_LINK(
1168 [#include <unistd.h>
1169 #include <time.h>
1170 ],
1171 [#if _POSIX_TIMERS > 0
1172 timespec tp;
1173 #endif
1174 clock_gettime(CLOCK_REALTIME, &tp);
1175 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1177 AC_MSG_RESULT($ac_has_clock_realtime)
1179 AC_MSG_CHECKING([for nanosleep])
1180 AC_TRY_LINK(
1181 [#include <unistd.h>
1182 #include <time.h>
1183 ],
1184 [#if _POSIX_TIMERS > 0
1185 timespec tp;
1186 #endif
1187 nanosleep(&tp, 0);
1188 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1190 AC_MSG_RESULT($ac_has_nanosleep)
1191 fi
1192 fi
1194 if test x"$ac_has_clock_monotonic" = x"yes"; then
1195 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1196 [ Defined if clock_gettime has monotonic clock support. ])
1197 fi
1199 if test x"$ac_has_clock_realtime" = x"yes"; then
1200 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1201 [ Defined if clock_gettime has realtime clock support. ])
1202 fi
1204 if test x"$ac_has_nanosleep" = x"yes"; then
1205 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1206 [ Defined if nanosleep is available. ])
1207 fi
1209 AC_SUBST(GLIBCXX_LIBS)
1211 CXXFLAGS="$ac_save_CXXFLAGS"
1212 LIBS="$ac_save_LIBS"
1213 AC_LANG_RESTORE
1214 ])
1216 dnl
1217 dnl Check for gettimeofday, used in the implementation of 20.8.5
1218 dnl [time.clock] in the current C++0x working draft.
1219 dnl
1220 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1222 AC_MSG_CHECKING([for gettimeofday])
1224 AC_LANG_SAVE
1225 AC_LANG_CPLUSPLUS
1226 ac_save_CXXFLAGS="$CXXFLAGS"
1227 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1229 ac_has_gettimeofday=no;
1230 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1231 if test x"$ac_has_sys_time_h" = x"yes"; then
1232 AC_MSG_CHECKING([for gettimeofday])
1233 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1234 [timeval tv; gettimeofday(&tv, 0);],
1235 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1237 AC_MSG_RESULT($ac_has_gettimeofday)
1238 fi
1240 if test x"$ac_has_gettimeofday" = x"yes"; then
1241 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1242 [ Defined if gettimeofday is available. ])
1243 fi
1245 CXXFLAGS="$ac_save_CXXFLAGS"
1246 AC_LANG_RESTORE
1247 ])
1249 dnl
1250 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1251 dnl facilities in Chapter 8, "C compatibility".
1252 dnl
1253 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1255 AC_LANG_SAVE
1256 AC_LANG_CPLUSPLUS
1258 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1259 # undefined and fake C99 facilities may be spuriously enabled.
1260 ac_save_CXXFLAGS="$CXXFLAGS"
1261 CXXFLAGS="$CXXFLAGS -std=c++98"
1263 # Check for the existence of <complex.h> complex math functions used
1264 # by tr1/complex.
1265 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1266 ac_c99_complex_tr1=no;
1267 if test x"$ac_has_complex_h" = x"yes"; then
1268 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1269 AC_TRY_COMPILE([#include <complex.h>],
1270 [typedef __complex__ float float_type; float_type tmpf;
1271 cacosf(tmpf);
1272 casinf(tmpf);
1273 catanf(tmpf);
1274 cacoshf(tmpf);
1275 casinhf(tmpf);
1276 catanhf(tmpf);
1277 typedef __complex__ double double_type; double_type tmpd;
1278 cacos(tmpd);
1279 casin(tmpd);
1280 catan(tmpd);
1281 cacosh(tmpd);
1282 casinh(tmpd);
1283 catanh(tmpd);
1284 typedef __complex__ long double ld_type; ld_type tmpld;
1285 cacosl(tmpld);
1286 casinl(tmpld);
1287 catanl(tmpld);
1288 cacoshl(tmpld);
1289 casinhl(tmpld);
1290 catanhl(tmpld);
1291 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1292 fi
1293 AC_MSG_RESULT($ac_c99_complex_tr1)
1294 if test x"$ac_c99_complex_tr1" = x"yes"; then
1295 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1296 [Define if C99 functions in <complex.h> should be used in
1297 <tr1/complex>. Using compiler builtins for these functions
1298 requires corresponding C99 library functions to be present.])
1299 fi
1301 # Check for the existence of <ctype.h> functions.
1302 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1303 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1304 AC_TRY_COMPILE([#include <ctype.h>],
1305 [int ch;
1306 int ret;
1307 ret = isblank(ch);
1308 ],[glibcxx_cv_c99_ctype_tr1=yes],
1309 [glibcxx_cv_c99_ctype_tr1=no])
1310 ])
1311 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1312 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1313 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1314 [Define if C99 functions in <ctype.h> should be imported in
1315 <tr1/cctype> in namespace std::tr1.])
1316 fi
1318 # Check for the existence of <fenv.h> functions.
1319 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1320 ac_c99_fenv_tr1=no;
1321 if test x"$ac_has_fenv_h" = x"yes"; then
1322 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1323 AC_TRY_COMPILE([#include <fenv.h>],
1324 [int except, mode;
1325 fexcept_t* pflag;
1326 fenv_t* penv;
1327 int ret;
1328 ret = feclearexcept(except);
1329 ret = fegetexceptflag(pflag, except);
1330 ret = feraiseexcept(except);
1331 ret = fesetexceptflag(pflag, except);
1332 ret = fetestexcept(except);
1333 ret = fegetround();
1334 ret = fesetround(mode);
1335 ret = fegetenv(penv);
1336 ret = feholdexcept(penv);
1337 ret = fesetenv(penv);
1338 ret = feupdateenv(penv);
1339 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1340 fi
1341 AC_MSG_RESULT($ac_c99_fenv_tr1)
1342 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1343 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1344 [Define if C99 functions in <fenv.h> should be imported in
1345 <tr1/cfenv> in namespace std::tr1.])
1346 fi
1348 # Check for the existence of <stdint.h> types.
1349 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1350 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1351 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1352 #define __STDC_CONSTANT_MACROS
1353 #include <stdint.h>],
1354 [typedef int8_t my_int8_t;
1355 my_int8_t i8 = INT8_MIN;
1356 i8 = INT8_MAX;
1357 typedef int16_t my_int16_t;
1358 my_int16_t i16 = INT16_MIN;
1359 i16 = INT16_MAX;
1360 typedef int32_t my_int32_t;
1361 my_int32_t i32 = INT32_MIN;
1362 i32 = INT32_MAX;
1363 typedef int64_t my_int64_t;
1364 my_int64_t i64 = INT64_MIN;
1365 i64 = INT64_MAX;
1366 typedef int_fast8_t my_int_fast8_t;
1367 my_int_fast8_t if8 = INT_FAST8_MIN;
1368 if8 = INT_FAST8_MAX;
1369 typedef int_fast16_t my_int_fast16_t;
1370 my_int_fast16_t if16 = INT_FAST16_MIN;
1371 if16 = INT_FAST16_MAX;
1372 typedef int_fast32_t my_int_fast32_t;
1373 my_int_fast32_t if32 = INT_FAST32_MIN;
1374 if32 = INT_FAST32_MAX;
1375 typedef int_fast64_t my_int_fast64_t;
1376 my_int_fast64_t if64 = INT_FAST64_MIN;
1377 if64 = INT_FAST64_MAX;
1378 typedef int_least8_t my_int_least8_t;
1379 my_int_least8_t il8 = INT_LEAST8_MIN;
1380 il8 = INT_LEAST8_MAX;
1381 typedef int_least16_t my_int_least16_t;
1382 my_int_least16_t il16 = INT_LEAST16_MIN;
1383 il16 = INT_LEAST16_MAX;
1384 typedef int_least32_t my_int_least32_t;
1385 my_int_least32_t il32 = INT_LEAST32_MIN;
1386 il32 = INT_LEAST32_MAX;
1387 typedef int_least64_t my_int_least64_t;
1388 my_int_least64_t il64 = INT_LEAST64_MIN;
1389 il64 = INT_LEAST64_MAX;
1390 typedef intmax_t my_intmax_t;
1391 my_intmax_t im = INTMAX_MAX;
1392 im = INTMAX_MIN;
1393 typedef intptr_t my_intptr_t;
1394 my_intptr_t ip = INTPTR_MAX;
1395 ip = INTPTR_MIN;
1396 typedef uint8_t my_uint8_t;
1397 my_uint8_t ui8 = UINT8_MAX;
1398 ui8 = UINT8_MAX;
1399 typedef uint16_t my_uint16_t;
1400 my_uint16_t ui16 = UINT16_MAX;
1401 ui16 = UINT16_MAX;
1402 typedef uint32_t my_uint32_t;
1403 my_uint32_t ui32 = UINT32_MAX;
1404 ui32 = UINT32_MAX;
1405 typedef uint64_t my_uint64_t;
1406 my_uint64_t ui64 = UINT64_MAX;
1407 ui64 = UINT64_MAX;
1408 typedef uint_fast8_t my_uint_fast8_t;
1409 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1410 uif8 = UINT_FAST8_MAX;
1411 typedef uint_fast16_t my_uint_fast16_t;
1412 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1413 uif16 = UINT_FAST16_MAX;
1414 typedef uint_fast32_t my_uint_fast32_t;
1415 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1416 uif32 = UINT_FAST32_MAX;
1417 typedef uint_fast64_t my_uint_fast64_t;
1418 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1419 uif64 = UINT_FAST64_MAX;
1420 typedef uint_least8_t my_uint_least8_t;
1421 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1422 uil8 = UINT_LEAST8_MAX;
1423 typedef uint_least16_t my_uint_least16_t;
1424 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1425 uil16 = UINT_LEAST16_MAX;
1426 typedef uint_least32_t my_uint_least32_t;
1427 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1428 uil32 = UINT_LEAST32_MAX;
1429 typedef uint_least64_t my_uint_least64_t;
1430 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1431 uil64 = UINT_LEAST64_MAX;
1432 typedef uintmax_t my_uintmax_t;
1433 my_uintmax_t uim = UINTMAX_MAX;
1434 uim = UINTMAX_MAX;
1435 typedef uintptr_t my_uintptr_t;
1436 my_uintptr_t uip = UINTPTR_MAX;
1437 uip = UINTPTR_MAX;
1438 ],[glibcxx_cv_c99_stdint_tr1=yes],
1439 [glibcxx_cv_c99_stdint_tr1=no])
1440 ])
1441 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1442 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1443 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1444 [Define if C99 types in <stdint.h> should be imported in
1445 <tr1/cstdint> in namespace std::tr1.])
1446 fi
1448 # Check for the existence of <math.h> functions.
1449 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1450 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1451 AC_TRY_COMPILE([#include <math.h>],
1452 [typedef double_t my_double_t;
1453 typedef float_t my_float_t;
1454 acosh(0.0);
1455 acoshf(0.0f);
1456 acoshl(0.0l);
1457 asinh(0.0);
1458 asinhf(0.0f);
1459 asinhl(0.0l);
1460 atanh(0.0);
1461 atanhf(0.0f);
1462 atanhl(0.0l);
1463 cbrt(0.0);
1464 cbrtf(0.0f);
1465 cbrtl(0.0l);
1466 copysign(0.0, 0.0);
1467 copysignf(0.0f, 0.0f);
1468 copysignl(0.0l, 0.0l);
1469 erf(0.0);
1470 erff(0.0f);
1471 erfl(0.0l);
1472 erfc(0.0);
1473 erfcf(0.0f);
1474 erfcl(0.0l);
1475 exp2(0.0);
1476 exp2f(0.0f);
1477 exp2l(0.0l);
1478 expm1(0.0);
1479 expm1f(0.0f);
1480 expm1l(0.0l);
1481 fdim(0.0, 0.0);
1482 fdimf(0.0f, 0.0f);
1483 fdiml(0.0l, 0.0l);
1484 fma(0.0, 0.0, 0.0);
1485 fmaf(0.0f, 0.0f, 0.0f);
1486 fmal(0.0l, 0.0l, 0.0l);
1487 fmax(0.0, 0.0);
1488 fmaxf(0.0f, 0.0f);
1489 fmaxl(0.0l, 0.0l);
1490 fmin(0.0, 0.0);
1491 fminf(0.0f, 0.0f);
1492 fminl(0.0l, 0.0l);
1493 hypot(0.0, 0.0);
1494 hypotf(0.0f, 0.0f);
1495 hypotl(0.0l, 0.0l);
1496 ilogb(0.0);
1497 ilogbf(0.0f);
1498 ilogbl(0.0l);
1499 lgamma(0.0);
1500 lgammaf(0.0f);
1501 lgammal(0.0l);
1502 llrint(0.0);
1503 llrintf(0.0f);
1504 llrintl(0.0l);
1505 llround(0.0);
1506 llroundf(0.0f);
1507 llroundl(0.0l);
1508 log1p(0.0);
1509 log1pf(0.0f);
1510 log1pl(0.0l);
1511 log2(0.0);
1512 log2f(0.0f);
1513 log2l(0.0l);
1514 logb(0.0);
1515 logbf(0.0f);
1516 logbl(0.0l);
1517 lrint(0.0);
1518 lrintf(0.0f);
1519 lrintl(0.0l);
1520 lround(0.0);
1521 lroundf(0.0f);
1522 lroundl(0.0l);
1523 nan(0);
1524 nanf(0);
1525 nanl(0);
1526 nearbyint(0.0);
1527 nearbyintf(0.0f);
1528 nearbyintl(0.0l);
1529 nextafter(0.0, 0.0);
1530 nextafterf(0.0f, 0.0f);
1531 nextafterl(0.0l, 0.0l);
1532 nexttoward(0.0, 0.0);
1533 nexttowardf(0.0f, 0.0f);
1534 nexttowardl(0.0l, 0.0l);
1535 remainder(0.0, 0.0);
1536 remainderf(0.0f, 0.0f);
1537 remainderl(0.0l, 0.0l);
1538 remquo(0.0, 0.0, 0);
1539 remquof(0.0f, 0.0f, 0);
1540 remquol(0.0l, 0.0l, 0);
1541 rint(0.0);
1542 rintf(0.0f);
1543 rintl(0.0l);
1544 round(0.0);
1545 roundf(0.0f);
1546 roundl(0.0l);
1547 scalbln(0.0, 0l);
1548 scalblnf(0.0f, 0l);
1549 scalblnl(0.0l, 0l);
1550 scalbn(0.0, 0);
1551 scalbnf(0.0f, 0);
1552 scalbnl(0.0l, 0);
1553 tgamma(0.0);
1554 tgammaf(0.0f);
1555 tgammal(0.0l);
1556 trunc(0.0);
1557 truncf(0.0f);
1558 truncl(0.0l);
1559 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1560 ])
1561 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1562 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1563 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1564 [Define if C99 functions or macros in <math.h> should be imported
1565 in <tr1/cmath> in namespace std::tr1.])
1566 fi
1568 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1569 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1570 ac_c99_inttypes_tr1=no;
1571 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1572 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1573 AC_TRY_COMPILE([#include <inttypes.h>],
1574 [intmax_t i, numer, denom, base;
1575 const char* s;
1576 char** endptr;
1577 intmax_t ret = imaxabs(i);
1578 imaxdiv_t dret = imaxdiv(numer, denom);
1579 ret = strtoimax(s, endptr, base);
1580 uintmax_t uret = strtoumax(s, endptr, base);
1581 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1582 fi
1583 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1584 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1585 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1586 [Define if C99 functions in <inttypes.h> should be imported in
1587 <tr1/cinttypes> in namespace std::tr1.])
1588 fi
1590 # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1591 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1592 ac_c99_inttypes_wchar_t_tr1=no;
1593 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1594 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1595 AC_TRY_COMPILE([#include <inttypes.h>],
1596 [intmax_t base;
1597 const wchar_t* s;
1598 wchar_t** endptr;
1599 intmax_t ret = wcstoimax(s, endptr, base);
1600 uintmax_t uret = wcstoumax(s, endptr, base);
1601 ],[ac_c99_inttypes_wchar_t_tr1=yes],
1602 [ac_c99_inttypes_wchar_t_tr1=no])
1603 fi
1604 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1605 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1606 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1607 [Define if wchar_t C99 functions in <inttypes.h> should be
1608 imported in <tr1/cinttypes> in namespace std::tr1.])
1609 fi
1611 # Check for the existence of the <stdbool.h> header.
1612 AC_CHECK_HEADERS(stdbool.h)
1614 CXXFLAGS="$ac_save_CXXFLAGS"
1615 AC_LANG_RESTORE
1616 ])
1618 dnl
1619 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1620 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1621 dnl
1622 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1624 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1625 AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1626 if test -r /dev/random && test -r /dev/urandom; then
1627 glibcxx_cv_random_tr1=yes;
1628 else
1629 glibcxx_cv_random_tr1=no;
1630 fi
1631 ])
1632 AC_MSG_RESULT($glibcxx_cv_random_tr1)
1634 if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1635 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1636 [Define if /dev/random and /dev/urandom are available for
1637 the random_device of TR1 (Chapter 5.1).])
1638 fi
1640 ])
1642 dnl
1643 dnl Check whether EOF, SEEK_CUR, and SEEK_END have the most common values:
1644 dnl in that case including <cstdio> in some C++ headers can be avoided.
1645 dnl
1646 AC_DEFUN([GLIBCXX_CHECK_STDIO_MACROS], [
1648 AC_MSG_CHECKING([for EOF == -1, SEEK_CUR == 1, SEEK_END == 2])
1649 AC_CACHE_VAL(glibcxx_cv_stdio_macros, [
1650 AC_TRY_COMPILE([#include <stdio.h>],
1651 [#if ((EOF != -1) || (SEEK_CUR != 1) || (SEEK_END != 2))
1652 unusual values...
1653 #endif
1654 ], [glibcxx_cv_stdio_macros=yes],
1655 [glibcxx_cv_stdio_macros=no])
1656 ])
1657 AC_MSG_RESULT($glibcxx_cv_stdio_macros)
1658 if test x"$glibcxx_cv_stdio_macros" = x"yes"; then
1659 AC_DEFINE(_GLIBCXX_STDIO_MACROS, 1,
1660 [Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2.])
1661 fi
1663 ])
1665 dnl
1666 dnl Check whether macros, etc are present for <system_error>
1667 dnl
1668 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1670 m4_pushdef([n_syserr], [1])dnl
1671 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1672 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1673 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY],
1674 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1675 AC_MSG_CHECKING([for syserr])
1676 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1677 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1678 [int i = syserr;])],
1679 [glibcxx_cv_system_error[]n_syserr=yes],
1680 [glibcxx_cv_system_error[]n_syserr=no])
1681 ])
1682 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1683 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1684 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1685 fi
1686 m4_define([n_syserr], m4_incr(n_syserr))dnl
1687 m4_popdef([SYSERR])dnl
1688 ])
1689 m4_popdef([n_syserr])dnl
1690 ])
1692 dnl
1693 dnl Check for what type of C headers to use.
1694 dnl
1695 dnl --enable-cheaders= [does stuff].
1696 dnl --disable-cheaders [does not do anything, really].
1697 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1698 dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1699 dnl
1700 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1701 GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1702 [construct "C" headers for g++], [permit c|c_std|c_global])
1703 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1705 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1707 # Allow overrides to configure.host here.
1708 if test $enable_cheaders = c_global; then
1709 c_compatibility=yes
1710 fi
1712 if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1713 c_extra=yes
1714 fi
1716 AC_SUBST(C_INCLUDE_DIR)
1717 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1718 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1719 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1720 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1721 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1722 ])
1725 dnl
1726 dnl Check for which locale library to use. The choice is mapped to
1727 dnl a subdirectory of config/locale.
1728 dnl
1729 dnl Default is generic.
1730 dnl
1731 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1732 GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1733 [use MODEL for target locale package],
1734 [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1736 # Deal with gettext issues. Default to not using it (=no) until we detect
1737 # support for it later. Let the user turn it off via --e/d, but let that
1738 # default to on for easier handling.
1739 USE_NLS=no
1740 AC_ARG_ENABLE(nls,
1741 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1742 [],
1743 [enable_nls=yes])
1745 # Either a known packaage, or "auto"
1746 if test $enable_clocale = no || test $enable_clocale = yes; then
1747 enable_clocale=auto
1748 fi
1749 enable_clocale_flag=$enable_clocale
1751 # Probe for locale model to use if none specified.
1752 # Default to "generic".
1753 if test $enable_clocale_flag = auto; then
1754 case ${target_os} in
1755 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1756 enable_clocale_flag=gnu
1757 ;;
1758 darwin* | freebsd*)
1759 enable_clocale_flag=darwin
1760 ;;
1761 *)
1762 enable_clocale_flag=generic
1763 ;;
1764 esac
1765 fi
1767 # Sanity check model, and test for special functionality.
1768 if test $enable_clocale_flag = gnu; then
1769 AC_EGREP_CPP([_GLIBCXX_ok], [
1770 #include <features.h>
1771 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1772 _GLIBCXX_ok
1773 #endif
1774 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1776 if test $enable_clocale = auto; then
1777 # Test for bugs early in glibc-2.2.x series
1778 AC_TRY_RUN([
1779 #define _GNU_SOURCE 1
1780 #include <locale.h>
1781 #include <string.h>
1782 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1783 extern __typeof(newlocale) __newlocale;
1784 extern __typeof(duplocale) __duplocale;
1785 extern __typeof(strcoll_l) __strcoll_l;
1786 #endif
1787 int main()
1788 {
1789 const char __one[] = "Äuglein Augmen";
1790 const char __two[] = "Äuglein";
1791 int i;
1792 int j;
1793 __locale_t loc;
1794 __locale_t loc_dup;
1795 loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1796 loc_dup = __duplocale(loc);
1797 i = __strcoll_l(__one, __two, loc);
1798 j = __strcoll_l(__one, __two, loc_dup);
1799 return 0;
1800 }
1801 ],
1802 [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1803 [enable_clocale_flag=generic])
1804 fi
1806 # Set it to scream when it hurts.
1807 ac_save_CFLAGS="$CFLAGS"
1808 CFLAGS="-Wimplicit-function-declaration -Werror"
1810 # Use strxfrm_l if available.
1811 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1812 #include <string.h>
1813 #include <locale.h>],
1814 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1815 AC_DEFINE(HAVE_STRXFRM_L, 1,
1816 [Define if strxfrm_l is available in <string.h>.]),)
1818 # Use strerror_l if available.
1819 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1820 #include <string.h>
1821 #include <locale.h>],
1822 [__locale_t loc; strerror_l(5, loc);],
1823 AC_DEFINE(HAVE_STRERROR_L, 1,
1824 [Define if strerror_l is available in <string.h>.]),)
1826 CFLAGS="$ac_save_CFLAGS"
1827 fi
1829 # Perhaps use strerror_r if available, and strerror_l isn't.
1830 ac_save_CFLAGS="$CFLAGS"
1831 CFLAGS="-Wimplicit-function-declaration -Werror"
1832 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1833 #include <string.h>
1834 #include <locale.h>],
1835 [char s[128]; strerror_r(5, s, 128);],
1836 AC_DEFINE(HAVE_STRERROR_R, 1,
1837 [Define if strerror_r is available in <string.h>.]),)
1838 CFLAGS="$ac_save_CFLAGS"
1840 # Set configure bits for specified locale package
1841 AC_MSG_CHECKING([for C locale to use])
1842 case ${enable_clocale_flag} in
1843 generic)
1844 AC_MSG_RESULT(generic)
1846 CLOCALE_H=config/locale/generic/c_locale.h
1847 CLOCALE_CC=config/locale/generic/c_locale.cc
1848 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1849 CCOLLATE_CC=config/locale/generic/collate_members.cc
1850 CCTYPE_CC=config/locale/generic/ctype_members.cc
1851 CMESSAGES_H=config/locale/generic/messages_members.h
1852 CMESSAGES_CC=config/locale/generic/messages_members.cc
1853 CMONEY_CC=config/locale/generic/monetary_members.cc
1854 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1855 CTIME_H=config/locale/generic/time_members.h
1856 CTIME_CC=config/locale/generic/time_members.cc
1857 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1858 ;;
1859 darwin)
1860 AC_MSG_RESULT(darwin or freebsd)
1862 CLOCALE_H=config/locale/generic/c_locale.h
1863 CLOCALE_CC=config/locale/generic/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/darwin/ctype_members.cc
1867 CMESSAGES_H=config/locale/generic/messages_members.h
1868 CMESSAGES_CC=config/locale/generic/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
1874 ;;
1876 gnu)
1877 AC_MSG_RESULT(gnu)
1879 # Declare intention to use gettext, and add support for specific
1880 # languages.
1881 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1882 ALL_LINGUAS="de fr"
1884 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1885 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1886 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1887 USE_NLS=yes
1888 fi
1889 # Export the build objects.
1890 for ling in $ALL_LINGUAS; do \
1891 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1892 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1893 done
1894 AC_SUBST(glibcxx_MOFILES)
1895 AC_SUBST(glibcxx_POFILES)
1897 CLOCALE_H=config/locale/gnu/c_locale.h
1898 CLOCALE_CC=config/locale/gnu/c_locale.cc
1899 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1900 CCOLLATE_CC=config/locale/gnu/collate_members.cc
1901 CCTYPE_CC=config/locale/gnu/ctype_members.cc
1902 CMESSAGES_H=config/locale/gnu/messages_members.h
1903 CMESSAGES_CC=config/locale/gnu/messages_members.cc
1904 CMONEY_CC=config/locale/gnu/monetary_members.cc
1905 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1906 CTIME_H=config/locale/gnu/time_members.h
1907 CTIME_CC=config/locale/gnu/time_members.cc
1908 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1909 ;;
1910 ieee_1003.1-2001)
1911 AC_MSG_RESULT(IEEE 1003.1)
1913 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1914 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1915 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1916 CCOLLATE_CC=config/locale/generic/collate_members.cc
1917 CCTYPE_CC=config/locale/generic/ctype_members.cc
1918 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1919 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1920 CMONEY_CC=config/locale/generic/monetary_members.cc
1921 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1922 CTIME_H=config/locale/generic/time_members.h
1923 CTIME_CC=config/locale/generic/time_members.cc
1924 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1925 ;;
1926 esac
1928 # This is where the testsuite looks for locale catalogs, using the
1929 # -DLOCALEDIR define during testsuite compilation.
1930 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1931 AC_SUBST(glibcxx_localedir)
1933 # A standalone libintl (e.g., GNU libintl) may be in use.
1934 if test $USE_NLS = yes; then
1935 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1936 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1937 fi
1938 if test $USE_NLS = yes; then
1939 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
1940 [Define if NLS translations are to be used.])
1941 fi
1943 AC_SUBST(USE_NLS)
1944 AC_SUBST(CLOCALE_H)
1945 AC_SUBST(CMESSAGES_H)
1946 AC_SUBST(CCODECVT_CC)
1947 AC_SUBST(CCOLLATE_CC)
1948 AC_SUBST(CCTYPE_CC)
1949 AC_SUBST(CMESSAGES_CC)
1950 AC_SUBST(CMONEY_CC)
1951 AC_SUBST(CNUMERIC_CC)
1952 AC_SUBST(CTIME_H)
1953 AC_SUBST(CTIME_CC)
1954 AC_SUBST(CLOCALE_CC)
1955 AC_SUBST(CLOCALE_INTERNAL_H)
1956 ])
1959 dnl
1960 dnl Check for which std::allocator base class to use. The choice is
1961 dnl mapped from a subdirectory of include/ext.
1962 dnl
1963 dnl Default is new.
1964 dnl
1965 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1966 AC_MSG_CHECKING([for std::allocator base class])
1967 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1968 [use KIND for target std::allocator base],
1969 [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1971 # If they didn't use this option switch, or if they specified --enable
1972 # with no specific model, we'll have to look for one. If they
1973 # specified --disable (???), do likewise.
1974 if test $enable_libstdcxx_allocator = no ||
1975 test $enable_libstdcxx_allocator = yes;
1976 then
1977 enable_libstdcxx_allocator=auto
1978 fi
1980 # Either a known package, or "auto". Auto implies the default choice
1981 # for a particular platform.
1982 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1984 # Probe for host-specific support if no specific model is specified.
1985 # Default to "new".
1986 if test $enable_libstdcxx_allocator_flag = auto; then
1987 case ${target_os} in
1988 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1989 enable_libstdcxx_allocator_flag=new
1990 ;;
1991 *)
1992 enable_libstdcxx_allocator_flag=new
1993 ;;
1994 esac
1995 fi
1996 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1999 # Set configure bits for specified locale package
2000 case ${enable_libstdcxx_allocator_flag} in
2001 bitmap)
2002 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2003 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2004 ;;
2005 malloc)
2006 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2007 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2008 ;;
2009 mt)
2010 ALLOCATOR_H=config/allocator/mt_allocator_base.h
2011 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2012 ;;
2013 new)
2014 ALLOCATOR_H=config/allocator/new_allocator_base.h
2015 ALLOCATOR_NAME=__gnu_cxx::new_allocator
2016 ;;
2017 pool)
2018 ALLOCATOR_H=config/allocator/pool_allocator_base.h
2019 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2020 ;;
2021 esac
2023 AC_SUBST(ALLOCATOR_H)
2024 AC_SUBST(ALLOCATOR_NAME)
2025 ])
2028 dnl
2029 dnl Check for whether the Boost-derived checks should be turned on.
2030 dnl
2031 dnl --enable-concept-checks turns them on.
2032 dnl --disable-concept-checks leaves them off.
2033 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2034 dnl Where DEFAULT is either `yes' or `no'.
2035 dnl
2036 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2037 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2038 if test $enable_concept_checks = yes; then
2039 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2040 [Define to use concept checking code from the boost libraries.])
2041 fi
2042 ])
2044 dnl
2045 dnl Check for parallel mode pre-requisites, including OpenMP support.
2046 dnl
2047 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
2048 dnl
2049 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2051 enable_parallel=no;
2053 # See if configured libgomp/omp.h exists. (libgomp may be in
2054 # noconfigdirs but not explicitly disabled.)
2055 if test -f $glibcxx_builddir/../libgomp/omp.h; then
2056 enable_parallel=yes;
2057 else
2058 AC_MSG_NOTICE([$glibcxx_builddir/../libgomp/omp.h not found])
2059 fi
2061 AC_MSG_CHECKING([for parallel mode support])
2062 AC_MSG_RESULT([$enable_parallel])
2063 GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2064 ])
2067 dnl
2068 dnl Check for which I/O library to use: stdio, or something specific.
2069 dnl
2070 dnl Default is stdio.
2071 dnl
2072 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2073 AC_MSG_CHECKING([for underlying I/O to use])
2074 GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
2075 [use target-specific I/O package], [permit stdio])
2077 # Now that libio has been removed, you can have any color you want as long
2078 # as it's black. This is one big no-op until other packages are added, but
2079 # showing the framework never hurts.
2080 case ${enable_cstdio} in
2081 stdio)
2082 CSTDIO_H=config/io/c_io_stdio.h
2083 BASIC_FILE_H=config/io/basic_file_stdio.h
2084 BASIC_FILE_CC=config/io/basic_file_stdio.cc
2085 AC_MSG_RESULT(stdio)
2086 ;;
2087 esac
2089 AC_SUBST(CSTDIO_H)
2090 AC_SUBST(BASIC_FILE_H)
2091 AC_SUBST(BASIC_FILE_CC)
2092 ])
2095 dnl
2096 dnl Check for "unusual" flags to pass to the compiler while building.
2097 dnl
2098 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2099 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2100 dnl --disable-cxx-flags passes nothing.
2101 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2102 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2103 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2104 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2105 dnl If "default flags" is an empty string, the effect is the same
2106 dnl as --disable or --enable=no.
2107 dnl
2108 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2109 AC_MSG_CHECKING([for extra compiler flags for building])
2110 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2111 [pass compiler FLAGS when building library],
2112 [case "x$enable_cxx_flags" in
2113 xno | x) enable_cxx_flags= ;;
2114 x-*) ;;
2115 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2116 esac])
2118 # Run through flags (either default or command-line) and set anything
2119 # extra (e.g., #defines) that must accompany particular g++ options.
2120 if test -n "$enable_cxx_flags"; then
2121 for f in $enable_cxx_flags; do
2122 case "$f" in
2123 -fhonor-std) ;;
2124 -*) ;;
2125 *) # and we're trying to pass /what/ exactly?
2126 AC_MSG_ERROR([compiler flags start with a -]) ;;
2127 esac
2128 done
2129 fi
2131 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2132 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2133 AC_SUBST(EXTRA_CXX_FLAGS)
2134 ])
2137 dnl
2138 dnl Check to see if debugging libraries are to be built.
2139 dnl
2140 dnl --enable-libstdcxx-debug
2141 dnl builds a separate set of debugging libraries in addition to the
2142 dnl normal (shared, static) libstdc++ binaries.
2143 dnl
2144 dnl --disable-libstdcxx-debug
2145 dnl builds only one (non-debug) version of libstdc++.
2146 dnl
2147 dnl --enable-libstdcxx-debug-flags=FLAGS
2148 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2149 dnl
2150 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2151 dnl Where DEFAULT is either `yes' or `no'.
2152 dnl
2153 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2154 AC_MSG_CHECKING([for additional debug build])
2155 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2156 AC_MSG_RESULT($enable_libstdcxx_debug)
2157 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2158 ])
2161 dnl
2162 dnl Check for explicit debug flags.
2163 dnl
2164 dnl --enable-libstdcxx-debug-flags='-O1'
2165 dnl is a general method for passing flags to be used when
2166 dnl building debug libraries with --enable-debug.
2167 dnl
2168 dnl --disable-libstdcxx-debug-flags does nothing.
2169 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2170 dnl If "default flags" is an empty string, the effect is the same
2171 dnl as --disable or --enable=no.
2172 dnl
2173 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2174 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2175 [pass compiler FLAGS when building debug library],
2176 [case "x$enable_libstdcxx_debug_flags" in
2177 xno | x) enable_libstdcxx_debug_flags= ;;
2178 x-*) ;;
2179 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2180 esac])
2182 # Option parsed, now set things appropriately
2183 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2184 AC_SUBST(DEBUG_FLAGS)
2186 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2187 ])
2190 dnl
2191 dnl Check if the user only wants a freestanding library implementation.
2192 dnl
2193 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2194 dnl installing only the headers required by [17.4.1.3] and the language
2195 dnl support library. More than that will be built (to keep the Makefiles
2196 dnl conveniently clean), but not installed.
2197 dnl
2198 dnl Sets:
2199 dnl is_hosted (yes/no)
2200 dnl
2201 dnl Defines:
2202 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
2203 dnl
2204 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2205 AC_ARG_ENABLE([hosted-libstdcxx],
2206 AC_HELP_STRING([--disable-hosted-libstdcxx],
2207 [only build freestanding C++ runtime support]),,
2208 [case "$host" in
2209 arm*-*-symbianelf*)
2210 enable_hosted_libstdcxx=no
2211 ;;
2212 *)
2213 enable_hosted_libstdcxx=yes
2214 ;;
2215 esac])
2216 if test "$enable_hosted_libstdcxx" = no; then
2217 AC_MSG_NOTICE([Only freestanding libraries will be built])
2218 is_hosted=no
2219 hosted_define=0
2220 enable_abi_check=no
2221 enable_libstdcxx_pch=no
2222 else
2223 is_hosted=yes
2224 hosted_define=1
2225 fi
2226 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2227 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2228 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2229 ])
2232 dnl
2233 dnl Check for template specializations for the 'long long' type.
2234 dnl The result determines only whether 'long long' I/O is enabled; things
2235 dnl like numeric_limits<> specializations are always available.
2236 dnl
2237 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2238 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2239 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2240 dnl Where DEFAULT is either `yes' or `no'.
2241 dnl
2242 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2243 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2244 if test $enable_long_long = yes; then
2245 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2246 [Define if code specialized for long long should be used.])
2247 fi
2248 AC_MSG_CHECKING([for enabled long long specializations])
2249 AC_MSG_RESULT([$enable_long_long])
2250 ])
2253 dnl
2254 dnl Check for template specializations for the 'wchar_t' type.
2255 dnl
2256 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2257 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2258 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2259 dnl Where DEFAULT is either `yes' or `no'.
2260 dnl
2261 dnl Necessary support must also be present.
2262 dnl
2263 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2264 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2266 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2267 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2268 AC_MSG_CHECKING([for mbstate_t])
2269 AC_TRY_COMPILE([#include <wchar.h>],
2270 [mbstate_t teststate;],
2271 have_mbstate_t=yes, have_mbstate_t=no)
2272 AC_MSG_RESULT($have_mbstate_t)
2273 if test x"$have_mbstate_t" = xyes; then
2274 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2275 fi
2277 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2278 # ac_has_wchar_h.
2279 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2281 if test x"$enable_wchar_t" = x"yes"; then
2283 AC_LANG_SAVE
2284 AC_LANG_CPLUSPLUS
2286 if test x"$ac_has_wchar_h" = xyes &&
2287 test x"$ac_has_wctype_h" = xyes; then
2288 AC_TRY_COMPILE([#include <wchar.h>
2289 #include <stddef.h>
2290 wint_t i;
2291 long l = WEOF;
2292 long j = WCHAR_MIN;
2293 long k = WCHAR_MAX;
2294 namespace test
2295 {
2296 using ::btowc;
2297 using ::fgetwc;
2298 using ::fgetws;
2299 using ::fputwc;
2300 using ::fputws;
2301 using ::fwide;
2302 using ::fwprintf;
2303 using ::fwscanf;
2304 using ::getwc;
2305 using ::getwchar;
2306 using ::mbrlen;
2307 using ::mbrtowc;
2308 using ::mbsinit;
2309 using ::mbsrtowcs;
2310 using ::putwc;
2311 using ::putwchar;
2312 using ::swprintf;
2313 using ::swscanf;
2314 using ::ungetwc;
2315 using ::vfwprintf;
2316 using ::vswprintf;
2317 using ::vwprintf;
2318 using ::wcrtomb;
2319 using ::wcscat;
2320 using ::wcschr;
2321 using ::wcscmp;
2322 using ::wcscoll;
2323 using ::wcscpy;
2324 using ::wcscspn;
2325 using ::wcsftime;
2326 using ::wcslen;
2327 using ::wcsncat;
2328 using ::wcsncmp;
2329 using ::wcsncpy;
2330 using ::wcspbrk;
2331 using ::wcsrchr;
2332 using ::wcsrtombs;
2333 using ::wcsspn;
2334 using ::wcsstr;
2335 using ::wcstod;
2336 using ::wcstok;
2337 using ::wcstol;
2338 using ::wcstoul;
2339 using ::wcsxfrm;
2340 using ::wctob;
2341 using ::wmemchr;
2342 using ::wmemcmp;
2343 using ::wmemcpy;
2344 using ::wmemmove;
2345 using ::wmemset;
2346 using ::wprintf;
2347 using ::wscanf;
2348 }
2349 ],[],[], [enable_wchar_t=no])
2350 else
2351 enable_wchar_t=no
2352 fi
2354 AC_LANG_RESTORE
2355 fi
2357 if test x"$enable_wchar_t" = x"yes"; then
2358 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2359 [Define if code specialized for wchar_t should be used.])
2360 fi
2362 AC_MSG_CHECKING([for enabled wchar_t specializations])
2363 AC_MSG_RESULT([$enable_wchar_t])
2364 ])
2367 dnl
2368 dnl Check to see if building and using a C++ precompiled header can be done.
2369 dnl
2370 dnl --enable-libstdcxx-pch=yes
2371 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2372 dnl may work, after some light-hearted attempts to puzzle out compiler
2373 dnl support, flip bits on in include/Makefile.am
2374 dnl
2375 dnl --disable-libstdcxx-pch
2376 dnl turns off attempts to use or build stdc++.h.gch.
2377 dnl
2378 dnl Substs:
2379 dnl glibcxx_PCHFLAGS
2380 dnl
2381 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2382 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2383 if test $enable_libstdcxx_pch = yes; then
2384 AC_CACHE_CHECK([for compiler with PCH support],
2385 [glibcxx_cv_prog_CXX_pch],
2386 [ac_save_CXXFLAGS="$CXXFLAGS"
2387 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2388 AC_LANG_SAVE
2389 AC_LANG_CPLUSPLUS
2390 echo '#include <math.h>' > conftest.h
2391 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2392 -o conftest.h.gch 1>&5 2>&1 &&
2393 echo '#error "pch failed"' > conftest.h &&
2394 echo '#include "conftest.h"' > conftest.cc &&
2395 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2396 then
2397 glibcxx_cv_prog_CXX_pch=yes
2398 else
2399 glibcxx_cv_prog_CXX_pch=no
2400 fi
2401 rm -f conftest*
2402 CXXFLAGS=$ac_save_CXXFLAGS
2403 AC_LANG_RESTORE
2404 ])
2405 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2406 fi
2408 AC_MSG_CHECKING([for enabled PCH])
2409 AC_MSG_RESULT([$enable_libstdcxx_pch])
2411 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2412 if test $enable_libstdcxx_pch = yes; then
2413 glibcxx_PCHFLAGS="-include bits/stdc++.h"
2414 else
2415 glibcxx_PCHFLAGS=""
2416 fi
2417 AC_SUBST(glibcxx_PCHFLAGS)
2418 ])
2421 dnl
2422 dnl Check for atomic builtins.
2423 dnl See:
2424 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2425 dnl
2426 dnl This checks to see if the host supports the compiler-generated
2427 dnl builtins for atomic operations for various integral sizes. Note, this
2428 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2429 dnl that are used should be checked.
2430 dnl
2431 dnl Note:
2432 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
2433 dnl see: CHECK_SYNC_FETCH_AND_ADD
2434 dnl
2435 dnl Defines:
2436 dnl _GLIBCXX_ATOMIC_BUILTINS_1
2437 dnl _GLIBCXX_ATOMIC_BUILTINS_2
2438 dnl _GLIBCXX_ATOMIC_BUILTINS_4
2439 dnl _GLIBCXX_ATOMIC_BUILTINS_8
2440 dnl
2441 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2442 AC_LANG_SAVE
2443 AC_LANG_CPLUSPLUS
2444 old_CXXFLAGS="$CXXFLAGS"
2446 # Compile unoptimized.
2447 CXXFLAGS='-O0 -S'
2449 # Fake what AC_TRY_COMPILE does, without linking as this is
2450 # unnecessary for a builtins test.
2452 cat > conftest.$ac_ext << EOF
2453 [#]line __oline__ "configure"
2454 int main()
2455 {
2456 typedef bool atomic_type;
2457 atomic_type c1;
2458 atomic_type c2;
2459 const atomic_type c3(0);
2460 __sync_fetch_and_add(&c1, c2);
2461 __sync_val_compare_and_swap(&c1, c3, c2);
2462 __sync_lock_test_and_set(&c1, c3);
2463 __sync_lock_release(&c1);
2464 __sync_synchronize();
2465 return 0;
2466 }
2467 EOF
2469 AC_MSG_CHECKING([for atomic builtins for bool])
2470 if AC_TRY_EVAL(ac_compile); then
2471 if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2472 enable_atomic_builtinsb=no
2473 else
2474 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2475 [Define if builtin atomic operations for bool are supported on this host.])
2476 enable_atomic_builtinsb=yes
2477 fi
2478 fi
2479 AC_MSG_RESULT($enable_atomic_builtinsb)
2480 rm -f conftest*
2482 cat > conftest.$ac_ext << EOF
2483 [#]line __oline__ "configure"
2484 int main()
2485 {
2486 typedef short atomic_type;
2487 atomic_type c1;
2488 atomic_type c2;
2489 const atomic_type c3(0);
2490 __sync_fetch_and_add(&c1, c2);
2491 __sync_val_compare_and_swap(&c1, c3, c2);
2492 __sync_lock_test_and_set(&c1, c3);
2493 __sync_lock_release(&c1);
2494 __sync_synchronize();
2495 return 0;
2496 }
2497 EOF
2499 AC_MSG_CHECKING([for atomic builtins for short])
2500 if AC_TRY_EVAL(ac_compile); then
2501 if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2502 enable_atomic_builtinss=no
2503 else
2504 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1,
2505 [Define if builtin atomic operations for short are supported on this host.])
2506 enable_atomic_builtinss=yes
2507 fi
2508 fi
2509 AC_MSG_RESULT($enable_atomic_builtinss)
2510 rm -f conftest*
2512 cat > conftest.$ac_ext << EOF
2513 [#]line __oline__ "configure"
2514 int main()
2515 {
2516 // NB: _Atomic_word not necessarily int.
2517 typedef int atomic_type;
2518 atomic_type c1;
2519 atomic_type c2;
2520 const atomic_type c3(0);
2521 __sync_fetch_and_add(&c1, c2);
2522 __sync_val_compare_and_swap(&c1, c3, c2);
2523 __sync_lock_test_and_set(&c1, c3);
2524 __sync_lock_release(&c1);
2525 __sync_synchronize();
2526 return 0;
2527 }
2528 EOF
2530 AC_MSG_CHECKING([for atomic builtins for int])
2531 if AC_TRY_EVAL(ac_compile); then
2532 if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2533 enable_atomic_builtinsi=no
2534 else
2535 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2536 [Define if builtin atomic operations for int are supported on this host.])
2537 enable_atomic_builtinsi=yes
2538 fi
2539 fi
2540 AC_MSG_RESULT($enable_atomic_builtinsi)
2541 rm -f conftest*
2543 cat > conftest.$ac_ext << EOF
2544 [#]line __oline__ "configure"
2545 int main()
2546 {
2547 typedef long long atomic_type;
2548 atomic_type c1;
2549 atomic_type c2;
2550 const atomic_type c3(0);
2551 __sync_fetch_and_add(&c1, c2);
2552 __sync_val_compare_and_swap(&c1, c3, c2);
2553 __sync_lock_test_and_set(&c1, c3);
2554 __sync_lock_release(&c1);
2555 __sync_synchronize();
2556 return 0;
2557 }
2558 EOF
2560 AC_MSG_CHECKING([for atomic builtins for long long])
2561 if AC_TRY_EVAL(ac_compile); then
2562 if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2563 enable_atomic_builtinsll=no
2564 else
2565 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1,
2566 [Define if builtin atomic operations for long long are supported on this host.])
2567 enable_atomic_builtinsll=yes
2568 fi
2569 fi
2570 AC_MSG_RESULT($enable_atomic_builtinsll)
2571 rm -f conftest*
2574 CXXFLAGS="$old_CXXFLAGS"
2575 AC_LANG_RESTORE
2577 # Set atomicity_dir to builtins if either of above tests pass.
2578 if test $enable_atomic_builtinsi = yes || test $enable_atomic_builtinsb = yes ; then
2579 atomicity_dir=cpu/generic/atomicity_builtins
2580 fi
2582 # If still generic, set to mutex.
2583 if test $atomicity_dir = "cpu/generic" ; then
2584 atomicity_dir=cpu/generic/atomicity_mutex
2585 AC_MSG_WARN([No native atomic operations are provided for this platform.])
2586 if test "x$target_thread_file" = xsingle; then
2587 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2588 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2589 else
2590 AC_MSG_WARN([They will be faked using a mutex.])
2591 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2592 fi
2593 fi
2595 ])
2598 dnl
2599 dnl Check for exception handling support. If an explicit enable/disable
2600 dnl sjlj exceptions is given, we don't have to detect. Otherwise the
2601 dnl target may or may not support call frame exceptions.
2602 dnl
2603 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2604 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2605 dnl Neither one forces an attempt at detection.
2606 dnl
2607 dnl Defines:
2608 dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2609 dnl
2610 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2611 AC_MSG_CHECKING([for exception model to use])
2612 AC_LANG_SAVE
2613 AC_LANG_CPLUSPLUS
2614 GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2615 [force use of builtin_setjmp for exceptions],
2616 [permit yes|no|auto])
2618 if test $enable_sjlj_exceptions = auto; then
2619 # Botheration. Now we've got to detect the exception model. Link tests
2620 # against libgcc.a are problematic since we've not been given proper -L
2621 # bits for single-tree newlib and libgloss.
2622 #
2623 # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style.
2624 cat > conftest.$ac_ext << EOF
2625 [#]line __oline__ "configure"
2626 struct S { ~S(); };
2627 void bar();
2628 void foo()
2629 {
2630 S s;
2631 bar();
2632 }
2633 EOF
2634 old_CXXFLAGS="$CXXFLAGS"
2635 CXXFLAGS=-S
2636 if AC_TRY_EVAL(ac_compile); then
2637 if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2638 enable_sjlj_exceptions=yes
2639 elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2640 enable_sjlj_exceptions=no
2641 elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2642 enable_sjlj_exceptions=no
2643 fi
2644 fi
2645 CXXFLAGS="$old_CXXFLAGS"
2646 rm -f conftest*
2647 fi
2649 # This is a tad weird, for hysterical raisins. We have to map
2650 # enable/disable to two different models.
2651 case $enable_sjlj_exceptions in
2652 yes)
2653 AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2654 [Define if the compiler is configured for setjmp/longjmp exceptions.])
2655 ac_exception_model_name=sjlj
2656 ;;
2657 no)
2658 ac_exception_model_name="call frame"
2659 ;;
2660 *)
2661 AC_MSG_ERROR([unable to detect exception model])
2662 ;;
2663 esac
2664 AC_LANG_RESTORE
2665 AC_MSG_RESULT($ac_exception_model_name)
2666 ])
2669 dnl
2670 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2671 dnl
2672 dnl --enable-visibility enables attempt to use visibility attributes.
2673 dnl --disable-visibility turns off all use of visibility attributes.
2674 dnl + Usage: GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2675 dnl Where DEFAULT is 'yes'.
2676 dnl
2677 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2678 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2680 if test x$enable_visibility = xyes ; then
2681 dnl all hail libgfortran
2682 dnl Check whether the target supports hidden visibility.
2683 AC_CACHE_CHECK([whether the target supports hidden visibility],
2684 glibcxx_cv_have_attribute_visibility, [
2685 save_CFLAGS="$CFLAGS"
2686 CFLAGS="$CFLAGS -Werror"
2687 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2688 [], glibcxx_cv_have_attribute_visibility=yes,
2689 glibcxx_cv_have_attribute_visibility=no)
2690 CFLAGS="$save_CFLAGS"])
2691 if test $glibcxx_cv_have_attribute_visibility = no; then
2692 enable_visibility=no
2693 fi
2694 fi
2696 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2697 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2698 ])
2701 dnl
2702 dnl Add version tags to symbols in shared library (or not), additionally
2703 dnl marking other symbols as private/local (or not).
2704 dnl
2705 dnl --enable-symvers=style adds a version script to the linker call when
2706 dnl creating the shared library. The choice of version script is
2707 dnl controlled by 'style'.
2708 dnl --disable-symvers does not.
2709 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2710 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
2711 dnl choose a default style based on linker characteristics. Passing
2712 dnl 'no' disables versioning.
2713 dnl
2714 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2716 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2717 [enables symbol versioning of the shared library],
2718 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2720 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2721 # don't know enough about $LD to do tricks...
2722 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2724 # Turn a 'yes' into a suitable default.
2725 if test x$enable_symvers = xyes ; then
2726 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2727 enable_symvers=no
2728 else
2729 if test $with_gnu_ld = yes ; then
2730 case ${target_os} in
2731 cygwin* | pe | mingw32* | hpux*)
2732 enable_symvers=no ;;
2733 *)
2734 enable_symvers=gnu ;;
2735 esac
2736 else
2737 case ${target_os} in
2738 darwin*)
2739 enable_symvers=darwin ;;
2740 *)
2741 enable_symvers=no ;;
2742 esac
2743 fi
2744 fi
2745 fi
2747 # Check to see if 'darwin' or 'darwin-export' can win.
2748 if test x$enable_symvers = xdarwin-export ; then
2749 enable_symvers=darwin
2750 fi
2752 # Check to see if 'gnu' can win.
2753 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2754 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2755 AC_MSG_CHECKING([for shared libgcc])
2756 ac_save_CFLAGS="$CFLAGS"
2757 CFLAGS=' -lgcc_s'
2758 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2759 CFLAGS="$ac_save_CFLAGS"
2760 if test $glibcxx_shared_libgcc = no; then
2761 cat > conftest.c <<EOF
2762 int main (void) { return 0; }
2763 EOF
2764 changequote(,)dnl
2765 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2766 -shared -shared-libgcc -o conftest.so \
2767 conftest.c -v 2>&1 >/dev/null \
2768 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2769 changequote([,])dnl
2770 rm -f conftest.c conftest.so
2771 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2772 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2773 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2774 CFLAGS="$ac_save_CFLAGS"
2775 fi
2776 fi
2777 AC_MSG_RESULT($glibcxx_shared_libgcc)
2779 # For GNU ld, we need at least this version. The format is described in
2780 # GLIBCXX_CHECK_LINKER_FEATURES above.
2781 glibcxx_min_gnu_ld_version=21400
2783 # If no shared libgcc, can't win.
2784 if test $glibcxx_shared_libgcc != yes; then
2785 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2786 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2787 AC_MSG_WARN([=== Symbol versioning will be disabled.])
2788 enable_symvers=no
2789 elif test $with_gnu_ld != yes ; then
2790 # just fail for now
2791 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2792 AC_MSG_WARN([=== you are not using the GNU linker.])
2793 AC_MSG_WARN([=== Symbol versioning will be disabled.])
2794 enable_symvers=no
2795 elif test $glibcxx_ld_is_gold = yes ; then
2796 : All versions of gold support symbol versioning.
2797 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2798 # The right tools, the right setup, but too old. Fallbacks?
2799 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2800 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2801 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2802 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2803 AC_MSG_WARN([=== Symbol versioning will be disabled.])
2804 enable_symvers=no
2805 fi
2806 fi
2808 # Everything parsed; figure out what file to use.
2809 case $enable_symvers in
2810 no)
2811 SYMVER_FILE=config/abi/pre/none.ver
2812 ;;
2813 gnu)
2814 SYMVER_FILE=config/abi/pre/gnu.ver
2815 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
2816 [Define to use GNU versioning in the shared library.])
2817 ;;
2818 gnu-versioned-namespace)
2819 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2820 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
2821 [Define to use GNU namespace versioning in the shared library.])
2822 ;;
2823 darwin)
2824 SYMVER_FILE=config/abi/pre/gnu.ver
2825 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
2826 [Define to use darwin versioning in the shared library.])
2827 ;;
2828 esac
2830 if test x$enable_symvers != xno ; then
2831 AC_DEFINE(_GLIBCXX_SYMVER, 1,
2832 [Define to use symbol versioning in the shared library.])
2833 fi
2835 AC_CACHE_CHECK([whether the target supports .symver directive],
2836 glibcxx_cv_have_as_symver_directive, [
2837 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
2838 [], glibcxx_cv_have_as_symver_directive=yes,
2839 glibcxx_cv_have_as_symver_directive=no)])
2840 if test $glibcxx_cv_have_as_symver_directive = yes; then
2841 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
2842 [Define to 1 if the target assembler supports .symver directive.])
2843 fi
2845 AC_SUBST(SYMVER_FILE)
2846 AC_SUBST(port_specific_symbol_files)
2847 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2848 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2849 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2850 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2851 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2853 # Now, set up compatibility support, if any.
2854 # In addition, need this to deal with std::size_t mangling in
2855 # src/compatibility.cc. In a perfect world, could use
2856 # typeid(std::size_t).name()[0] to do direct substitution.
2857 AC_MSG_CHECKING([for size_t as unsigned int])
2858 ac_save_CFLAGS="$CFLAGS"
2859 CFLAGS="-Werror"
2860 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
2861 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2862 CFLAGS=$ac_save_CFLAGS
2863 if test "$glibcxx_size_t_is_i" = yes; then
2864 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2865 fi
2866 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2868 AC_MSG_CHECKING([for ptrdiff_t as int])
2869 ac_save_CFLAGS="$CFLAGS"
2870 CFLAGS="-Werror"
2871 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
2872 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2873 CFLAGS=$ac_save_CFLAGS
2874 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2875 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2876 fi
2877 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2878 ])
2881 dnl
2882 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2883 dnl We must stage the required headers so that they will be installed
2884 dnl with the library (unlike libgcc, the STL implementation is provided
2885 dnl solely within headers). Since we must not inject random user-space
2886 dnl macro names into user-provided C++ code, we first stage into <file>-in
2887 dnl and process to <file> with an output command. The reason for a two-
2888 dnl stage process here is to correctly handle $srcdir!=$objdir without
2889 dnl having to write complex code (the sed commands to clean the macro
2890 dnl namespace are complex and fragile enough as it is). We must also
2891 dnl add a relative path so that -I- is supported properly.
2892 dnl
2893 dnl Substs:
2894 dnl glibcxx_thread_h
2895 dnl
2896 dnl Defines:
2897 dnl HAVE_GTHR_DEFAULT
2898 dnl
2899 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2900 AC_MSG_CHECKING([for thread model used by GCC])
2901 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2902 AC_MSG_RESULT([$target_thread_file])
2904 if test $target_thread_file != single; then
2905 AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2906 [Define if gthr-default.h exists
2907 (meaning that threading support is enabled).])
2908 fi
2910 glibcxx_thread_h=gthr-$target_thread_file.h
2912 dnl Check for __GTHREADS define.
2913 gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2914 if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2915 enable_thread=yes
2916 else
2917 enable_thread=no
2918 fi
2920 AC_SUBST(glibcxx_thread_h)
2921 ])
2924 dnl
2925 dnl Check if gthread implementation defines the types and functions
2926 dnl required by the c++0x thread library. Conforming gthread
2927 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
2928 dnl
2929 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
2930 AC_LANG_SAVE
2931 AC_LANG_CPLUSPLUS
2933 ac_save_CXXFLAGS="$CXXFLAGS"
2934 CXXFLAGS="$CXXFLAGS -fno-exceptions -I${toplevel_srcdir}/gcc"
2936 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2937 case $target_thread_file in
2938 posix)
2939 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
2940 esac
2942 AC_MSG_CHECKING([for gthreads library])
2944 AC_TRY_COMPILE([#include "gthr.h"],
2945 [
2946 #ifndef __GTHREADS_CXX0X
2947 #error
2948 #endif
2950 // In case of POSIX threads check _POSIX_TIMEOUTS too.
2951 #if (defined(_PTHREADS) \
2952 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
2953 #error
2954 #endif
2955 ], [ac_has_gthreads=yes], [ac_has_gthreads=no])
2957 AC_MSG_RESULT([$ac_has_gthreads])
2959 if test x"$ac_has_gthreads" = x"yes"; then
2960 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
2961 [Define if gthreads library is available.])
2962 fi
2964 CXXFLAGS="$ac_save_CXXFLAGS"
2965 AC_LANG_RESTORE
2966 ])
2969 # Check whether LC_MESSAGES is available in <locale.h>.
2970 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2971 #
2972 # This file file be copied and used freely without restrictions. It can
2973 # be used in projects which are not available under the GNU Public License
2974 # but which still want to provide support for the GNU gettext functionality.
2975 # Please note that the actual code is *not* freely available.
2976 AC_DEFUN([AC_LC_MESSAGES], [
2977 AC_CHECK_HEADER(locale.h, [
2978 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2979 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
2980 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2981 if test $ac_cv_val_LC_MESSAGES = yes; then
2982 AC_DEFINE(HAVE_LC_MESSAGES, 1,
2983 [Define if LC_MESSAGES is available in <locale.h>.])
2984 fi
2985 ])
2986 ])
2988 # Macros from the top-level gcc directory.
2989 m4_include([../config/tls.m4])