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