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