]> 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
acinclude.m4 ([GLIBCXX_CHECK_GTHREADS]): New.
[thirdparty/gcc.git] / libstdc++-v3 / acinclude.m4
CommitLineData
ff66d28f 1
92eabea2
PE		 2dnl
3dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
4dnl
5dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
6dnl end of configure. This lets tested variables be reassigned, and the
7dnl conditional will depend on the final state of the variable. For a simple
8dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
9dnl
10m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
f214923c 11AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
92eabea2
PE		 12 m4_divert_text([glibcxx_diversion],dnl
13 AM_CONDITIONAL([$1],[$2])
14 )dnl
15])dnl
f214923c 16AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
92eabea2
PE		 17
18
ff66d28f
PE		 19dnl
20dnl Check to see what architecture and operating system we are compiling
21dnl for. Also, if architecture- or OS-specific flags are required for
22dnl compilation, pick them up here.
23dnl
f214923c 24AC_DEFUN([GLIBCXX_CHECK_HOST], [
ff66d28f 25 . $glibcxx_srcdir/configure.host
f214923c
BK		 26 AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
27 AC_MSG_NOTICE([OS config directory is $os_include_dir])
ff66d28f
PE		 28])
29
ff66d28f
PE		 30dnl
31dnl Initialize the rest of the library configury. At this point we have
32dnl variables like $host.
aebb8c22 33dnl
ff66d28f 34dnl Sets:
82ba99d5 35dnl SUBDIRS
ff66d28f
PE		 36dnl Substs:
37dnl glibcxx_builddir (absolute path)
38dnl glibcxx_srcdir (absolute path)
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.
4312e020 52 m4_define([glibcxx_SUBDIRS],[include libmath libsupc++ src doc po testsuite])
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
ff66d28f 63 toplevel_srcdir=${glibcxx_srcdir}/..
3d7c150e
BK		 64 AC_SUBST(glibcxx_builddir)
65 AC_SUBST(glibcxx_srcdir)
ff66d28f 66 AC_SUBST(toplevel_srcdir)
d2caef2e 67
ff66d28f
PE		 68 # We use these options to decide which functions to include. They are
69 # set from the top level.
70 AC_ARG_WITH([target-subdir],
71 AC_HELP_STRING([--with-target-subdir=SUBDIR],
72 [configuring in a subdirectory]))
73
74 AC_ARG_WITH([cross-host],
75 AC_HELP_STRING([--with-cross-host=HOST],
76 [configuring with a cross compiler]))
77
78 AC_ARG_WITH([newlib],
79 AC_HELP_STRING([--with-newlib],
80 [assume newlib as a system C library]))
81
ff66d28f
PE		 82 # We're almost certainly being configured before anything else which uses
83 # C++, so all of our AC_PROG_* discoveries will be cached. It's vital that
84 # we not cache the value of CXX that we "discover" here, because it's set
85 # to something unique for us and libjava. Other target libraries need to
86 # find CXX for themselves. We yank the rug out from under the normal AC_*
87 # process by sneakily renaming the cache variable. This also lets us debug
88 # the value of "our" CXX in postmortems.
89 #
90 # We must also force CXX to /not/ be a precious variable, otherwise the
91 # wrong (non-multilib-adjusted) value will be used in multilibs. This
92 # little trick also affects CPPFLAGS, CXXFLAGS, and LDFLAGS. And as a side
93 # effect, CXXFLAGS is no longer automagically subst'd, so we have to do
f6dda651 94 # that ourselves. Un-preciousing AC_PROG_CC also affects CC and CFLAGS.
ff66d28f
PE		 95 #
96 # -fno-builtin must be present here so that a non-conflicting form of
97 # std::exit can be guessed by AC_PROG_CXX, and used in later tests.
fbe057bb 98
ff66d28f
PE		 99 m4_define([ac_cv_prog_CXX],[glibcxx_cv_prog_CXX])
100 m4_rename([_AC_ARG_VAR_PRECIOUS],[glibcxx_PRECIOUS])
101 m4_define([_AC_ARG_VAR_PRECIOUS],[])
102 save_CXXFLAGS="$CXXFLAGS"
103 CXXFLAGS="$CXXFLAGS -fno-builtin"
f6dda651 104 AC_PROG_CC
ff66d28f
PE		 105 AC_PROG_CXX
106 CXXFLAGS="$save_CXXFLAGS"
107 m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
f6dda651 108 AC_SUBST(CFLAGS)
ff66d28f 109 AC_SUBST(CXXFLAGS)
b2dad0e3 110
ff66d28f
PE		 111 # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
112 # available). Uncomment the next line to force a particular method.
113 AC_PROG_LN_S
114 #LN_S='cp -p'
115
5780a46b
BK		 116 AC_CHECK_TOOL(AS, as)
117 AC_CHECK_TOOL(AR, ar)
46840bcd 118 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
b2dad0e3 119
5780a46b 120 AM_MAINTAINER_MODE
b2dad0e3 121
92eabea2
PE		 122 # Set up safe default values for all subsequent AM_CONDITIONAL tests
123 # which are themselves conditionally expanded.
124 ## (Right now, this only matters for enable_wchar_t, but nothing prevents
125 ## other macros from doing the same. This should be automated.) -pme
16da539b 126 need_libmath=no
16da539b 127
464aea98
JM		 128 # Check for uClibc since Linux platforms use different configuration
129 # directories depending on the C library in use.
130 AC_EGREP_CPP([_using_uclibc], [
131 #include <stdio.h>
132 #if __UCLIBC__
133 _using_uclibc
134 #endif
135 ], uclibc=yes, uclibc=no)
136
ff66d28f
PE		 137 # Find platform-specific directories containing configuration info.
138 # Also possibly modify flags used elsewhere, as needed by the platform.
3d7c150e 139 GLIBCXX_CHECK_HOST
b2dad0e3
BK		 140])
141
142
c470c17d 143dnl
52b55e7d
PE		 144dnl Tests for newer compiler features, or features that are present in newer
145dnl compiler versions but not older compiler versions still in use, should
146dnl be placed here.
b2dad0e3 147dnl
ff66d28f
PE		 148dnl Defines:
149dnl WERROR='-Werror' if requested and possible; g++'s that lack the
150dnl new inlining code or the new system_header pragma will die on -Werror.
151dnl Leave it out by default and use maint-mode to use it.
152dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if
153dnl compiler supports it and the user has not requested debug mode.
c21b6f87 154dnl
f214923c 155AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
a4e99046 156 # All these tests are for C++; save the language and the compiler flags.
52b55e7d 157 # The CXXFLAGS thing is suspicious, but based on similar bits previously
3d7c150e 158 # found in GLIBCXX_CONFIGURE.
a4e99046
PE		 159 AC_LANG_SAVE
160 AC_LANG_CPLUSPLUS
161 ac_test_CXXFLAGS="${CXXFLAGS+set}"
162 ac_save_CXXFLAGS="$CXXFLAGS"
a4e99046 163
7f586614
BK		 164 # Check for maintainer-mode bits.
165 if test x"$USE_MAINTAINER_MODE" = xno; then
166 WERROR=''
8bd636c5 167 else
7f586614 168 WERROR='-Werror'
8bd636c5
PE		 169 fi
170
c470c17d
BK		 171 # Check for -ffunction-sections -fdata-sections
172 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
85ee35ca
BK		 173 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
174 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
c470c17d
BK		 175 if test "$ac_test_CXXFLAGS" = set; then
176 CXXFLAGS="$ac_save_CXXFLAGS"
177 else
178 # this is the suspicious part
179 CXXFLAGS=''
180 fi
6aa43d99 181 if test x"$ac_fdsections" = x"yes"; then
c470c17d
BK		 182 SECTION_FLAGS='-ffunction-sections -fdata-sections'
183 fi
184 AC_MSG_RESULT($ac_fdsections)
185
a4e99046 186 AC_LANG_RESTORE
8bd636c5 187 AC_SUBST(WERROR)
c470c17d 188 AC_SUBST(SECTION_FLAGS)
b2dad0e3
BK		 189])
190
c470c17d
BK		 191
192dnl
421173e6
PE		 193dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
194dnl the native linker is in use, all variables will be defined to something
195dnl safe (like an empty string).
196dnl
ff66d28f
PE		 197dnl Defines:
198dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
a429affe 199dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
ff66d28f
PE		 200dnl LD (as a side effect of testing)
201dnl Sets:
202dnl with_gnu_ld
d60a2d4d 203dnl glibcxx_ld_is_gold (set to "no" or "yes")
ff66d28f
PE		 204dnl glibcxx_gnu_ld_version (possibly)
205dnl
206dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
207dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
c470c17d 208dnl
f214923c 209AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
421173e6
PE		 210 # If we're not using GNU ld, then there's no point in even trying these
211 # tests. Check for that first. We should have already tested for gld
212 # by now (in libtool), but require it now just to be safe...
654421eb
DE		 213 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
214 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
421173e6 215 AC_REQUIRE([AC_PROG_LD])
ff66d28f 216 AC_REQUIRE([AC_PROG_AWK])
5bd17d39 217
c98b201b
PE		 218 # The name set by libtool depends on the version of libtool. Shame on us
219 # for depending on an impl detail, but c'est la vie. Older versions used
220 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
221 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
222 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
223 # set (hence we're using an older libtool), then set it.
224 if test x${with_gnu_ld+set} != xset; then
225 if test x${ac_cv_prog_gnu_ld+set} != xset; then
226 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
227 with_gnu_ld=no
228 else
229 with_gnu_ld=$ac_cv_prog_gnu_ld
230 fi
231 fi
232
233 # Start by getting the version number. I think the libtool test already
234 # does some of this, but throws away the result.
d60a2d4d 235 glibcxx_ld_is_gold=no
e2c104d8
BK		 236 if test x"$with_gnu_ld" = x"yes"; then
237 AC_MSG_CHECKING([for ld version])
238 changequote(,)
d60a2d4d
ILT		 239 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
240 glibcxx_ld_is_gold=yes
241 fi
e2c104d8 242 ldver=`$LD --version 2>/dev/null | head -1 | \
d60a2d4d 243 sed -e 's/GNU \(go\)\{0,1\}ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\4/'`
e2c104d8
BK		 244 changequote([,])
245 glibcxx_gnu_ld_version=`echo $ldver | \
246 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
247 AC_MSG_RESULT($glibcxx_gnu_ld_version)
248 fi
c98b201b 249
5bd17d39 250 # Set --gc-sections.
d60a2d4d
ILT		 251 glibcxx_have_gc_sections=no
252 if test "$glibcxx_ld_is_gold" = "yes"; then
253 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
254 glibcxx_have_gc_sections=yes
255 fi
256 else
257 glibcxx_gcsections_min_ld=21602
258 if test x"$with_gnu_ld" = x"yes" &&
ac2b2479 259 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
d60a2d4d
ILT		 260 glibcxx_have_gc_sections=yes
261 fi
262 fi
263 if test "$glibcxx_have_gc_sections" = "yes"; then
ac2b2479
BK		 264 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
265 # NB: This flag only works reliably after 2.16.1. Configure tests
266 # for this are difficult, so hard wire a value that should work.
421173e6 267
421173e6
PE		 268 ac_test_CFLAGS="${CFLAGS+set}"
269 ac_save_CFLAGS="$CFLAGS"
2a0ab51c 270 CFLAGS='-Wl,--gc-sections'
421173e6
PE		 271
272 # Check for -Wl,--gc-sections
273 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
acb6e9be
BK		 274 AC_TRY_LINK([ int one(void) { return 1; }
275 int two(void) { return 2; }
276 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
360e8759
L		 277 if test "$ac_gcsections" = "yes"; then
278 rm -f conftest.c
279 touch conftest.c
280 if $CC -c conftest.c; then
281 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
282 grep "Warning: gc-sections option ignored" > /dev/null; then
283 ac_gcsections=no
284 fi
285 fi
286 rm -f conftest.c conftest.o conftest
287 fi
acb6e9be
BK		 288 if test "$ac_gcsections" = "yes"; then
289 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
290 fi
291 AC_MSG_RESULT($ac_gcsections)
292
421173e6
PE		 293 if test "$ac_test_CFLAGS" = set; then
294 CFLAGS="$ac_save_CFLAGS"
295 else
296 # this is the suspicious part
297 CFLAGS=''
298 fi
5bd17d39 299 fi
a9117427 300
a429affe 301 # Set -z,relro.
952c7b74 302 # Note this is only for shared objects.
a429affe
BK		 303 ac_ld_relro=no
304 if test x"$with_gnu_ld" = x"yes"; then
305 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
306 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
307 if test -n "$cxx_z_relo"; then
308 OPT_LDFLAGS="-Wl,-z,relro"
309 ac_ld_relro=yes
310 fi
311 AC_MSG_RESULT($ac_ld_relro)
312 fi
313
5bd17d39 314 # Set linker optimization flags.
6aa43d99 315 if test x"$with_gnu_ld" = x"yes"; then
654421eb 316 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
421173e6 317 fi
5bd17d39 318
c470c17d 319 AC_SUBST(SECTION_LDFLAGS)
421173e6 320 AC_SUBST(OPT_LDFLAGS)
c470c17d
BK		 321])
322
323
b2dad0e3 324dnl
ff66d28f
PE		 325dnl Check for headers for, and arguments to, the setrlimit() function.
326dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
6aa43d99 327dnl
ff66d28f 328dnl Defines:
2ae6e982
PC		 329dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
330dnl various HAVE_LIMIT_* for individual limit names
6aa43d99 331dnl
f214923c 332AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
e0103440 333 AC_MSG_CHECKING([for RLIMIT_$1])
ff66d28f
PE		 334 AC_TRY_COMPILE(
335 [#include <unistd.h>
336 #include <sys/time.h>
337 #include <sys/resource.h>
338 ],
339 [ int f = RLIMIT_$1 ; ],
340 [glibcxx_mresult=1], [glibcxx_mresult=0])
2ae6e982 341 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
ff66d28f 342 [Only used in build directory testsuite_hooks.h.])
e0103440
GK		 343 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
344 AC_MSG_RESULT($res)
ff66d28f
PE		 345])
346
f214923c 347AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
ff66d28f
PE		 348 setrlimit_have_headers=yes
349 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
350 [],
351 [setrlimit_have_headers=no])
352 # If don't have the headers, then we can't run the tests now, and we
353 # won't be seeing any of these during testsuite compilation.
354 if test $setrlimit_have_headers = yes; then
355 # Can't do these in a loop, else the resulting syntax is wrong.
356 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
357 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
358 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
359 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
2ae6e982 360 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
ff66d28f
PE		 361
362 # Check for rlimit, setrlimit.
6d26724a 363 AC_CACHE_VAL(glibcxx_cv_setrlimit, [
ff66d28f
PE		 364 AC_TRY_COMPILE(
365 [#include <unistd.h>
366 #include <sys/time.h>
367 #include <sys/resource.h>
368 ],
369 [struct rlimit r;
370 setrlimit(0, &r);],
6d26724a 371 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
ff66d28f
PE		 372 ])
373 fi
374
2ae6e982 375 AC_MSG_CHECKING([for testsuite resource limits support])
6d26724a 376 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
2ae6e982 377 ac_res_limits=yes
4651e622
KC		 378 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
379 [Define if using setrlimit to set resource limits during
380 "make check"])
ff66d28f 381 else
2ae6e982 382 ac_res_limits=no
ff66d28f 383 fi
2ae6e982 384 AC_MSG_RESULT($ac_res_limits)
6aa43d99
BK		 385])
386
387
6aa43d99 388dnl
ff66d28f
PE		 389dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
390dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
6aa43d99 391dnl
f214923c 392AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
74745ec5
PC		 393
394 AC_LANG_SAVE
395 AC_LANG_CPLUSPLUS
396 ac_save_CXXFLAGS="$CXXFLAGS"
397 CXXFLAGS="$CXXFLAGS -fno-exceptions"
398
e0103440 399 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
ff66d28f 400 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
74745ec5 401 GCC_TRY_COMPILE_OR_LINK(
ff66d28f
PE		 402 [#include <sys/stat.h>],
403 [struct stat buffer;
404 fstat(0, &buffer);
405 S_ISREG(buffer.st_mode);],
406 [glibcxx_cv_S_ISREG=yes],
407 [glibcxx_cv_S_ISREG=no])
408 ])
409 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
74745ec5 410 GCC_TRY_COMPILE_OR_LINK(
ff66d28f
PE		 411 [#include <sys/stat.h>],
412 [struct stat buffer;
413 fstat(0, &buffer);
414 S_IFREG & buffer.st_mode;],
415 [glibcxx_cv_S_IFREG=yes],
416 [glibcxx_cv_S_IFREG=no])
417 ])
e0103440 418 res=no
ff66d28f 419 if test $glibcxx_cv_S_ISREG = yes; then
4651e622
KC		 420 AC_DEFINE(HAVE_S_ISREG, 1,
421 [Define if S_IFREG is available in <sys/stat.h>.])
e0103440 422 res=S_ISREG
ff66d28f 423 elif test $glibcxx_cv_S_IFREG = yes; then
4651e622
KC		 424 AC_DEFINE(HAVE_S_IFREG, 1,
425 [Define if S_IFREG is available in <sys/stat.h>.])
e0103440 426 res=S_IFREG
ff66d28f 427 fi
e0103440 428 AC_MSG_RESULT($res)
74745ec5
PC		 429
430 CXXFLAGS="$ac_save_CXXFLAGS"
431 AC_LANG_RESTORE
b2dad0e3
BK		 432])
433
434
dcfa0bc8 435dnl
ff66d28f 436dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
dcfa0bc8 437dnl
f214923c 438AC_DEFUN([GLIBCXX_CHECK_POLL], [
74745ec5
PC		 439
440 AC_LANG_SAVE
441 AC_LANG_CPLUSPLUS
442 ac_save_CXXFLAGS="$CXXFLAGS"
443 CXXFLAGS="$CXXFLAGS -fno-exceptions"
444
e0103440 445 AC_MSG_CHECKING([for poll])
ff66d28f 446 AC_CACHE_VAL(glibcxx_cv_POLL, [
74745ec5 447 GCC_TRY_COMPILE_OR_LINK(
ff66d28f
PE		 448 [#include <poll.h>],
449 [struct pollfd pfd[1];
450 pfd[0].events = POLLIN;
451 poll(pfd, 1, 0);],
452 [glibcxx_cv_POLL=yes],
453 [glibcxx_cv_POLL=no])
454 ])
455 if test $glibcxx_cv_POLL = yes; then
4651e622 456 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
ff66d28f 457 fi
e0103440 458 AC_MSG_RESULT($glibcxx_cv_POLL)
74745ec5
PC		 459
460 CXXFLAGS="$ac_save_CXXFLAGS"
461 AC_LANG_RESTORE
ff66d28f
PE		 462])
463
464
465dnl
466dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
467dnl
f214923c 468AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
74745ec5
PC		 469
470 AC_LANG_SAVE
471 AC_LANG_CPLUSPLUS
472 ac_save_CXXFLAGS="$CXXFLAGS"
473 CXXFLAGS="$CXXFLAGS -fno-exceptions"
474
e0103440 475 AC_MSG_CHECKING([for writev])
ff66d28f 476 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
74745ec5 477 GCC_TRY_COMPILE_OR_LINK(
ff66d28f
PE		 478 [#include <sys/uio.h>],
479 [struct iovec iov[2];
480 writev(0, iov, 0);],
481 [glibcxx_cv_WRITEV=yes],
482 [glibcxx_cv_WRITEV=no])
483 ])
484 if test $glibcxx_cv_WRITEV = yes; then
4651e622 485 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
ff66d28f 486 fi
e0103440 487 AC_MSG_RESULT($glibcxx_cv_WRITEV)
74745ec5
PC		 488
489 CXXFLAGS="$ac_save_CXXFLAGS"
490 AC_LANG_RESTORE
ff66d28f
PE		 491])
492
493
3d05b345
PC		 494dnl
495dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
fc9ab7b4 496dnl Also check whether int64_t is actually a typedef to long or long long.
3d05b345 497dnl
f214923c 498AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
fc9ab7b4
PC		 499
500 AC_LANG_SAVE
501 AC_LANG_CPLUSPLUS
502
e0103440 503 AC_MSG_CHECKING([for int64_t])
3d05b345
PC		 504 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
505 AC_TRY_COMPILE(
506 [#include <stdint.h>],
507 [int64_t var;],
508 [glibcxx_cv_INT64_T=yes],
509 [glibcxx_cv_INT64_T=no])
510 ])
fc9ab7b4 511
3d05b345 512 if test $glibcxx_cv_INT64_T = yes; then
4651e622 513 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
fc9ab7b4
PC		 514 AC_MSG_RESULT($glibcxx_cv_INT64_T)
515
516 AC_MSG_CHECKING([for int64_t as long])
517 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
518 AC_TRY_COMPILE(
519 [#include <stdint.h>
520 template<typename, typename> struct same { enum { value = -1 }; };
521 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
522 int array[same<int64_t, long>::value];], [],
523 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
524 ])
525
526 if test $glibcxx_cv_int64_t_long = yes; then
527 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
528 AC_MSG_RESULT($glibcxx_cv_int64_t_long)
529 fi
530
531 AC_MSG_CHECKING([for int64_t as long long])
532 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
533 AC_TRY_COMPILE(
534 [#include <stdint.h>
535 template<typename, typename> struct same { enum { value = -1 }; };
536 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
537 int array[same<int64_t, long long>::value];], [],
538 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
539 ])
540
541 if test $glibcxx_cv_int64_t_long_long = yes; then
542 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
543 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
544 fi
3d05b345 545 fi
fc9ab7b4
PC		 546
547 AC_LANG_RESTORE
3d05b345
PC		 548])
549
550
551dnl
552dnl Check whether LFS support is available.
553dnl
f214923c 554AC_DEFUN([GLIBCXX_CHECK_LFS], [
0c6b814a 555 AC_LANG_SAVE
9d47bc51
PC		 556 AC_LANG_CPLUSPLUS
557 ac_save_CXXFLAGS="$CXXFLAGS"
558 CXXFLAGS="$CXXFLAGS -fno-exceptions"
e0103440 559 AC_MSG_CHECKING([for LFS support])
3d05b345 560 AC_CACHE_VAL(glibcxx_cv_LFS, [
74745ec5 561 GCC_TRY_COMPILE_OR_LINK(
0c6b814a
PC		 562 [#include <unistd.h>
563 #include <stdio.h>
dd5d134b 564 #include <sys/stat.h>
0c6b814a 565 ],
5c89246d
PC		 566 [FILE* fp;
567 fopen64("t", "w");
568 fseeko64(fp, 0, SEEK_CUR);
569 ftello64(fp);
dd5d134b
PC		 570 lseek64(1, 0, SEEK_CUR);
571 struct stat64 buf;
572 fstat64(1, &buf);],
3d05b345
PC		 573 [glibcxx_cv_LFS=yes],
574 [glibcxx_cv_LFS=no])
575 ])
576 if test $glibcxx_cv_LFS = yes; then
4651e622 577 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
3d05b345 578 fi
e0103440 579 AC_MSG_RESULT($glibcxx_cv_LFS)
9d47bc51
PC		 580 CXXFLAGS="$ac_save_CXXFLAGS"
581 AC_LANG_RESTORE
3d05b345
PC		 582])
583
584
1165dc50
PC		 585dnl
586dnl Check for whether a fully dynamic basic_string implementation should
587dnl be turned on, that does not put empty objects in per-process static
588dnl memory (mostly useful together with shared memory allocators, see PR
589dnl libstdc++/16612 for details).
590dnl
591dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
592dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
593dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
594dnl Where DEFAULT is either `yes' or `no'.
595dnl
596AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
597 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
598 if test $enable_fully_dynamic_string = yes; then
4651e622
KC		 599 AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
600 [Define if a fully dynamic basic_string is wanted.])
1165dc50
PC		 601 fi
602])
603
604
ff66d28f
PE		 605dnl
606dnl Does any necessary configuration of the testsuite directory. Generates
607dnl the testsuite_hooks.h header.
608dnl
609dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
610dnl
611dnl Sets:
84946e72 612dnl enable_abi_check
e3f78d9b
BK		 613dnl GLIBCXX_TEST_WCHAR_T
614dnl GLIBCXX_TEST_THREAD
ff66d28f
PE		 615dnl Substs:
616dnl baseline_dir
617dnl
f214923c 618AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
0646b059 619 if $GLIBCXX_IS_NATIVE ; then
2ae6e982 620 # Do checks for resource limit functions.
ff66d28f
PE		 621 GLIBCXX_CHECK_SETRLIMIT
622
623 # Look for setenv, so that extended locale tests can be performed.
624 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
0646b059 625 fi
dbc66058 626
0646b059
GK		 627 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
628 test $enable_symvers != no; then
629 case "$host" in
630 *-*-cygwin*)
631 enable_abi_check=no ;;
632 *)
633 enable_abi_check=yes ;;
634 esac
dbc66058
DJ		 635 else
636 # Only build this as native, since automake does not understand
637 # CXX_FOR_BUILD.
638 enable_abi_check=no
ff66d28f 639 fi
84946e72 640
ff66d28f 641 # Export file names for ABI checking.
fb5c309d 642 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}\$(MULTISUBDIR)"
ff66d28f 643 AC_SUBST(baseline_dir)
ff66d28f
PE		 644])
645
646
647dnl
648dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
649dnl
650dnl Substs:
651dnl GLIBCXX_INCLUDES
652dnl TOPLEVEL_INCLUDES
ff66d28f 653dnl
f214923c 654AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
0df3f383
PE		 655 # Used for every C++ compile we perform.
656 GLIBCXX_INCLUDES="\
657-I$glibcxx_builddir/include/$host_alias \
658-I$glibcxx_builddir/include \
659-I$glibcxx_srcdir/libsupc++"
ff66d28f 660
0df3f383 661 # For Canadian crosses, pick this up too.
ff66d28f 662 if test $CANADIAN = yes; then
37e0ff11 663 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
ff66d28f
PE		 664 fi
665
0df3f383
PE		 666 # Stuff in the actual top level. Currently only used by libsupc++ to
667 # get unwind* headers from the gcc dir.
668 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
669 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
ff66d28f
PE		 670
671 # Now, export this to all the little Makefiles....
672 AC_SUBST(GLIBCXX_INCLUDES)
673 AC_SUBST(TOPLEVEL_INCLUDES)
ff66d28f
PE		 674])
675
676
677dnl
678dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
679dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
680dnl
681dnl Substs:
682dnl OPTIMIZE_CXXFLAGS
683dnl WARN_FLAGS
684dnl
f214923c 685AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
ff66d28f
PE		 686 # Optimization flags that are probably a good idea for thrill-seekers. Just
687 # uncomment the lines below and make, everything else is ready to go...
62801a96 688 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
ff66d28f 689 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
ff66d28f
PE		 690 AC_SUBST(OPTIMIZE_CXXFLAGS)
691
dc7c62ae 692 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
ff66d28f
PE		 693 AC_SUBST(WARN_FLAGS)
694])
695
696
697dnl
698dnl All installation directory information is determined here.
699dnl
700dnl Substs:
701dnl gxx_install_dir
702dnl glibcxx_prefixdir
703dnl glibcxx_toolexecdir
704dnl glibcxx_toolexeclibdir
705dnl
706dnl Assumes cross_compiling bits already done, and with_cross_host in
707dnl particular.
708dnl
0f57bf40 709dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
505692b0 710dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
f214923c 711AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
ff66d28f
PE		 712 glibcxx_toolexecdir=no
713 glibcxx_toolexeclibdir=no
714 glibcxx_prefixdir=$prefix
715
716 AC_MSG_CHECKING([for gxx-include-dir])
717 AC_ARG_WITH([gxx-include-dir],
718 AC_HELP_STRING([--with-gxx-include-dir=DIR],
719 [installation directory for include files]),
720 [case "$withval" in
721 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
722 no) gxx_include_dir=no ;;
723 *) gxx_include_dir=$withval ;;
724 esac],
725 [gxx_include_dir=no])
726 AC_MSG_RESULT($gxx_include_dir)
727
728 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
729 AC_ARG_ENABLE([version-specific-runtime-libs],
730 AC_HELP_STRING([--enable-version-specific-runtime-libs],
731 [Specify that runtime libraries should be installed in a compiler-specific directory]),
732 [case "$enableval" in
733 yes) version_specific_libs=yes ;;
734 no) version_specific_libs=no ;;
735 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
736 esac],
737 [version_specific_libs=no])
738 AC_MSG_RESULT($version_specific_libs)
739
740 # Default case for install directory for include files.
741 if test $version_specific_libs = no && test $gxx_include_dir = no; then
0f57bf40
MM		 742 gxx_include_dir='include/c++/${gcc_version}'
743 if test -n "$with_cross_host" &&
744 test x"$with_cross_host" != x"no"; then
745 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
746 else
747 gxx_include_dir='${prefix}/'"$gxx_include_dir"
748 fi
ff66d28f
PE		 749 fi
750
751 # Version-specific runtime libs processing.
752 if test $version_specific_libs = yes; then
753 # Need the gcc compiler version to know where to install libraries
754 # and header files if --enable-version-specific-runtime-libs option
0314451d
GK		 755 # is selected. FIXME: these variables are misnamed, there are
756 # no executables installed in _toolexecdir or _toolexeclibdir.
ff66d28f 757 if test x"$gxx_include_dir" = x"no"; then
47194af4 758 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
ff66d28f 759 fi
0314451d 760 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
47194af4 761 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
ff66d28f
PE		 762 fi
763
764 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
765 # Install a library built with a cross compiler in tooldir, not libdir.
766 if test x"$glibcxx_toolexecdir" = x"no"; then
767 if test -n "$with_cross_host" &&
768 test x"$with_cross_host" != x"no"; then
fbe057bb
PE		 769 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
770 glibcxx_toolexeclibdir='${toolexecdir}/lib'
ff66d28f 771 else
0314451d 772 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
fbe057bb 773 glibcxx_toolexeclibdir='${libdir}'
ff66d28f 774 fi
fbe057bb 775 multi_os_directory=`$CXX -print-multi-os-directory`
ff66d28f
PE		 776 case $multi_os_directory in
777 .) ;; # Avoid trailing /.
778 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
779 esac
780 fi
781
782 AC_MSG_CHECKING([for install location])
783 AC_MSG_RESULT($gxx_include_dir)
784
785 AC_SUBST(glibcxx_prefixdir)
786 AC_SUBST(gxx_include_dir)
787 AC_SUBST(glibcxx_toolexecdir)
788 AC_SUBST(glibcxx_toolexeclibdir)
789])
790
791
792dnl
793dnl GLIBCXX_ENABLE
794dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
795dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
796dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
797dnl
798dnl See docs/html/17_intro/configury.html#enable for documentation.
799dnl
800m4_define([GLIBCXX_ENABLE],[dnl
801m4_define([_g_switch],[--enable-$1])dnl
802m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
803 AC_ARG_ENABLE($1,_g_help,
804 m4_bmatch([$5],
805 [^permit ],
806 [[
807 case "$enableval" in
808 m4_bpatsubst([$5],[permit ])) ;;
809 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
810 dnl Idea for future: generate a URL pointing to
811 dnl "onlinedocs/configopts.html#whatever"
812 esac
813 ]],
814 [^$],
815 [[
816 case "$enableval" in
817 yes|no) ;;
818 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
819 esac
820 ]],
821 [[$5]]),
822 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
823m4_undefine([_g_switch])dnl
824m4_undefine([_g_help])dnl
825])
826
827
828dnl
829dnl Check for ISO/IEC 9899:1999 "C99" support.
830dnl
831dnl --enable-c99 defines _GLIBCXX_USE_C99
832dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
833dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
834dnl Where DEFAULT is either `yes' or `no'.
835dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
836dnl
f214923c 837AC_DEFUN([GLIBCXX_ENABLE_C99], [
ff66d28f
PE		 838 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
839
347669a0
BK		 840 if test x"$enable_c99" = x"yes"; then
841
ff66d28f
PE		 842 AC_LANG_SAVE
843 AC_LANG_CPLUSPLUS
844
18f310b7
PC		 845 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
846 # undefined and fake C99 facilities - like pre-standard snprintf - may be
847 # spuriously enabled.
848 # Long term, -std=c++0x could be even better, could manage to explicitely
849 # request C99 facilities to the underlying C headers.
b6f914f6 850 ac_save_CXXFLAGS="$CXXFLAGS"
18f310b7 851 CXXFLAGS="$CXXFLAGS -std=c++98"
b6f914f6
RS		 852 ac_save_LIBS="$LIBS"
853 ac_save_gcc_no_link="$gcc_no_link"
854
855 if test x$gcc_no_link != xyes; then
856 # Use -fno-exceptions to that the C driver can link these tests without
857 # hitting undefined references to personality routines.
858 CXXFLAGS="$CXXFLAGS -fno-exceptions"
859 AC_CHECK_LIB(m, sin, [
860 LIBS="$LIBS -lm"
861 ], [
862 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
863 gcc_no_link=yes
864 ])
865 fi
866
ff66d28f 867 # Check for the existence of <math.h> functions used if C99 is enabled.
ff66d28f 868 AC_MSG_CHECKING([for ISO C99 support in <math.h>])
6d26724a 869 AC_CACHE_VAL(glibcxx_cv_c99_math, [
b6f914f6
RS		 870 GCC_TRY_COMPILE_OR_LINK(
871 [#include <math.h>
872 volatile double d1, d2;
873 volatile int i;],
874 [i = fpclassify(d1);
875 i = isfinite(d1);
876 i = isinf(d1);
877 i = isnan(d1);
878 i = isnormal(d1);
879 i = signbit(d1);
880 i = isgreater(d1, d2);
881 i = isgreaterequal(d1, d2);
882 i = isless(d1, d2);
883 i = islessequal(d1, d2);
884 i = islessgreater(d1, d2);
885 i = islessgreater(d1, d2);
886 i = isunordered(d1, d2);
6d26724a 887 ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
347669a0 888 ])
6d26724a
RW		 889 AC_MSG_RESULT($glibcxx_cv_c99_math)
890 if test x"$glibcxx_cv_c99_math" = x"yes"; then
4651e622
KC		 891 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
892 [Define if C99 functions or macros in <math.h> should be imported
893 in <cmath> in namespace std.])
517da0ce
MM		 894 fi
895
225962a0 896 # Check for the existence of <complex.h> complex math functions.
52e6723c
BK		 897 # This is necessary even though libstdc++ uses the builtin versions
898 # of these functions, because if the builtin cannot be used, a reference
899 # to the library function is emitted.
5ad2f32d 900 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
52e6723c 901 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
6d26724a 902 glibcxx_cv_c99_complex=no;
52e6723c 903 if test x"$ac_has_complex_h" = x"yes"; then
52e6723c 904 AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
b6f914f6
RS		 905 GCC_TRY_COMPILE_OR_LINK(
906 [#include <complex.h>
907 typedef __complex__ float float_type;
908 typedef __complex__ double double_type;
909 typedef __complex__ long double ld_type;
910 volatile float_type tmpf;
911 volatile double_type tmpd;
912 volatile ld_type tmpld;
913 volatile float f;
914 volatile double d;
915 volatile long double ld;],
916 [f = cabsf(tmpf);
917 f = cargf(tmpf);
918 tmpf = ccosf(tmpf);
919 tmpf = ccoshf(tmpf);
920 tmpf = cexpf(tmpf);
921 tmpf = clogf(tmpf);
922 tmpf = csinf(tmpf);
923 tmpf = csinhf(tmpf);
924 tmpf = csqrtf(tmpf);
925 tmpf = ctanf(tmpf);
926 tmpf = ctanhf(tmpf);
927 tmpf = cpowf(tmpf, tmpf);
3cd54fc9 928 tmpf = cprojf(tmpf);
b6f914f6
RS		 929 d = cabs(tmpd);
930 d = carg(tmpd);
931 tmpd = ccos(tmpd);
932 tmpd = ccosh(tmpd);
933 tmpd = cexp(tmpd);
934 tmpd = clog(tmpd);
935 tmpd = csin(tmpd);
936 tmpd = csinh(tmpd);
937 tmpd = csqrt(tmpd);
938 tmpd = ctan(tmpd);
939 tmpd = ctanh(tmpd);
940 tmpd = cpow(tmpd, tmpd);
3cd54fc9 941 tmpd = cproj(tmpd);
b6f914f6
RS		 942 ld = cabsl(tmpld);
943 ld = cargl(tmpld);
944 tmpld = ccosl(tmpld);
945 tmpld = ccoshl(tmpld);
946 tmpld = cexpl(tmpld);
947 tmpld = clogl(tmpld);
948 tmpld = csinl(tmpld);
949 tmpld = csinhl(tmpld);
950 tmpld = csqrtl(tmpld);
951 tmpld = ctanl(tmpld);
952 tmpld = ctanhl(tmpld);
953 tmpld = cpowl(tmpld, tmpld);
3cd54fc9 954 tmpld = cprojl(tmpld);
6d26724a 955 ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
52e6723c 956 fi
6d26724a
RW		 957 AC_MSG_RESULT($glibcxx_cv_c99_complex)
958 if test x"$glibcxx_cv_c99_complex" = x"yes"; then
4651e622
KC		 959 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
960 [Define if C99 functions in <complex.h> should be used in
961 <complex>. Using compiler builtins for these functions requires
962 corresponding C99 library functions to be present.])
52e6723c
BK		 963 fi
964
ff66d28f 965 # Check for the existence in <stdio.h> of vscanf, et. al.
ff66d28f 966 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
6d26724a 967 AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
b6f914f6
RS		 968 GCC_TRY_COMPILE_OR_LINK(
969 [#include <stdio.h>
970 #include <stdarg.h>
971 void foo(char* fmt, ...)
972 {
973 va_list args; va_start(args, fmt);
974 vfscanf(stderr, "%i", args);
975 vscanf("%i", args);
976 vsnprintf(fmt, 0, "%i", args);
977 vsscanf(fmt, "%i", args);
978 }],
979 [snprintf("12", 0, "%i");],
6d26724a 980 [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
347669a0 981 ])
6d26724a 982 AC_MSG_RESULT($glibcxx_cv_c99_stdio)
ff66d28f
PE		 983
984 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
ff66d28f 985 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
6d26724a 986 AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
b6f914f6
RS		 987 GCC_TRY_COMPILE_OR_LINK(
988 [#include <stdlib.h>
989 volatile float f;
990 volatile long double ld;
991 volatile unsigned long long ll;
992 lldiv_t mydivt;],
993 [char* tmp;
994 f = strtof("gnu", &tmp);
995 ld = strtold("gnu", &tmp);
996 ll = strtoll("gnu", &tmp, 10);
997 ll = strtoull("gnu", &tmp, 10);
998 ll = llabs(10);
999 mydivt = lldiv(10,1);
1000 ll = mydivt.quot;
1001 ll = mydivt.rem;
1002 ll = atoll("10");
1003 _Exit(0);
6d26724a 1004 ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
347669a0 1005 ])
6d26724a 1006 AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
ff66d28f 1007
8a9b2875 1008 # Check for the existence in <wchar.h> of wcstold, etc.
6d26724a 1009 glibcxx_cv_c99_wchar=no;
347669a0
BK		 1010 if test x"$ac_has_wchar_h" = xyes &&
1011 test x"$ac_has_wctype_h" = xyes; then
8a9b2875 1012 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
347669a0 1013 AC_TRY_COMPILE([#include <wchar.h>
347669a0
BK		 1014 namespace test
1015 {
347669a0
BK		 1016 using ::wcstold;
1017 using ::wcstoll;
347669a0 1018 using ::wcstoull;
347669a0 1019 }
6d26724a 1020 ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
347669a0
BK		 1021
1022 # Checks for wide character functions that may not be present.
1023 # Injection of these is wrapped with guard macros.
1024 # NB: only put functions here, instead of immediately above, if
1025 # absolutely necessary.
1026 AC_TRY_COMPILE([#include <wchar.h>
1027 namespace test { using ::vfwscanf; } ], [],
1028 [AC_DEFINE(HAVE_VFWSCANF,1,
1029 [Defined if vfwscanf exists.])],[])
1030
1031 AC_TRY_COMPILE([#include <wchar.h>
1032 namespace test { using ::vswscanf; } ], [],
1033 [AC_DEFINE(HAVE_VSWSCANF,1,
1034 [Defined if vswscanf exists.])],[])
1035
1036 AC_TRY_COMPILE([#include <wchar.h>
1037 namespace test { using ::vwscanf; } ], [],
1038 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1039
1040 AC_TRY_COMPILE([#include <wchar.h>
1041 namespace test { using ::wcstof; } ], [],
1042 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1043
1044 AC_TRY_COMPILE([#include <wctype.h>],
1045 [ wint_t t; int i = iswblank(t);],
1046 [AC_DEFINE(HAVE_ISWBLANK,1,
1047 [Defined if iswblank exists.])],[])
1048
6d26724a 1049 AC_MSG_RESULT($glibcxx_cv_c99_wchar)
347669a0 1050 fi
ff66d28f 1051
347669a0 1052 # Option parsed, now set things appropriately.
6d26724a
RW		 1053 if test x"$glibcxx_cv_c99_math" = x"no" ||
1054 test x"$glibcxx_cv_c99_complex" = x"no" ||
1055 test x"$glibcxx_cv_c99_stdio" = x"no" ||
1056 test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1057 test x"$glibcxx_cv_c99_wchar" = x"no"; then
ff66d28f 1058 enable_c99=no;
347669a0 1059 else
4651e622
KC		 1060 AC_DEFINE(_GLIBCXX_USE_C99, 1,
1061 [Define if C99 functions or macros from <wchar.h>, <math.h>,
1062 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
ff66d28f
PE		 1063 fi
1064
b6f914f6
RS		 1065 gcc_no_link="$ac_save_gcc_no_link"
1066 LIBS="$ac_save_LIBS"
1067 CXXFLAGS="$ac_save_CXXFLAGS"
ff66d28f 1068 AC_LANG_RESTORE
347669a0
BK		 1069 fi
1070
1071 AC_MSG_CHECKING([for fully enabled ISO C99 support])
1072 AC_MSG_RESULT($enable_c99)
dcfa0bc8
PE		 1073])
1074
1075
15e38d0d 1076dnl
610870b2
PC		 1077dnl Check for clock_gettime clocks, used in the implementation of 20.8.5
1078dnl [time.clock] in the current C++0x working draft.
15e38d0d 1079dnl
610870b2
PC		 1080dnl --enable-clock-gettime
1081dnl --enable-clock-gettime=yes
6c3385c1
PC		 1082dnl checks for the availability of monotonic and realtime clocks
1083dnl in libc and libposix4 and in case links the latter
610870b2 1084dnl --enable-clock-gettime=rt
6c3385c1 1085dnl also searches (and, in case, links) librt. Note that this is
610870b2 1086dnl not always desirable because, in glibc, for example, in turn it
6c3385c1
PC		 1087dnl triggers the linking of libpthread too, which activates locking,
1088dnl a large overhead for single-thread programs.
610870b2
PC		 1089dnl --enable-clock-gettime=no
1090dnl --disable-clock-gettime
1091dnl disables the checks completely
1092dnl
1093AC_DEFUN([GLIBCXX_ENABLE_CLOCK_GETTIME], [
1094
1095 AC_MSG_CHECKING([for clock_gettime clocks])
727cd0bc 1096 GLIBCXX_ENABLE(clock-gettime,$1,[=KIND],
610870b2
PC		 1097 [use KIND for check type],
1098 [permit yes|no|rt])
15e38d0d
CF		 1099
1100 AC_LANG_SAVE
1101 AC_LANG_CPLUSPLUS
1102 ac_save_CXXFLAGS="$CXXFLAGS"
1103 CXXFLAGS="$CXXFLAGS -fno-exceptions"
ec6fa56a
PB		 1104 ac_save_LIBS="$LIBS"
1105
610870b2
PC		 1106 ac_has_clock_monotonic=no;
1107 ac_has_clock_realtime=no;
ec6fa56a 1108
610870b2 1109 if test x"$enable_clock_gettime" != x"no"; then
ec6fa56a 1110
610870b2
PC		 1111 if test x"$enable_clock_gettime" = x"rt"; then
1112 AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1113 else
1114 AC_SEARCH_LIBS(clock_gettime, [posix4])
1115 fi
1116
1117 case "$ac_cv_search_clock_gettime" in
1118 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1119 esac
1120
1121 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1122
1123 if test x"$ac_has_unistd_h" = x"yes"; then
1124 AC_MSG_CHECKING([for monotonic clock])
1125 AC_TRY_LINK(
1126 [#include <unistd.h>
1127 #include <time.h>
1128 ],
1129 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1130 timespec tp;
1131 #endif
1132 clock_gettime(CLOCK_MONOTONIC, &tp);
1133 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1134
1135 AC_MSG_RESULT($ac_has_clock_monotonic)
15e38d0d 1136
610870b2
PC		 1137 AC_MSG_CHECKING([for realtime clock])
1138 AC_TRY_LINK(
1139 [#include <unistd.h>
1140 #include <time.h>
1141 ],
1142 [#if _POSIX_TIMERS > 0
1143 timespec tp;
1144 #endif
1145 clock_gettime(CLOCK_REALTIME, &tp);
1146 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1147
1148 AC_MSG_RESULT($ac_has_clock_realtime)
1149 fi
1150
1151 fi
1152
15e38d0d
CF		 1153 if test x"$ac_has_clock_monotonic" = x"yes"; then
1154 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1155 [ Defined if clock_gettime has monotonic clock support. ])
1156 fi
ec6fa56a 1157
15e38d0d
CF		 1158 if test x"$ac_has_clock_realtime" = x"yes"; then
1159 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1160 [ Defined if clock_gettime has realtime clock support. ])
1161 fi
ec6fa56a
PB		 1162
1163 AC_SUBST(GLIBCXX_LIBS)
1164
15e38d0d 1165 CXXFLAGS="$ac_save_CXXFLAGS"
ec6fa56a 1166 LIBS="$ac_save_LIBS"
15e38d0d
CF		 1167 AC_LANG_RESTORE
1168])
1169
1170dnl
610870b2
PC		 1171dnl Check for gettimeofday, used in the implementation of 20.8.5
1172dnl [time.clock] in the current C++0x working draft.
15e38d0d
CF		 1173dnl
1174AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1175
610870b2
PC		 1176 AC_MSG_CHECKING([for gettimeofday])
1177
15e38d0d
CF		 1178 AC_LANG_SAVE
1179 AC_LANG_CPLUSPLUS
1180 ac_save_CXXFLAGS="$CXXFLAGS"
1181 CXXFLAGS="$CXXFLAGS -fno-exceptions"
1182
1183 ac_has_gettimeofday=no;
1184 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1185 if test x"$ac_has_sys_time_h" = x"yes"; then
1186 AC_MSG_CHECKING([for gettimeofday])
610870b2 1187 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
15e38d0d
CF		 1188 [timeval tv; gettimeofday(&tv, 0);],
1189 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1190
1191 AC_MSG_RESULT($ac_has_gettimeofday)
1192 fi
1193
1194 if test x"$ac_has_gettimeofday" = x"yes"; then
1195 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1196 [ Defined if gettimeofday is available. ])
1197 fi
1198
1199 CXXFLAGS="$ac_save_CXXFLAGS"
1200 AC_LANG_RESTORE
1201])
1202
bd2bb1ea
PC		 1203dnl
1204dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1205dnl facilities in Chapter 8, "C compatibility".
1206dnl
1207AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1208
1209 AC_LANG_SAVE
1210 AC_LANG_CPLUSPLUS
1211
18f310b7
PC		 1212 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1213 # undefined and fake C99 facilities may be spuriously enabled.
1214 ac_save_CXXFLAGS="$CXXFLAGS"
1215 CXXFLAGS="$CXXFLAGS -std=c++98"
1216
bd2bb1ea
PC		 1217 # Check for the existence of <complex.h> complex math functions used
1218 # by tr1/complex.
1219 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1220 ac_c99_complex_tr1=no;
1221 if test x"$ac_has_complex_h" = x"yes"; then
1222 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1223 AC_TRY_COMPILE([#include <complex.h>],
1224 [typedef __complex__ float float_type; float_type tmpf;
1225 cacosf(tmpf);
1226 casinf(tmpf);
1227 catanf(tmpf);
1228 cacoshf(tmpf);
1229 casinhf(tmpf);
1230 catanhf(tmpf);
1231 typedef __complex__ double double_type; double_type tmpd;
1232 cacos(tmpd);
1233 casin(tmpd);
1234 catan(tmpd);
1235 cacosh(tmpd);
1236 casinh(tmpd);
1237 catanh(tmpd);
1238 typedef __complex__ long double ld_type; ld_type tmpld;
1239 cacosl(tmpld);
1240 casinl(tmpld);
1241 catanl(tmpld);
1242 cacoshl(tmpld);
1243 casinhl(tmpld);
1244 catanhl(tmpld);
1245 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1246 fi
1247 AC_MSG_RESULT($ac_c99_complex_tr1)
1248 if test x"$ac_c99_complex_tr1" = x"yes"; then
1249 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1250 [Define if C99 functions in <complex.h> should be used in
1251 <tr1/complex>. Using compiler builtins for these functions
1252 requires corresponding C99 library functions to be present.])
1253 fi
1254
1255 # Check for the existence of <ctype.h> functions.
1256 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
6d26724a 1257 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
bd2bb1ea 1258 AC_TRY_COMPILE([#include <ctype.h>],
20921e53 1259 [int ch;
98fb1d29
PC		 1260 int ret;
1261 ret = isblank(ch);
0f24e8de
PC		 1262 ],[glibcxx_cv_c99_ctype_tr1=yes],
1263 [glibcxx_cv_c99_ctype_tr1=no])
bd2bb1ea 1264 ])
6d26724a
RW		 1265 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1266 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
bd2bb1ea
PC		 1267 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1268 [Define if C99 functions in <ctype.h> should be imported in
1269 <tr1/cctype> in namespace std::tr1.])
1270 fi
1271
20921e53
PC		 1272 # Check for the existence of <fenv.h> functions.
1273 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1274 ac_c99_fenv_tr1=no;
1275 if test x"$ac_has_fenv_h" = x"yes"; then
1276 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1277 AC_TRY_COMPILE([#include <fenv.h>],
1278 [int except, mode;
1279 fexcept_t* pflag;
1280 fenv_t* penv;
98fb1d29
PC		 1281 int ret;
1282 ret = feclearexcept(except);
1283 ret = fegetexceptflag(pflag, except);
1284 ret = feraiseexcept(except);
1285 ret = fesetexceptflag(pflag, except);
1286 ret = fetestexcept(except);
1287 ret = fegetround();
1288 ret = fesetround(mode);
1289 ret = fegetenv(penv);
1290 ret = feholdexcept(penv);
1291 ret = fesetenv(penv);
1292 ret = feupdateenv(penv);
20921e53
PC		 1293 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1294 fi
1295 AC_MSG_RESULT($ac_c99_fenv_tr1)
1296 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1297 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1298 [Define if C99 functions in <fenv.h> should be imported in
1299 <tr1/cfenv> in namespace std::tr1.])
1300 fi
1301
2a1d6346
PC		 1302 # Check for the existence of <stdint.h> types.
1303 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
6d26724a 1304 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
5289e808
PC		 1305 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1306 #define __STDC_CONSTANT_MACROS
1307 #include <stdint.h>],
2a1d6346 1308 [typedef int8_t my_int8_t;
5289e808
PC		 1309 my_int8_t i8 = INT8_MIN;
1310 i8 = INT8_MAX;
2a1d6346 1311 typedef int16_t my_int16_t;
5289e808
PC		 1312 my_int16_t i16 = INT16_MIN;
1313 i16 = INT16_MAX;
2a1d6346 1314 typedef int32_t my_int32_t;
5289e808
PC		 1315 my_int32_t i32 = INT32_MIN;
1316 i32 = INT32_MAX;
2a1d6346 1317 typedef int64_t my_int64_t;
5289e808
PC		 1318 my_int64_t i64 = INT64_MIN;
1319 i64 = INT64_MAX;
2a1d6346 1320 typedef int_fast8_t my_int_fast8_t;
5289e808
PC		 1321 my_int_fast8_t if8 = INT_FAST8_MIN;
1322 if8 = INT_FAST8_MAX;
2a1d6346 1323 typedef int_fast16_t my_int_fast16_t;
5289e808
PC		 1324 my_int_fast16_t if16 = INT_FAST16_MIN;
1325 if16 = INT_FAST16_MAX;
2a1d6346 1326 typedef int_fast32_t my_int_fast32_t;
5289e808
PC		 1327 my_int_fast32_t if32 = INT_FAST32_MIN;
1328 if32 = INT_FAST32_MAX;
1329 typedef int_fast64_t my_int_fast64_t;
1330 my_int_fast64_t if64 = INT_FAST64_MIN;
1331 if64 = INT_FAST64_MAX;
2a1d6346 1332 typedef int_least8_t my_int_least8_t;
5289e808
PC		 1333 my_int_least8_t il8 = INT_LEAST8_MIN;
1334 il8 = INT_LEAST8_MAX;
2a1d6346 1335 typedef int_least16_t my_int_least16_t;
5289e808
PC		 1336 my_int_least16_t il16 = INT_LEAST16_MIN;
1337 il16 = INT_LEAST16_MAX;
2a1d6346 1338 typedef int_least32_t my_int_least32_t;
5289e808
PC		 1339 my_int_least32_t il32 = INT_LEAST32_MIN;
1340 il32 = INT_LEAST32_MAX;
2a1d6346 1341 typedef int_least64_t my_int_least64_t;
5289e808
PC		 1342 my_int_least64_t il64 = INT_LEAST64_MIN;
1343 il64 = INT_LEAST64_MAX;
2a1d6346 1344 typedef intmax_t my_intmax_t;
5289e808
PC		 1345 my_intmax_t im = INTMAX_MAX;
1346 im = INTMAX_MIN;
2a1d6346 1347 typedef intptr_t my_intptr_t;
5289e808
PC		 1348 my_intptr_t ip = INTPTR_MAX;
1349 ip = INTPTR_MIN;
2a1d6346 1350 typedef uint8_t my_uint8_t;
5289e808
PC		 1351 my_uint8_t ui8 = UINT8_MAX;
1352 ui8 = UINT8_MAX;
2a1d6346 1353 typedef uint16_t my_uint16_t;
5289e808
PC		 1354 my_uint16_t ui16 = UINT16_MAX;
1355 ui16 = UINT16_MAX;
2a1d6346 1356 typedef uint32_t my_uint32_t;
5289e808
PC		 1357 my_uint32_t ui32 = UINT32_MAX;
1358 ui32 = UINT32_MAX;
2a1d6346 1359 typedef uint64_t my_uint64_t;
5289e808
PC		 1360 my_uint64_t ui64 = UINT64_MAX;
1361 ui64 = UINT64_MAX;
2a1d6346 1362 typedef uint_fast8_t my_uint_fast8_t;
5289e808
PC		 1363 my_uint_fast8_t uif8 = UINT_FAST8_MAX;
1364 uif8 = UINT_FAST8_MAX;
2a1d6346 1365 typedef uint_fast16_t my_uint_fast16_t;
5289e808
PC		 1366 my_uint_fast16_t uif16 = UINT_FAST16_MAX;
1367 uif16 = UINT_FAST16_MAX;
2a1d6346 1368 typedef uint_fast32_t my_uint_fast32_t;
5289e808
PC		 1369 my_uint_fast32_t uif32 = UINT_FAST32_MAX;
1370 uif32 = UINT_FAST32_MAX;
1371 typedef uint_fast64_t my_uint_fast64_t;
1372 my_uint_fast64_t uif64 = UINT_FAST64_MAX;
1373 uif64 = UINT_FAST64_MAX;
2a1d6346 1374 typedef uint_least8_t my_uint_least8_t;
5289e808
PC		 1375 my_uint_least8_t uil8 = UINT_LEAST8_MAX;
1376 uil8 = UINT_LEAST8_MAX;
2a1d6346 1377 typedef uint_least16_t my_uint_least16_t;
5289e808
PC		 1378 my_uint_least16_t uil16 = UINT_LEAST16_MAX;
1379 uil16 = UINT_LEAST16_MAX;
2a1d6346 1380 typedef uint_least32_t my_uint_least32_t;
5289e808
PC		 1381 my_uint_least32_t uil32 = UINT_LEAST32_MAX;
1382 uil32 = UINT_LEAST32_MAX;
2a1d6346 1383 typedef uint_least64_t my_uint_least64_t;
5289e808
PC		 1384 my_uint_least64_t uil64 = UINT_LEAST64_MAX;
1385 uil64 = UINT_LEAST64_MAX;
2a1d6346 1386 typedef uintmax_t my_uintmax_t;
5289e808
PC		 1387 my_uintmax_t uim = UINTMAX_MAX;
1388 uim = UINTMAX_MAX;
2a1d6346 1389 typedef uintptr_t my_uintptr_t;
5289e808
PC		 1390 my_uintptr_t uip = UINTPTR_MAX;
1391 uip = UINTPTR_MAX;
0f24e8de
PC		 1392 ],[glibcxx_cv_c99_stdint_tr1=yes],
1393 [glibcxx_cv_c99_stdint_tr1=no])
2a1d6346 1394 ])
6d26724a
RW		 1395 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1396 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
2a1d6346
PC		 1397 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1398 [Define if C99 types in <stdint.h> should be imported in
1399 <tr1/cstdint> in namespace std::tr1.])
1400 fi
1401
4f0de5dd
PC		 1402 # Check for the existence of <math.h> functions.
1403 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
6d26724a 1404 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
4f0de5dd 1405 AC_TRY_COMPILE([#include <math.h>],
9a7ab578
PC		 1406 [typedef double_t my_double_t;
1407 typedef float_t my_float_t;
1408 acosh(0.0);
4f0de5dd
PC		 1409 acoshf(0.0f);
1410 acoshl(0.0l);
1411 asinh(0.0);
1412 asinhf(0.0f);
1413 asinhl(0.0l);
1414 atanh(0.0);
1415 atanhf(0.0f);
1416 atanhl(0.0l);
1417 cbrt(0.0);
1418 cbrtf(0.0f);
1419 cbrtl(0.0l);
1420 copysign(0.0, 0.0);
1421 copysignf(0.0f, 0.0f);
1422 copysignl(0.0l, 0.0l);
1423 erf(0.0);
1424 erff(0.0f);
1425 erfl(0.0l);
1426 erfc(0.0);
1427 erfcf(0.0f);
1428 erfcl(0.0l);
1429 exp2(0.0);
1430 exp2f(0.0f);
1431 exp2l(0.0l);
1432 expm1(0.0);
1433 expm1f(0.0f);
1434 expm1l(0.0l);
1435 fdim(0.0, 0.0);
1436 fdimf(0.0f, 0.0f);
1437 fdiml(0.0l, 0.0l);
1438 fma(0.0, 0.0, 0.0);
1439 fmaf(0.0f, 0.0f, 0.0f);
1440 fmal(0.0l, 0.0l, 0.0l);
1441 fmax(0.0, 0.0);
1442 fmaxf(0.0f, 0.0f);
1443 fmaxl(0.0l, 0.0l);
1444 fmin(0.0, 0.0);
1445 fminf(0.0f, 0.0f);
1446 fminl(0.0l, 0.0l);
1447 hypot(0.0, 0.0);
1448 hypotf(0.0f, 0.0f);
1449 hypotl(0.0l, 0.0l);
1450 ilogb(0.0);
1451 ilogbf(0.0f);
1452 ilogbl(0.0l);
1453 lgamma(0.0);
1454 lgammaf(0.0f);
1455 lgammal(0.0l);
1456 llrint(0.0);
1457 llrintf(0.0f);
1458 llrintl(0.0l);
1459 llround(0.0);
1460 llroundf(0.0f);
1461 llroundl(0.0l);
1462 log1p(0.0);
1463 log1pf(0.0f);
1464 log1pl(0.0l);
1465 log2(0.0);
1466 log2f(0.0f);
1467 log2l(0.0l);
1468 logb(0.0);
1469 logbf(0.0f);
1470 logbl(0.0l);
1471 lrint(0.0);
1472 lrintf(0.0f);
1473 lrintl(0.0l);
1474 lround(0.0);
1475 lroundf(0.0f);
1476 lroundl(0.0l);
1477 nan(0);
1478 nanf(0);
1479 nanl(0);
1480 nearbyint(0.0);
1481 nearbyintf(0.0f);
1482 nearbyintl(0.0l);
1483 nextafter(0.0, 0.0);
1484 nextafterf(0.0f, 0.0f);
1485 nextafterl(0.0l, 0.0l);
1486 nexttoward(0.0, 0.0);
1487 nexttowardf(0.0f, 0.0f);
1488 nexttowardl(0.0l, 0.0l);
1489 remainder(0.0, 0.0);
1490 remainderf(0.0f, 0.0f);
1491 remainderl(0.0l, 0.0l);
1492 remquo(0.0, 0.0, 0);
1493 remquo(0.0f, 0.0f, 0);
1494 remquo(0.0l, 0.0l, 0);
1495 rint(0.0);
1496 rintf(0.0f);
1497 rintl(0.0l);
1498 round(0.0);
1499 roundf(0.0f);
1500 roundl(0.0l);
1501 scalbln(0.0, 0l);
1502 scalblnf(0.0f, 0l);
1503 scalblnl(0.0l, 0l);
1504 scalbn(0.0, 0);
1505 scalbnf(0.0f, 0);
1506 scalbnl(0.0l, 0);
1507 tgamma(0.0);
1508 tgammaf(0.0f);
1509 tgammal(0.0l);
1510 trunc(0.0);
1511 truncf(0.0f);
1512 truncl(0.0l);
6d26724a 1513 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
4f0de5dd 1514 ])
6d26724a
RW		 1515 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1516 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
4f0de5dd
PC		 1517 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1518 [Define if C99 functions or macros in <math.h> should be imported
1519 in <tr1/cmath> in namespace std::tr1.])
1520 fi
1521
03bf3bc1
PC		 1522 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1523 # sense if the previous check fails, per C99, 7.8/1).
1524 ac_c99_inttypes_tr1=no;
6d26724a 1525 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
03bf3bc1
PC		 1526 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1527 AC_TRY_COMPILE([#include <inttypes.h>],
1528 [intmax_t i, numer, denom, base;
1529 const char* s;
1530 char** endptr;
af66a43e
PC		 1531 intmax_t ret = imaxabs(i);
1532 imaxdiv_t dret = imaxdiv(numer, denom);
03bf3bc1 1533 ret = strtoimax(s, endptr, base);
af66a43e 1534 uintmax_t uret = strtoumax(s, endptr, base);
03bf3bc1
PC		 1535 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1536 fi
52a64bd3
PC		 1537 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1538 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1539 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1540 [Define if C99 functions in <inttypes.h> should be imported in
03bf3bc1 1541 <tr1/cinttypes> in namespace std::tr1.])
52a64bd3
PC		 1542 fi
1543
1e41a98c
PC		 1544 # Check for the existence of the <stdbool.h> header.
1545 AC_CHECK_HEADERS(stdbool.h)
1546
18f310b7 1547 CXXFLAGS="$ac_save_CXXFLAGS"
bd2bb1ea
PC		 1548 AC_LANG_RESTORE
1549])
1550
d8bc9819 1551dnl
9ce0a22e 1552dnl Check whether "/dev/random" and "/dev/urandom" are available for the
d8bc9819
PC		 1553dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1554dnl
1555AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1556
9ce0a22e 1557 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
6d26724a 1558 AC_CACHE_VAL(glibcxx_cv_random_tr1, [
9ce0a22e
PC		 1559 if test -r /dev/random && test -r /dev/urandom; then
1560 glibcxx_cv_random_tr1=yes;
1561 else
1562 glibcxx_cv_random_tr1=no;
1563 fi
d8bc9819 1564 ])
6d26724a 1565 AC_MSG_RESULT($glibcxx_cv_random_tr1)
9ce0a22e 1566
6d26724a 1567 if test x"$glibcxx_cv_random_tr1" = x"yes"; then
d8bc9819 1568 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
9ce0a22e 1569 [Define if /dev/random and /dev/urandom are available for
d8bc9819
PC		 1570 the random_device of TR1 (Chapter 5.1).])
1571 fi
1572
1573])
bd2bb1ea 1574
1814157e
PC		 1575dnl
1576dnl Check whether EOF, SEEK_CUR, and SEEK_END have the most common values:
1577dnl in that case including <cstdio> in some C++ headers can be avoided.
1578dnl
1579AC_DEFUN([GLIBCXX_CHECK_STDIO_MACROS], [
1580
1581 AC_MSG_CHECKING([for EOF == -1, SEEK_CUR == 1, SEEK_END == 2])
1582 AC_CACHE_VAL(glibcxx_cv_stdio_macros, [
1583 AC_TRY_COMPILE([#include <stdio.h>],
1584 [#if ((EOF != -1) || (SEEK_CUR != 1) || (SEEK_END != 2))
1585 unusual values...
1586 #endif
1587 ], [glibcxx_cv_stdio_macros=yes],
1588 [glibcxx_cv_stdio_macros=no])
1589 ])
1590 AC_MSG_RESULT($glibcxx_cv_stdio_macros)
1591 if test x"$glibcxx_cv_stdio_macros" = x"yes"; then
1592 AC_DEFINE(_GLIBCXX_STDIO_MACROS, 1,
1593 [Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2.])
1594 fi
1595
1596])
1597
0646d8a3
BK		 1598dnl
1599dnl Check whether macros, etc are present for <system_error>
1600dnl
1601AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1602
6d26724a
RW		 1603m4_pushdef([n_syserr], [1])dnl
1604m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
70593ad2 1605 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
6d26724a
RW		 1606 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY],
1607[m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1608AC_MSG_CHECKING([for syserr])
1609AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1610AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1611 [int i = syserr;])],
1612 [glibcxx_cv_system_error[]n_syserr=yes],
1613 [glibcxx_cv_system_error[]n_syserr=no])
1614])
1615AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1616if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1617 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1618fi
1619m4_define([n_syserr], m4_incr(n_syserr))dnl
1620m4_popdef([SYSERR])dnl
1621])
1622m4_popdef([n_syserr])dnl
0646d8a3
BK		 1623])
1624
d466a7e2
BK		 1625dnl
1626dnl Check whether C++200x's standard layout types are supported.
1627dnl
1628AC_DEFUN([GLIBCXX_CHECK_STANDARD_LAYOUT], [
1629
1630 AC_MSG_CHECKING([for ISO C++200x standard layout type support])
1631 AC_CACHE_VAL(ac_standard_layout, [
1632 AC_LANG_SAVE
1633 AC_LANG_CPLUSPLUS
1634 ac_test_CXXFLAGS="${CXXFLAGS+set}"
1635 ac_save_CXXFLAGS="$CXXFLAGS"
1636 CXXFLAGS='-std=gnu++0x'
1637
1638 AC_TRY_COMPILE([struct b
1639 {
1640 bool t;
1641
1642 // Need standard layout relaxation from POD
1643 private:
1644 b& operator=(const b&);
1645 b(const b&);
1646 };
1647
1648 int main()
1649 {
1650 b tst1 = { false };
1651 return 0;
1652 }],,
1653 [ac_standard_layout=yes], [ac_standard_layout=no])
1654
1655 CXXFLAGS="$ac_save_CXXFLAGS"
1656 AC_LANG_RESTORE
1657 ])
1658 AC_MSG_RESULT($ac_standard_layout)
1659 if test x"$ac_standard_layout" = x"yes"; then
1660 AC_DEFINE(_GLIBCXX_USE_STANDARD_LAYOUT, 1,
1661 [Define if standard layout types are supported in C++200x.])
1662 fi
1663])
1664
0214010c 1665dnl
ff66d28f
PE		 1666dnl Check for what type of C headers to use.
1667dnl
1668dnl --enable-cheaders= [does stuff].
1669dnl --disable-cheaders [does not do anything, really].
1670dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
af13a7a6 1671dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
ff66d28f 1672dnl
f214923c 1673AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
ff66d28f 1674 GLIBCXX_ENABLE(cheaders,$1,[=KIND],
af13a7a6 1675 [construct "C" headers for g++], [permit c|c_std|c_global])
ff66d28f
PE		 1676 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1677
1678 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1679
af13a7a6
BK		 1680 # Allow overrides to configure.host here.
1681 if test $enable_cheaders = c_global; then
1682 c_compatibility=yes
1683 fi
1684
1685 if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1686 c_extra=yes
1687 fi
1688
ff66d28f 1689 AC_SUBST(C_INCLUDE_DIR)
92eabea2
PE		 1690 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1691 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
af13a7a6 1692 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
92eabea2 1693 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
af13a7a6 1694 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
ff66d28f
PE		 1695])
1696
1697
0214010c 1698dnl
ff66d28f
PE		 1699dnl Check for which locale library to use. The choice is mapped to
1700dnl a subdirectory of config/locale.
37bc6ca2 1701dnl
ff66d28f 1702dnl Default is generic.
0214010c 1703dnl
f214923c 1704AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
ff66d28f
PE		 1705 GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1706 [use MODEL for target locale package],
1707 [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
0258dc3a
BK		 1708
1709 # Deal with gettext issues. Default to not using it (=no) until we detect
1710 # support for it later. Let the user turn it off via --e/d, but let that
1711 # default to on for easier handling.
1712 USE_NLS=no
1713 AC_ARG_ENABLE(nls,
1714 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1715 [],
1716 [enable_nls=yes])
ff66d28f 1717
0258dc3a 1718 # Either a known packaage, or "auto"
ff66d28f
PE		 1719 if test $enable_clocale = no || test $enable_clocale = yes; then
1720 enable_clocale=auto
1721 fi
0214010c
BK		 1722 enable_clocale_flag=$enable_clocale
1723
0258dc3a 1724 # Probe for locale model to use if none specified.
ff66d28f
PE		 1725 # Default to "generic".
1726 if test $enable_clocale_flag = auto; then
7d3998a4
PE		 1727 case ${target_os} in
1728 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
0258dc3a 1729 enable_clocale_flag=gnu
56deb74c 1730 ;;
a7f7b334 1731 darwin* | freebsd*)
f9686024
GK		 1732 enable_clocale_flag=darwin
1733 ;;
56deb74c 1734 *)
ff66d28f
PE		 1735 enable_clocale_flag=generic
1736 ;;
56deb74c
BK		 1737 esac
1738 fi
1739
0258dc3a
BK		 1740 # Sanity check model, and test for special functionality.
1741 if test $enable_clocale_flag = gnu; then
1742 AC_EGREP_CPP([_GLIBCXX_ok], [
1743 #include <features.h>
1744 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1745 _GLIBCXX_ok
1746 #endif
1747 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1748
1ba74130
PC		 1749 if test $enable_clocale = auto; then
1750 # Test for bugs early in glibc-2.2.x series
1751 AC_TRY_RUN([
1752 #define _GNU_SOURCE 1
1753 #include <locale.h>
1754 #include <string.h>
1755 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1756 extern __typeof(newlocale) __newlocale;
1757 extern __typeof(duplocale) __duplocale;
1758 extern __typeof(strcoll_l) __strcoll_l;
1759 #endif
1760 int main()
1761 {
1762