projects / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
gimple.h (gimple_set_in_transaction): Remove.
[gcc.git] / libstdc++-v3 / acinclude.m4
1 dnl
2 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
3 dnl
4 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
5 dnl end of configure. This lets tested variables be reassigned, and the
6 dnl conditional will depend on the final state of the variable. For a simple
7 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
8 dnl
9 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
10 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
11 m4_divert_text([glibcxx_diversion],dnl
12 AM_CONDITIONAL([$1],[$2])
13 )dnl
14 ])dnl
15 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
16
17
18 dnl
19 dnl Check to see what architecture and operating system we are compiling
20 dnl for. Also, if architecture- or OS-specific flags are required for
21 dnl compilation, pick them up here.
22 dnl
23 AC_DEFUN([GLIBCXX_CHECK_HOST], [
24 . $glibcxx_srcdir/configure.host
25 AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
26 AC_MSG_NOTICE([OS config directory is $os_include_dir])
27 ])
28
29 dnl
30 dnl Initialize the rest of the library configury. At this point we have
31 dnl variables like $host.
32 dnl
33 dnl Sets:
34 dnl SUBDIRS
35 dnl Substs:
36 dnl glibcxx_builddir (absolute path)
37 dnl glibcxx_srcdir (absolute path)
38 dnl toplevel_builddir (absolute path)
39 dnl toplevel_srcdir (absolute path)
40 dnl with_cross_host
41 dnl with_newlib
42 dnl with_target_subdir
43 dnl plus
44 dnl - the variables in GLIBCXX_CHECK_HOST / configure.host
45 dnl - default settings for all AM_CONFITIONAL test variables
46 dnl - lots of tools, like CC and CXX
47 dnl
48 AC_DEFUN([GLIBCXX_CONFIGURE], [
49 # Keep these sync'd with the list in Makefile.am. The first provides an
50 # expandable list at autoconf time; the second provides an expandable list
51 # (i.e., shell variable) at configure time.
52 m4_define([glibcxx_SUBDIRS],[include libsupc++ python src src/c++98 src/c++11 doc po testsuite])
53 SUBDIRS='glibcxx_SUBDIRS'
54
55 # These need to be absolute paths, yet at the same time need to
56 # canonicalize only relative paths, because then amd will not unmount
57 # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
58 glibcxx_builddir=`${PWDCMD-pwd}`
59 case $srcdir in
60 [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
61 *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
62 esac
63 toplevel_builddir=${glibcxx_builddir}/..
64 toplevel_srcdir=${glibcxx_srcdir}/..
65 AC_SUBST(glibcxx_builddir)
66 AC_SUBST(glibcxx_srcdir)
67 AC_SUBST(toplevel_builddir)
68 AC_SUBST(toplevel_srcdir)
69
70 # We use these options to decide which functions to include. They are
71 # set from the top level.
72 AC_ARG_WITH([target-subdir],
73 AC_HELP_STRING([--with-target-subdir=SUBDIR],
74 [configuring in a subdirectory]))
75
76 AC_ARG_WITH([cross-host],
77 AC_HELP_STRING([--with-cross-host=HOST],
78 [configuring with a cross compiler]))
79
80 AC_ARG_WITH([newlib],
81 AC_HELP_STRING([--with-newlib],
82 [assume newlib as a system C library]))
83
84 # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
85 # available). Uncomment the next line to force a particular method.
86 AC_PROG_LN_S
87 #LN_S='cp -p'
88
89 AC_CHECK_TOOL(AS, as)
90 AC_CHECK_TOOL(AR, ar)
91 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
92
93 AM_MAINTAINER_MODE
94
95 # Set up safe default values for all subsequent AM_CONDITIONAL tests
96 # which are themselves conditionally expanded.
97 ## (Right now, this only matters for enable_wchar_t, but nothing prevents
98 ## other macros from doing the same. This should be automated.) -pme
99
100 # Check for C library flavor since GNU/Linux platforms use different
101 # configuration directories depending on the C library in use.
102 AC_EGREP_CPP([_using_uclibc], [
103 #include <stdio.h>
104 #if __UCLIBC__
105 _using_uclibc
106 #endif
107 ], uclibc=yes, uclibc=no)
108
109 AC_EGREP_CPP([_using_bionic], [
110 #include <stdio.h>
111 #if __BIONIC__
112 _using_bionic
113 #endif
114 ], bionic=yes, bionic=no)
115
116 # Find platform-specific directories containing configuration info.
117 # Also possibly modify flags used elsewhere, as needed by the platform.
118 GLIBCXX_CHECK_HOST
119 ])
120
121
122 dnl
123 dnl Tests for newer compiler features, or features that are present in newer
124 dnl compiler versions but not older compiler versions still in use, should
125 dnl be placed here.
126 dnl
127 dnl Defines:
128 dnl WERROR='-Werror' if requested and possible; g++'s that lack the
129 dnl new inlining code or the new system_header pragma will die on -Werror.
130 dnl Leave it out by default and use maint-mode to use it.
131 dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if
132 dnl compiler supports it and the user has not requested debug mode.
133 dnl
134 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
135 # All these tests are for C++; save the language and the compiler flags.
136 # The CXXFLAGS thing is suspicious, but based on similar bits previously
137 # found in GLIBCXX_CONFIGURE.
138 AC_LANG_SAVE
139 AC_LANG_CPLUSPLUS
140 ac_test_CXXFLAGS="${CXXFLAGS+set}"
141 ac_save_CXXFLAGS="$CXXFLAGS"
142
143 # Check for maintainer-mode bits.
144 if test x"$USE_MAINTAINER_MODE" = xno; then
145 WERROR=''
146 else
147 WERROR='-Werror'
148 fi
149
150 # Check for -ffunction-sections -fdata-sections
151 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
152 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
153 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
154 if test "$ac_test_CXXFLAGS" = set; then
155 CXXFLAGS="$ac_save_CXXFLAGS"
156 else
157 # this is the suspicious part
158 CXXFLAGS=''
159 fi
160 if test x"$ac_fdsections" = x"yes"; then
161 SECTION_FLAGS='-ffunction-sections -fdata-sections'
162 fi
163 AC_MSG_RESULT($ac_fdsections)
164
165 AC_LANG_RESTORE
166 AC_SUBST(WERROR)
167 AC_SUBST(SECTION_FLAGS)
168 ])
169
170
171 dnl
172 dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
173 dnl the native linker is in use, all variables will be defined to something
174 dnl safe (like an empty string).
175 dnl
176 dnl Defines:
177 dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
178 dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
179 dnl LD (as a side effect of testing)
180 dnl Sets:
181 dnl with_gnu_ld
182 dnl glibcxx_ld_is_gold (set to "no" or "yes")
183 dnl glibcxx_gnu_ld_version (possibly)
184 dnl
185 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
186 dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
187 dnl
188 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
189 # If we're not using GNU ld, then there's no point in even trying these
190 # tests. Check for that first. We should have already tested for gld
191 # by now (in libtool), but require it now just to be safe...
192 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
193 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
194 AC_REQUIRE([AC_PROG_LD])
195 AC_REQUIRE([AC_PROG_AWK])
196
197 # The name set by libtool depends on the version of libtool. Shame on us
198 # for depending on an impl detail, but c'est la vie. Older versions used
199 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
200 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
201 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
202 # set (hence we're using an older libtool), then set it.
203 if test x${with_gnu_ld+set} != xset; then
204 if test x${ac_cv_prog_gnu_ld+set} != xset; then
205 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
206 with_gnu_ld=no
207 else
208 with_gnu_ld=$ac_cv_prog_gnu_ld
209 fi
210 fi
211
212 # Start by getting the version number. I think the libtool test already
213 # does some of this, but throws away the result.
214 glibcxx_ld_is_gold=no
215 if test x"$with_gnu_ld" = x"yes"; then
216 AC_MSG_CHECKING([for ld version])
217 changequote(,)
218 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
219 glibcxx_ld_is_gold=yes
220 fi
221 ldver=`$LD --version 2>/dev/null |
222 sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'`
223 changequote([,])
224 glibcxx_gnu_ld_version=`echo $ldver | \
225 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
226 AC_MSG_RESULT($glibcxx_gnu_ld_version)
227 fi
228
229 # Set --gc-sections.
230 glibcxx_have_gc_sections=no
231 if test "$glibcxx_ld_is_gold" = "yes"; then
232 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
233 glibcxx_have_gc_sections=yes
234 fi
235 else
236 glibcxx_gcsections_min_ld=21602
237 if test x"$with_gnu_ld" = x"yes" &&
238 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
239 glibcxx_have_gc_sections=yes
240 fi
241 fi
242 if test "$glibcxx_have_gc_sections" = "yes"; then
243 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
244 # NB: This flag only works reliably after 2.16.1. Configure tests
245 # for this are difficult, so hard wire a value that should work.
246
247 ac_test_CFLAGS="${CFLAGS+set}"
248 ac_save_CFLAGS="$CFLAGS"
249 CFLAGS='-Wl,--gc-sections'
250
251 # Check for -Wl,--gc-sections
252 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
253 AC_TRY_LINK([ int one(void) { return 1; }
254 int two(void) { return 2; }
255 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
256 if test "$ac_gcsections" = "yes"; then
257 rm -f conftest.c
258 touch conftest.c
259 if $CC -c conftest.c; then
260 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
261 grep "Warning: gc-sections option ignored" > /dev/null; then
262 ac_gcsections=no
263 fi
264 fi
265 rm -f conftest.c conftest.o conftest
266 fi
267 if test "$ac_gcsections" = "yes"; then
268 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
269 fi
270 AC_MSG_RESULT($ac_gcsections)
271
272 if test "$ac_test_CFLAGS" = set; then
273 CFLAGS="$ac_save_CFLAGS"
274 else
275 # this is the suspicious part
276 CFLAGS=''
277 fi
278 fi
279
280 # Set -z,relro.
281 # Note this is only for shared objects.
282 ac_ld_relro=no
283 if test x"$with_gnu_ld" = x"yes"; then
284 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
285 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
286 if test -n "$cxx_z_relo"; then
287 OPT_LDFLAGS="-Wl,-z,relro"
288 ac_ld_relro=yes
289 fi
290 AC_MSG_RESULT($ac_ld_relro)
291 fi
292
293 # Set linker optimization flags.
294 if test x"$with_gnu_ld" = x"yes"; then
295 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
296 fi
297
298 AC_SUBST(SECTION_LDFLAGS)
299 AC_SUBST(OPT_LDFLAGS)
300 ])
301
302
303 dnl
304 dnl Check for headers for, and arguments to, the setrlimit() function.
305 dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
306 dnl
307 dnl Defines:
308 dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
309 dnl various HAVE_LIMIT_* for individual limit names
310 dnl
311 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
312 AC_MSG_CHECKING([for RLIMIT_$1])
313 AC_TRY_COMPILE(
314 [#include <unistd.h>
315 #include <sys/time.h>
316 #include <sys/resource.h>
317 ],
318 [ int f = RLIMIT_$1 ; ],
319 [glibcxx_mresult=1], [glibcxx_mresult=0])
320 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
321 [Only used in build directory testsuite_hooks.h.])
322 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
323 AC_MSG_RESULT($res)
324 ])
325
326 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
327 setrlimit_have_headers=yes
328 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
329 [],
330 [setrlimit_have_headers=no])
331 # If don't have the headers, then we can't run the tests now, and we
332 # won't be seeing any of these during testsuite compilation.
333 if test $setrlimit_have_headers = yes; then
334 # Can't do these in a loop, else the resulting syntax is wrong.
335 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
336 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
337 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
338 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
339 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
340
341 # Check for rlimit, setrlimit.
342 AC_CACHE_VAL(glibcxx_cv_setrlimit, [
343 AC_TRY_COMPILE(
344 [#include <unistd.h>
345 #include <sys/time.h>
346 #include <sys/resource.h>
347 ],
348 [struct rlimit r;
349 setrlimit(0, &r);],
350 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
351 ])
352 fi
353
354 AC_MSG_CHECKING([for testsuite resource limits support])
355 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
356 ac_res_limits=yes
357 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
358 [Define if using setrlimit to set resource limits during
359 "make check"])
360 else
361 ac_res_limits=no
362 fi
363 AC_MSG_RESULT($ac_res_limits)
364 ])
365
366
367 dnl
368 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
369 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
370 dnl
371 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
372
373 AC_LANG_SAVE
374 AC_LANG_CPLUSPLUS
375 ac_save_CXXFLAGS="$CXXFLAGS"
376 CXXFLAGS="$CXXFLAGS -fno-exceptions"
377
378 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
379 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
380 GCC_TRY_COMPILE_OR_LINK(
381 [#include <sys/stat.h>],
382 [struct stat buffer;
383 fstat(0, &buffer);
384 S_ISREG(buffer.st_mode);],
385 [glibcxx_cv_S_ISREG=yes],
386 [glibcxx_cv_S_ISREG=no])
387 ])
388 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
389 GCC_TRY_COMPILE_OR_LINK(
390 [#include <sys/stat.h>],
391 [struct stat buffer;
392 fstat(0, &buffer);
393 S_IFREG & buffer.st_mode;],
394 [glibcxx_cv_S_IFREG=yes],
395 [glibcxx_cv_S_IFREG=no])
396 ])
397 res=no
398 if test $glibcxx_cv_S_ISREG = yes; then
399 AC_DEFINE(HAVE_S_ISREG, 1,
400 [Define if S_IFREG is available in <sys/stat.h>.])
401 res=S_ISREG
402 elif test $glibcxx_cv_S_IFREG = yes; then
403 AC_DEFINE(HAVE_S_IFREG, 1,
404 [Define if S_IFREG is available in <sys/stat.h>.])
405 res=S_IFREG
406 fi
407 AC_MSG_RESULT($res)
408
409 CXXFLAGS="$ac_save_CXXFLAGS"
410 AC_LANG_RESTORE
411 ])
412
413
414 dnl
415 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
416 dnl
417 AC_DEFUN([GLIBCXX_CHECK_POLL], [
418
419 AC_LANG_SAVE
420 AC_LANG_CPLUSPLUS
421 ac_save_CXXFLAGS="$CXXFLAGS"
422 CXXFLAGS="$CXXFLAGS -fno-exceptions"
423
424 AC_MSG_CHECKING([for poll])
425 AC_CACHE_VAL(glibcxx_cv_POLL, [
426 GCC_TRY_COMPILE_OR_LINK(
427 [#include <poll.h>],
428 [struct pollfd pfd[1];
429 pfd[0].events = POLLIN;
430 poll(pfd, 1, 0);],
431 [glibcxx_cv_POLL=yes],
432 [glibcxx_cv_POLL=no])
433 ])
434 if test $glibcxx_cv_POLL = yes; then
435 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
436 fi
437 AC_MSG_RESULT($glibcxx_cv_POLL)
438
439 CXXFLAGS="$ac_save_CXXFLAGS"
440 AC_LANG_RESTORE
441 ])
442
443
444 dnl
445 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
446 dnl
447 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
448
449 AC_LANG_SAVE
450 AC_LANG_CPLUSPLUS
451 ac_save_CXXFLAGS="$CXXFLAGS"
452 CXXFLAGS="$CXXFLAGS -fno-exceptions"
453
454 AC_MSG_CHECKING([for writev])
455 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
456 GCC_TRY_COMPILE_OR_LINK(
457 [#include <sys/uio.h>],
458 [struct iovec iov[2];
459 writev(0, iov, 0);],
460 [glibcxx_cv_WRITEV=yes],
461 [glibcxx_cv_WRITEV=no])
462 ])
463 if test $glibcxx_cv_WRITEV = yes; then
464 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
465 fi
466 AC_MSG_RESULT($glibcxx_cv_WRITEV)
467
468 CXXFLAGS="$ac_save_CXXFLAGS"
469 AC_LANG_RESTORE
470 ])
471
472
473 dnl
474 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
475 dnl Also check whether int64_t is actually a typedef to long or long long.
476 dnl
477 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
478
479 AC_LANG_SAVE
480 AC_LANG_CPLUSPLUS
481
482 AC_MSG_CHECKING([for int64_t])
483 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
484 AC_TRY_COMPILE(
485 [#include <stdint.h>],
486 [int64_t var;],
487 [glibcxx_cv_INT64_T=yes],
488 [glibcxx_cv_INT64_T=no])
489 ])
490
491 if test $glibcxx_cv_INT64_T = yes; then
492 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
493 AC_MSG_RESULT($glibcxx_cv_INT64_T)
494
495 AC_MSG_CHECKING([for int64_t as long])
496 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
497 AC_TRY_COMPILE(
498 [#include <stdint.h>
499 template<typename, typename> struct same { enum { value = -1 }; };
500 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
501 int array[same<int64_t, long>::value];], [],
502 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
503 ])
504
505 if test $glibcxx_cv_int64_t_long = yes; then
506 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
507 AC_MSG_RESULT($glibcxx_cv_int64_t_long)
508 fi
509
510 AC_MSG_CHECKING([for int64_t as long long])
511 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
512 AC_TRY_COMPILE(
513 [#include <stdint.h>
514 template<typename, typename> struct same { enum { value = -1 }; };
515 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
516 int array[same<int64_t, long long>::value];], [],
517 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
518 ])
519
520 if test $glibcxx_cv_int64_t_long_long = yes; then
521 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
522 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
523 fi
524 fi
525
526 AC_LANG_RESTORE
527 ])
528
529
530 dnl
531 dnl Check whether LFS support is available.
532 dnl
533 AC_DEFUN([GLIBCXX_CHECK_LFS], [
534 AC_LANG_SAVE
535 AC_LANG_CPLUSPLUS
536 ac_save_CXXFLAGS="$CXXFLAGS"
537 CXXFLAGS="$CXXFLAGS -fno-exceptions"
538 AC_MSG_CHECKING([for LFS support])
539 AC_CACHE_VAL(glibcxx_cv_LFS, [
540 GCC_TRY_COMPILE_OR_LINK(
541 [#include <unistd.h>
542 #include <stdio.h>
543 #include <sys/stat.h>
544 ],
545 [FILE* fp;
546 fopen64("t", "w");
547 fseeko64(fp, 0, SEEK_CUR);
548 ftello64(fp);
549 lseek64(1, 0, SEEK_CUR);
550 struct stat64 buf;
551 fstat64(1, &buf);],
552 [glibcxx_cv_LFS=yes],
553 [glibcxx_cv_LFS=no])
554 ])
555 if test $glibcxx_cv_LFS = yes; then
556 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
557 fi
558 AC_MSG_RESULT($glibcxx_cv_LFS)
559 CXXFLAGS="$ac_save_CXXFLAGS"
560 AC_LANG_RESTORE
561 ])
562
563
564 dnl
565 dnl Check for whether a fully dynamic basic_string implementation should
566 dnl be turned on, that does not put empty objects in per-process static
567 dnl memory (mostly useful together with shared memory allocators, see PR
568 dnl libstdc++/16612 for details).
569 dnl
570 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
571 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
572 dnl otherwise undefined
573 dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
574 dnl Where DEFAULT is either `yes' or `no'.
575 dnl
576 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
577 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
578 if test $enable_fully_dynamic_string = yes; then
579 enable_fully_dynamic_string_def=1
580 else
581 enable_fully_dynamic_string_def=0
582 fi
583 AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
584 [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
585 ])
586
587
588 dnl
589 dnl Does any necessary configuration of the testsuite directory. Generates
590 dnl the testsuite_hooks.h header.
591 dnl
592 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
593 dnl
594 dnl Sets:
595 dnl enable_abi_check
596 dnl GLIBCXX_TEST_WCHAR_T
597 dnl GLIBCXX_TEST_THREAD
598 dnl Substs:
599 dnl baseline_dir
600 dnl baseline_subdir_switch
601 dnl
602 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
603 if $GLIBCXX_IS_NATIVE ; then
604 # Do checks for resource limit functions.
605 GLIBCXX_CHECK_SETRLIMIT
606
607 # Look for setenv, so that extended locale tests can be performed.
608 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
609 fi
610
611 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
612 test $enable_symvers != no; then
613 case "$host" in
614 *-*-cygwin*)
615 enable_abi_check=no ;;
616 *)
617 enable_abi_check=yes ;;
618 esac
619 else
620 # Only build this as native, since automake does not understand
621 # CXX_FOR_BUILD.
622 enable_abi_check=no
623 fi
624
625 # Export file names for ABI checking.
626 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
627 AC_SUBST(baseline_dir)
628 baseline_subdir_switch="$abi_baseline_subdir_switch"
629 AC_SUBST(baseline_subdir_switch)
630 ])
631
632
633 dnl
634 dnl Does any necessary configuration for docbook in the docs directory.
635 dnl
636 dnl XSLTPROC must be set before this
637 dnl
638 dnl Sets:
639 dnl glibcxx_stylesheets
640 dnl Substs:
641 dnl XSL_STYLE_DIR
642 dnl
643 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
644
645 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
646 glibcxx_stylesheets=no
647 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then
648 glibcxx_stylesheets=yes
649 fi
650 AC_MSG_RESULT($glibcxx_stylesheets)
651
652 AC_MSG_CHECKING([for local stylesheet directory])
653 glibcxx_local_stylesheets=no
654 if test x"$glibcxx_stylesheets" = x"yes"; then
655 if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then
656 glibcxx_local_stylesheets=yes
657 XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets
658 fi
659 if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then
660 glibcxx_local_stylesheets=yes
661 XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
662 fi
663 fi
664 AC_MSG_RESULT($glibcxx_local_stylesheets)
665
666 if test x"$glibcxx_local_stylesheets" = x"yes"; then
667 AC_SUBST(XSL_STYLE_DIR)
668 AC_MSG_NOTICE($XSL_STYLE_DIR)
669 else
670 glibcxx_stylesheets=no
671 fi
672
673 # Check for epub3 dependencies.
674 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
675 glibcxx_epub_stylesheets=no
676 if test x"$glibcxx_local_stylesheets" = x"yes"; then
677 if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
678 glibcxx_epub_stylesheets=yes
679 fi
680 fi
681 AC_MSG_RESULT($glibcxx_epub_stylesheets)
682 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
683
684 ])
685
686
687 dnl
688 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
689 dnl
690 dnl Substs:
691 dnl GLIBCXX_INCLUDES
692 dnl TOPLEVEL_INCLUDES
693 dnl
694 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
695 # Used for every C++ compile we perform.
696 GLIBCXX_INCLUDES="\
697 -I$glibcxx_builddir/include/$host_alias \
698 -I$glibcxx_builddir/include \
699 -I$glibcxx_srcdir/libsupc++"
700
701 # For Canadian crosses, pick this up too.
702 if test $CANADIAN = yes; then
703 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
704 fi
705
706 # Stuff in the actual top level. Currently only used by libsupc++ to
707 # get unwind* headers from the libgcc dir.
708 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
709 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
710
711 # Now, export this to all the little Makefiles....
712 AC_SUBST(GLIBCXX_INCLUDES)
713 AC_SUBST(TOPLEVEL_INCLUDES)
714 ])
715
716
717 dnl
718 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
719 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
720 dnl
721 dnl Substs:
722 dnl OPTIMIZE_CXXFLAGS
723 dnl WARN_FLAGS
724 dnl
725 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
726 # Optimization flags that are probably a good idea for thrill-seekers. Just
727 # uncomment the lines below and make, everything else is ready to go...
728 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
729 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
730 AC_SUBST(OPTIMIZE_CXXFLAGS)
731
732 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi'
733 AC_SUBST(WARN_FLAGS)
734 ])
735
736
737 dnl
738 dnl All installation directory information is determined here.
739 dnl
740 dnl Substs:
741 dnl gxx_install_dir
742 dnl glibcxx_prefixdir
743 dnl glibcxx_toolexecdir
744 dnl glibcxx_toolexeclibdir
745 dnl
746 dnl Assumes cross_compiling bits already done, and with_cross_host in
747 dnl particular.
748 dnl
749 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
750 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
751 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
752 glibcxx_toolexecdir=no
753 glibcxx_toolexeclibdir=no
754 glibcxx_prefixdir=$prefix
755
756 AC_MSG_CHECKING([for gxx-include-dir])
757 AC_ARG_WITH([gxx-include-dir],
758 AC_HELP_STRING([--with-gxx-include-dir=DIR],
759 [installation directory for include files]),
760 [case "$withval" in
761 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
762 no) gxx_include_dir=no ;;
763 *) gxx_include_dir=$withval ;;
764 esac],
765 [gxx_include_dir=no])
766 AC_MSG_RESULT($gxx_include_dir)
767
768 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
769 AC_ARG_ENABLE([version-specific-runtime-libs],
770 AC_HELP_STRING([--enable-version-specific-runtime-libs],
771 [Specify that runtime libraries should be installed in a compiler-specific directory]),
772 [case "$enableval" in
773 yes) version_specific_libs=yes ;;
774 no) version_specific_libs=no ;;
775 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
776 esac],
777 [version_specific_libs=no])
778 AC_MSG_RESULT($version_specific_libs)
779
780 # Default case for install directory for include files.
781 if test $version_specific_libs = no && test $gxx_include_dir = no; then
782 gxx_include_dir='include/c++/${gcc_version}'
783 if test -n "$with_cross_host" &&
784 test x"$with_cross_host" != x"no"; then
785 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
786 else
787 gxx_include_dir='${prefix}/'"$gxx_include_dir"
788 fi
789 fi
790
791 # Version-specific runtime libs processing.
792 if test $version_specific_libs = yes; then
793 # Need the gcc compiler version to know where to install libraries
794 # and header files if --enable-version-specific-runtime-libs option
795 # is selected. FIXME: these variables are misnamed, there are
796 # no executables installed in _toolexecdir or _toolexeclibdir.
797 if test x"$gxx_include_dir" = x"no"; then
798 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
799 fi
800 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
801 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
802 fi
803
804 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
805 # Install a library built with a cross compiler in tooldir, not libdir.
806 if test x"$glibcxx_toolexecdir" = x"no"; then
807 if test -n "$with_cross_host" &&
808 test x"$with_cross_host" != x"no"; then
809 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
810 glibcxx_toolexeclibdir='${toolexecdir}/lib'
811 else
812 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
813 glibcxx_toolexeclibdir='${libdir}'
814 fi
815 multi_os_directory=`$CXX -print-multi-os-directory`
816 case $multi_os_directory in
817 .) ;; # Avoid trailing /.
818 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
819 esac
820 fi
821
822 AC_MSG_CHECKING([for install location])
823 AC_MSG_RESULT($gxx_include_dir)
824
825 AC_SUBST(glibcxx_prefixdir)
826 AC_SUBST(gxx_include_dir)
827 AC_SUBST(glibcxx_toolexecdir)
828 AC_SUBST(glibcxx_toolexeclibdir)
829 ])
830
831
832 dnl
833 dnl GLIBCXX_ENABLE
834 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
835 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
836 dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
837 dnl
838 dnl See docs/html/17_intro/configury.html#enable for documentation.
839 dnl
840 m4_define([GLIBCXX_ENABLE],[dnl
841 m4_define([_g_switch],[--enable-$1])dnl
842 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
843 AC_ARG_ENABLE([$1],m4_dquote(_g_help),
844 m4_bmatch([$5],
845 [^permit ],
846 [[
847 case "$enableval" in
848 m4_bpatsubst([$5],[permit ])) ;;
849 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
850 dnl Idea for future: generate a URL pointing to
851 dnl "onlinedocs/configopts.html#whatever"
852 esac
853 ]],
854 [^$],
855 [[
856 case "$enableval" in
857 yes|no) ;;
858 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
859 esac
860 ]],
861 [[$5]]),
862 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
863 m4_undefine([_g_switch])dnl
864 m4_undefine([_g_help])dnl
865 ])
866
867
868 dnl
869 dnl Check for ISO/IEC 9899:1999 "C99" support.
870 dnl
871 dnl --enable-c99 defines _GLIBCXX_USE_C99
872 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
873 dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
874 dnl Where DEFAULT is either `yes' or `no'.
875 dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
876 dnl
877 AC_DEFUN([GLIBCXX_ENABLE_C99], [
878 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
879
880 if test x"$enable_c99" = x"yes"; then
881
882 AC_LANG_SAVE
883 AC_LANG_CPLUSPLUS
884
885 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
886 # undefined and fake C99 facilities - like pre-standard snprintf - may be
887 # spuriously enabled.
888 # Long term, -std=c++0x could be even better, could manage to explicitely
889 # request C99 facilities to the underlying C headers.
890 ac_save_CXXFLAGS="$CXXFLAGS"
891 CXXFLAGS="$CXXFLAGS -std=c++98"
892 ac_save_LIBS="$LIBS"
893 ac_save_gcc_no_link="$gcc_no_link"
894
895 if test x$gcc_no_link != xyes; then
896 # Use -fno-exceptions to that the C driver can link these tests without
897 # hitting undefined references to personality routines.
898 CXXFLAGS="$CXXFLAGS -fno-exceptions"
899 AC_CHECK_LIB(m, sin, [
900 LIBS="$LIBS -lm"
901 ], [
902 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
903 gcc_no_link=yes
904 ])
905 fi
906
907 # Check for the existence of <math.h> functions used if C99 is enabled.
908 AC_MSG_CHECKING([for ISO C99 support in <math.h>])
909 AC_CACHE_VAL(glibcxx_cv_c99_math, [
910 GCC_TRY_COMPILE_OR_LINK(
911 [#include <math.h>
912 volatile double d1, d2;
913 volatile int i;],
914 [i = fpclassify(d1);
915 i = isfinite(d1);
916 i = isinf(d1);
917 i = isnan(d1);
918 i = isnormal(d1);
919 i = signbit(d1);
920 i = isgreater(d1, d2);
921 i = isgreaterequal(d1, d2);
922 i = isless(d1, d2);
923 i = islessequal(d1, d2);
924 i = islessgreater(d1, d2);
925 i = islessgreater(d1, d2);
926 i = isunordered(d1, d2);
927 ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
928 ])
929 AC_MSG_RESULT($glibcxx_cv_c99_math)
930 if test x"$glibcxx_cv_c99_math" = x"yes"; then
931 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
932 [Define if C99 functions or macros in <math.h> should be imported
933 in <cmath> in namespace std.])
934 fi
935
936 # Check for the existence of <complex.h> complex math functions.
937 # This is necessary even though libstdc++ uses the builtin versions
938 # of these functions, because if the builtin cannot be used, a reference
939 # to the library function is emitted.
940 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
941 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
942 glibcxx_cv_c99_complex=no;
943 if test x"$ac_has_complex_h" = x"yes"; then
944 AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
945 GCC_TRY_COMPILE_OR_LINK(
946 [#include <complex.h>
947 typedef __complex__ float float_type;
948 typedef __complex__ double double_type;
949 typedef __complex__ long double ld_type;
950 volatile float_type tmpf;
951 volatile double_type tmpd;
952 volatile ld_type tmpld;
953 volatile float f;
954 volatile double d;
955 volatile long double ld;],
956 [f = cabsf(tmpf);
957 f = cargf(tmpf);
958 tmpf = ccosf(tmpf);
959 tmpf = ccoshf(tmpf);
960 tmpf = cexpf(tmpf);
961 tmpf = clogf(tmpf);
962 tmpf = csinf(tmpf);
963 tmpf = csinhf(tmpf);
964 tmpf = csqrtf(tmpf);
965 tmpf = ctanf(tmpf);
966 tmpf = ctanhf(tmpf);
967 tmpf = cpowf(tmpf, tmpf);
968 tmpf = cprojf(tmpf);
969 d = cabs(tmpd);
970 d = carg(tmpd);
971 tmpd = ccos(tmpd);
972 tmpd = ccosh(tmpd);
973 tmpd = cexp(tmpd);
974 tmpd = clog(tmpd);
975 tmpd = csin(tmpd);
976 tmpd = csinh(tmpd);
977 tmpd = csqrt(tmpd);
978 tmpd = ctan(tmpd);
979 tmpd = ctanh(tmpd);
980 tmpd = cpow(tmpd, tmpd);
981 tmpd = cproj(tmpd);
982 ld = cabsl(tmpld);
983 ld = cargl(tmpld);
984 tmpld = ccosl(tmpld);
985 tmpld = ccoshl(tmpld);
986 tmpld = cexpl(tmpld);
987 tmpld = clogl(tmpld);
988 tmpld = csinl(tmpld);
989 tmpld = csinhl(tmpld);
990 tmpld = csqrtl(tmpld);
991 tmpld = ctanl(tmpld);
992 tmpld = ctanhl(tmpld);
993 tmpld = cpowl(tmpld, tmpld);
994 tmpld = cprojl(tmpld);
995 ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
996 fi
997 AC_MSG_RESULT($glibcxx_cv_c99_complex)
998 if test x"$glibcxx_cv_c99_complex" = x"yes"; then
999 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
1000 [Define if C99 functions in <complex.h> should be used in
1001 <complex>. Using compiler builtins for these functions requires
1002 corresponding C99 library functions to be present.])
1003 fi
1004
1005 # Check for the existence in <stdio.h> of vscanf, et. al.
1006 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1007 AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
1008 GCC_TRY_COMPILE_OR_LINK(
1009 [#include <stdio.h>
1010 #include <stdarg.h>
1011 void foo(char* fmt, ...)
1012 {
1013 va_list args; va_start(args, fmt);
1014 vfscanf(stderr, "%i", args);
1015 vscanf("%i", args);
1016 vsnprintf(fmt, 0, "%i", args);
1017 vsscanf(fmt, "%i", args);
1018 }],
1019 [snprintf("12", 0, "%i");],
1020 [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
1021 ])
1022 AC_MSG_RESULT($glibcxx_cv_c99_stdio)
1023
1024 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1025 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1026 AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
1027 GCC_TRY_COMPILE_OR_LINK(
1028 [#include <stdlib.h>
1029 volatile float f;
1030 volatile long double ld;
1031 volatile unsigned long long ll;
1032 lldiv_t mydivt;],
1033 [char* tmp;
1034 f = strtof("gnu", &tmp);
1035 ld = strtold("gnu", &tmp);
1036 ll = strtoll("gnu", &tmp, 10);
1037 ll = strtoull("gnu", &tmp, 10);
1038 ll = llabs(10);
1039 mydivt = lldiv(10,1);
1040 ll = mydivt.quot;
1041 ll = mydivt.rem;
1042 ll = atoll("10");
1043 _Exit(0);
1044 ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
1045 ])
1046 AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
1047
1048 # Check for the existence in <wchar.h> of wcstold, etc.
1049 glibcxx_cv_c99_wchar=no;
1050 if test x"$ac_has_wchar_h" = xyes &&
1051 test x"$ac_has_wctype_h" = xyes; then
1052 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1053 AC_TRY_COMPILE([#include <wchar.h>
1054 namespace test
1055 {
1056 using ::wcstold;
1057 using ::wcstoll;
1058 using ::wcstoull;
1059 }
1060 ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
1061
1062 # Checks for wide character functions that may not be present.
1063 # Injection of these is wrapped with guard macros.
1064 # NB: only put functions here, instead of immediately above, if
1065 # absolutely necessary.
1066 AC_TRY_COMPILE([#include <wchar.h>
1067 namespace test { using ::vfwscanf; } ], [],
1068 [AC_DEFINE(HAVE_VFWSCANF,1,
1069 [Defined if vfwscanf exists.])],[])
1070
1071 AC_TRY_COMPILE([#include <wchar.h>
1072 namespace test { using ::vswscanf; } ], [],
1073 [AC_DEFINE(HAVE_VSWSCANF,1,
1074 [Defined if vswscanf exists.])],[])
1075
1076 AC_TRY_COMPILE([#include <wchar.h>
1077 namespace test { using ::vwscanf; } ], [],
1078 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1079
1080 AC_TRY_COMPILE([#include <wchar.h>
1081 namespace test { using ::wcstof; } ], [],
1082 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1083
1084 AC_TRY_COMPILE([#include <wctype.h>],
1085 [ wint_t t; int i = iswblank(t);],
1086 [AC_DEFINE(HAVE_ISWBLANK,1,
1087 [Defined if iswblank exists.])],[])
1088
1089 AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1090 fi
1091
1092 # Option parsed, now set things appropriately.
1093 if test x"$glibcxx_cv_c99_math" = x"no" ||
1094 test x"$glibcxx_cv_c99_complex" = x"no" ||
1095 test x"$glibcxx_cv_c99_stdio" = x"no" ||
1096 test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1097 test x"$glibcxx_cv_c99_wchar" = x"no"; then
1098 enable_c99=no;
1099 else
1100 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1101 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1102 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1103 fi
1104
1105 gcc_no_link="$ac_save_gcc_no_link"
1106 LIBS="$ac_save_LIBS"
1107 CXXFLAGS="$ac_save_CXXFLAGS"
1108 AC_LANG_RESTORE
1109 fi
1110
1111 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1112 AC_MSG_RESULT($enable_c99)
1113 ])
1114
1115
1116 dnl
1117 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1118 dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this]
1119 dnl in the current C++0x working draft.
1120 dnl
1121 dnl --enable-libstdcxx-time
1122 dnl --enable-libstdcxx-time=yes
1123 dnl checks for the availability of monotonic and realtime clocks,
1124 dnl nanosleep and sched_yield in libc and libposix4 and, in case, links
1125 dnl the latter
1126 dnl --enable-libstdcxx-time=rt
1127 dnl also searches (and, in case, links) librt. Note that this is
1128 dnl not always desirable because, in glibc, for example, in turn it
1129 dnl triggers the linking of libpthread too, which activates locking,
1130 dnl a large overhead for single-thread programs.
1131 dnl --enable-libstdcxx-time=no
1132 dnl --disable-libstdcxx-time
1133 dnl disables the checks completely
1134 dnl
1135 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1136
1137 AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1138 GLIBCXX_ENABLE(libstdcxx-time,$1,[[[=KIND]]],
1139 [use KIND for check type],
1140 [permit yes|no|rt])
1141
1142 AC_LANG_SAVE
1143 AC_LANG_CPLUSPLUS
1144 ac_save_CXXFLAGS="$CXXFLAGS"
1145 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1146 ac_save_LIBS="$LIBS"
1147
1148 ac_has_clock_monotonic=no
1149 ac_has_clock_realtime=no
1150 AC_MSG_RESULT($enable_libstdcxx_time)
1151
1152 if test x"$enable_libstdcxx_time" != x"no"; then
1153
1154 if test x"$enable_libstdcxx_time" = x"rt"; then
1155 AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1156 AC_SEARCH_LIBS(nanosleep, [rt posix4])
1157 else
1158 AC_SEARCH_LIBS(clock_gettime, [posix4])
1159 AC_SEARCH_LIBS(nanosleep, [posix4])
1160 fi
1161
1162 case "$ac_cv_search_clock_gettime" in
1163 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1164 ;;
1165 esac
1166 case "$ac_cv_search_nanosleep" in
1167 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1168 ;;
1169 esac
1170
1171 AC_SEARCH_LIBS(sched_yield, [rt posix4])
1172
1173 case "$ac_cv_search_sched_yield" in
1174 -lposix4*)
1175 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1176 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1177 [ Defined if sched_yield is available. ])
1178 ;;
1179 -lrt*)
1180 if test x"$enable_libstdcxx_time" = x"rt"; then
1181 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1182 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1183 [ Defined if sched_yield is available. ])
1184 fi
1185 ;;
1186 *)
1187 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1188 [ Defined if sched_yield is available. ])
1189 ;;
1190 esac
1191
1192 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1193
1194 if test x"$ac_has_unistd_h" = x"yes"; then
1195 AC_MSG_CHECKING([for monotonic clock])
1196 AC_TRY_LINK(
1197 [#include <unistd.h>
1198 #include <time.h>
1199 ],
1200 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1201 timespec tp;
1202 #endif
1203 clock_gettime(CLOCK_MONOTONIC, &tp);
1204 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1205
1206 AC_MSG_RESULT($ac_has_clock_monotonic)
1207
1208 AC_MSG_CHECKING([for realtime clock])
1209 AC_TRY_LINK(
1210 [#include <unistd.h>
1211 #include <time.h>
1212 ],
1213 [#if _POSIX_TIMERS > 0
1214 timespec tp;
1215 #endif
1216 clock_gettime(CLOCK_REALTIME, &tp);
1217 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1218
1219 AC_MSG_RESULT($ac_has_clock_realtime)
1220
1221 AC_MSG_CHECKING([for nanosleep])
1222 AC_TRY_LINK(
1223 [#include <unistd.h>
1224 #include <time.h>
1225 ],
1226 [#if _POSIX_TIMERS > 0
1227 timespec tp;
1228 #endif
1229 nanosleep(&tp, 0);
1230 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1231
1232 AC_MSG_RESULT($ac_has_nanosleep)
1233 fi
1234 fi
1235
1236 if test x"$ac_has_clock_monotonic" = x"yes"; then
1237 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1238 [ Defined if clock_gettime has monotonic clock support. ])
1239 fi
1240
1241 if test x"$ac_has_clock_realtime" = x"yes"; then
1242 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1243 [ Defined if clock_gettime has realtime clock support. ])
1244 fi
1245
1246 if test x"$ac_has_nanosleep" = x"yes"; then
1247 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1248 [ Defined if nanosleep is available. ])
1249 fi
1250
1251 AC_SUBST(GLIBCXX_LIBS)
1252
1253 CXXFLAGS="$ac_save_CXXFLAGS"
1254 LIBS="$ac_save_LIBS"
1255 AC_LANG_RESTORE
1256 ])
1257
1258 dnl
1259 dnl Check for gettimeofday, used in the implementation of 20.8.5
1260 dnl [time.clock] in the current C++0x working draft.
1261 dnl
1262 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1263
1264 AC_MSG_CHECKING([for gettimeofday])
1265
1266 AC_LANG_SAVE
1267 AC_LANG_CPLUSPLUS
1268 ac_save_CXXFLAGS="$CXXFLAGS"
1269 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1270
1271 ac_has_gettimeofday=no;
1272 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1273 if test x"$ac_has_sys_time_h" = x"yes"; then
1274 AC_MSG_CHECKING([for gettimeofday])
1275 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1276 [timeval tv; gettimeofday(&tv, 0);],
1277 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1278
1279 AC_MSG_RESULT($ac_has_gettimeofday)
1280 fi
1281
1282 if test x"$ac_has_gettimeofday" = x"yes"; then
1283 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1284 [ Defined if gettimeofday is available. ])
1285 fi
1286
1287 CXXFLAGS="$ac_save_CXXFLAGS"
1288 AC_LANG_RESTORE
1289 ])
1290
1291 dnl
1292 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1293 dnl facilities in Chapter 8, "C compatibility".
1294 dnl
1295 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1296
1297 AC_LANG_SAVE
1298 AC_LANG_CPLUSPLUS
1299
1300 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1301 # undefined and fake C99 facilities may be spuriously enabled.
1302 ac_save_CXXFLAGS="$CXXFLAGS"
1303 CXXFLAGS="$CXXFLAGS -std=c++98"
1304
1305 # Check for the existence of <complex.h> complex math functions used
1306 # by tr1/complex.
1307 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1308 ac_c99_complex_tr1=no;
1309 if test x"$ac_has_complex_h" = x"yes"; then
1310 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1311 AC_TRY_COMPILE([#include <complex.h>],
1312 [typedef __complex__ float float_type; float_type tmpf;
1313 cacosf(tmpf);
1314 casinf(tmpf);
1315 catanf(tmpf);
1316 cacoshf(tmpf);
1317 casinhf(tmpf);
1318 catanhf(tmpf);
1319 typedef __complex__ double double_type; double_type tmpd;
1320 cacos(tmpd);
1321 casin(tmpd);
1322 catan(tmpd);
1323 cacosh(tmpd);
1324 casinh(tmpd);
1325 catanh(tmpd);
1326 typedef __complex__ long double ld_type; ld_type tmpld;
1327 cacosl(tmpld);
1328 casinl(tmpld);
1329 catanl(tmpld);
1330 cacoshl(tmpld);
1331 casinhl(tmpld);
1332 catanhl(tmpld);
1333 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1334 fi
1335 AC_MSG_RESULT($ac_c99_complex_tr1)
1336 if test x"$ac_c99_complex_tr1" = x"yes"; then
1337 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1338 [Define if C99 functions in <complex.h> should be used in
1339 <tr1/complex>. Using compiler builtins for these functions
1340 requires corresponding C99 library functions to be present.])
1341 fi
1342
1343 # Check for the existence of <ctype.h> functions.
1344 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1345 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1346 AC_TRY_COMPILE([#include <ctype.h>],
1347 [int ch;
1348 int ret;
1349 ret = isblank(ch);
1350 ],[glibcxx_cv_c99_ctype_tr1=yes],
1351 [glibcxx_cv_c99_ctype_tr1=no])
1352 ])
1353 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1354 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1355 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1356 [Define if C99 functions in <ctype.h> should be imported in
1357 <tr1/cctype> in namespace std::tr1.])
1358 fi
1359
1360 # Check for the existence of <fenv.h> functions.
1361 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1362 ac_c99_fenv_tr1=no;
1363 if test x"$ac_has_fenv_h" = x"yes"; then
1364 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1365 AC_TRY_COMPILE([#include <fenv.h>],
1366 [int except, mode;
1367 fexcept_t* pflag;
1368 fenv_t* penv;
1369 int ret;
1370 ret = feclearexcept(except);
1371 ret = fegetexceptflag(pflag, except);
1372 ret = feraiseexcept(except);
1373 ret = fesetexceptflag(pflag, except);
1374 ret = fetestexcept(except);
1375 ret = fegetround();
1376 ret = fesetround(mode);
1377 ret = fegetenv(penv);
1378 ret = feholdexcept(penv);
1379 ret = fesetenv(penv);
1380 ret = feupdateenv(penv);
1381 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1382 fi
1383 AC_MSG_RESULT($ac_c99_fenv_tr1)
1384 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1385 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1386 [Define if C99 functions in <fenv.h> should be imported in
1387 <tr1/cfenv> in namespace std::tr1.])
1388 fi
1389
1390 # Check for the existence of <stdint.h> types.
1391 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1392 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1393 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1394 #define __STDC_CONSTANT_MACROS
1395 #include <stdint.h>],
1396 [typedef int8_t my_int8_t;
1397 my_int8_t i8 = INT8_MIN;
1398 i8 = INT8_MAX;
1399 typedef int16_t my_int16_t;
1400 my_int16_t i16 = INT16_MIN;
1401 i16 = INT16_MAX;
1402 typedef int32_t my_int32_t;
1403 my_int32_t i32 = INT32_MIN;
1404 i32 = INT32_MAX;
1405 typedef int64_t my_int64_t;
1406 my_int64_t i64 = INT64_MIN;
1407 i64 = INT64_MAX;
1408 typedef int_fast8_t my_int_fast8_t;
1409 my_int_fast8_t if8 = INT_FAST8_MIN;
1410 if8 = INT_FAST8_MAX;
1411 typedef int_fast16_t my_int_fast16_t;
1412 my_int_fast16_t if16 = INT_FAST16_MIN;
1413 if16 = INT_FAST16_MAX;
1414 typedef int_fast32_t my_int_fast32_t;
1415 my_int_fast32_t if32 = INT_FAST32_MIN;
1416 if32 = INT_FAST32_MAX;
1417 typedef int_fast64_t my_int_fast64_t;
1418 my_int_fast64_t if64 = INT_FAST64_MIN;
1419 if64 = INT_FAST64_MAX;
1420 typedef int_least8_t my_int_least8_t;
1421 my_int_least8_t il8 = INT_LEAST8_MIN;
1422 il8 = INT_LEAST8_MAX;
1423 typedef int_least16_t my_int_least16_t;
1424 my_int_least16_t il16 = INT_LEAST16_MIN;
1425 il16 = INT_LEAST16_MAX;
1426 typedef int_least32_t my_int_least32_t;
1427 my_int_least32_t il32 = INT_LEAST32_MIN;
1428 il32 = INT_LEAST32_MAX;
1429 typedef int_least64_t my_int_least64_t;
1430 my_int_least64_t il64 = INT_LEAST64_MIN;
1431 il64 = INT_LEAST64_MAX;
1432 typedef intmax_t my_intmax_t;
1433 my_intmax_t im = INTMAX_MAX;
1434 im = INTMAX_MIN;
1435 typedef intptr_t my_intptr_t;
1436 my_intptr_t ip = INTPTR_MAX;
1437 ip = INTPTR_MIN;
1438 typedef uint8_t my_uint8_t;
1439 my_uint8_t ui8 = UINT8_MAX;
1440 ui8 = UINT8_MAX;
1441 typedef uint16_t my_uint16_t;
1442 my_uint16_t ui16 = UINT16_MAX;
1443 ui16 = UINT16_MAX;
1444 typedef uint32_t my_uint32_t;
1445 my_uint32_t ui32 = UINT32_MAX;
1446 ui32 = UINT32_MAX;
1447 typedef uint64_t my_uint64_t;
1448 my_uint64_t ui64 = UINT64_MAX;
1449 ui64 = UINT64_MAX;
1450 typedef uint_fast8_t my_uint_fast8_t;
1451 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1452 uif8 = UINT_FAST8_MAX;
1453 typedef uint_fast16_t my_uint_fast16_t;
1454 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1455 uif16 = UINT_FAST16_MAX;
1456 typedef uint_fast32_t my_uint_fast32_t;
1457 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1458 uif32 = UINT_FAST32_MAX;
1459 typedef uint_fast64_t my_uint_fast64_t;
1460 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1461 uif64 = UINT_FAST64_MAX;
1462 typedef uint_least8_t my_uint_least8_t;
1463 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1464 uil8 = UINT_LEAST8_MAX;
1465 typedef uint_least16_t my_uint_least16_t;
1466 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1467 uil16 = UINT_LEAST16_MAX;
1468 typedef uint_least32_t my_uint_least32_t;
1469 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1470 uil32 = UINT_LEAST32_MAX;
1471 typedef uint_least64_t my_uint_least64_t;
1472 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1473 uil64 = UINT_LEAST64_MAX;
1474 typedef uintmax_t my_uintmax_t;
1475 my_uintmax_t uim = UINTMAX_MAX;
1476 uim = UINTMAX_MAX;
1477 typedef uintptr_t my_uintptr_t;
1478 my_uintptr_t uip = UINTPTR_MAX;
1479 uip = UINTPTR_MAX;
1480 ],[glibcxx_cv_c99_stdint_tr1=yes],
1481 [glibcxx_cv_c99_stdint_tr1=no])
1482 ])
1483 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1484 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1485 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1486 [Define if C99 types in <stdint.h> should be imported in
1487 <tr1/cstdint> in namespace std::tr1.])
1488 fi
1489
1490 # Check for the existence of <math.h> functions.
1491 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1492 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1493 AC_TRY_COMPILE([#include <math.h>],
1494 [typedef double_t my_double_t;
1495 typedef float_t my_float_t;
1496 acosh(0.0);
1497 acoshf(0.0f);
1498 acoshl(0.0l);
1499 asinh(0.0);
1500 asinhf(0.0f);
1501 asinhl(0.0l);
1502 atanh(0.0);
1503 atanhf(0.0f);
1504 atanhl(0.0l);
1505 cbrt(0.0);
1506 cbrtf(0.0f);
1507 cbrtl(0.0l);
1508 copysign(0.0, 0.0);
1509 copysignf(0.0f, 0.0f);
1510 copysignl(0.0l, 0.0l);
1511 erf(0.0);
1512 erff(0.0f);
1513 erfl(0.0l);
1514 erfc(0.0);
1515 erfcf(0.0f);
1516 erfcl(0.0l);
1517 exp2(0.0);
1518 exp2f(0.0f);
1519 exp2l(0.0l);
1520 expm1(0.0);
1521 expm1f(0.0f);
1522 expm1l(0.0l);
1523 fdim(0.0, 0.0);
1524 fdimf(0.0f, 0.0f);
1525 fdiml(0.0l, 0.0l);
1526 fma(0.0, 0.0, 0.0);
1527 fmaf(0.0f, 0.0f, 0.0f);
1528 fmal(0.0l, 0.0l, 0.0l);
1529 fmax(0.0, 0.0);
1530 fmaxf(0.0f, 0.0f);
1531 fmaxl(0.0l, 0.0l);
1532 fmin(0.0, 0.0);
1533 fminf(0.0f, 0.0f);
1534 fminl(0.0l, 0.0l);
1535 hypot(0.0, 0.0);
1536 hypotf(0.0f, 0.0f);
1537 hypotl(0.0l, 0.0l);
1538 ilogb(0.0);
1539 ilogbf(0.0f);
1540 ilogbl(0.0l);
1541 lgamma(0.0);
1542 lgammaf(0.0f);
1543 lgammal(0.0l);
1544 llrint(0.0);
1545 llrintf(0.0f);
1546 llrintl(0.0l);
1547 llround(0.0);
1548 llroundf(0.0f);
1549 llroundl(0.0l);
1550 log1p(0.0);
1551 log1pf(0.0f);
1552 log1pl(0.0l);
1553 log2(0.0);
1554 log2f(0.0f);
1555 log2l(0.0l);
1556 logb(0.0);
1557 logbf(0.0f);
1558 logbl(0.0l);
1559 lrint(0.0);
1560 lrintf(0.0f);
1561 lrintl(0.0l);
1562 lround(0.0);
1563 lroundf(0.0f);
1564 lroundl(0.0l);
1565 nan(0);
1566 nanf(0);
1567 nanl(0);
1568 nearbyint(0.0);
1569 nearbyintf(0.0f);
1570 nearbyintl(0.0l);
1571 nextafter(0.0, 0.0);
1572 nextafterf(0.0f, 0.0f);
1573 nextafterl(0.0l, 0.0l);
1574 nexttoward(0.0, 0.0);
1575 nexttowardf(0.0f, 0.0f);
1576 nexttowardl(0.0l, 0.0l);
1577 remainder(0.0, 0.0);
1578 remainderf(0.0f, 0.0f);
1579 remainderl(0.0l, 0.0l);
1580 remquo(0.0, 0.0, 0);
1581 remquof(0.0f, 0.0f, 0);
1582 remquol(0.0l, 0.0l, 0);
1583 rint(0.0);
1584 rintf(0.0f);
1585 rintl(0.0l);
1586 round(0.0);
1587 roundf(0.0f);
1588 roundl(0.0l);
1589 scalbln(0.0, 0l);
1590 scalblnf(0.0f, 0l);
1591 scalblnl(0.0l, 0l);
1592 scalbn(0.0, 0);
1593 scalbnf(0.0f, 0);
1594 scalbnl(0.0l, 0);
1595 tgamma(0.0);
1596 tgammaf(0.0f);
1597 tgammal(0.0l);
1598 trunc(0.0);
1599 truncf(0.0f);
1600 truncl(0.0l);
1601 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1602 ])
1603 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1604 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1605 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1606 [Define if C99 functions or macros in <math.h> should be imported
1607 in <tr1/cmath> in namespace std::tr1.])
1608 fi
1609
1610 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1611 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1612 ac_c99_inttypes_tr1=no;
1613 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1614 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1615 AC_TRY_COMPILE([#include <inttypes.h>],
1616 [intmax_t i, numer, denom, base;
1617 const char* s;
1618 char** endptr;
1619 intmax_t ret = imaxabs(i);
1620 imaxdiv_t dret = imaxdiv(numer, denom);
1621 ret = strtoimax(s, endptr, base);
1622 uintmax_t uret = strtoumax(s, endptr, base);
1623 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1624 fi
1625 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1626 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1627 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1628 [Define if C99 functions in <inttypes.h> should be imported in
1629 <tr1/cinttypes> in namespace std::tr1.])
1630 fi
1631
1632 # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1633 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1634 ac_c99_inttypes_wchar_t_tr1=no;
1635 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1636 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1637 AC_TRY_COMPILE([#include <inttypes.h>],
1638 [intmax_t base;
1639 const wchar_t* s;
1640 wchar_t** endptr;
1641 intmax_t ret = wcstoimax(s, endptr, base);
1642 uintmax_t uret = wcstoumax(s, endptr, base);
1643 ],[ac_c99_inttypes_wchar_t_tr1=yes],
1644 [ac_c99_inttypes_wchar_t_tr1=no])
1645 fi
1646 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1647 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1648 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1649 [Define if wchar_t C99 functions in <inttypes.h> should be
1650 imported in <tr1/cinttypes> in namespace std::tr1.])
1651 fi
1652
1653 # Check for the existence of the <stdbool.h> header.
1654 AC_CHECK_HEADERS(stdbool.h)
1655
1656 # Check for the existence of the <stdalign.h> header.
1657 AC_CHECK_HEADERS(stdalign.h)
1658
1659 CXXFLAGS="$ac_save_CXXFLAGS"
1660 AC_LANG_RESTORE
1661 ])
1662
1663 dnl
1664 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1665 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1666 dnl
1667 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1668
1669 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1670 AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1671 if test -r /dev/random && test -r /dev/urandom; then
1672 glibcxx_cv_random_tr1=yes;
1673 else
1674 glibcxx_cv_random_tr1=no;
1675 fi
1676 ])
1677 AC_MSG_RESULT($glibcxx_cv_random_tr1)
1678
1679 if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1680 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1681 [Define if /dev/random and /dev/urandom are available for
1682 the random_device of TR1 (Chapter 5.1).])
1683 fi
1684
1685 ])
1686
1687 dnl
1688 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
1689 dnl
1690 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
1691
1692 AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
1693 AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
1694 [#include <stdio.h>],
1695 [AC_MSG_ERROR([computing EOF failed])])
1696 ])
1697 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
1698 [Define to the value of the EOF integer constant.])
1699
1700 AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
1701 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
1702 [#include <stdio.h>],
1703 [AC_MSG_ERROR([computing SEEK_CUR failed])])
1704 ])
1705 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
1706 [Define to the value of the SEEK_CUR integer constant.])
1707
1708 AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
1709 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
1710 [#include <stdio.h>],
1711 [AC_MSG_ERROR([computing SEEK_END failed])])
1712 ])
1713 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
1714 [Define to the value of the SEEK_END integer constant.])
1715 ])
1716
1717 dnl
1718 dnl Check whether required C++ overloads are present in <stdio.h>.
1719 dnl
1720 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
1721
1722 AC_LANG_SAVE
1723 AC_LANG_CPLUSPLUS
1724
1725 AC_MSG_CHECKING([for gets declaration])
1726 AC_CACHE_VAL(glibcxx_cv_gets, [
1727 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1728 [#include <stdio.h>
1729 namespace test
1730 {
1731 using ::gets;
1732 }
1733 ])],
1734 [glibcxx_cv_gets=yes],
1735 [glibcxx_cv_gets=no]
1736 )])
1737
1738 if test $glibcxx_cv_gets = yes; then
1739 AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h>.])
1740 fi
1741 AC_MSG_RESULT($glibcxx_cv_gets)
1742
1743 AC_LANG_RESTORE
1744 ])
1745
1746 dnl
1747 dnl Check whether macros, etc are present for <system_error>
1748 dnl
1749 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1750
1751 m4_pushdef([n_syserr], [1])dnl
1752 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1753 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1754 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
1755 ECHILD, ENOSPC, EPERM,
1756 ETIMEDOUT, EWOULDBLOCK],
1757 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1758 AC_MSG_CHECKING([for syserr])
1759 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1760 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1761 [int i = syserr;])],
1762 [glibcxx_cv_system_error[]n_syserr=yes],
1763 [glibcxx_cv_system_error[]n_syserr=no])
1764 ])
1765 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1766 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1767 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1768 fi
1769 m4_define([n_syserr], m4_incr(n_syserr))dnl
1770 m4_popdef([SYSERR])dnl
1771 ])
1772 m4_popdef([n_syserr])dnl
1773 ])
1774
1775 dnl
1776 dnl Check for what type of C headers to use.
1777 dnl
1778 dnl --enable-cheaders= [does stuff].
1779 dnl --disable-cheaders [does not do anything, really].
1780 dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1781 dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1782 dnl
1783 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1784 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
1785 [construct "C" headers for g++], [permit c|c_std|c_global])
1786 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1787
1788 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1789
1790 # Allow overrides to configure.host here.
1791 if test $enable_cheaders = c_global; then
1792 c_compatibility=yes
1793 fi
1794
1795 AC_SUBST(C_INCLUDE_DIR)
1796 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1797 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1798 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1799 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1800 ])
1801
1802
1803 dnl
1804 dnl Check for which locale library to use. The choice is mapped to
1805 dnl a subdirectory of config/locale.
1806 dnl
1807 dnl Default is generic.
1808 dnl
1809 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1810 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
1811 [use MODEL for target locale package],
1812 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
1813
1814 # Deal with gettext issues. Default to not using it (=no) until we detect
1815 # support for it later. Let the user turn it off via --e/d, but let that
1816 # default to on for easier handling.
1817 USE_NLS=no
1818 AC_ARG_ENABLE(nls,
1819 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1820 [],
1821 [enable_nls=yes])
1822
1823 # Either a known package, or "auto"
1824 if test $enable_clocale = no || test $enable_clocale = yes; then
1825 enable_clocale=auto
1826 fi
1827 enable_clocale_flag=$enable_clocale
1828
1829 # Probe for locale model to use if none specified.
1830 # Default to "generic".
1831 if test $enable_clocale_flag = auto; then
1832 case ${target_os} in
1833 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1834 enable_clocale_flag=gnu
1835 ;;
1836 darwin* | freebsd*)
1837 enable_clocale_flag=darwin
1838 ;;
1839 *)
1840 if test x"$with_newlib" = x"yes"; then
1841 enable_clocale_flag=newlib
1842 else
1843 enable_clocale_flag=generic
1844 fi
1845 ;;
1846 esac
1847 fi
1848
1849 # Sanity check model, and test for special functionality.
1850 if test $enable_clocale_flag = gnu; then
1851 AC_EGREP_CPP([_GLIBCXX_ok], [
1852 #include <features.h>
1853 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1854 _GLIBCXX_ok
1855 #endif
1856 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1857
1858 # Set it to scream when it hurts.
1859 ac_save_CFLAGS="$CFLAGS"
1860 CFLAGS="-Wimplicit-function-declaration -Werror"
1861
1862 # Use strxfrm_l if available.
1863 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1864 #include <string.h>
1865 #include <locale.h>],
1866 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1867 AC_DEFINE(HAVE_STRXFRM_L, 1,
1868 [Define if strxfrm_l is available in <string.h>.]),)
1869
1870 # Use strerror_l if available.
1871 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1872 #include <string.h>
1873 #include <locale.h>],
1874 [__locale_t loc; strerror_l(5, loc);],
1875 AC_DEFINE(HAVE_STRERROR_L, 1,
1876 [Define if strerror_l is available in <string.h>.]),)
1877
1878 CFLAGS="$ac_save_CFLAGS"
1879 fi
1880
1881 # Perhaps use strerror_r if available, and strerror_l isn't.
1882 ac_save_CFLAGS="$CFLAGS"
1883 CFLAGS="-Wimplicit-function-declaration -Werror"
1884 AC_TRY_COMPILE([#define _GNU_SOURCE 1
1885 #include <string.h>
1886 #include <locale.h>],
1887 [char s[128]; strerror_r(5, s, 128);],
1888 AC_DEFINE(HAVE_STRERROR_R, 1,
1889 [Define if strerror_r is available in <string.h>.]),)
1890 CFLAGS="$ac_save_CFLAGS"
1891
1892 # Set configure bits for specified locale package
1893 AC_MSG_CHECKING([for C locale to use])
1894 case ${enable_clocale_flag} in
1895 generic)
1896 AC_MSG_RESULT(generic)
1897
1898 CLOCALE_H=config/locale/generic/c_locale.h
1899 CLOCALE_CC=config/locale/generic/c_locale.cc
1900 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1901 CCOLLATE_CC=config/locale/generic/collate_members.cc
1902 CCTYPE_CC=config/locale/generic/ctype_members.cc
1903 CMESSAGES_H=config/locale/generic/messages_members.h
1904 CMESSAGES_CC=config/locale/generic/messages_members.cc
1905 CMONEY_CC=config/locale/generic/monetary_members.cc
1906 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1907 CTIME_H=config/locale/generic/time_members.h
1908 CTIME_CC=config/locale/generic/time_members.cc
1909 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1910 ;;
1911 darwin)
1912 AC_MSG_RESULT(darwin or freebsd)
1913
1914 CLOCALE_H=config/locale/generic/c_locale.h
1915 CLOCALE_CC=config/locale/generic/c_locale.cc
1916 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1917 CCOLLATE_CC=config/locale/generic/collate_members.cc
1918 CCTYPE_CC=config/locale/darwin/ctype_members.cc
1919 CMESSAGES_H=config/locale/generic/messages_members.h
1920 CMESSAGES_CC=config/locale/generic/messages_members.cc
1921 CMONEY_CC=config/locale/generic/monetary_members.cc
1922 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1923 CTIME_H=config/locale/generic/time_members.h
1924 CTIME_CC=config/locale/generic/time_members.cc
1925 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1926 ;;
1927
1928 gnu)
1929 AC_MSG_RESULT(gnu)
1930
1931 # Declare intention to use gettext, and add support for specific
1932 # languages.
1933 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1934 ALL_LINGUAS="de fr"
1935
1936 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1937 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1938 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1939 USE_NLS=yes
1940 fi
1941 # Export the build objects.
1942 for ling in $ALL_LINGUAS; do \
1943 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1944 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1945 done
1946 AC_SUBST(glibcxx_MOFILES)
1947 AC_SUBST(glibcxx_POFILES)
1948
1949 CLOCALE_H=config/locale/gnu/c_locale.h
1950 CLOCALE_CC=config/locale/gnu/c_locale.cc
1951 CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1952 CCOLLATE_CC=config/locale/gnu/collate_members.cc
1953 CCTYPE_CC=config/locale/gnu/ctype_members.cc
1954 CMESSAGES_H=config/locale/gnu/messages_members.h
1955 CMESSAGES_CC=config/locale/gnu/messages_members.cc
1956 CMONEY_CC=config/locale/gnu/monetary_members.cc
1957 CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1958 CTIME_H=config/locale/gnu/time_members.h
1959 CTIME_CC=config/locale/gnu/time_members.cc
1960 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1961 ;;
1962 ieee_1003.1-2001)
1963 AC_MSG_RESULT(IEEE 1003.1)
1964
1965 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1966 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1967 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1968 CCOLLATE_CC=config/locale/generic/collate_members.cc
1969 CCTYPE_CC=config/locale/generic/ctype_members.cc
1970 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1971 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1972 CMONEY_CC=config/locale/generic/monetary_members.cc
1973 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1974 CTIME_H=config/locale/generic/time_members.h
1975 CTIME_CC=config/locale/generic/time_members.cc
1976 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1977 ;;
1978 newlib)
1979 AC_MSG_RESULT(newlib)
1980
1981 CLOCALE_H=config/locale/generic/c_locale.h
1982 CLOCALE_CC=config/locale/generic/c_locale.cc
1983 CCODECVT_CC=config/locale/generic/codecvt_members.cc
1984 CCOLLATE_CC=config/locale/generic/collate_members.cc
1985 CCTYPE_CC=config/locale/newlib/ctype_members.cc
1986 CMESSAGES_H=config/locale/generic/messages_members.h
1987 CMESSAGES_CC=config/locale/generic/messages_members.cc
1988 CMONEY_CC=config/locale/generic/monetary_members.cc
1989 CNUMERIC_CC=config/locale/generic/numeric_members.cc
1990 CTIME_H=config/locale/generic/time_members.h
1991 CTIME_CC=config/locale/generic/time_members.cc
1992 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1993 ;;
1994 esac
1995
1996 # This is where the testsuite looks for locale catalogs, using the
1997 # -DLOCALEDIR define during testsuite compilation.
1998 glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1999 AC_SUBST(glibcxx_localedir)
2000
2001 # A standalone libintl (e.g., GNU libintl) may be in use.
2002 if test $USE_NLS = yes; then
2003 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2004 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2005 fi
2006 if test $USE_NLS = yes; then
2007 AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2008 [Define if NLS translations are to be used.])
2009 fi
2010
2011 AC_SUBST(USE_NLS)
2012 AC_SUBST(CLOCALE_H)
2013 AC_SUBST(CMESSAGES_H)
2014 AC_SUBST(CCODECVT_CC)
2015 AC_SUBST(CCOLLATE_CC)
2016 AC_SUBST(CCTYPE_CC)
2017 AC_SUBST(CMESSAGES_CC)
2018 AC_SUBST(CMONEY_CC)
2019 AC_SUBST(CNUMERIC_CC)
2020 AC_SUBST(CTIME_H)
2021 AC_SUBST(CTIME_CC)
2022 AC_SUBST(CLOCALE_CC)
2023 AC_SUBST(CLOCALE_INTERNAL_H)
2024 ])
2025
2026
2027 dnl
2028 dnl Check for which std::allocator base class to use. The choice is
2029 dnl mapped from a subdirectory of include/ext.
2030 dnl
2031 dnl Default is new.
2032 dnl
2033 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2034 AC_MSG_CHECKING([for std::allocator base class])
2035 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2036 [use KIND for target std::allocator base],
2037 [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2038
2039 # If they didn't use this option switch, or if they specified --enable
2040 # with no specific model, we'll have to look for one. If they
2041 # specified --disable (???), do likewise.
2042 if test $enable_libstdcxx_allocator = no ||
2043 test $enable_libstdcxx_allocator = yes;
2044 then
2045 enable_libstdcxx_allocator=auto
2046 fi
2047
2048 # Either a known package, or "auto". Auto implies the default choice
2049 # for a particular platform.
2050 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2051
2052 # Probe for host-specific support if no specific model is specified.
2053 # Default to "new".
2054 if test $enable_libstdcxx_allocator_flag = auto; then
2055 case ${target_os} in
2056 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2057 enable_libstdcxx_allocator_flag=new
2058 ;;
2059 *)
2060 enable_libstdcxx_allocator_flag=new
2061 ;;
2062 esac
2063 fi
2064 AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2065
2066
2067 # Set configure bits for specified locale package
2068 case ${enable_libstdcxx_allocator_flag} in
2069 bitmap)
2070 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2071 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2072 ;;
2073 malloc)
2074 ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2075 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2076 ;;
2077 mt)
2078 ALLOCATOR_H=config/allocator/mt_allocator_base.h
2079 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2080 ;;
2081 new)
2082 ALLOCATOR_H=config/allocator/new_allocator_base.h
2083 ALLOCATOR_NAME=__gnu_cxx::new_allocator
2084 ;;
2085 pool)
2086 ALLOCATOR_H=config/allocator/pool_allocator_base.h
2087 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2088 ;;
2089 esac
2090
2091 AC_SUBST(ALLOCATOR_H)
2092 AC_SUBST(ALLOCATOR_NAME)
2093 ])
2094
2095
2096 dnl
2097 dnl Check for whether the Boost-derived checks should be turned on.
2098 dnl
2099 dnl --enable-concept-checks turns them on.
2100 dnl --disable-concept-checks leaves them off.
2101 dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2102 dnl Where DEFAULT is either `yes' or `no'.
2103 dnl
2104 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2105 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2106 if test $enable_concept_checks = yes; then
2107 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2108 [Define to use concept checking code from the boost libraries.])
2109 fi
2110 ])
2111
2112 dnl
2113 dnl Use extern templates.
2114 dnl
2115 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2116 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2117
2118 dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2119 dnl Where DEFAULT is `yes' or `no'.
2120 dnl
2121 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2122
2123 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2124
2125 AC_MSG_CHECKING([for extern template support])
2126 AC_MSG_RESULT([$enable_extern_template])
2127
2128 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2129 ])
2130
2131 dnl
2132 dnl Check for parallel mode pre-requisites, including OpenMP support.
2133 dnl
2134 dnl + Usage: GLIBCXX_ENABLE_PARALLEL
2135 dnl
2136 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2137
2138 enable_parallel=no;
2139
2140 # See if configured libgomp/omp.h exists. (libgomp may be in
2141 # noconfigdirs but not explicitly disabled.)
2142 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2143 enable_parallel=yes;
2144 else
2145 AC_MSG_NOTICE([target-libgomp not built])
2146 fi
2147
2148 AC_MSG_CHECKING([for parallel mode support])
2149 AC_MSG_RESULT([$enable_parallel])
2150 GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2151 ])
2152
2153
2154 dnl
2155 dnl Check for which I/O library to use: stdio, or something specific.
2156 dnl
2157 dnl Default is stdio.
2158 dnl
2159 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2160 AC_MSG_CHECKING([for underlying I/O to use])
2161 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2162 [use target-specific I/O package], [permit stdio])
2163
2164 # Now that libio has been removed, you can have any color you want as long
2165 # as it's black. This is one big no-op until other packages are added, but
2166 # showing the framework never hurts.
2167 case ${enable_cstdio} in
2168 stdio)
2169 CSTDIO_H=config/io/c_io_stdio.h
2170 BASIC_FILE_H=config/io/basic_file_stdio.h
2171 BASIC_FILE_CC=config/io/basic_file_stdio.cc
2172 AC_MSG_RESULT(stdio)
2173 ;;
2174 esac
2175
2176 AC_SUBST(CSTDIO_H)
2177 AC_SUBST(BASIC_FILE_H)
2178 AC_SUBST(BASIC_FILE_CC)
2179 ])
2180
2181
2182 dnl
2183 dnl Check for "unusual" flags to pass to the compiler while building.
2184 dnl
2185 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2186 dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2187 dnl --disable-cxx-flags passes nothing.
2188 dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2189 dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2190 dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2191 dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2192 dnl If "default flags" is an empty string, the effect is the same
2193 dnl as --disable or --enable=no.
2194 dnl
2195 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2196 AC_MSG_CHECKING([for extra compiler flags for building])
2197 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2198 [pass compiler FLAGS when building library],
2199 [case "x$enable_cxx_flags" in
2200 xno | x) enable_cxx_flags= ;;
2201 x-*) ;;
2202 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2203 esac])
2204
2205 # Run through flags (either default or command-line) and set anything
2206 # extra (e.g., #defines) that must accompany particular g++ options.
2207 if test -n "$enable_cxx_flags"; then
2208 for f in $enable_cxx_flags; do
2209 case "$f" in
2210 -fhonor-std) ;;
2211 -*) ;;
2212 *) # and we're trying to pass /what/ exactly?
2213 AC_MSG_ERROR([compiler flags start with a -]) ;;
2214 esac
2215 done
2216 fi
2217
2218 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2219 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2220 AC_SUBST(EXTRA_CXX_FLAGS)
2221 ])
2222
2223
2224 dnl
2225 dnl Check to see if debugging libraries are to be built.
2226 dnl
2227 dnl --enable-libstdcxx-debug
2228 dnl builds a separate set of debugging libraries in addition to the
2229 dnl normal (shared, static) libstdc++ binaries.
2230 dnl
2231 dnl --disable-libstdcxx-debug
2232 dnl builds only one (non-debug) version of libstdc++.
2233 dnl
2234 dnl --enable-libstdcxx-debug-flags=FLAGS
2235 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2236 dnl
2237 dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2238 dnl Where DEFAULT is either `yes' or `no'.
2239 dnl
2240 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2241 AC_MSG_CHECKING([for additional debug build])
2242 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2243 AC_MSG_RESULT($enable_libstdcxx_debug)
2244 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2245 ])
2246
2247
2248 dnl
2249 dnl Check for explicit debug flags.
2250 dnl
2251 dnl --enable-libstdcxx-debug-flags='-O1'
2252 dnl is a general method for passing flags to be used when
2253 dnl building debug libraries with --enable-debug.
2254 dnl
2255 dnl --disable-libstdcxx-debug-flags does nothing.
2256 dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2257 dnl If "default flags" is an empty string, the effect is the same
2258 dnl as --disable or --enable=no.
2259 dnl
2260 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2261 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2262 [pass compiler FLAGS when building debug library],
2263 [case "x$enable_libstdcxx_debug_flags" in
2264 xno | x) enable_libstdcxx_debug_flags= ;;
2265 x-*) ;;
2266 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2267 esac])
2268
2269 # Option parsed, now set things appropriately
2270 DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2271 AC_SUBST(DEBUG_FLAGS)
2272
2273 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2274 ])
2275
2276
2277 dnl
2278 dnl Check if the user only wants a freestanding library implementation.
2279 dnl
2280 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2281 dnl installing only the headers required by [17.4.1.3] and the language
2282 dnl support library. More than that will be built (to keep the Makefiles
2283 dnl conveniently clean), but not installed.
2284 dnl
2285 dnl Sets:
2286 dnl is_hosted (yes/no)
2287 dnl
2288 dnl Defines:
2289 dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0)
2290 dnl
2291 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2292 AC_ARG_ENABLE([hosted-libstdcxx],
2293 AC_HELP_STRING([--disable-hosted-libstdcxx],
2294 [only build freestanding C++ runtime support]),,
2295 [case "$host" in
2296 arm*-*-symbianelf*)
2297 enable_hosted_libstdcxx=no
2298 ;;
2299 *)
2300 enable_hosted_libstdcxx=yes
2301 ;;
2302 esac])
2303 if test "$enable_hosted_libstdcxx" = no; then
2304 AC_MSG_NOTICE([Only freestanding libraries will be built])
2305 is_hosted=no
2306 hosted_define=0
2307 enable_abi_check=no
2308 enable_libstdcxx_pch=no
2309 else
2310 is_hosted=yes
2311 hosted_define=1
2312 fi
2313 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2314 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2315 [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2316 ])
2317
2318
2319 dnl
2320 dnl Check for template specializations for the 'long long' type.
2321 dnl The result determines only whether 'long long' I/O is enabled; things
2322 dnl like numeric_limits<> specializations are always available.
2323 dnl
2324 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2325 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2326 dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2327 dnl Where DEFAULT is either `yes' or `no'.
2328 dnl
2329 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2330 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2331 if test $enable_long_long = yes; then
2332 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2333 [Define if code specialized for long long should be used.])
2334 fi
2335 AC_MSG_CHECKING([for enabled long long specializations])
2336 AC_MSG_RESULT([$enable_long_long])
2337 ])
2338
2339
2340 dnl
2341 dnl Check for decimal floating point.
2342 dnl See:
2343 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2344 dnl
2345 dnl This checks to see if the host supports decimal floating point types.
2346 dnl
2347 dnl Defines:
2348 dnl _GLIBCXX_USE_DECIMAL_FLOAT
2349 dnl
2350 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2351
2352 # Fake what AC_TRY_COMPILE does, without linking as this is
2353 # unnecessary for this test.
2354
2355 cat > conftest.$ac_ext << EOF
2356 [#]line __oline__ "configure"
2357 int main()
2358 {
2359 _Decimal32 d1;
2360 _Decimal64 d2;
2361 _Decimal128 d3;
2362 return 0;
2363 }
2364 EOF
2365
2366 AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2367 if AC_TRY_EVAL(ac_compile); then
2368 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2369 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2370 enable_dfp=yes
2371 else
2372 enable_dfp=no
2373 fi
2374 AC_MSG_RESULT($enable_dfp)
2375 rm -f conftest*
2376 ])
2377
2378 dnl
2379 dnl Check for GNU 128-bit integer and floating point types.
2380 dnl
2381 dnl Note: also checks that the types aren't standard types.
2382 dnl
2383 dnl Defines:
2384 dnl _GLIBCXX_USE_INT128
2385 dnl _GLIBCXX_USE_FLOAT128
2386 dnl
2387 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
2388
2389 AC_LANG_SAVE
2390 AC_LANG_CPLUSPLUS
2391
2392 # Fake what AC_TRY_COMPILE does, without linking as this is
2393 # unnecessary for this test.
2394
2395 cat > conftest.$ac_ext << EOF
2396 [#]line __oline__ "configure"
2397 template<typename T1, typename T2>
2398 struct same
2399 { typedef T2 type; };
2400
2401 template<typename T>
2402 struct same<T, T>;
2403
2404 int main()
2405 {
2406 typename same<long, __int128>::type i1;
2407 typename same<long long, __int128>::type i2;
2408 }
2409 EOF
2410
2411 AC_MSG_CHECKING([for __int128])
2412 if AC_TRY_EVAL(ac_compile); then
2413 AC_DEFINE(_GLIBCXX_USE_INT128, 1,
2414 [Define if __int128 is supported on this host.])
2415 enable_int128=yes
2416 else
2417 enable_int128=no
2418 fi
2419 AC_MSG_RESULT($enable_int128)
2420 rm -f conftest*
2421
2422 cat > conftest.$ac_ext << EOF
2423 [#]line __oline__ "configure"
2424 template<typename T1, typename T2>
2425 struct same
2426 { typedef T2 type; };
2427
2428 template<typename T>
2429 struct same<T, T>;
2430
2431 int main()
2432 {
2433 typename same<double, __float128>::type f1;
2434 typename same<long double, __float128>::type f2;
2435 }
2436 EOF
2437
2438 AC_MSG_CHECKING([for __float128])
2439 if AC_TRY_EVAL(ac_compile); then
2440 AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
2441 [Define if __float128 is supported on this host.])
2442 enable_float128=yes
2443 else
2444 enable_float128=no
2445 fi
2446 AC_MSG_RESULT($enable_float128)
2447 rm -f conftest*
2448
2449 AC_LANG_RESTORE
2450 ])
2451
2452 dnl
2453 dnl Check for template specializations for the 'wchar_t' type.
2454 dnl
2455 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2456 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2457 dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2458 dnl Where DEFAULT is either `yes' or `no'.
2459 dnl
2460 dnl Necessary support must also be present.
2461 dnl
2462 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2463 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2464
2465 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2466 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2467 AC_MSG_CHECKING([for mbstate_t])
2468 AC_TRY_COMPILE([#include <wchar.h>],
2469 [mbstate_t teststate;],
2470 have_mbstate_t=yes, have_mbstate_t=no)
2471 AC_MSG_RESULT($have_mbstate_t)
2472 if test x"$have_mbstate_t" = xyes; then
2473 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2474 fi
2475
2476 # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2477 # ac_has_wchar_h.
2478 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2479
2480 if test x"$enable_wchar_t" = x"yes"; then
2481
2482 AC_LANG_SAVE
2483 AC_LANG_CPLUSPLUS
2484
2485 if test x"$ac_has_wchar_h" = xyes &&
2486 test x"$ac_has_wctype_h" = xyes; then
2487 AC_TRY_COMPILE([#include <wchar.h>
2488 #include <stddef.h>
2489 wint_t i;
2490 long l = WEOF;
2491 long j = WCHAR_MIN;
2492 long k = WCHAR_MAX;
2493 namespace test
2494 {
2495 using ::btowc;
2496 using ::fgetwc;
2497 using ::fgetws;
2498 using ::fputwc;
2499 using ::fputws;
2500 using ::fwide;
2501 using ::fwprintf;
2502 using ::fwscanf;
2503 using ::getwc;
2504 using ::getwchar;
2505 using ::mbrlen;
2506 using ::mbrtowc;
2507 using ::mbsinit;
2508 using ::mbsrtowcs;
2509 using ::putwc;
2510 using ::putwchar;
2511 using ::swprintf;
2512 using ::swscanf;
2513 using ::ungetwc;
2514 using ::vfwprintf;
2515 using ::vswprintf;
2516 using ::vwprintf;
2517 using ::wcrtomb;
2518 using ::wcscat;
2519 using ::wcschr;
2520 using ::wcscmp;
2521 using ::wcscoll;
2522 using ::wcscpy;
2523 using ::wcscspn;
2524 using ::wcsftime;
2525 using ::wcslen;
2526 using ::wcsncat;
2527 using ::wcsncmp;
2528 using ::wcsncpy;
2529 using ::wcspbrk;
2530 using ::wcsrchr;
2531 using ::wcsrtombs;
2532 using ::wcsspn;
2533 using ::wcsstr;
2534 using ::wcstod;
2535 using ::wcstok;
2536 using ::wcstol;
2537 using ::wcstoul;
2538 using ::wcsxfrm;
2539 using ::wctob;
2540 using ::wmemchr;
2541 using ::wmemcmp;
2542 using ::wmemcpy;
2543 using ::wmemmove;
2544 using ::wmemset;
2545 using ::wprintf;
2546 using ::wscanf;
2547 }
2548 ],[],[], [enable_wchar_t=no])
2549 else
2550 enable_wchar_t=no
2551 fi
2552
2553 AC_LANG_RESTORE
2554 fi
2555
2556 if test x"$enable_wchar_t" = x"yes"; then
2557 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2558 [Define if code specialized for wchar_t should be used.])
2559 fi
2560
2561 AC_MSG_CHECKING([for enabled wchar_t specializations])
2562 AC_MSG_RESULT([$enable_wchar_t])
2563 ])
2564
2565
2566 dnl
2567 dnl Check to see if building and using a C++ precompiled header can be done.
2568 dnl
2569 dnl --enable-libstdcxx-pch=yes
2570 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2571 dnl may work, after some light-hearted attempts to puzzle out compiler
2572 dnl support, flip bits on in include/Makefile.am
2573 dnl
2574 dnl --disable-libstdcxx-pch
2575 dnl turns off attempts to use or build stdc++.h.gch.
2576 dnl
2577 dnl Substs:
2578 dnl glibcxx_PCHFLAGS
2579 dnl
2580 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2581 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2582 if test $enable_libstdcxx_pch = yes; then
2583 AC_CACHE_CHECK([for compiler with PCH support],
2584 [glibcxx_cv_prog_CXX_pch],
2585 [ac_save_CXXFLAGS="$CXXFLAGS"
2586 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2587 AC_LANG_SAVE
2588 AC_LANG_CPLUSPLUS
2589 echo '#include <math.h>' > conftest.h
2590 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2591 -o conftest.h.gch 1>&5 2>&1 &&
2592 echo '#error "pch failed"' > conftest.h &&
2593 echo '#include "conftest.h"' > conftest.cc &&
2594 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2595 then
2596 glibcxx_cv_prog_CXX_pch=yes
2597 else
2598 glibcxx_cv_prog_CXX_pch=no
2599 fi
2600 rm -f conftest*
2601 CXXFLAGS=$ac_save_CXXFLAGS
2602 AC_LANG_RESTORE
2603 ])
2604 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2605 fi
2606
2607 AC_MSG_CHECKING([for enabled PCH])
2608 AC_MSG_RESULT([$enable_libstdcxx_pch])
2609
2610 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2611 if test $enable_libstdcxx_pch = yes; then
2612 glibcxx_PCHFLAGS="-include bits/stdc++.h"
2613 else
2614 glibcxx_PCHFLAGS=""
2615 fi
2616 AC_SUBST(glibcxx_PCHFLAGS)
2617 ])
2618
2619
2620 dnl
2621 dnl Check for atomic builtins.
2622 dnl See:
2623 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
2624 dnl
2625 dnl This checks to see if the host supports the compiler-generated
2626 dnl builtins for atomic operations for various integral sizes. Note, this
2627 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2628 dnl that are used should be checked.
2629 dnl
2630 dnl Note:
2631 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2632 dnl
2633 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2634 AC_LANG_SAVE
2635 AC_LANG_CPLUSPLUS
2636 old_CXXFLAGS="$CXXFLAGS"
2637
2638 # Do link tests if possible, instead asm tests, limited to some platforms
2639 # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2640 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2641 atomic_builtins_link_tests=no
2642 if test x$gcc_no_link != xyes; then
2643 # Can do link tests. Limit to some tested platforms
2644 case "$host" in
2645 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2646 atomic_builtins_link_tests=yes
2647 ;;
2648 esac
2649 fi
2650
2651 if test x$atomic_builtins_link_tests = xyes; then
2652
2653 # Do link tests.
2654
2655 CXXFLAGS="$CXXFLAGS -fno-exceptions"
2656
2657 AC_MSG_CHECKING([for atomic builtins for bool])
2658 AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2659 AC_TRY_LINK(
2660 [ ],
2661 [typedef bool atomic_type;
2662 atomic_type c1;
2663 atomic_type c2;
2664 atomic_type c3(0);
2665 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2666 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2667 __ATOMIC_RELAXED);
2668 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2669 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2670 ],
2671 [glibcxx_cv_atomic_bool=yes],
2672 [glibcxx_cv_atomic_bool=no])
2673 ])
2674 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2675
2676 AC_MSG_CHECKING([for atomic builtins for short])
2677 AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2678 AC_TRY_LINK(
2679 [ ],
2680 [typedef short atomic_type;
2681 atomic_type c1;
2682 atomic_type c2;
2683 atomic_type c3(0);
2684 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2685 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2686 __ATOMIC_RELAXED);
2687 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2688 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2689 ],
2690 [glibcxx_cv_atomic_short=yes],
2691 [glibcxx_cv_atomic_short=no])
2692 ])
2693 AC_MSG_RESULT($glibcxx_cv_atomic_short)
2694
2695 AC_MSG_CHECKING([for atomic builtins for int])
2696 AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2697 AC_TRY_LINK(
2698 [ ],
2699 [typedef int atomic_type;
2700 atomic_type c1;
2701 atomic_type c2;
2702 atomic_type c3(0);
2703 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2704 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2705 __ATOMIC_RELAXED);
2706 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2707 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2708 ],
2709 [glibcxx_cv_atomic_int=yes],
2710 [glibcxx_cv_atomic_int=no])
2711 ])
2712 AC_MSG_RESULT($glibcxx_cv_atomic_int)
2713
2714 AC_MSG_CHECKING([for atomic builtins for long long])
2715 AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2716 AC_TRY_LINK(
2717 [ ],
2718 [typedef long long atomic_type;
2719 atomic_type c1;
2720 atomic_type c2;
2721 atomic_type c3(0);
2722 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2723 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2724 __ATOMIC_RELAXED);
2725 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2726 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2727 ],
2728 [glibcxx_cv_atomic_long_long=yes],
2729 [glibcxx_cv_atomic_long_long=no])
2730 ])
2731 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2732
2733 else
2734
2735 # Do asm tests.
2736
2737 # Compile unoptimized.
2738 CXXFLAGS='-O0 -S'
2739
2740 # Fake what AC_TRY_COMPILE does.
2741
2742 cat > conftest.$ac_ext << EOF
2743 [#]line __oline__ "configure"
2744 int main()
2745 {
2746 typedef bool atomic_type;
2747 atomic_type c1;
2748 atomic_type c2;
2749 atomic_type c3(0);
2750 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2751 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2752 __ATOMIC_RELAXED);
2753 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2754 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2755
2756 return 0;
2757 }
2758 EOF
2759
2760 AC_MSG_CHECKING([for atomic builtins for bool])
2761 if AC_TRY_EVAL(ac_compile); then
2762 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2763 glibcxx_cv_atomic_bool=no
2764 else
2765 glibcxx_cv_atomic_bool=yes
2766 fi
2767 fi
2768 AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2769 rm -f conftest*
2770
2771 cat > conftest.$ac_ext << EOF
2772 [#]line __oline__ "configure"
2773 int main()
2774 {
2775 typedef short atomic_type;
2776 atomic_type c1;
2777 atomic_type c2;
2778 atomic_type c3(0);
2779 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2780 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2781 __ATOMIC_RELAXED);
2782 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2783 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2784
2785 return 0;
2786 }
2787 EOF
2788
2789 AC_MSG_CHECKING([for atomic builtins for short])
2790 if AC_TRY_EVAL(ac_compile); then
2791 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2792 glibcxx_cv_atomic_short=no
2793 else
2794 glibcxx_cv_atomic_short=yes
2795 fi
2796 fi
2797 AC_MSG_RESULT($glibcxx_cv_atomic_short)
2798 rm -f conftest*
2799
2800 cat > conftest.$ac_ext << EOF
2801 [#]line __oline__ "configure"
2802 int main()
2803 {
2804 // NB: _Atomic_word not necessarily int.
2805 typedef int atomic_type;
2806 atomic_type c1;
2807 atomic_type c2;
2808 atomic_type c3(0);
2809 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2810 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2811 __ATOMIC_RELAXED);
2812 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2813 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2814
2815 return 0;
2816 }
2817 EOF
2818
2819 AC_MSG_CHECKING([for atomic builtins for int])
2820 if AC_TRY_EVAL(ac_compile); then
2821 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2822 glibcxx_cv_atomic_int=no
2823 else
2824 glibcxx_cv_atomic_int=yes
2825 fi
2826 fi
2827 AC_MSG_RESULT($glibcxx_cv_atomic_int)
2828 rm -f conftest*
2829
2830 cat > conftest.$ac_ext << EOF
2831 [#]line __oline__ "configure"
2832 int main()
2833 {
2834 typedef long long atomic_type;
2835 atomic_type c1;
2836 atomic_type c2;
2837 atomic_type c3(0);
2838 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2839 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2840 __ATOMIC_RELAXED);
2841 __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2842 __atomic_load_n(&c1, __ATOMIC_RELAXED);
2843
2844 return 0;
2845 }
2846 EOF
2847
2848 AC_MSG_CHECKING([for atomic builtins for long long])
2849 if AC_TRY_EVAL(ac_compile); then
2850 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2851 glibcxx_cv_atomic_long_long=no
2852 else
2853 glibcxx_cv_atomic_long_long=yes
2854 fi
2855 fi
2856 AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2857 rm -f conftest*
2858
2859 fi
2860
2861 CXXFLAGS="$old_CXXFLAGS"
2862 AC_LANG_RESTORE
2863
2864 # Set atomicity_dir to builtins if all but the long long test above passes.
2865 if test $glibcxx_cv_atomic_bool = yes \
2866 && test $glibcxx_cv_atomic_short = yes \
2867 && test $glibcxx_cv_atomic_int = yes; then
2868 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2869 [Define if the compiler supports C++11 atomics.])
2870 atomicity_dir=cpu/generic/atomicity_builtins
2871 fi
2872
2873 # If still generic, set to mutex.
2874 if test $atomicity_dir = "cpu/generic" ; then
2875 atomicity_dir=cpu/generic/atomicity_mutex
2876 AC_MSG_WARN([No native atomic operations are provided for this platform.])
2877 if test "x$target_thread_file" = xsingle; then
2878 AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2879 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2880 else
2881 AC_MSG_WARN([They will be faked using a mutex.])
2882 AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2883 fi
2884 fi
2885
2886 ])
2887
2888
2889 dnl
2890 dnl Check for exception handling support. If an explicit enable/disable
2891 dnl sjlj exceptions is given, we don't have to detect. Otherwise the
2892 dnl target may or may not support call frame exceptions.
2893 dnl
2894 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2895 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2896 dnl Neither one forces an attempt at detection.
2897 dnl
2898 dnl Defines:
2899 dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2900 dnl
2901 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2902 AC_MSG_CHECKING([for exception model to use])
2903 AC_LANG_SAVE
2904 AC_LANG_CPLUSPLUS
2905 GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2906 [force use of builtin_setjmp for exceptions],
2907 [permit yes|no|auto])
2908
2909 if test $enable_sjlj_exceptions = auto; then
2910 # Botheration. Now we've got to detect the exception model. Link tests
2911 # against libgcc.a are problematic since we've not been given proper -L
2912 # bits for single-tree newlib and libgloss.
2913 #
2914 # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style.
2915 cat > conftest.$ac_ext << EOF
2916 [#]line __oline__ "configure"
2917 struct S { ~S(); };
2918 void bar();
2919 void foo()
2920 {
2921 S s;
2922 bar();
2923 }
2924 EOF
2925 old_CXXFLAGS="$CXXFLAGS"
2926 CXXFLAGS=-S
2927 if AC_TRY_EVAL(ac_compile); then
2928 if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2929 enable_sjlj_exceptions=yes
2930 elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2931 enable_sjlj_exceptions=no
2932 elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2933 enable_sjlj_exceptions=no
2934 fi
2935 fi
2936 CXXFLAGS="$old_CXXFLAGS"
2937 rm -f conftest*
2938 fi
2939
2940 # This is a tad weird, for hysterical raisins. We have to map
2941 # enable/disable to two different models.
2942 case $enable_sjlj_exceptions in
2943 yes)
2944 AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2945 [Define if the compiler is configured for setjmp/longjmp exceptions.])
2946 ac_exception_model_name=sjlj
2947 ;;
2948 no)
2949 ac_exception_model_name="call frame"
2950 ;;
2951 *)
2952 AC_MSG_ERROR([unable to detect exception model])
2953 ;;
2954 esac
2955 AC_LANG_RESTORE
2956 AC_MSG_RESULT($ac_exception_model_name)
2957 ])
2958
2959
2960 dnl
2961 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2962 dnl
2963 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
2964 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
2965 dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
2966 dnl Where DEFAULT is 'yes'.
2967 dnl
2968 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
2969 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
2970
2971 if test x$enable_libstdcxx_visibility = xyes ; then
2972 dnl all hail libgfortran
2973 dnl Check whether the target supports hidden visibility.
2974 AC_CACHE_CHECK([whether the target supports hidden visibility],
2975 glibcxx_cv_have_attribute_visibility, [
2976 save_CFLAGS="$CFLAGS"
2977 CFLAGS="$CFLAGS -Werror"
2978 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2979 [], glibcxx_cv_have_attribute_visibility=yes,
2980 glibcxx_cv_have_attribute_visibility=no)
2981 CFLAGS="$save_CFLAGS"])
2982 if test $glibcxx_cv_have_attribute_visibility = no; then
2983 enable_libstdcxx_visibility=no
2984 fi
2985 fi
2986
2987 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
2988 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
2989 ])
2990
2991
2992 dnl
2993 dnl Add version tags to symbols in shared library (or not), additionally
2994 dnl marking other symbols as private/local (or not).
2995 dnl
2996 dnl Sets libtool_VERSION, and determines shared library SONAME.
2997 dnl
2998 dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
2999 dnl
3000 dnl --enable-symvers=style adds a version script to the linker call when
3001 dnl creating the shared library. The choice of version script is
3002 dnl controlled by 'style'.
3003 dnl --disable-symvers does not.
3004 dnl
3005 dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3006 dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
3007 dnl choose a default style based on linker characteristics. Passing
3008 dnl 'no' disables versioning.
3009 dnl
3010 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3011
3012 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3013 [enables symbol versioning of the shared library],
3014 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3015
3016 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3017 # don't know enough about $LD to do tricks...
3018 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3019 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3020 # with extern "C++" in version scripts.
3021 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3022
3023 # Turn a 'yes' into a suitable default.
3024 if test x$enable_symvers = xyes ; then
3025 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3026 enable_symvers=no
3027 else
3028 if test $with_gnu_ld = yes ; then
3029 case ${target_os} in
3030 hpux*)
3031 enable_symvers=no ;;
3032 *)
3033 enable_symvers=gnu ;;
3034 esac
3035 else
3036 case ${target_os} in
3037 darwin*)
3038 enable_symvers=darwin ;;
3039 # Sun symbol versioning exists since Solaris 2.5.
3040 solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3041 # make_sunver.pl needs GNU c++filt to support extern "C++" in
3042 # version scripts, so disable symbol versioning if none can be
3043 # found.
3044 if test -z "$ac_cv_path_CXXFILT"; then
3045 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3046 AC_MSG_WARN([=== no GNU c++filt could be found.])
3047 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3048 enable_symvers=no
3049 else
3050 enable_symvers=sun
3051 fi
3052 ;;
3053 *)
3054 enable_symvers=no ;;
3055 esac
3056 fi
3057 fi
3058 fi
3059
3060 # Check to see if 'darwin' or 'darwin-export' can win.
3061 if test x$enable_symvers = xdarwin-export ; then
3062 enable_symvers=darwin
3063 fi
3064
3065 # Check if 'sun' was requested on non-Solaris 2 platforms.
3066 if test x$enable_symvers = xsun ; then
3067 case ${target_os} in
3068 solaris2*)
3069 # All fine.
3070 ;;
3071 *)
3072 # Unlikely to work.
3073 AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3074 AC_MSG_WARN([=== you are not targetting Solaris 2.])
3075 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3076 enable_symvers=no
3077 ;;
3078 esac
3079 fi
3080
3081 # Check to see if 'gnu' can win.
3082 if test $enable_symvers = gnu ||
3083 test $enable_symvers = gnu-versioned-namespace ||
3084 test $enable_symvers = sun; then
3085 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3086 AC_MSG_CHECKING([for shared libgcc])
3087 ac_save_CFLAGS="$CFLAGS"
3088 CFLAGS=' -lgcc_s'
3089 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3090 CFLAGS="$ac_save_CFLAGS"
3091 if test $glibcxx_shared_libgcc = no; then
3092 cat > conftest.c <<EOF
3093 int main (void) { return 0; }
3094 EOF
3095 changequote(,)dnl
3096 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3097 -shared -shared-libgcc -o conftest.so \
3098 conftest.c -v 2>&1 >/dev/null \
3099 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3100 changequote([,])dnl
3101 rm -f conftest.c conftest.so
3102 if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3103 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3104 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3105 CFLAGS="$ac_save_CFLAGS"
3106 fi
3107 fi
3108 AC_MSG_RESULT($glibcxx_shared_libgcc)
3109
3110 # For GNU ld, we need at least this version. The format is described in
3111 # GLIBCXX_CHECK_LINKER_FEATURES above.
3112 glibcxx_min_gnu_ld_version=21400
3113
3114 # If no shared libgcc, can't win.
3115 if test $glibcxx_shared_libgcc != yes; then
3116 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3117 AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3118 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3119 enable_symvers=no
3120 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3121 : All interesting versions of Sun ld support sun style symbol versioning.
3122 elif test $with_gnu_ld != yes ; then
3123 # just fail for now
3124 AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3125 AC_MSG_WARN([=== you are not using the GNU linker.])
3126 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3127 enable_symvers=no
3128 elif test $glibcxx_ld_is_gold = yes ; then
3129 : All versions of gold support symbol versioning.
3130 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3131 # The right tools, the right setup, but too old. Fallbacks?
3132 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3133 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3134 AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3135 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3136 AC_MSG_WARN([=== Symbol versioning will be disabled.])
3137 enable_symvers=no
3138 fi
3139 fi
3140
3141 # For libtool versioning info, format is CURRENT:REVISION:AGE
3142 libtool_VERSION=6:17:0
3143
3144 # Everything parsed; figure out what files and settings to use.
3145 case $enable_symvers in
3146 no)
3147 SYMVER_FILE=config/abi/pre/none.ver
3148 ;;
3149 gnu)
3150 SYMVER_FILE=config/abi/pre/gnu.ver
3151 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3152 [Define to use GNU versioning in the shared library.])
3153 ;;
3154 gnu-versioned-namespace)
3155 libtool_VERSION=7:0:0
3156 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3157 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3158 [Define to use GNU namespace versioning in the shared library.])
3159 ;;
3160 darwin)
3161 SYMVER_FILE=config/abi/pre/gnu.ver
3162 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3163 [Define to use darwin versioning in the shared library.])
3164 ;;
3165 sun)
3166 SYMVER_FILE=config/abi/pre/gnu.ver
3167 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3168 [Define to use Sun versioning in the shared library.])
3169 ;;
3170 esac
3171
3172 if test x$enable_symvers != xno ; then
3173 AC_DEFINE(_GLIBCXX_SYMVER, 1,
3174 [Define to use symbol versioning in the shared library.])
3175 fi
3176
3177 AC_CACHE_CHECK([whether the target supports .symver directive],
3178 glibcxx_cv_have_as_symver_directive, [
3179 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3180 [], glibcxx_cv_have_as_symver_directive=yes,
3181 glibcxx_cv_have_as_symver_directive=no)])
3182 if test $glibcxx_cv_have_as_symver_directive = yes; then
3183 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3184 [Define to 1 if the target assembler supports .symver directive.])
3185 fi
3186
3187 AC_SUBST(SYMVER_FILE)
3188 AC_SUBST(port_specific_symbol_files)
3189 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3190 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3191 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3192 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3193 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3194 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3195
3196 if test $enable_symvers != no ; then
3197 case ${target_os} in
3198 # The Solaris 2 runtime linker doesn't support the GNU extension of
3199 # binding the same symbol to different versions
3200 solaris2*)
3201 ;;
3202 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3203 *)
3204 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3205 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3206 ;;
3207 esac
3208 fi
3209
3210 # Now, set up compatibility support, if any.
3211 # In addition, need this to deal with std::size_t mangling in
3212 # src/compatibility.cc. In a perfect world, could use
3213 # typeid(std::size_t).name()[0] to do direct substitution.
3214 AC_MSG_CHECKING([for size_t as unsigned int])
3215 ac_save_CFLAGS="$CFLAGS"
3216 CFLAGS="-Werror"
3217 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3218 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3219 CFLAGS=$ac_save_CFLAGS
3220 if test "$glibcxx_size_t_is_i" = yes; then
3221 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3222 fi
3223 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3224
3225 AC_MSG_CHECKING([for ptrdiff_t as int])
3226 ac_save_CFLAGS="$CFLAGS"
3227 CFLAGS="-Werror"
3228 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3229 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3230 CFLAGS=$ac_save_CFLAGS
3231 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3232 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3233 fi
3234 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3235 ])
3236
3237
3238 dnl
3239 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3240 dnl We must stage the required headers so that they will be installed
3241 dnl with the library (unlike libgcc, the STL implementation is provided
3242 dnl solely within headers). Since we must not inject random user-space
3243 dnl macro names into user-provided C++ code, we first stage into <file>-in
3244 dnl and process to <file> with an output command. The reason for a two-
3245 dnl stage process here is to correctly handle $srcdir!=$objdir without
3246 dnl having to write complex code (the sed commands to clean the macro
3247 dnl namespace are complex and fragile enough as it is). We must also
3248 dnl add a relative path so that -I- is supported properly.
3249 dnl
3250 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3251 AC_MSG_CHECKING([for thread model used by GCC])
3252 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3253 AC_MSG_RESULT([$target_thread_file])
3254 ])
3255
3256
3257 dnl
3258 dnl Check if gthread implementation defines the types and functions
3259 dnl required by the c++0x thread library. Conforming gthread
3260 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3261 dnl
3262 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3263 dnl
3264 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3265 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3266
3267 if test x$enable_libstdcxx_threads = xauto ||
3268 test x$enable_libstdcxx_threads = xyes; then
3269
3270 AC_LANG_SAVE
3271 AC_LANG_CPLUSPLUS
3272
3273 ac_save_CXXFLAGS="$CXXFLAGS"
3274 CXXFLAGS="$CXXFLAGS -fno-exceptions \
3275 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3276
3277 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3278 case $target_thread_file in
3279 posix)
3280 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3281 esac
3282
3283 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3284
3285 AC_TRY_COMPILE([#include <unistd.h>],
3286 [
3287 // In case of POSIX threads check _POSIX_TIMEOUTS.
3288 #if (defined(_PTHREADS) \
3289 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3290 #error
3291 #endif
3292 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3293
3294 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3295 [Define to 1 if mutex_timedlock is available.])
3296
3297 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3298 else res_mutex_timedlock=no ; fi
3299 AC_MSG_RESULT([$res_mutex_timedlock])
3300
3301 AC_MSG_CHECKING([for gthreads library])
3302
3303 AC_TRY_COMPILE([#include "gthr.h"],
3304 [
3305 #ifndef __GTHREADS_CXX0X
3306 #error
3307 #endif
3308 ], [case $target_os in
3309 # gthreads support breaks symbol versioning on Solaris 9 (PR
3310 # libstdc++/52189).
3311 solaris2.9*)
3312 if test x$enable_symvers = xno; then
3313 ac_has_gthreads=yes
3314 elif test x$enable_libstdcxx_threads = xyes; then
3315 AC_MSG_WARN([You have requested C++11 threads support, but])
3316 AC_MSG_WARN([this breaks symbol versioning.])
3317 ac_has_gthreads=yes
3318 else
3319 ac_has_gthreads=no
3320 fi
3321 ;;
3322 *)
3323 ac_has_gthreads=yes
3324 ;;
3325 esac],
3326 [ac_has_gthreads=no])
3327 else
3328 ac_has_gthreads=no
3329 fi
3330
3331 AC_MSG_RESULT([$ac_has_gthreads])
3332
3333 if test x"$ac_has_gthreads" = x"yes"; then
3334 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3335 [Define if gthreads library is available.])
3336 fi
3337
3338 CXXFLAGS="$ac_save_CXXFLAGS"
3339 AC_LANG_RESTORE
3340 ])
3341
3342
3343 # Check whether LC_MESSAGES is available in <locale.h>.
3344 # Ulrich Drepper <drepper@cygnus.com>, 1995.
3345 #
3346 # This file file be copied and used freely without restrictions. It can
3347 # be used in projects which are not available under the GNU Public License
3348 # but which still want to provide support for the GNU gettext functionality.
3349 # Please note that the actual code is *not* freely available.
3350 AC_DEFUN([AC_LC_MESSAGES], [
3351 AC_CHECK_HEADER(locale.h, [
3352 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3353 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3354 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3355 if test $ac_cv_val_LC_MESSAGES = yes; then
3356 AC_DEFINE(HAVE_LC_MESSAGES, 1,
3357 [Define if LC_MESSAGES is available in <locale.h>.])
3358 fi
3359 ])
3360 ])
3361
3362 dnl
3363 dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
3364 dnl
3365 AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
3366
3367 AC_LANG_SAVE
3368 AC_LANG_CPLUSPLUS
3369 ac_save_CXXFLAGS="$CXXFLAGS"
3370 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3371
3372 AC_MSG_CHECKING([for get_nprocs])
3373 AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
3374 GCC_TRY_COMPILE_OR_LINK(
3375 [#include <sys/sysinfo.h>],
3376 [int n = get_nprocs();],
3377 [glibcxx_cv_GET_NPROCS=yes],
3378 [glibcxx_cv_GET_NPROCS=no])
3379 ])
3380 if test $glibcxx_cv_GET_NPROCS = yes; then
3381 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
3382 fi
3383 AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
3384
3385 CXXFLAGS="$ac_save_CXXFLAGS"
3386 AC_LANG_RESTORE
3387 ])
3388
3389 dnl
3390 dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
3391 dnl
3392 AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
3393
3394 AC_LANG_SAVE
3395 AC_LANG_CPLUSPLUS
3396 ac_save_CXXFLAGS="$CXXFLAGS"
3397 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3398
3399 AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
3400 AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
3401 GCC_TRY_COMPILE_OR_LINK(
3402 [#include <unistd.h>],
3403 [int n = sysconf(_SC_NPROCESSORS_ONLN);],
3404 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
3405 [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
3406 ])
3407 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
3408 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.])
3409 fi
3410 AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
3411
3412 CXXFLAGS="$ac_save_CXXFLAGS"
3413 AC_LANG_RESTORE
3414 ])
3415
3416 dnl
3417 dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
3418 dnl
3419 AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
3420
3421 AC_LANG_SAVE
3422 AC_LANG_CPLUSPLUS
3423 ac_save_CXXFLAGS="$CXXFLAGS"
3424 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3425
3426 AC_MSG_CHECKING([for _SC_NPROC_ONLN])
3427 AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [
3428 GCC_TRY_COMPILE_OR_LINK(
3429 [#include <unistd.h>],
3430 [int n = sysconf(_SC_NPROC_ONLN);],
3431 [glibcxx_cv_SC_NPROC_ONLN=yes],
3432 [glibcxx_cv_SC_NPROC_ONLN=no])
3433 ])
3434 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
3435 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.])
3436 fi
3437 AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN)
3438
3439 CXXFLAGS="$ac_save_CXXFLAGS"
3440 AC_LANG_RESTORE
3441 ])
3442
3443 dnl
3444 dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
3445 dnl
3446 AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
3447
3448 AC_LANG_SAVE
3449 AC_LANG_CPLUSPLUS
3450 ac_save_CXXFLAGS="$CXXFLAGS"
3451 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3452
3453 AC_MSG_CHECKING([for pthreads_num_processors_np])
3454 AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
3455 GCC_TRY_COMPILE_OR_LINK(
3456 [#include <pthread.h>],
3457 [int n = pthread_num_processors_np();],
3458 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
3459 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
3460 ])
3461 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
3462 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
3463 fi
3464 AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP)
3465
3466 CXXFLAGS="$ac_save_CXXFLAGS"
3467 AC_LANG_RESTORE
3468 ])
3469
3470 dnl
3471 dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
3472 dnl
3473 AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
3474
3475 AC_LANG_SAVE
3476 AC_LANG_CPLUSPLUS
3477 ac_save_CXXFLAGS="$CXXFLAGS"
3478 CXXFLAGS="$CXXFLAGS -fno-exceptions"
3479
3480 AC_MSG_CHECKING([for hw.ncpu sysctl])
3481 AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [
3482 GCC_TRY_COMPILE_OR_LINK(
3483 [
3484 #include <stddef.h>
3485 #include <sys/sysctl.h>
3486 ],
3487 [
3488 int count;
3489 size_t size = sizeof(count);
3490 int mib[] = { CTL_HW, HW_NCPU };
3491 sysctl(mib, 2, &count, &size, NULL, 0);
3492 ],
3493 [glibcxx_cv_SYSCTL_HW_NCPU=yes],
3494 [glibcxx_cv_SYSCTL_HW_NCPU=no])
3495 ])
3496 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
3497 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
3498 fi
3499 AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU)
3500
3501 CXXFLAGS="$ac_save_CXXFLAGS"
3502 AC_LANG_RESTORE
3503 ])
3504
3505 dnl
3506 dnl Check to see if python pretty printing can be activated.
3507 dnl
3508 dnl --with-python-dir=dir
3509 dnl installs directory into $prefix/dir
3510 AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
3511
3512 AC_MSG_CHECKING([for custom python install directory])
3513 AC_ARG_WITH([python-dir],
3514 AS_HELP_STRING([--with-python-dir],
3515 [the location to install Python modules. This path is relative starting from the prefix.]),
3516 [with_python_dir=$withval], [with_python_dir="no"])
3517 AC_MSG_RESULT(${with_python_dir})
3518
3519 # Needed for installing Python modules during make install.
3520 python_mod_dir="${with_python_dir}"
3521 AC_SUBST(python_mod_dir)
3522 GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
3523 ])
3524
3525 dnl
3526 dnl Check to see if -Werror is disabled.
3527 dnl
3528 dnl --enable-werror/--disable-werror
3529 AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
3530 AC_MSG_CHECKING([for -Werror])
3531 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
3532 AC_MSG_RESULT($enable_werror)
3533 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
3534 ])
3535
3536
3537 # Macros from the top-level gcc directory.
3538 m4_include([../config/gc++filt.m4])
3539 m4_include([../config/tls.m4])