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