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