]> 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
Add parallel mode.
[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.
52 m4_define([glibcxx_SUBDIRS],[include libmath libsupc++ src po testsuite])
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
203dnl glibcxx_gnu_ld_version (possibly)
204dnl
205dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
206dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems.
c470c17d 207dnl
f214923c 208AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
421173e6
PE		 209 # If we're not using GNU ld, then there's no point in even trying these
210 # tests. Check for that first. We should have already tested for gld
211 # by now (in libtool), but require it now just to be safe...
654421eb
DE		 212 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
213 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
421173e6 214 AC_REQUIRE([AC_PROG_LD])
ff66d28f 215 AC_REQUIRE([AC_PROG_AWK])
5bd17d39 216
c98b201b
PE		 217 # The name set by libtool depends on the version of libtool. Shame on us
218 # for depending on an impl detail, but c'est la vie. Older versions used
219 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
220 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
221 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
222 # set (hence we're using an older libtool), then set it.
223 if test x${with_gnu_ld+set} != xset; then
224 if test x${ac_cv_prog_gnu_ld+set} != xset; then
225 # We got through "ac_require(ac_prog_ld)" and still not set? Huh?
226 with_gnu_ld=no
227 else
228 with_gnu_ld=$ac_cv_prog_gnu_ld
229 fi
230 fi
231
232 # Start by getting the version number. I think the libtool test already
233 # does some of this, but throws away the result.
e2c104d8
BK		 234 if test x"$with_gnu_ld" = x"yes"; then
235 AC_MSG_CHECKING([for ld version])
236 changequote(,)
237 ldver=`$LD --version 2>/dev/null | head -1 | \
daa07a06 238 sed -e 's/GNU ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\3/'`
e2c104d8
BK		 239 changequote([,])
240 glibcxx_gnu_ld_version=`echo $ldver | \
241 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
242 AC_MSG_RESULT($glibcxx_gnu_ld_version)
243 fi
c98b201b 244
5bd17d39 245 # Set --gc-sections.
ac2b2479
BK		 246 glibcxx_gcsections_min_ld=21602
247 if test x"$with_gnu_ld" = x"yes" &&
248 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
249
250 # Sufficiently young GNU ld it is! Joy and bunny rabbits!
251 # NB: This flag only works reliably after 2.16.1. Configure tests
252 # for this are difficult, so hard wire a value that should work.
421173e6 253
421173e6
PE		 254 ac_test_CFLAGS="${CFLAGS+set}"
255 ac_save_CFLAGS="$CFLAGS"
2a0ab51c 256 CFLAGS='-Wl,--gc-sections'
421173e6
PE		 257
258 # Check for -Wl,--gc-sections
259 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
acb6e9be
BK		 260 AC_TRY_LINK([ int one(void) { return 1; }
261 int two(void) { return 2; }
262 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
360e8759
L		 263 if test "$ac_gcsections" = "yes"; then
264 rm -f conftest.c
265 touch conftest.c
266 if $CC -c conftest.c; then
267 if $LD --gc-sections -o conftest conftest.o 2>&1 | \
268 grep "Warning: gc-sections option ignored" > /dev/null; then
269 ac_gcsections=no
270 fi
271 fi
272 rm -f conftest.c conftest.o conftest
273 fi
acb6e9be
BK		 274 if test "$ac_gcsections" = "yes"; then
275 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
276 fi
277 AC_MSG_RESULT($ac_gcsections)
278
421173e6
PE		 279 if test "$ac_test_CFLAGS" = set; then
280 CFLAGS="$ac_save_CFLAGS"
281 else
282 # this is the suspicious part
283 CFLAGS=''
284 fi
5bd17d39 285 fi
a9117427 286
a429affe 287 # Set -z,relro.
952c7b74 288 # Note this is only for shared objects.
a429affe
BK		 289 ac_ld_relro=no
290 if test x"$with_gnu_ld" = x"yes"; then
291 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
292 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
293 if test -n "$cxx_z_relo"; then
294 OPT_LDFLAGS="-Wl,-z,relro"
295 ac_ld_relro=yes
296 fi
297 AC_MSG_RESULT($ac_ld_relro)
298 fi
299
5bd17d39 300 # Set linker optimization flags.
6aa43d99 301 if test x"$with_gnu_ld" = x"yes"; then
654421eb 302 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
421173e6 303 fi
5bd17d39 304
c470c17d 305 AC_SUBST(SECTION_LDFLAGS)
421173e6 306 AC_SUBST(OPT_LDFLAGS)
c470c17d
BK		 307])
308
309
b2dad0e3 310dnl
ff66d28f
PE		 311dnl Check for headers for, and arguments to, the setrlimit() function.
312dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
6aa43d99 313dnl
ff66d28f 314dnl Defines:
2ae6e982
PC		 315dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
316dnl various HAVE_LIMIT_* for individual limit names
6aa43d99 317dnl
f214923c 318AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
e0103440 319 AC_MSG_CHECKING([for RLIMIT_$1])
ff66d28f
PE		 320 AC_TRY_COMPILE(
321 [#include <unistd.h>
322 #include <sys/time.h>
323 #include <sys/resource.h>
324 ],
325 [ int f = RLIMIT_$1 ; ],
326 [glibcxx_mresult=1], [glibcxx_mresult=0])
2ae6e982 327 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
ff66d28f 328 [Only used in build directory testsuite_hooks.h.])
e0103440
GK		 329 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
330 AC_MSG_RESULT($res)
ff66d28f
PE		 331])
332
f214923c 333AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
ff66d28f
PE		 334 setrlimit_have_headers=yes
335 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
336 [],
337 [setrlimit_have_headers=no])
338 # If don't have the headers, then we can't run the tests now, and we
339 # won't be seeing any of these during testsuite compilation.
340 if test $setrlimit_have_headers = yes; then
341 # Can't do these in a loop, else the resulting syntax is wrong.
342 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
343 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
344 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
345 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
2ae6e982 346 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
ff66d28f
PE		 347
348 # Check for rlimit, setrlimit.
349 AC_CACHE_VAL(ac_setrlimit, [
350 AC_TRY_COMPILE(
351 [#include <unistd.h>
352 #include <sys/time.h>
353 #include <sys/resource.h>
354 ],
355 [struct rlimit r;
356 setrlimit(0, &r);],
357 [ac_setrlimit=yes], [ac_setrlimit=no])
358 ])
359 fi
360
2ae6e982 361 AC_MSG_CHECKING([for testsuite resource limits support])
ff66d28f 362 if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
2ae6e982 363 ac_res_limits=yes
4651e622
KC		 364 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
365 [Define if using setrlimit to set resource limits during
366 "make check"])
ff66d28f 367 else
2ae6e982 368 ac_res_limits=no
ff66d28f 369 fi
2ae6e982 370 AC_MSG_RESULT($ac_res_limits)
6aa43d99
BK		 371])
372
373
6aa43d99 374dnl
ff66d28f
PE		 375dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
376dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
6aa43d99 377dnl
f214923c 378AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
e0103440 379 AC_MSG_CHECKING([for S_ISREG or S_IFREG])
ff66d28f
PE		 380 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
381 AC_TRY_LINK(
382 [#include <sys/stat.h>],
383 [struct stat buffer;
384 fstat(0, &buffer);
385 S_ISREG(buffer.st_mode);],
386 [glibcxx_cv_S_ISREG=yes],
387 [glibcxx_cv_S_ISREG=no])
388 ])
389 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
390 AC_TRY_LINK(
391 [#include <sys/stat.h>],
392 [struct stat buffer;
393 fstat(0, &buffer);
394 S_IFREG & buffer.st_mode;],
395 [glibcxx_cv_S_IFREG=yes],
396 [glibcxx_cv_S_IFREG=no])
397 ])
e0103440 398 res=no
ff66d28f 399 if test $glibcxx_cv_S_ISREG = yes; then
4651e622
KC		 400 AC_DEFINE(HAVE_S_ISREG, 1,
401 [Define if S_IFREG is available in <sys/stat.h>.])
e0103440 402 res=S_ISREG
ff66d28f 403 elif test $glibcxx_cv_S_IFREG = yes; then
4651e622
KC		 404 AC_DEFINE(HAVE_S_IFREG, 1,
405 [Define if S_IFREG is available in <sys/stat.h>.])
e0103440 406 res=S_IFREG
ff66d28f 407 fi
e0103440 408 AC_MSG_RESULT($res)
b2dad0e3
BK		 409])
410
411
dcfa0bc8 412dnl
ff66d28f 413dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
dcfa0bc8 414dnl
f214923c 415AC_DEFUN([GLIBCXX_CHECK_POLL], [
e0103440 416 AC_MSG_CHECKING([for poll])
ff66d28f 417 AC_CACHE_VAL(glibcxx_cv_POLL, [
3d05b345 418 AC_TRY_LINK(
ff66d28f
PE		 419 [#include <poll.h>],
420 [struct pollfd pfd[1];
421 pfd[0].events = POLLIN;
422 poll(pfd, 1, 0);],
423 [glibcxx_cv_POLL=yes],
424 [glibcxx_cv_POLL=no])
425 ])
426 if test $glibcxx_cv_POLL = yes; then
4651e622 427 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
ff66d28f 428 fi
e0103440 429 AC_MSG_RESULT($glibcxx_cv_POLL)
ff66d28f
PE		 430])
431
432
433dnl
434dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
435dnl
f214923c 436AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
e0103440 437 AC_MSG_CHECKING([for writev])
ff66d28f 438 AC_CACHE_VAL(glibcxx_cv_WRITEV, [
3d05b345 439 AC_TRY_LINK(
ff66d28f
PE		 440 [#include <sys/uio.h>],
441 [struct iovec iov[2];
442 writev(0, iov, 0);],
443 [glibcxx_cv_WRITEV=yes],
444 [glibcxx_cv_WRITEV=no])
445 ])
446 if test $glibcxx_cv_WRITEV = yes; then
4651e622 447 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
ff66d28f 448 fi
e0103440 449 AC_MSG_RESULT($glibcxx_cv_WRITEV)
ff66d28f
PE		 450])
451
452
3d05b345
PC		 453dnl
454dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
455dnl
f214923c 456AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
e0103440 457 AC_MSG_CHECKING([for int64_t])
3d05b345
PC		 458 AC_CACHE_VAL(glibcxx_cv_INT64_T, [
459 AC_TRY_COMPILE(
460 [#include <stdint.h>],
461 [int64_t var;],
462 [glibcxx_cv_INT64_T=yes],
463 [glibcxx_cv_INT64_T=no])
464 ])
465 if test $glibcxx_cv_INT64_T = yes; then
4651e622 466 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
3d05b345 467 fi
e0103440 468 AC_MSG_RESULT($glibcxx_cv_INT64_T)
3d05b345
PC		 469])
470
471
472dnl
473dnl Check whether LFS support is available.
474dnl
f214923c 475AC_DEFUN([GLIBCXX_CHECK_LFS], [
0c6b814a 476 AC_LANG_SAVE
9d47bc51
PC		 477 AC_LANG_CPLUSPLUS
478 ac_save_CXXFLAGS="$CXXFLAGS"
479 CXXFLAGS="$CXXFLAGS -fno-exceptions"
e0103440 480 AC_MSG_CHECKING([for LFS support])
3d05b345
PC		 481 AC_CACHE_VAL(glibcxx_cv_LFS, [
482 AC_TRY_LINK(
0c6b814a
PC		 483 [#include <unistd.h>
484 #include <stdio.h>
dd5d134b 485 #include <sys/stat.h>
0c6b814a 486 ],
5c89246d
PC		 487 [FILE* fp;
488 fopen64("t", "w");
489 fseeko64(fp, 0, SEEK_CUR);
490 ftello64(fp);
dd5d134b
PC		 491 lseek64(1, 0, SEEK_CUR);
492 struct stat64 buf;
493 fstat64(1, &buf);],
3d05b345
PC		 494 [glibcxx_cv_LFS=yes],
495 [glibcxx_cv_LFS=no])
496 ])
497 if test $glibcxx_cv_LFS = yes; then
4651e622 498 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
3d05b345 499 fi
e0103440 500 AC_MSG_RESULT($glibcxx_cv_LFS)
9d47bc51
PC		 501 CXXFLAGS="$ac_save_CXXFLAGS"
502 AC_LANG_RESTORE
3d05b345
PC		 503])
504
505
1165dc50
PC		 506dnl
507dnl Check for whether a fully dynamic basic_string implementation should
508dnl be turned on, that does not put empty objects in per-process static
509dnl memory (mostly useful together with shared memory allocators, see PR
510dnl libstdc++/16612 for details).
511dnl
512dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
513dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
514dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
515dnl Where DEFAULT is either `yes' or `no'.
516dnl
517AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
518 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
519 if test $enable_fully_dynamic_string = yes; then
4651e622
KC		 520 AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
521 [Define if a fully dynamic basic_string is wanted.])
1165dc50
PC		 522 fi
523])
524
525
ff66d28f
PE		 526dnl
527dnl Does any necessary configuration of the testsuite directory. Generates
528dnl the testsuite_hooks.h header.
529dnl
530dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
531dnl
532dnl Sets:
84946e72 533dnl enable_abi_check
e3f78d9b
BK		 534dnl GLIBCXX_TEST_WCHAR_T
535dnl GLIBCXX_TEST_THREAD
ff66d28f
PE		 536dnl Substs:
537dnl baseline_dir
538dnl
f214923c 539AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
0646b059 540 if $GLIBCXX_IS_NATIVE ; then
2ae6e982 541 # Do checks for resource limit functions.
ff66d28f
PE		 542 GLIBCXX_CHECK_SETRLIMIT
543
544 # Look for setenv, so that extended locale tests can be performed.
545 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
0646b059 546 fi
dbc66058 547
0646b059
GK		 548 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
549 test $enable_symvers != no; then
550 case "$host" in
551 *-*-cygwin*)
552 enable_abi_check=no ;;
553 *)
554 enable_abi_check=yes ;;
555 esac
dbc66058
DJ		 556 else
557 # Only build this as native, since automake does not understand
558 # CXX_FOR_BUILD.
559 enable_abi_check=no
ff66d28f 560 fi
84946e72 561
ff66d28f 562 # Export file names for ABI checking.
fb5c309d 563 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}\$(MULTISUBDIR)"
ff66d28f 564 AC_SUBST(baseline_dir)
ff66d28f
PE		 565])
566
567
568dnl
569dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
570dnl
571dnl Substs:
572dnl GLIBCXX_INCLUDES
573dnl TOPLEVEL_INCLUDES
ff66d28f 574dnl
f214923c 575AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
0df3f383
PE		 576 # Used for every C++ compile we perform.
577 GLIBCXX_INCLUDES="\
578-I$glibcxx_builddir/include/$host_alias \
579-I$glibcxx_builddir/include \
580-I$glibcxx_srcdir/libsupc++"
ff66d28f 581
0df3f383 582 # For Canadian crosses, pick this up too.
ff66d28f 583 if test $CANADIAN = yes; then
37e0ff11 584 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
ff66d28f
PE		 585 fi
586
0df3f383
PE		 587 # Stuff in the actual top level. Currently only used by libsupc++ to
588 # get unwind* headers from the gcc dir.
589 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
590 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
ff66d28f
PE		 591
592 # Now, export this to all the little Makefiles....
593 AC_SUBST(GLIBCXX_INCLUDES)
594 AC_SUBST(TOPLEVEL_INCLUDES)
ff66d28f
PE		 595])
596
597
598dnl
599dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
600dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
601dnl
602dnl Substs:
603dnl OPTIMIZE_CXXFLAGS
604dnl WARN_FLAGS
605dnl
f214923c 606AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
ff66d28f
PE		 607 # Optimization flags that are probably a good idea for thrill-seekers. Just
608 # uncomment the lines below and make, everything else is ready to go...
62801a96 609 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
ff66d28f 610 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
ff66d28f
PE		 611 AC_SUBST(OPTIMIZE_CXXFLAGS)
612
dc7c62ae 613 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
ff66d28f
PE		 614 AC_SUBST(WARN_FLAGS)
615])
616
617
618dnl
619dnl All installation directory information is determined here.
620dnl
621dnl Substs:
622dnl gxx_install_dir
623dnl glibcxx_prefixdir
624dnl glibcxx_toolexecdir
625dnl glibcxx_toolexeclibdir
626dnl
627dnl Assumes cross_compiling bits already done, and with_cross_host in
628dnl particular.
629dnl
0f57bf40 630dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
505692b0 631dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
f214923c 632AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
ff66d28f
PE		 633 glibcxx_toolexecdir=no
634 glibcxx_toolexeclibdir=no
635 glibcxx_prefixdir=$prefix
636
637 AC_MSG_CHECKING([for gxx-include-dir])
638 AC_ARG_WITH([gxx-include-dir],
639 AC_HELP_STRING([--with-gxx-include-dir=DIR],
640 [installation directory for include files]),
641 [case "$withval" in
642 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
643 no) gxx_include_dir=no ;;
644 *) gxx_include_dir=$withval ;;
645 esac],
646 [gxx_include_dir=no])
647 AC_MSG_RESULT($gxx_include_dir)
648
649 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
650 AC_ARG_ENABLE([version-specific-runtime-libs],
651 AC_HELP_STRING([--enable-version-specific-runtime-libs],
652 [Specify that runtime libraries should be installed in a compiler-specific directory]),
653 [case "$enableval" in
654 yes) version_specific_libs=yes ;;
655 no) version_specific_libs=no ;;
656 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
657 esac],
658 [version_specific_libs=no])
659 AC_MSG_RESULT($version_specific_libs)
660
661 # Default case for install directory for include files.
662 if test $version_specific_libs = no && test $gxx_include_dir = no; then
0f57bf40
MM		 663 gxx_include_dir='include/c++/${gcc_version}'
664 if test -n "$with_cross_host" &&
665 test x"$with_cross_host" != x"no"; then
666 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
667 else
668 gxx_include_dir='${prefix}/'"$gxx_include_dir"
669 fi
ff66d28f
PE		 670 fi
671
672 # Version-specific runtime libs processing.
673 if test $version_specific_libs = yes; then
674 # Need the gcc compiler version to know where to install libraries
675 # and header files if --enable-version-specific-runtime-libs option
0314451d
GK		 676 # is selected. FIXME: these variables are misnamed, there are
677 # no executables installed in _toolexecdir or _toolexeclibdir.
ff66d28f 678 if test x"$gxx_include_dir" = x"no"; then
47194af4 679 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
ff66d28f 680 fi
0314451d 681 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
47194af4 682 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
ff66d28f
PE		 683 fi
684
685 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
686 # Install a library built with a cross compiler in tooldir, not libdir.
687 if test x"$glibcxx_toolexecdir" = x"no"; then
688 if test -n "$with_cross_host" &&
689 test x"$with_cross_host" != x"no"; then
fbe057bb
PE		 690 glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
691 glibcxx_toolexeclibdir='${toolexecdir}/lib'
ff66d28f 692 else
0314451d 693 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
fbe057bb 694 glibcxx_toolexeclibdir='${libdir}'
ff66d28f 695 fi
fbe057bb 696 multi_os_directory=`$CXX -print-multi-os-directory`
ff66d28f
PE		 697 case $multi_os_directory in
698 .) ;; # Avoid trailing /.
699 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
700 esac
701 fi
702
703 AC_MSG_CHECKING([for install location])
704 AC_MSG_RESULT($gxx_include_dir)
705
706 AC_SUBST(glibcxx_prefixdir)
707 AC_SUBST(gxx_include_dir)
708 AC_SUBST(glibcxx_toolexecdir)
709 AC_SUBST(glibcxx_toolexeclibdir)
710])
711
712
713dnl
714dnl GLIBCXX_ENABLE
715dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
716dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
717dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
718dnl
719dnl See docs/html/17_intro/configury.html#enable for documentation.
720dnl
721m4_define([GLIBCXX_ENABLE],[dnl
722m4_define([_g_switch],[--enable-$1])dnl
723m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
724 AC_ARG_ENABLE($1,_g_help,
725 m4_bmatch([$5],
726 [^permit ],
727 [[
728 case "$enableval" in
729 m4_bpatsubst([$5],[permit ])) ;;
730 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
731 dnl Idea for future: generate a URL pointing to
732 dnl "onlinedocs/configopts.html#whatever"
733 esac
734 ]],
735 [^$],
736 [[
737 case "$enableval" in
738 yes|no) ;;
739 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
740 esac
741 ]],
742 [[$5]]),
743 [enable_]m4_bpatsubst([$1],-,_)[=][$2])
744m4_undefine([_g_switch])dnl
745m4_undefine([_g_help])dnl
746])
747
748
749dnl
750dnl Check for ISO/IEC 9899:1999 "C99" support.
751dnl
752dnl --enable-c99 defines _GLIBCXX_USE_C99
753dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
754dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)]
755dnl Where DEFAULT is either `yes' or `no'.
756dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
757dnl
f214923c 758AC_DEFUN([GLIBCXX_ENABLE_C99], [
ff66d28f
PE		 759 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
760
347669a0
BK		 761 if test x"$enable_c99" = x"yes"; then
762
ff66d28f
PE		 763 AC_LANG_SAVE
764 AC_LANG_CPLUSPLUS
765
766 # Check for the existence of <math.h> functions used if C99 is enabled.
ff66d28f 767 AC_MSG_CHECKING([for ISO C99 support in <math.h>])
347669a0 768 AC_CACHE_VAL(ac_c99_math, [
ff66d28f 769 AC_TRY_COMPILE([#include <math.h>],
347669a0
BK		 770 [fpclassify(0.0);
771 isfinite(0.0);
772 isinf(0.0);
773 isnan(0.0);
774 isnormal(0.0);
775 signbit(0.0);
776 isgreater(0.0,0.0);
777 isgreaterequal(0.0,0.0);
778 isless(0.0,0.0);
779 islessequal(0.0,0.0);
780 islessgreater(0.0,0.0);
781 islessgreater(0.0,0.0);
782 isunordered(0.0,0.0);
783 ],[ac_c99_math=yes], [ac_c99_math=no])
784 ])
ff66d28f 785 AC_MSG_RESULT($ac_c99_math)
517da0ce 786 if test x"$ac_c99_math" = x"yes"; then
4651e622
KC		 787 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
788 [Define if C99 functions or macros in <math.h> should be imported
789 in <cmath> in namespace std.])
517da0ce
MM		 790 fi
791
225962a0 792 # Check for the existence of <complex.h> complex math functions.
52e6723c
BK		 793 # This is necessary even though libstdc++ uses the builtin versions
794 # of these functions, because if the builtin cannot be used, a reference
795 # to the library function is emitted.
5ad2f32d 796 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
52e6723c
BK		 797 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
798 ac_c99_complex=no;
799 if test x"$ac_has_complex_h" = x"yes"; then
52e6723c
BK		 800 AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
801 AC_TRY_COMPILE([#include <complex.h>],
347669a0
BK		 802 [typedef __complex__ float float_type; float_type tmpf;
803 cabsf(tmpf);
804 cargf(tmpf);
805 ccosf(tmpf);
806 ccoshf(tmpf);
807 cexpf(tmpf);
9d997b96 808 clogf(tmpf);
347669a0
BK		 809 csinf(tmpf);
810 csinhf(tmpf);
811 csqrtf(tmpf);
812 ctanf(tmpf);
813 ctanhf(tmpf);
814 cpowf(tmpf, tmpf);
815 typedef __complex__ double double_type; double_type tmpd;
816 cabs(tmpd);
817 carg(tmpd);
818 ccos(tmpd);
819 ccosh(tmpd);
820 cexp(tmpd);
9d997b96 821 clog(tmpd);
347669a0
BK		 822 csin(tmpd);
823 csinh(tmpd);
824 csqrt(tmpd);
825 ctan(tmpd);
826 ctanh(tmpd);
827 cpow(tmpd, tmpd);
828 typedef __complex__ long double ld_type; ld_type tmpld;
829 cabsl(tmpld);
830 cargl(tmpld);
831 ccosl(tmpld);
832 ccoshl(tmpld);
833 cexpl(tmpld);
9d997b96 834 clogl(tmpld);
347669a0
BK		 835 csinl(tmpld);
836 csinhl(tmpld);
837 csqrtl(tmpld);
838 ctanl(tmpld);
839 ctanhl(tmpld);
840 cpowl(tmpld, tmpld);
841 ],[ac_c99_complex=yes], [ac_c99_complex=no])
52e6723c
BK		 842 fi
843 AC_MSG_RESULT($ac_c99_complex)
52e6723c 844 if test x"$ac_c99_complex" = x"yes"; then
4651e622
KC		 845 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
846 [Define if C99 functions in <complex.h> should be used in
847 <complex>. Using compiler builtins for these functions requires
848 corresponding C99 library functions to be present.])
52e6723c
BK		 849 fi
850
ff66d28f 851 # Check for the existence in <stdio.h> of vscanf, et. al.
ff66d28f 852 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
347669a0 853 AC_CACHE_VAL(ac_c99_stdio, [
ff66d28f 854 AC_TRY_COMPILE([#include <stdio.h>
347669a0 855 #include <stdarg.h>
ff66d28f 856 void foo(char* fmt, ...)
347669a0
BK		 857 {
858 va_list args; va_start(args, fmt);
859 vfscanf(stderr, "%i", args);
860 vscanf("%i", args);
861 vsnprintf(fmt, 0, "%i", args);
862 vsscanf(fmt, "%i", args);
863 }],
864 [snprintf("12", 0, "%i");],
865 [ac_c99_stdio=yes], [ac_c99_stdio=no])
866 ])
ff66d28f
PE		 867 AC_MSG_RESULT($ac_c99_stdio)
868
869 # Check for the existence in <stdlib.h> of lldiv_t, et. al.
ff66d28f 870 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
347669a0 871 AC_CACHE_VAL(ac_c99_stdlib, [
ff66d28f 872 AC_TRY_COMPILE([#include <stdlib.h>],
10d877a8
PC		 873 [char* tmp;
874 strtof("gnu", &tmp);
347669a0 875 strtold("gnu", &tmp);
10d877a8
PC		 876 strtoll("gnu", &tmp, 10);
877 strtoull("gnu", &tmp, 10);
878 llabs(10);
879 lldiv(10,1);
880 atoll("10");
347669a0
BK		 881 _Exit(0);
882 lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
883 ])
ff66d28f
PE		 884 AC_MSG_RESULT($ac_c99_stdlib)
885
8a9b2875 886 # Check for the existence in <wchar.h> of wcstold, etc.
347669a0
BK		 887 ac_c99_wchar=no;
888 if test x"$ac_has_wchar_h" = xyes &&
889 test x"$ac_has_wctype_h" = xyes; then
8a9b2875 890 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
347669a0 891 AC_TRY_COMPILE([#include <wchar.h>
347669a0
BK		 892 namespace test
893 {
347669a0
BK		 894 using ::wcstold;
895 using ::wcstoll;
347669a0 896 using ::wcstoull;
347669a0
BK		 897 }
898 ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
899
900 # Checks for wide character functions that may not be present.
901 # Injection of these is wrapped with guard macros.
902 # NB: only put functions here, instead of immediately above, if
903 # absolutely necessary.
904 AC_TRY_COMPILE([#include <wchar.h>
905 namespace test { using ::vfwscanf; } ], [],
906 [AC_DEFINE(HAVE_VFWSCANF,1,
907 [Defined if vfwscanf exists.])],[])
908
909 AC_TRY_COMPILE([#include <wchar.h>
910 namespace test { using ::vswscanf; } ], [],
911 [AC_DEFINE(HAVE_VSWSCANF,1,
912 [Defined if vswscanf exists.])],[])
913
914 AC_TRY_COMPILE([#include <wchar.h>
915 namespace test { using ::vwscanf; } ], [],
916 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
917
918 AC_TRY_COMPILE([#include <wchar.h>
919 namespace test { using ::wcstof; } ], [],
920 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
921
922 AC_TRY_COMPILE([#include <wctype.h>],
923 [ wint_t t; int i = iswblank(t);],
924 [AC_DEFINE(HAVE_ISWBLANK,1,
925 [Defined if iswblank exists.])],[])
926
347669a0
BK		 927 AC_MSG_RESULT($ac_c99_wchar)
928 fi
ff66d28f 929
347669a0 930 # Option parsed, now set things appropriately.
ff66d28f 931 if test x"$ac_c99_math" = x"no" ||
02a65d23 932 test x"$ac_c99_complex" = x"no" ||
ff66d28f
PE		 933 test x"$ac_c99_stdio" = x"no" ||
934 test x"$ac_c99_stdlib" = x"no" ||
935 test x"$ac_c99_wchar" = x"no"; then
936 enable_c99=no;
347669a0 937 else
4651e622
KC		 938 AC_DEFINE(_GLIBCXX_USE_C99, 1,
939 [Define if C99 functions or macros from <wchar.h>, <math.h>,
940 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
ff66d28f
PE		 941 fi
942
943 AC_LANG_RESTORE
347669a0
BK		 944 fi
945
946 AC_MSG_CHECKING([for fully enabled ISO C99 support])
947 AC_MSG_RESULT($enable_c99)
dcfa0bc8
PE		 948])
949
950
bd2bb1ea
PC		 951dnl
952dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
953dnl facilities in Chapter 8, "C compatibility".
954dnl
955AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
956
957 AC_LANG_SAVE
958 AC_LANG_CPLUSPLUS
959
960 # Check for the existence of <complex.h> complex math functions used
961 # by tr1/complex.
962 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
963 ac_c99_complex_tr1=no;
964 if test x"$ac_has_complex_h" = x"yes"; then
965 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
966 AC_TRY_COMPILE([#include <complex.h>],
967 [typedef __complex__ float float_type; float_type tmpf;
968 cacosf(tmpf);
969 casinf(tmpf);
970 catanf(tmpf);
971 cacoshf(tmpf);
972 casinhf(tmpf);
973 catanhf(tmpf);
974 typedef __complex__ double double_type; double_type tmpd;
975 cacos(tmpd);
976 casin(tmpd);
977 catan(tmpd);
978 cacosh(tmpd);
979 casinh(tmpd);
980 catanh(tmpd);
981 typedef __complex__ long double ld_type; ld_type tmpld;
982 cacosl(tmpld);
983 casinl(tmpld);
984 catanl(tmpld);
985 cacoshl(tmpld);
986 casinhl(tmpld);
987 catanhl(tmpld);
988 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
989 fi
990 AC_MSG_RESULT($ac_c99_complex_tr1)
991 if test x"$ac_c99_complex_tr1" = x"yes"; then
992 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
993 [Define if C99 functions in <complex.h> should be used in
994 <tr1/complex>. Using compiler builtins for these functions
995 requires corresponding C99 library functions to be present.])
996 fi
997
998 # Check for the existence of <ctype.h> functions.
999 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1000 AC_CACHE_VAL(ac_c99_ctype_tr1, [
1001 AC_TRY_COMPILE([#include <ctype.h>],
20921e53 1002 [int ch;
98fb1d29
PC		 1003 int ret;
1004 ret = isblank(ch);
bd2bb1ea
PC		 1005 ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no])
1006 ])
1007 AC_MSG_RESULT($ac_c99_ctype_tr1)
1008 if test x"$ac_c99_ctype_tr1" = x"yes"; then
1009 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1010 [Define if C99 functions in <ctype.h> should be imported in
1011 <tr1/cctype> in namespace std::tr1.])
1012 fi
1013
20921e53
PC		 1014 # Check for the existence of <fenv.h> functions.
1015 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1016 ac_c99_fenv_tr1=no;
1017 if test x"$ac_has_fenv_h" = x"yes"; then
1018 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1019 AC_TRY_COMPILE([#include <fenv.h>],
1020 [int except, mode;
1021 fexcept_t* pflag;
1022 fenv_t* penv;
98fb1d29
PC		 1023 int ret;
1024 ret = feclearexcept(except);
1025 ret = fegetexceptflag(pflag, except);
1026 ret = feraiseexcept(except);
1027 ret = fesetexceptflag(pflag, except);
1028 ret = fetestexcept(except);
1029 ret = fegetround();
1030 ret = fesetround(mode);
1031 ret = fegetenv(penv);
1032 ret = feholdexcept(penv);
1033 ret = fesetenv(penv);
1034 ret = feupdateenv(penv);
20921e53
PC		 1035 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1036 fi
1037 AC_MSG_RESULT($ac_c99_fenv_tr1)
1038 if test x"$ac_c99_fenv_tr1" = x"yes"; then
1039 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1040 [Define if C99 functions in <fenv.h> should be imported in
1041 <tr1/cfenv> in namespace std::tr1.])
1042 fi
1043
2a1d6346
PC		 1044 # Check for the existence of <stdint.h> types.
1045 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1046 AC_CACHE_VAL(ac_c99_stdint_tr1, [
1047 AC_TRY_COMPILE([#include <stdint.h>],
1048 [typedef int8_t my_int8_t;
1049 typedef int16_t my_int16_t;
1050 typedef int32_t my_int32_t;
1051 typedef int64_t my_int64_t;
1052 typedef int_fast8_t my_int_fast8_t;
1053 typedef int_fast16_t my_int_fast16_t;
1054 typedef int_fast32_t my_int_fast32_t;
1055 typedef int_fast64_t my_int_fast64_t;
1056 typedef int_least8_t my_int_least8_t;
1057 typedef int_least16_t my_int_least16_t;
1058 typedef int_least32_t my_int_least32_t;
1059 typedef int_least64_t my_int_least64_t;
1060 typedef intmax_t my_intmax_t;
1061 typedef intptr_t my_intptr_t;
1062 typedef uint8_t my_uint8_t;
1063 typedef uint16_t my_uint16_t;
1064 typedef uint32_t my_uint32_t;
1065 typedef uint64_t my_uint64_t;
1066 typedef uint_fast8_t my_uint_fast8_t;
1067 typedef uint_fast16_t my_uint_fast16_t;
1068 typedef uint_fast32_t my_uint_fast32_t;
1069 typedef uint_fast64_t my_uint_fast64_t;
1070 typedef uint_least8_t my_uint_least8_t;
1071 typedef uint_least16_t my_uint_least16_t;
1072 typedef uint_least32_t my_uint_least32_t;
1073 typedef uint_least64_t my_uint_least64_t;
1074 typedef uintmax_t my_uintmax_t;
1075 typedef uintptr_t my_uintptr_t;
1076 ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no])
1077 ])
1078 AC_MSG_RESULT($ac_c99_stdint_tr1)
1079 if test x"$ac_c99_stdint_tr1" = x"yes"; then
1080 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1081 [Define if C99 types in <stdint.h> should be imported in
1082 <tr1/cstdint> in namespace std::tr1.])
1083 fi
1084
4f0de5dd
PC		 1085 # Check for the existence of <math.h> functions.
1086 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1087 AC_CACHE_VAL(ac_c99_math_tr1, [
1088 AC_TRY_COMPILE([#include <math.h>],
9a7ab578
PC		 1089 [typedef double_t my_double_t;
1090 typedef float_t my_float_t;
1091 acosh(0.0);
4f0de5dd
PC		 1092 acoshf(0.0f);
1093 acoshl(0.0l);
1094 asinh(0.0);
1095 asinhf(0.0f);
1096 asinhl(0.0l);
1097 atanh(0.0);
1098 atanhf(0.0f);
1099 atanhl(0.0l);
1100 cbrt(0.0);
1101 cbrtf(0.0f);
1102 cbrtl(0.0l);
1103 copysign(0.0, 0.0);
1104 copysignf(0.0f, 0.0f);
1105 copysignl(0.0l, 0.0l);
1106 erf(0.0);
1107 erff(0.0f);
1108 erfl(0.0l);
1109 erfc(0.0);
1110 erfcf(0.0f);
1111 erfcl(0.0l);
1112 exp2(0.0);
1113 exp2f(0.0f);
1114 exp2l(0.0l);
1115 expm1(0.0);
1116 expm1f(0.0f);
1117 expm1l(0.0l);
1118 fdim(0.0, 0.0);
1119 fdimf(0.0f, 0.0f);
1120 fdiml(0.0l, 0.0l);
1121 fma(0.0, 0.0, 0.0);
1122 fmaf(0.0f, 0.0f, 0.0f);
1123 fmal(0.0l, 0.0l, 0.0l);
1124 fmax(0.0, 0.0);
1125 fmaxf(0.0f, 0.0f);
1126 fmaxl(0.0l, 0.0l);
1127 fmin(0.0, 0.0);
1128 fminf(0.0f, 0.0f);
1129 fminl(0.0l, 0.0l);
1130 hypot(0.0, 0.0);
1131 hypotf(0.0f, 0.0f);
1132 hypotl(0.0l, 0.0l);
1133 ilogb(0.0);
1134 ilogbf(0.0f);
1135 ilogbl(0.0l);
1136 lgamma(0.0);
1137 lgammaf(0.0f);
1138 lgammal(0.0l);
1139 llrint(0.0);
1140 llrintf(0.0f);
1141 llrintl(0.0l);
1142 llround(0.0);
1143 llroundf(0.0f);
1144 llroundl(0.0l);
1145 log1p(0.0);
1146 log1pf(0.0f);
1147 log1pl(0.0l);
1148 log2(0.0);
1149 log2f(0.0f);
1150 log2l(0.0l);
1151 logb(0.0);
1152 logbf(0.0f);
1153 logbl(0.0l);
1154 lrint(0.0);
1155 lrintf(0.0f);
1156 lrintl(0.0l);
1157 lround(0.0);
1158 lroundf(0.0f);
1159 lroundl(0.0l);
1160 nan(0);
1161 nanf(0);
1162 nanl(0);
1163 nearbyint(0.0);
1164 nearbyintf(0.0f);
1165 nearbyintl(0.0l);
1166 nextafter(0.0, 0.0);
1167 nextafterf(0.0f, 0.0f);
1168 nextafterl(0.0l, 0.0l);
1169 nexttoward(0.0, 0.0);
1170 nexttowardf(0.0f, 0.0f);
1171 nexttowardl(0.0l, 0.0l);
1172 remainder(0.0, 0.0);
1173 remainderf(0.0f, 0.0f);
1174 remainderl(0.0l, 0.0l);
1175 remquo(0.0, 0.0, 0);
1176 remquo(0.0f, 0.0f, 0);
1177 remquo(0.0l, 0.0l, 0);
1178 rint(0.0);
1179 rintf(0.0f);
1180 rintl(0.0l);
1181 round(0.0);
1182 roundf(0.0f);
1183 roundl(0.0l);
1184 scalbln(0.0, 0l);
1185 scalblnf(0.0f, 0l);
1186 scalblnl(0.0l, 0l);
1187 scalbn(0.0, 0);
1188 scalbnf(0.0f, 0);
1189 scalbnl(0.0l, 0);
1190 tgamma(0.0);
1191 tgammaf(0.0f);
1192 tgammal(0.0l);
1193 trunc(0.0);
1194 truncf(0.0f);
1195 truncl(0.0l);
1196 ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
1197 ])
1198 AC_MSG_RESULT($ac_c99_math_tr1)
1199 if test x"$ac_c99_math_tr1" = x"yes"; then
1200 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1201 [Define if C99 functions or macros in <math.h> should be imported
1202 in <tr1/cmath> in namespace std::tr1.])
1203 fi
1204
03bf3bc1
PC		 1205 # Check for the existence of <inttypes.h> functions (NB: doesn't make
1206 # sense if the previous check fails, per C99, 7.8/1).
1207 ac_c99_inttypes_tr1=no;
1208 if test x"$ac_c99_stdint_tr1" = x"yes"; then
1209 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1210 AC_TRY_COMPILE([#include <inttypes.h>],
1211 [intmax_t i, numer, denom, base;
1212 const char* s;
1213 char** endptr;
af66a43e
PC		 1214 intmax_t ret = imaxabs(i);
1215 imaxdiv_t dret = imaxdiv(numer, denom);
03bf3bc1 1216 ret = strtoimax(s, endptr, base);
af66a43e 1217 uintmax_t uret = strtoumax(s, endptr, base);
03bf3bc1
PC		 1218 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1219 fi
52a64bd3
PC		 1220 AC_MSG_RESULT($ac_c99_inttypes_tr1)
1221 if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1222 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1223 [Define if C99 functions in <inttypes.h> should be imported in
03bf3bc1 1224 <tr1/cinttypes> in namespace std::tr1.])
52a64bd3
PC		 1225 fi
1226
1e41a98c
PC		 1227 # Check for the existence of the <stdbool.h> header.
1228 AC_CHECK_HEADERS(stdbool.h)
1229
bd2bb1ea
PC		 1230 AC_LANG_RESTORE
1231])
1232
d8bc9819
PC		 1233dnl
1234dnl Check whether "dev/random" and "dev/urandom" are available for the
1235dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1236dnl
1237AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1238
1239 AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1240 AC_CACHE_VAL(ac_random_tr1, [
1241 AC_TRY_RUN([#include <stdio.h>
1242 int main()
1243 {
1244 return !(fopen("/dev/random", "r")
1245 && fopen("/dev/urandom", "r"));
1246 }
1247 ],
1248 [ac_random_tr1=yes], [ac_random_tr1=no],
1249 [ac_random_tr1=no])
1250 ])
1251 AC_MSG_RESULT($ac_random_tr1)
1252 if test x"$ac_random_tr1" = x"yes"; then
1253 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1254 [Define if dev/random and dev/urandom are available for
1255 the random_device of TR1 (Chapter 5.1).])
1256 fi
1257
1258])
bd2bb1ea 1259
0646d8a3
BK		 1260dnl
1261dnl Check whether macros, etc are present for <system_error>
1262dnl
1263AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1264
1265 AC_MSG_CHECKING([for EOWNERDEAD])
1266 AC_CACHE_VAL(ac_system_error1, [
1267 AC_TRY_COMPILE([#include <errno.h>], [ int i = EOWNERDEAD; ],
1268 [ac_system_error1=yes], [ac_system_error1=no])
1269 ])
1270 AC_MSG_RESULT($ac_system_error1)
1271 if test x"$ac_system_error1" = x"yes"; then
1272 AC_DEFINE(HAVE_EOWNERDEAD, 1, [Define if EOWNERDEAD exists.])
1273 fi
1274
1275 AC_MSG_CHECKING([for ENOTRECOVERABLE])
1276 AC_CACHE_VAL(ac_system_error2, [
1277 AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOTRECOVERABLE; ],
1278 [ac_system_error2=yes], [ac_system_error2=no])
1279 ])
1280 AC_MSG_RESULT($ac_system_error2)
1281 if test x"$ac_system_error2" = x"yes"; then
1282 AC_DEFINE(HAVE_ENOTRECOVERABLE, 1, [Define if ENOTRECOVERABLE exists.])
1283 fi
1284
c6a8035a
BK		 1285 AC_MSG_CHECKING([for ENOLINK])
1286 AC_CACHE_VAL(ac_system_error3, [
1287 AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOLINK; ],
1288 [ac_system_error3=yes], [ac_system_error3=no])
1289 ])
1290 AC_MSG_RESULT($ac_system_error3)
1291 if test x"$ac_system_error3" = x"yes"; then
1292 AC_DEFINE(HAVE_ENOLINK, 1, [Define if ENOLINK exists.])
1293 fi
1294
1295 AC_MSG_CHECKING([for EPROTO])
1296 AC_CACHE_VAL(ac_system_error_4, [
1297 AC_TRY_COMPILE([#include <errno.h>], [ int i = EPROTO; ],
1298 [ac_system_error_4=yes], [ac_system_error_4=no])
1299 ])
1300 AC_MSG_RESULT($ac_system_error_4)
1301 if test x"$ac_system_error_4" = x"yes"; then
1302 AC_DEFINE(HAVE_EPROTO, 1, [Define if EPROTO exists.])
1303 fi
1304
e4e5e7f5
BK		 1305 AC_MSG_CHECKING([for ENODATA])
1306 AC_CACHE_VAL(ac_system_error_5, [
1307 AC_TRY_COMPILE([#include <errno.h>], [ int i = ENODATA; ],
1308 [ac_system_error_5=yes], [ac_system_error_5=no])
1309 ])
1310 AC_MSG_RESULT($ac_system_error_5)
1311 if test x"$ac_system_error_5" = x"yes"; then
1312 AC_DEFINE(HAVE_ENODATA, 1, [Define if ENODATA exists.])
1313 fi
1314
1315 AC_MSG_CHECKING([for ENOSR])
1316 AC_CACHE_VAL(ac_system_error_6, [
1317 AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOSR; ],
1318 [ac_system_error_6=yes], [ac_system_error_6=no])
1319 ])
1320 AC_MSG_RESULT($ac_system_error_6)
1321 if test x"$ac_system_error_6" = x"yes"; then
1322 AC_DEFINE(HAVE_ENOSR, 1, [Define if ENOSR exists.])
1323 fi
1324
1325 AC_MSG_CHECKING([for ENOSTR])
1326 AC_CACHE_VAL(ac_system_error_7, [
1327 AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOSTR; ],
1328 [ac_system_error_7=yes], [ac_system_error_7=no])
1329 ])
1330 AC_MSG_RESULT($ac_system_error_7)
1331 if test x"$ac_system_error_7" = x"yes"; then
1332 AC_DEFINE(HAVE_ENOSTR, 1, [Define if ENOSTR exists.])
1333 fi
1334
1335 AC_MSG_CHECKING([for ETIME])
1336 AC_CACHE_VAL(ac_system_error_8, [
1337 AC_TRY_COMPILE([#include <errno.h>], [ int i = ETIME; ],
1338 [ac_system_error_8=yes], [ac_system_error_8=no])
1339 ])
1340 AC_MSG_RESULT($ac_system_error_8)
1341 if test x"$ac_system_error_8" = x"yes"; then
1342 AC_DEFINE(HAVE_ETIME, 1, [Define if ETIME exists.])
1343 fi
1344
0646d8a3 1345 AC_MSG_CHECKING([for sys_nerr])
80bf9cff 1346 AC_CACHE_VAL(ac_system_error9, [
0646d8a3 1347 AC_TRY_COMPILE([#include <errno.h> ], [ int i = sys_nerr; ],
80bf9cff 1348 [ac_system_error9=yes], [ac_system_error9=no])
0646d8a3 1349 ])
80bf9cff
BK		 1350 AC_MSG_RESULT($ac_system_error9)
1351 if test x"$ac_system_error9" = x"yes"; then
0646d8a3
BK		 1352 AC_DEFINE(HAVE_SYS_NERR, 1, [Define if sys_nerr exists.])
1353 fi
7336815f
RS		 1354
1355 AC_MSG_CHECKING([for EBADMSG])
1356 AC_CACHE_VAL(ac_system_error_10, [
1357 AC_TRY_COMPILE([#include <errno.h>], [ int i = EBADMSG; ],
1358 [ac_system_error_10=yes], [ac_system_error_10=no])
1359 ])
1360 AC_MSG_RESULT($ac_system_error_10)
1361 if test x"$ac_system_error_10" = x"yes"; then
1362 AC_DEFINE(HAVE_EBADMSG, 1, [Define if EBADMSG exists.])
1363 fi
3110357b
RS		 1364
1365 AC_MSG_CHECKING([for ECANCELED])
1366 AC_CACHE_VAL(ac_system_error_11, [
1367 AC_TRY_COMPILE([#include <errno.h>], [ int i = ECANCELED; ],
1368 [ac_system_error_11=yes], [ac_system_error_11=no])
1369 ])
1370 AC_MSG_RESULT($ac_system_error_11)
1371 if test x"$ac_system_error_11" = x"yes"; then
1372 AC_DEFINE(HAVE_ECANCELED, 1, [Define if ECANCELED exists.])
1373 fi
0646d8a3
BK		 1374])
1375
0214010c 1376dnl
ff66d28f
PE		 1377dnl Check for what type of C headers to use.
1378dnl
1379dnl --enable-cheaders= [does stuff].
1380dnl --disable-cheaders [does not do anything, really].
1381dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
af13a7a6 1382dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
ff66d28f 1383dnl
f214923c 1384AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
ff66d28f 1385 GLIBCXX_ENABLE(cheaders,$1,[=KIND],
af13a7a6 1386 [construct "C" headers for g++], [permit c|c_std|c_global])
ff66d28f
PE		 1387 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1388
1389 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1390
af13a7a6
BK		 1391 # Allow overrides to configure.host here.
1392 if test $enable_cheaders = c_global; then
1393 c_compatibility=yes
1394 fi
1395
1396 if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1397 c_extra=yes
1398 fi
1399
ff66d28f 1400 AC_SUBST(C_INCLUDE_DIR)
92eabea2
PE		 1401 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1402 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
af13a7a6 1403 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
92eabea2 1404 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
af13a7a6 1405 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
ff66d28f
PE		 1406])
1407
1408
0214010c 1409dnl
ff66d28f
PE		 1410dnl Check for which locale library to use. The choice is mapped to
1411dnl a subdirectory of config/locale.
37bc6ca2 1412dnl
ff66d28f 1413dnl Default is generic.
0214010c 1414dnl
f214923c 1415AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
ff66d28f
PE		 1416 GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1417 [use MODEL for target locale package],
1418 [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
0258dc3a
BK		 1419
1420 # Deal with gettext issues. Default to not using it (=no) until we detect
1421 # support for it later. Let the user turn it off via --e/d, but let that
1422 # default to on for easier handling.
1423 USE_NLS=no
1424 AC_ARG_ENABLE(nls,
1425 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1426 [],
1427 [enable_nls=yes])
ff66d28f 1428
0258dc3a 1429 # Either a known packaage, or "auto"
ff66d28f
PE		 1430 if test $enable_clocale = no || test $enable_clocale = yes; then
1431 enable_clocale=auto
1432 fi
0214010c
BK		 1433 enable_clocale_flag=$enable_clocale
1434
0258dc3a 1435 # Probe for locale model to use if none specified.
ff66d28f
PE		 1436 # Default to "generic".
1437 if test $enable_clocale_flag = auto; then
7d3998a4
PE		 1438 case ${target_os} in
1439 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
0258dc3a 1440 enable_clocale_flag=gnu
56deb74c 1441 ;;
a7f7b334 1442 darwin* | freebsd*)
f9686024
GK		 1443 enable_clocale_flag=darwin
1444 ;;
56deb74c 1445 *)
ff66d28f
PE		 1446 enable_clocale_flag=generic
1447 ;;
56deb74c
BK		 1448 esac
1449 fi
1450
0258dc3a
BK		 1451 # Sanity check model, and test for special functionality.
1452 if test $enable_clocale_flag = gnu; then
1453 AC_EGREP_CPP([_GLIBCXX_ok], [
1454 #include <features.h>
1455 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1456 _GLIBCXX_ok
1457 #endif
1458 ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1459
1ba74130
PC		 1460 if test $enable_clocale = auto; then
1461 # Test for bugs early in glibc-2.2.x series
1462 AC_TRY_RUN([
1463 #define _GNU_SOURCE 1
1464 #include <locale.h>
1465 #include <string.h>
1466 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1467 extern __typeof(newlocale) __newlocale;
1468 extern __typeof(duplocale) __duplocale;
1469 extern __typeof(strcoll_l) __strcoll_l;
1470 #endif
1471 int main()
1472 {
1473