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