OSDN Git Service

PR libstdc++/52839
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / acinclude.m4
1 dnl
2 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
3 dnl
4 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
5 dnl end of configure.  This lets tested variables be reassigned, and the
6 dnl conditional will depend on the final state of the variable.  For a simple
7 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
8 dnl
9 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
10 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
11   m4_divert_text([glibcxx_diversion],dnl
12    AM_CONDITIONAL([$1],[$2])
13   )dnl
14 ])dnl
15 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
16
17
18 dnl
19 dnl Check to see what architecture and operating system we are compiling
20 dnl for.  Also, if architecture- or OS-specific flags are required for
21 dnl compilation, pick them up here.
22 dnl
23 AC_DEFUN([GLIBCXX_CHECK_HOST], [
24   . $glibcxx_srcdir/configure.host
25   AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
26   AC_MSG_NOTICE([OS config directory is $os_include_dir])
27 ])
28
29 dnl
30 dnl Initialize the rest of the library configury.  At this point we have
31 dnl variables like $host.
32 dnl
33 dnl Sets:
34 dnl  SUBDIRS
35 dnl Substs:
36 dnl  glibcxx_builddir     (absolute path)
37 dnl  glibcxx_srcdir       (absolute path)
38 dnl  toplevel_builddir    (absolute path)
39 dnl  toplevel_srcdir      (absolute path)
40 dnl  with_cross_host
41 dnl  with_newlib
42 dnl  with_target_subdir
43 dnl plus
44 dnl  - the variables in GLIBCXX_CHECK_HOST / configure.host
45 dnl  - default settings for all AM_CONFITIONAL test variables
46 dnl  - lots of tools, like CC and CXX
47 dnl
48 AC_DEFUN([GLIBCXX_CONFIGURE], [
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 libsupc++ python src src/c++98 src/c++11 doc po testsuite])
53   SUBDIRS='glibcxx_SUBDIRS'
54
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.
58   glibcxx_builddir=`${PWDCMD-pwd}`
59   case $srcdir in
60     [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
61     *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
62   esac
63   toplevel_builddir=${glibcxx_builddir}/..
64   toplevel_srcdir=${glibcxx_srcdir}/..
65   AC_SUBST(glibcxx_builddir)
66   AC_SUBST(glibcxx_srcdir)
67   AC_SUBST(toplevel_builddir)
68   AC_SUBST(toplevel_srcdir)
69
70   # We use these options to decide which functions to include.  They are
71   # set from the top level.
72   AC_ARG_WITH([target-subdir],
73     AC_HELP_STRING([--with-target-subdir=SUBDIR],
74                    [configuring in a subdirectory]))
75
76   AC_ARG_WITH([cross-host],
77     AC_HELP_STRING([--with-cross-host=HOST],
78                    [configuring with a cross compiler]))
79
80   AC_ARG_WITH([newlib],
81     AC_HELP_STRING([--with-newlib],
82                    [assume newlib as a system C library]))
83
84   # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
85   # available).  Uncomment the next line to force a particular method.
86   AC_PROG_LN_S
87   #LN_S='cp -p'
88
89   AC_CHECK_TOOL(AS, as)
90   AC_CHECK_TOOL(AR, ar)
91   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
92
93   AM_MAINTAINER_MODE
94
95   # Set up safe default values for all subsequent AM_CONDITIONAL tests
96   # which are themselves conditionally expanded.
97   ## (Right now, this only matters for enable_wchar_t, but nothing prevents
98   ## other macros from doing the same.  This should be automated.)  -pme
99
100   # Check for C library flavor since GNU/Linux platforms use different
101   # configuration directories depending on the C library in use.
102   AC_EGREP_CPP([_using_uclibc], [
103   #include <stdio.h>
104   #if __UCLIBC__
105     _using_uclibc
106   #endif
107   ], uclibc=yes, uclibc=no)
108
109   AC_EGREP_CPP([_using_bionic], [
110   #include <stdio.h>
111   #if __BIONIC__
112     _using_bionic
113   #endif
114   ], bionic=yes, bionic=no)
115
116   # Find platform-specific directories containing configuration info.
117   # Also possibly modify flags used elsewhere, as needed by the platform.
118   GLIBCXX_CHECK_HOST
119 ])
120
121
122 dnl
123 dnl Tests for newer compiler features, or features that are present in newer
124 dnl compiler versions but not older compiler versions still in use, should
125 dnl be placed here.
126 dnl
127 dnl Defines:
128 dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
129 dnl   new inlining code or the new system_header pragma will die on -Werror.
130 dnl   Leave it out by default and use maint-mode to use it.
131 dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
132 dnl   compiler supports it and the user has not requested debug mode.
133 dnl
134 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
135   # All these tests are for C++; save the language and the compiler flags.
136   # The CXXFLAGS thing is suspicious, but based on similar bits previously
137   # found in GLIBCXX_CONFIGURE.
138   AC_LANG_SAVE
139   AC_LANG_CPLUSPLUS
140   ac_test_CXXFLAGS="${CXXFLAGS+set}"
141   ac_save_CXXFLAGS="$CXXFLAGS"
142
143   # Check for maintainer-mode bits.
144   if test x"$USE_MAINTAINER_MODE" = xno; then
145     WERROR=''
146   else
147     WERROR='-Werror'
148   fi
149
150   # Check for -ffunction-sections -fdata-sections
151   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
152   CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
153   AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
154   if test "$ac_test_CXXFLAGS" = set; then
155     CXXFLAGS="$ac_save_CXXFLAGS"
156   else
157     # this is the suspicious part
158     CXXFLAGS=''
159   fi
160   if test x"$ac_fdsections" = x"yes"; then
161     SECTION_FLAGS='-ffunction-sections -fdata-sections'
162   fi
163   AC_MSG_RESULT($ac_fdsections)
164
165   AC_LANG_RESTORE
166   AC_SUBST(WERROR)
167   AC_SUBST(SECTION_FLAGS)
168 ])
169
170
171 dnl
172 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
173 dnl the native linker is in use, all variables will be defined to something
174 dnl safe (like an empty string).
175 dnl
176 dnl Defines:
177 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
178 dnl  OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
179 dnl  LD (as a side effect of testing)
180 dnl Sets:
181 dnl  with_gnu_ld
182 dnl  glibcxx_ld_is_gold (set to "no" or "yes")
183 dnl  glibcxx_gnu_ld_version (possibly)
184 dnl
185 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
186 dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
187 dnl
188 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
189   # If we're not using GNU ld, then there's no point in even trying these
190   # tests.  Check for that first.  We should have already tested for gld
191   # by now (in libtool), but require it now just to be safe...
192   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
193   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
194   AC_REQUIRE([AC_PROG_LD])
195   AC_REQUIRE([AC_PROG_AWK])
196
197   # The name set by libtool depends on the version of libtool.  Shame on us
198   # for depending on an impl detail, but c'est la vie.  Older versions used
199   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
200   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
201   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
202   # set (hence we're using an older libtool), then set it.
203   if test x${with_gnu_ld+set} != xset; then
204     if test x${ac_cv_prog_gnu_ld+set} != xset; then
205       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
206       with_gnu_ld=no
207     else
208       with_gnu_ld=$ac_cv_prog_gnu_ld
209     fi
210   fi
211
212   # Start by getting the version number.  I think the libtool test already
213   # does some of this, but throws away the result.
214   glibcxx_ld_is_gold=no
215   if test x"$with_gnu_ld" = x"yes"; then
216     AC_MSG_CHECKING([for ld version])
217     changequote(,)
218     if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
219       glibcxx_ld_is_gold=yes
220     fi
221     ldver=`$LD --version 2>/dev/null |
222            sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'`
223     changequote([,])
224     glibcxx_gnu_ld_version=`echo $ldver | \
225            $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
226     AC_MSG_RESULT($glibcxx_gnu_ld_version)
227   fi
228
229   # Set --gc-sections.
230   glibcxx_have_gc_sections=no
231   if test "$glibcxx_ld_is_gold" = "yes"; then
232     if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
233       glibcxx_have_gc_sections=yes
234     fi
235   else
236     glibcxx_gcsections_min_ld=21602
237     if test x"$with_gnu_ld" = x"yes" &&
238         test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
239       glibcxx_have_gc_sections=yes
240     fi
241   fi
242   if test "$glibcxx_have_gc_sections" = "yes"; then
243     # Sufficiently young GNU ld it is!  Joy and bunny rabbits!
244     # NB: This flag only works reliably after 2.16.1. Configure tests
245     # for this are difficult, so hard wire a value that should work.
246
247     ac_test_CFLAGS="${CFLAGS+set}"
248     ac_save_CFLAGS="$CFLAGS"
249     CFLAGS='-Wl,--gc-sections'
250
251     # Check for -Wl,--gc-sections
252     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
253     AC_TRY_LINK([ int one(void) { return 1; }
254      int two(void) { return 2; }
255         ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
256     if test "$ac_gcsections" = "yes"; then
257       rm -f conftest.c
258       touch conftest.c
259       if $CC -c conftest.c; then
260         if $LD --gc-sections -o conftest conftest.o 2>&1 | \
261            grep "Warning: gc-sections option ignored" > /dev/null; then
262           ac_gcsections=no
263         fi
264       fi
265       rm -f conftest.c conftest.o conftest
266     fi
267     if test "$ac_gcsections" = "yes"; then
268       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
269     fi
270     AC_MSG_RESULT($ac_gcsections)
271
272     if test "$ac_test_CFLAGS" = set; then
273       CFLAGS="$ac_save_CFLAGS"
274     else
275       # this is the suspicious part
276       CFLAGS=''
277     fi
278   fi
279
280   # Set -z,relro.
281   # Note this is only for shared objects.
282   ac_ld_relro=no
283   if test x"$with_gnu_ld" = x"yes"; then
284     AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
285     cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
286     if test -n "$cxx_z_relo"; then
287       OPT_LDFLAGS="-Wl,-z,relro"
288       ac_ld_relro=yes
289     fi
290     AC_MSG_RESULT($ac_ld_relro)
291   fi
292
293   # Set linker optimization flags.
294   if test x"$with_gnu_ld" = x"yes"; then
295     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
296   fi
297
298   AC_SUBST(SECTION_LDFLAGS)
299   AC_SUBST(OPT_LDFLAGS)
300 ])
301
302
303 dnl
304 dnl Check for headers for, and arguments to, the setrlimit() function.
305 dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
306 dnl
307 dnl Defines:
308 dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits
309 dnl  various HAVE_LIMIT_* for individual limit names
310 dnl
311 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
312   AC_MSG_CHECKING([for RLIMIT_$1])
313   AC_TRY_COMPILE(
314     [#include <unistd.h>
315      #include <sys/time.h>
316      #include <sys/resource.h>
317     ],
318     [ int f = RLIMIT_$1 ; ],
319     [glibcxx_mresult=1], [glibcxx_mresult=0])
320   AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
321                      [Only used in build directory testsuite_hooks.h.])
322   if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
323   AC_MSG_RESULT($res)
324 ])
325
326 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
327   setrlimit_have_headers=yes
328   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
329                    [],
330                    [setrlimit_have_headers=no])
331   # If don't have the headers, then we can't run the tests now, and we
332   # won't be seeing any of these during testsuite compilation.
333   if test $setrlimit_have_headers = yes; then
334     # Can't do these in a loop, else the resulting syntax is wrong.
335     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
336     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
337     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
338     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
339     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
340
341     # Check for rlimit, setrlimit.
342     AC_CACHE_VAL(glibcxx_cv_setrlimit, [
343       AC_TRY_COMPILE(
344         [#include <unistd.h>
345          #include <sys/time.h>
346          #include <sys/resource.h>
347         ],
348         [struct rlimit r;
349          setrlimit(0, &r);],
350         [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
351     ])
352   fi
353
354   AC_MSG_CHECKING([for testsuite resource limits support])
355   if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
356     ac_res_limits=yes
357     AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
358               [Define if using setrlimit to set resource limits during
359               "make check"])
360   else
361     ac_res_limits=no
362   fi
363   AC_MSG_RESULT($ac_res_limits)
364 ])
365
366
367 dnl
368 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
369 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
370 dnl
371 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
372
373   AC_LANG_SAVE
374   AC_LANG_CPLUSPLUS
375   ac_save_CXXFLAGS="$CXXFLAGS"
376   CXXFLAGS="$CXXFLAGS -fno-exceptions"
377
378   AC_MSG_CHECKING([for S_ISREG or S_IFREG])
379   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
380     GCC_TRY_COMPILE_OR_LINK(
381       [#include <sys/stat.h>],
382       [struct stat buffer;
383        fstat(0, &buffer);
384        S_ISREG(buffer.st_mode);],
385       [glibcxx_cv_S_ISREG=yes],
386       [glibcxx_cv_S_ISREG=no])
387   ])
388   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
389     GCC_TRY_COMPILE_OR_LINK(
390       [#include <sys/stat.h>],
391       [struct stat buffer;
392        fstat(0, &buffer);
393        S_IFREG & buffer.st_mode;],
394       [glibcxx_cv_S_IFREG=yes],
395       [glibcxx_cv_S_IFREG=no])
396   ])
397   res=no
398   if test $glibcxx_cv_S_ISREG = yes; then
399     AC_DEFINE(HAVE_S_ISREG, 1,
400               [Define if S_IFREG is available in <sys/stat.h>.])
401     res=S_ISREG
402   elif test $glibcxx_cv_S_IFREG = yes; then
403     AC_DEFINE(HAVE_S_IFREG, 1,
404               [Define if S_IFREG is available in <sys/stat.h>.])
405     res=S_IFREG
406   fi
407   AC_MSG_RESULT($res)
408
409   CXXFLAGS="$ac_save_CXXFLAGS"
410   AC_LANG_RESTORE
411 ])
412
413
414 dnl
415 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
416 dnl
417 AC_DEFUN([GLIBCXX_CHECK_POLL], [
418
419   AC_LANG_SAVE
420   AC_LANG_CPLUSPLUS
421   ac_save_CXXFLAGS="$CXXFLAGS"
422   CXXFLAGS="$CXXFLAGS -fno-exceptions"
423
424   AC_MSG_CHECKING([for poll])
425   AC_CACHE_VAL(glibcxx_cv_POLL, [
426     GCC_TRY_COMPILE_OR_LINK(
427       [#include <poll.h>],
428       [struct pollfd pfd[1];
429        pfd[0].events = POLLIN;
430        poll(pfd, 1, 0);],
431       [glibcxx_cv_POLL=yes],
432       [glibcxx_cv_POLL=no])
433   ])
434   if test $glibcxx_cv_POLL = yes; then
435     AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
436   fi
437   AC_MSG_RESULT($glibcxx_cv_POLL)
438
439   CXXFLAGS="$ac_save_CXXFLAGS"
440   AC_LANG_RESTORE
441 ])
442
443
444 dnl
445 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
446 dnl
447 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
448
449   AC_LANG_SAVE
450   AC_LANG_CPLUSPLUS
451   ac_save_CXXFLAGS="$CXXFLAGS"
452   CXXFLAGS="$CXXFLAGS -fno-exceptions"
453
454   AC_MSG_CHECKING([for writev])
455   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
456     GCC_TRY_COMPILE_OR_LINK(
457       [#include <sys/uio.h>],
458       [struct iovec iov[2];
459        writev(0, iov, 0);],
460       [glibcxx_cv_WRITEV=yes],
461       [glibcxx_cv_WRITEV=no])
462   ])
463   if test $glibcxx_cv_WRITEV = yes; then
464     AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
465   fi
466   AC_MSG_RESULT($glibcxx_cv_WRITEV)
467
468   CXXFLAGS="$ac_save_CXXFLAGS"
469   AC_LANG_RESTORE
470 ])
471
472
473 dnl
474 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
475 dnl Also check whether int64_t is actually a typedef to long or long long.
476 dnl
477 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
478
479   AC_LANG_SAVE
480   AC_LANG_CPLUSPLUS
481
482   AC_MSG_CHECKING([for int64_t])
483   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
484     AC_TRY_COMPILE(
485       [#include <stdint.h>],
486       [int64_t var;],
487       [glibcxx_cv_INT64_T=yes],
488       [glibcxx_cv_INT64_T=no])
489   ])
490
491   if test $glibcxx_cv_INT64_T = yes; then
492     AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
493     AC_MSG_RESULT($glibcxx_cv_INT64_T)
494
495     AC_MSG_CHECKING([for int64_t as long])
496     AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
497       AC_TRY_COMPILE(
498         [#include <stdint.h>
499         template<typename, typename> struct same { enum { value = -1 }; };
500         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
501         int array[same<int64_t, long>::value];], [],
502         [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
503     ])
504
505     if test $glibcxx_cv_int64_t_long = yes; then
506       AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
507       AC_MSG_RESULT($glibcxx_cv_int64_t_long)
508     fi
509
510     AC_MSG_CHECKING([for int64_t as long long])
511     AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
512       AC_TRY_COMPILE(
513         [#include <stdint.h>
514         template<typename, typename> struct same { enum { value = -1 }; };
515         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
516         int array[same<int64_t, long long>::value];], [],
517         [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
518     ])
519
520     if test $glibcxx_cv_int64_t_long_long = yes; then
521       AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
522       AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
523     fi
524   fi
525
526   AC_LANG_RESTORE
527 ])
528
529
530 dnl
531 dnl Check whether LFS support is available.
532 dnl
533 AC_DEFUN([GLIBCXX_CHECK_LFS], [
534   AC_LANG_SAVE
535   AC_LANG_CPLUSPLUS
536   ac_save_CXXFLAGS="$CXXFLAGS"
537   CXXFLAGS="$CXXFLAGS -fno-exceptions"
538   AC_MSG_CHECKING([for LFS support])
539   AC_CACHE_VAL(glibcxx_cv_LFS, [
540     GCC_TRY_COMPILE_OR_LINK(
541       [#include <unistd.h>
542        #include <stdio.h>
543        #include <sys/stat.h>
544       ],
545       [FILE* fp;
546        fopen64("t", "w");
547        fseeko64(fp, 0, SEEK_CUR);
548        ftello64(fp);
549        lseek64(1, 0, SEEK_CUR);
550        struct stat64 buf;
551        fstat64(1, &buf);],
552       [glibcxx_cv_LFS=yes],
553       [glibcxx_cv_LFS=no])
554   ])
555   if test $glibcxx_cv_LFS = yes; then
556     AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
557   fi
558   AC_MSG_RESULT($glibcxx_cv_LFS)
559   CXXFLAGS="$ac_save_CXXFLAGS"
560   AC_LANG_RESTORE
561 ])
562
563
564 dnl
565 dnl Check for whether a fully dynamic basic_string implementation should
566 dnl be turned on, that does not put empty objects in per-process static
567 dnl memory (mostly useful together with shared memory allocators, see PR
568 dnl libstdc++/16612 for details).
569 dnl
570 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
571 dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
572 dnl otherwise undefined
573 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
574 dnl       Where DEFAULT is either `yes' or `no'.
575 dnl
576 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
577   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
578   if test $enable_fully_dynamic_string = yes; then
579     enable_fully_dynamic_string_def=1
580   else
581     enable_fully_dynamic_string_def=0
582   fi
583   AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
584               [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
585 ])
586
587
588 dnl
589 dnl Does any necessary configuration of the testsuite directory.  Generates
590 dnl the testsuite_hooks.h header.
591 dnl
592 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
593 dnl
594 dnl Sets:
595 dnl  enable_abi_check
596 dnl  GLIBCXX_TEST_WCHAR_T
597 dnl  GLIBCXX_TEST_THREAD
598 dnl Substs:
599 dnl  baseline_dir
600 dnl  baseline_subdir_switch
601 dnl
602 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
603   if $GLIBCXX_IS_NATIVE ; then
604     # Do checks for resource limit functions.
605     GLIBCXX_CHECK_SETRLIMIT
606
607     # Look for setenv, so that extended locale tests can be performed.
608     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
609   fi
610
611   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
612      test $enable_symvers != no; then
613     case "$host" in
614       *-*-cygwin*)
615         enable_abi_check=no ;;
616       *)
617         enable_abi_check=yes ;;
618     esac
619   else
620     # Only build this as native, since automake does not understand
621     # CXX_FOR_BUILD.
622     enable_abi_check=no
623   fi
624
625   # Export file names for ABI checking.
626   baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
627   AC_SUBST(baseline_dir)
628   baseline_subdir_switch="$abi_baseline_subdir_switch"
629   AC_SUBST(baseline_subdir_switch)
630 ])
631
632
633 dnl
634 dnl Does any necessary configuration for docbook in the docs directory.
635 dnl
636 dnl XSLTPROC must be set before this
637 dnl
638 dnl Sets:
639 dnl  glibcxx_stylesheets
640 dnl Substs:
641 dnl  XSL_STYLE_DIR
642 dnl
643 AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
644
645 AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
646 glibcxx_stylesheets=no
647 if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then
648   glibcxx_stylesheets=yes
649 fi
650 AC_MSG_RESULT($glibcxx_stylesheets)
651
652 AC_MSG_CHECKING([for local stylesheet directory])
653 glibcxx_local_stylesheets=no
654 if test x"$glibcxx_stylesheets" = x"yes"; then
655   if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then
656     glibcxx_local_stylesheets=yes
657     XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets
658   fi
659   if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then
660     glibcxx_local_stylesheets=yes
661     XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
662   fi
663 fi
664 AC_MSG_RESULT($glibcxx_local_stylesheets)
665
666 if test x"$glibcxx_local_stylesheets" = x"yes"; then
667   AC_SUBST(XSL_STYLE_DIR)
668   AC_MSG_NOTICE($XSL_STYLE_DIR)
669 else
670   glibcxx_stylesheets=no
671 fi
672
673 # Check for epub3 dependencies.
674 AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
675 glibcxx_epub_stylesheets=no
676 if test x"$glibcxx_local_stylesheets" = x"yes"; then
677    if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
678       glibcxx_epub_stylesheets=yes
679    fi
680 fi
681 AC_MSG_RESULT($glibcxx_epub_stylesheets)
682 AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
683
684 ])
685
686
687 dnl
688 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
689 dnl
690 dnl Substs:
691 dnl  GLIBCXX_INCLUDES
692 dnl  TOPLEVEL_INCLUDES
693 dnl
694 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
695   # Used for every C++ compile we perform.
696   GLIBCXX_INCLUDES="\
697 -I$glibcxx_builddir/include/$host_alias \
698 -I$glibcxx_builddir/include \
699 -I$glibcxx_srcdir/libsupc++"
700
701   # For Canadian crosses, pick this up too.
702   if test $CANADIAN = yes; then
703     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
704   fi
705
706   # Stuff in the actual top level.  Currently only used by libsupc++ to
707   # get unwind* headers from the libgcc dir.
708   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
709   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
710
711   # Now, export this to all the little Makefiles....
712   AC_SUBST(GLIBCXX_INCLUDES)
713   AC_SUBST(TOPLEVEL_INCLUDES)
714 ])
715
716
717 dnl
718 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
719 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
720 dnl
721 dnl Substs:
722 dnl  OPTIMIZE_CXXFLAGS
723 dnl  WARN_FLAGS
724 dnl
725 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
726   # Optimization flags that are probably a good idea for thrill-seekers. Just
727   # uncomment the lines below and make, everything else is ready to go...
728   # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
729   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
730   AC_SUBST(OPTIMIZE_CXXFLAGS)
731
732   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi'
733   AC_SUBST(WARN_FLAGS)
734 ])
735
736
737 dnl
738 dnl All installation directory information is determined here.
739 dnl
740 dnl Substs:
741 dnl  gxx_install_dir
742 dnl  glibcxx_prefixdir
743 dnl  glibcxx_toolexecdir
744 dnl  glibcxx_toolexeclibdir
745 dnl
746 dnl Assumes cross_compiling bits already done, and with_cross_host in
747 dnl particular.
748 dnl
749 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
750 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
751 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
752   glibcxx_toolexecdir=no
753   glibcxx_toolexeclibdir=no
754   glibcxx_prefixdir=$prefix
755
756   AC_MSG_CHECKING([for gxx-include-dir])
757   AC_ARG_WITH([gxx-include-dir],
758     AC_HELP_STRING([--with-gxx-include-dir=DIR],
759                    [installation directory for include files]),
760     [case "$withval" in
761       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
762       no)  gxx_include_dir=no ;;
763       *)   gxx_include_dir=$withval ;;
764      esac],
765     [gxx_include_dir=no])
766   AC_MSG_RESULT($gxx_include_dir)
767
768   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
769   AC_ARG_ENABLE([version-specific-runtime-libs],
770     AC_HELP_STRING([--enable-version-specific-runtime-libs],
771                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
772     [case "$enableval" in
773       yes) version_specific_libs=yes ;;
774       no)  version_specific_libs=no ;;
775       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
776      esac],
777     [version_specific_libs=no])
778   AC_MSG_RESULT($version_specific_libs)
779
780   # Default case for install directory for include files.
781   if test $version_specific_libs = no && test $gxx_include_dir = no; then
782     gxx_include_dir='include/c++/${gcc_version}'
783     if test -n "$with_cross_host" &&
784        test x"$with_cross_host" != x"no"; then
785       gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
786     else
787       gxx_include_dir='${prefix}/'"$gxx_include_dir"
788     fi
789   fi
790
791   # Version-specific runtime libs processing.
792   if test $version_specific_libs = yes; then
793     # Need the gcc compiler version to know where to install libraries
794     # and header files if --enable-version-specific-runtime-libs option
795     # is selected.  FIXME: these variables are misnamed, there are
796     # no executables installed in _toolexecdir or _toolexeclibdir.
797     if test x"$gxx_include_dir" = x"no"; then
798       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
799     fi
800     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
801     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
802   fi
803
804   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
805   # Install a library built with a cross compiler in tooldir, not libdir.
806   if test x"$glibcxx_toolexecdir" = x"no"; then
807     if test -n "$with_cross_host" &&
808        test x"$with_cross_host" != x"no"; then
809       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
810       glibcxx_toolexeclibdir='${toolexecdir}/lib'
811     else
812       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
813       glibcxx_toolexeclibdir='${libdir}'
814     fi
815     multi_os_directory=`$CXX -print-multi-os-directory`
816     case $multi_os_directory in
817       .) ;; # Avoid trailing /.
818       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
819     esac
820   fi
821
822   AC_MSG_CHECKING([for install location])
823   AC_MSG_RESULT($gxx_include_dir)
824
825   AC_SUBST(glibcxx_prefixdir)
826   AC_SUBST(gxx_include_dir)
827   AC_SUBST(glibcxx_toolexecdir)
828   AC_SUBST(glibcxx_toolexeclibdir)
829 ])
830
831
832 dnl
833 dnl GLIBCXX_ENABLE
834 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
835 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
836 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
837 dnl
838 dnl See docs/html/17_intro/configury.html#enable for documentation.
839 dnl
840 m4_define([GLIBCXX_ENABLE],[dnl
841 m4_define([_g_switch],[--enable-$1])dnl
842 m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
843  AC_ARG_ENABLE([$1],m4_dquote(_g_help),
844   m4_bmatch([$5],
845    [^permit ],
846      [[
847       case "$enableval" in
848        m4_bpatsubst([$5],[permit ])) ;;
849        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
850           dnl Idea for future:  generate a URL pointing to
851           dnl "onlinedocs/configopts.html#whatever"
852       esac
853      ]],
854    [^$],
855      [[
856       case "$enableval" in
857        yes|no) ;;
858        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
859       esac
860      ]],
861    [[$5]]),
862   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
863 m4_undefine([_g_switch])dnl
864 m4_undefine([_g_help])dnl
865 ])
866
867
868 dnl
869 dnl Check for ISO/IEC 9899:1999 "C99" support.
870 dnl
871 dnl --enable-c99 defines _GLIBCXX_USE_C99
872 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
873 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
874 dnl       Where DEFAULT is either `yes' or `no'.
875 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
876 dnl
877 AC_DEFUN([GLIBCXX_ENABLE_C99], [
878   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
879
880   if test x"$enable_c99" = x"yes"; then
881
882   AC_LANG_SAVE
883   AC_LANG_CPLUSPLUS
884
885   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
886   # undefined and fake C99 facilities - like pre-standard snprintf - may be
887   # spuriously enabled.
888   # Long term, -std=c++0x could be even better, could manage to explicitely
889   # request C99 facilities to the underlying C headers.
890   ac_save_CXXFLAGS="$CXXFLAGS"
891   CXXFLAGS="$CXXFLAGS -std=c++98"
892   ac_save_LIBS="$LIBS"
893   ac_save_gcc_no_link="$gcc_no_link"
894
895   if test x$gcc_no_link != xyes; then
896     # Use -fno-exceptions to that the C driver can link these tests without
897     # hitting undefined references to personality routines.
898     CXXFLAGS="$CXXFLAGS -fno-exceptions"
899     AC_CHECK_LIB(m, sin, [
900       LIBS="$LIBS -lm"
901     ], [
902       # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
903       gcc_no_link=yes
904     ])
905   fi
906
907   # Check for the existence of <math.h> functions used if C99 is enabled.
908   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
909   AC_CACHE_VAL(glibcxx_cv_c99_math, [
910   GCC_TRY_COMPILE_OR_LINK(
911      [#include <math.h>
912       volatile double d1, d2;
913       volatile int i;],
914      [i = fpclassify(d1);
915       i = isfinite(d1);
916       i = isinf(d1);
917       i = isnan(d1);
918       i = isnormal(d1);
919       i = signbit(d1);
920       i = isgreater(d1, d2);
921       i = isgreaterequal(d1, d2);
922       i = isless(d1, d2);
923       i = islessequal(d1, d2);
924       i = islessgreater(d1, d2);
925       i = islessgreater(d1, d2);
926       i = isunordered(d1, d2);
927      ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
928   ])
929   AC_MSG_RESULT($glibcxx_cv_c99_math)
930   if test x"$glibcxx_cv_c99_math" = x"yes"; then
931     AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
932               [Define if C99 functions or macros in <math.h> should be imported
933               in <cmath> in namespace std.])
934   fi
935
936   # Check for the existence of <complex.h> complex math functions.
937   # This is necessary even though libstdc++ uses the builtin versions
938   # of these functions, because if the builtin cannot be used, a reference
939   # to the library function is emitted.
940   AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
941   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
942   glibcxx_cv_c99_complex=no;
943   if test x"$ac_has_complex_h" = x"yes"; then
944     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
945     GCC_TRY_COMPILE_OR_LINK(
946        [#include <complex.h>
947         typedef __complex__ float float_type;
948         typedef __complex__ double double_type;
949         typedef __complex__ long double ld_type;
950         volatile float_type tmpf;
951         volatile double_type tmpd;
952         volatile ld_type tmpld;
953         volatile float f;
954         volatile double d;
955         volatile long double ld;],
956        [f = cabsf(tmpf);
957         f = cargf(tmpf);
958         tmpf = ccosf(tmpf);
959         tmpf = ccoshf(tmpf);
960         tmpf = cexpf(tmpf);
961         tmpf = clogf(tmpf);
962         tmpf = csinf(tmpf);
963         tmpf = csinhf(tmpf);
964         tmpf = csqrtf(tmpf);
965         tmpf = ctanf(tmpf);
966         tmpf = ctanhf(tmpf);
967         tmpf = cpowf(tmpf, tmpf);
968         tmpf = cprojf(tmpf);
969         d = cabs(tmpd);
970         d = carg(tmpd);
971         tmpd = ccos(tmpd);
972         tmpd = ccosh(tmpd);
973         tmpd = cexp(tmpd);
974         tmpd = clog(tmpd);
975         tmpd = csin(tmpd);
976         tmpd = csinh(tmpd);
977         tmpd = csqrt(tmpd);
978         tmpd = ctan(tmpd);
979         tmpd = ctanh(tmpd);
980         tmpd = cpow(tmpd, tmpd);
981         tmpd = cproj(tmpd);
982         ld = cabsl(tmpld);
983         ld = cargl(tmpld);
984         tmpld = ccosl(tmpld);
985         tmpld = ccoshl(tmpld);
986         tmpld = cexpl(tmpld);
987         tmpld = clogl(tmpld);
988         tmpld = csinl(tmpld);
989         tmpld = csinhl(tmpld);
990         tmpld = csqrtl(tmpld);
991         tmpld = ctanl(tmpld);
992         tmpld = ctanhl(tmpld);
993         tmpld = cpowl(tmpld, tmpld);
994         tmpld = cprojl(tmpld);
995        ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
996   fi
997   AC_MSG_RESULT($glibcxx_cv_c99_complex)
998   if test x"$glibcxx_cv_c99_complex" = x"yes"; then
999     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
1000               [Define if C99 functions in <complex.h> should be used in
1001               <complex>. Using compiler builtins for these functions requires
1002               corresponding C99 library functions to be present.])
1003   fi
1004
1005   # Check for the existence in <stdio.h> of vscanf, et. al.
1006   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1007   AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
1008   GCC_TRY_COMPILE_OR_LINK(
1009      [#include <stdio.h>
1010       #include <stdarg.h>
1011       void foo(char* fmt, ...)
1012       {
1013         va_list args; va_start(args, fmt);
1014         vfscanf(stderr, "%i", args);
1015         vscanf("%i", args);
1016         vsnprintf(fmt, 0, "%i", args);
1017         vsscanf(fmt, "%i", args);
1018       }],
1019      [snprintf("12", 0, "%i");],
1020      [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
1021   ])
1022   AC_MSG_RESULT($glibcxx_cv_c99_stdio)
1023
1024   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1025   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1026   AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
1027   GCC_TRY_COMPILE_OR_LINK(
1028      [#include <stdlib.h>
1029       volatile float f;
1030       volatile long double ld;
1031       volatile unsigned long long ll;
1032       lldiv_t mydivt;],
1033      [char* tmp;
1034       f = strtof("gnu", &tmp);
1035       ld = strtold("gnu", &tmp);
1036       ll = strtoll("gnu", &tmp, 10);
1037       ll = strtoull("gnu", &tmp, 10);
1038       ll = llabs(10);
1039       mydivt = lldiv(10,1);
1040       ll = mydivt.quot;
1041       ll = mydivt.rem;
1042       ll = atoll("10");
1043       _Exit(0);
1044       ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
1045   ])
1046   AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
1047
1048   # Check for the existence in <wchar.h> of wcstold, etc.
1049   glibcxx_cv_c99_wchar=no;
1050   if test x"$ac_has_wchar_h" = xyes &&
1051      test x"$ac_has_wctype_h" = xyes; then
1052     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1053     AC_TRY_COMPILE([#include <wchar.h>
1054                     namespace test
1055                     {
1056                       using ::wcstold;
1057                       using ::wcstoll;
1058                       using ::wcstoull;
1059                     }
1060                    ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
1061
1062     # Checks for wide character functions that may not be present.
1063     # Injection of these is wrapped with guard macros.
1064     # NB: only put functions here, instead of immediately above, if
1065     # absolutely necessary.
1066     AC_TRY_COMPILE([#include <wchar.h>
1067                     namespace test { using ::vfwscanf; } ], [],
1068                    [AC_DEFINE(HAVE_VFWSCANF,1,
1069                         [Defined if vfwscanf exists.])],[])
1070
1071     AC_TRY_COMPILE([#include <wchar.h>
1072                     namespace test { using ::vswscanf; } ], [],
1073                    [AC_DEFINE(HAVE_VSWSCANF,1,
1074                         [Defined if vswscanf exists.])],[])
1075
1076     AC_TRY_COMPILE([#include <wchar.h>
1077                     namespace test { using ::vwscanf; } ], [],
1078                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1079
1080     AC_TRY_COMPILE([#include <wchar.h>
1081                     namespace test { using ::wcstof; } ], [],
1082                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1083
1084     AC_TRY_COMPILE([#include <wctype.h>],
1085                    [ wint_t t; int i = iswblank(t);],
1086                    [AC_DEFINE(HAVE_ISWBLANK,1,
1087                         [Defined if iswblank exists.])],[])
1088
1089     AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1090   fi
1091
1092   # Option parsed, now set things appropriately.
1093   if test x"$glibcxx_cv_c99_math" = x"no" ||
1094      test x"$glibcxx_cv_c99_complex" = x"no" ||
1095      test x"$glibcxx_cv_c99_stdio" = x"no" ||
1096      test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1097      test x"$glibcxx_cv_c99_wchar" = x"no"; then
1098     enable_c99=no;
1099   else
1100     AC_DEFINE(_GLIBCXX_USE_C99, 1,
1101     [Define if C99 functions or macros from <wchar.h>, <math.h>,
1102     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1103   fi
1104
1105   gcc_no_link="$ac_save_gcc_no_link"
1106   LIBS="$ac_save_LIBS"
1107   CXXFLAGS="$ac_save_CXXFLAGS"
1108   AC_LANG_RESTORE
1109   fi
1110
1111   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1112   AC_MSG_RESULT($enable_c99)
1113 ])
1114
1115
1116 dnl
1117 dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1118 dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this]
1119 dnl in the current C++0x working draft.
1120 dnl
1121 dnl --enable-libstdcxx-time
1122 dnl --enable-libstdcxx-time=yes
1123 dnl        checks for the availability of monotonic and realtime clocks,
1124 dnl        nanosleep and sched_yield in libc and libposix4 and, in case, links
1125 dnl       the latter
1126 dnl --enable-libstdcxx-time=rt
1127 dnl        also searches (and, in case, links) librt.  Note that this is
1128 dnl        not always desirable because, in glibc, for example, in turn it
1129 dnl        triggers the linking of libpthread too, which activates locking,
1130 dnl        a large overhead for single-thread programs.
1131 dnl --enable-libstdcxx-time=no
1132 dnl --disable-libstdcxx-time
1133 dnl        disables the checks completely
1134 dnl
1135 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1136
1137   AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1138   GLIBCXX_ENABLE(libstdcxx-time,$1,[[[=KIND]]],
1139     [use KIND for check type],
1140     [permit yes|no|rt])
1141
1142   AC_LANG_SAVE
1143   AC_LANG_CPLUSPLUS
1144   ac_save_CXXFLAGS="$CXXFLAGS"
1145   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1146   ac_save_LIBS="$LIBS"
1147
1148   ac_has_clock_monotonic=no
1149   ac_has_clock_realtime=no
1150   AC_MSG_RESULT($enable_libstdcxx_time)
1151
1152   if test x"$enable_libstdcxx_time" != x"no"; then
1153
1154     if test x"$enable_libstdcxx_time" = x"rt"; then
1155       AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1156       AC_SEARCH_LIBS(nanosleep, [rt posix4])
1157     else
1158       AC_SEARCH_LIBS(clock_gettime, [posix4])
1159       AC_SEARCH_LIBS(nanosleep, [posix4])
1160     fi
1161
1162     case "$ac_cv_search_clock_gettime" in
1163       -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1164       ;;
1165     esac
1166     case "$ac_cv_search_nanosleep" in
1167       -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1168       ;;
1169     esac
1170
1171     AC_SEARCH_LIBS(sched_yield, [rt posix4])
1172
1173     case "$ac_cv_search_sched_yield" in
1174       -lposix4*)
1175       GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1176       AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1177                 [ Defined if sched_yield is available. ])
1178       ;;
1179       -lrt*)
1180       if test x"$enable_libstdcxx_time" = x"rt"; then
1181         GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1182         AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1183                   [ Defined if sched_yield is available. ])
1184       fi
1185       ;;
1186       *)
1187       AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1188                 [ Defined if sched_yield is available. ])
1189       ;;
1190     esac
1191
1192     AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1193
1194     if test x"$ac_has_unistd_h" = x"yes"; then
1195       AC_MSG_CHECKING([for monotonic clock])
1196       AC_TRY_LINK(
1197         [#include <unistd.h>
1198          #include <time.h>
1199         ],
1200         [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1201           timespec tp;
1202          #endif
1203           clock_gettime(CLOCK_MONOTONIC, &tp);
1204         ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1205
1206       AC_MSG_RESULT($ac_has_clock_monotonic)
1207
1208       AC_MSG_CHECKING([for realtime clock])
1209       AC_TRY_LINK(
1210         [#include <unistd.h>
1211          #include <time.h>
1212         ],
1213         [#if _POSIX_TIMERS > 0
1214           timespec tp;
1215          #endif
1216           clock_gettime(CLOCK_REALTIME, &tp);
1217         ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1218
1219       AC_MSG_RESULT($ac_has_clock_realtime)
1220
1221       AC_MSG_CHECKING([for nanosleep])
1222       AC_TRY_LINK(
1223         [#include <unistd.h>
1224          #include <time.h>
1225         ],
1226         [#if _POSIX_TIMERS > 0
1227           timespec tp;
1228          #endif
1229           nanosleep(&tp, 0);
1230         ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1231
1232       AC_MSG_RESULT($ac_has_nanosleep)
1233     fi
1234   fi
1235
1236   if test x"$ac_has_clock_monotonic" = x"yes"; then
1237     AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1238       [ Defined if clock_gettime has monotonic clock support. ])
1239   fi
1240
1241   if test x"$ac_has_clock_realtime" = x"yes"; then
1242     AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1243       [ Defined if clock_gettime has realtime clock support. ])
1244   fi
1245
1246   if test x"$ac_has_nanosleep" = x"yes"; then
1247     AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1248       [ Defined if nanosleep is available. ])
1249   fi
1250
1251   AC_SUBST(GLIBCXX_LIBS)
1252
1253   CXXFLAGS="$ac_save_CXXFLAGS"
1254   LIBS="$ac_save_LIBS"
1255   AC_LANG_RESTORE
1256 ])
1257
1258 dnl
1259 dnl Check for gettimeofday, used in the implementation of 20.8.5
1260 dnl [time.clock] in the current C++0x working draft.
1261 dnl
1262 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1263
1264   AC_MSG_CHECKING([for gettimeofday])
1265
1266   AC_LANG_SAVE
1267   AC_LANG_CPLUSPLUS
1268   ac_save_CXXFLAGS="$CXXFLAGS"
1269   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1270
1271   ac_has_gettimeofday=no;
1272   AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1273   if test x"$ac_has_sys_time_h" = x"yes"; then
1274     AC_MSG_CHECKING([for gettimeofday])
1275     GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1276       [timeval tv; gettimeofday(&tv, 0);],
1277       [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1278
1279     AC_MSG_RESULT($ac_has_gettimeofday)
1280   fi
1281
1282   if test x"$ac_has_gettimeofday" = x"yes"; then
1283     AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1284       [ Defined if gettimeofday is available. ])
1285   fi
1286
1287   CXXFLAGS="$ac_save_CXXFLAGS"
1288   AC_LANG_RESTORE
1289 ])
1290
1291 dnl
1292 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1293 dnl facilities in Chapter 8, "C compatibility".
1294 dnl
1295 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1296
1297   AC_LANG_SAVE
1298   AC_LANG_CPLUSPLUS
1299
1300   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1301   # undefined and fake C99 facilities may be spuriously enabled.
1302   ac_save_CXXFLAGS="$CXXFLAGS"
1303   CXXFLAGS="$CXXFLAGS -std=c++98"
1304
1305   # Check for the existence of <complex.h> complex math functions used
1306   # by tr1/complex.
1307   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1308   ac_c99_complex_tr1=no;
1309   if test x"$ac_has_complex_h" = x"yes"; then
1310     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1311     AC_TRY_COMPILE([#include <complex.h>],
1312                    [typedef __complex__ float float_type; float_type tmpf;
1313                     cacosf(tmpf);
1314                     casinf(tmpf);
1315                     catanf(tmpf);
1316                     cacoshf(tmpf);
1317                     casinhf(tmpf);
1318                     catanhf(tmpf);
1319                     typedef __complex__ double double_type; double_type tmpd;
1320                     cacos(tmpd);
1321                     casin(tmpd);
1322                     catan(tmpd);
1323                     cacosh(tmpd);
1324                     casinh(tmpd);
1325                     catanh(tmpd);
1326                     typedef __complex__ long double ld_type; ld_type tmpld;
1327                     cacosl(tmpld);
1328                     casinl(tmpld);
1329                     catanl(tmpld);
1330                     cacoshl(tmpld);
1331                     casinhl(tmpld);
1332                     catanhl(tmpld);
1333                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1334   fi
1335   AC_MSG_RESULT($ac_c99_complex_tr1)
1336   if test x"$ac_c99_complex_tr1" = x"yes"; then
1337     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1338               [Define if C99 functions in <complex.h> should be used in
1339               <tr1/complex>. Using compiler builtins for these functions
1340               requires corresponding C99 library functions to be present.])
1341   fi
1342
1343   # Check for the existence of <ctype.h> functions.
1344   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1345   AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1346   AC_TRY_COMPILE([#include <ctype.h>],
1347                  [int ch;
1348                   int ret;
1349                   ret = isblank(ch);
1350                  ],[glibcxx_cv_c99_ctype_tr1=yes],
1351                    [glibcxx_cv_c99_ctype_tr1=no])
1352   ])
1353   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1354   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1355     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1356               [Define if C99 functions in <ctype.h> should be imported in
1357               <tr1/cctype> in namespace std::tr1.])
1358   fi
1359
1360   # Check for the existence of <fenv.h> functions.
1361   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1362   ac_c99_fenv_tr1=no;
1363   if test x"$ac_has_fenv_h" = x"yes"; then
1364     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1365     AC_TRY_COMPILE([#include <fenv.h>],
1366                    [int except, mode;
1367                     fexcept_t* pflag;
1368                     fenv_t* penv;
1369                     int ret;
1370                     ret = feclearexcept(except);
1371                     ret = fegetexceptflag(pflag, except);
1372                     ret = feraiseexcept(except);
1373                     ret = fesetexceptflag(pflag, except);
1374                     ret = fetestexcept(except);
1375                     ret = fegetround();
1376                     ret = fesetround(mode);
1377                     ret = fegetenv(penv);
1378                     ret = feholdexcept(penv);
1379                     ret = fesetenv(penv);
1380                     ret = feupdateenv(penv);
1381                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1382   fi
1383   AC_MSG_RESULT($ac_c99_fenv_tr1)
1384   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1385     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1386               [Define if C99 functions in <fenv.h> should be imported in
1387               <tr1/cfenv> in namespace std::tr1.])
1388   fi
1389
1390   # Check for the existence of <stdint.h> types.
1391   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1392   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1393   AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1394                   #define __STDC_CONSTANT_MACROS
1395                   #include <stdint.h>],
1396                  [typedef int8_t          my_int8_t;
1397                   my_int8_t               i8 = INT8_MIN;
1398                   i8 = INT8_MAX;
1399                   typedef int16_t         my_int16_t;
1400                   my_int16_t              i16 = INT16_MIN;
1401                   i16 = INT16_MAX;
1402                   typedef int32_t         my_int32_t;
1403                   my_int32_t              i32 = INT32_MIN;
1404                   i32 = INT32_MAX;
1405                   typedef int64_t         my_int64_t;
1406                   my_int64_t              i64 = INT64_MIN;
1407                   i64 = INT64_MAX;
1408                   typedef int_fast8_t     my_int_fast8_t;
1409                   my_int_fast8_t          if8 = INT_FAST8_MIN;
1410                   if8 = INT_FAST8_MAX;
1411                   typedef int_fast16_t    my_int_fast16_t;
1412                   my_int_fast16_t         if16 = INT_FAST16_MIN;
1413                   if16 = INT_FAST16_MAX;
1414                   typedef int_fast32_t    my_int_fast32_t;
1415                   my_int_fast32_t         if32 = INT_FAST32_MIN;
1416                   if32 = INT_FAST32_MAX;
1417                   typedef int_fast64_t    my_int_fast64_t;
1418                   my_int_fast64_t         if64 = INT_FAST64_MIN;
1419                   if64 = INT_FAST64_MAX;
1420                   typedef int_least8_t    my_int_least8_t;
1421                   my_int_least8_t         il8 = INT_LEAST8_MIN;
1422                   il8 = INT_LEAST8_MAX;
1423                   typedef int_least16_t   my_int_least16_t;
1424                   my_int_least16_t        il16 = INT_LEAST16_MIN;
1425                   il16 = INT_LEAST16_MAX;
1426                   typedef int_least32_t   my_int_least32_t;
1427                   my_int_least32_t        il32 = INT_LEAST32_MIN;
1428                   il32 = INT_LEAST32_MAX;
1429                   typedef int_least64_t   my_int_least64_t;
1430                   my_int_least64_t        il64 = INT_LEAST64_MIN;
1431                   il64 = INT_LEAST64_MAX;
1432                   typedef intmax_t        my_intmax_t;
1433                   my_intmax_t             im = INTMAX_MAX;
1434                   im = INTMAX_MIN;
1435                   typedef intptr_t        my_intptr_t;
1436                   my_intptr_t             ip = INTPTR_MAX;
1437                   ip = INTPTR_MIN;
1438                   typedef uint8_t         my_uint8_t;
1439                   my_uint8_t              ui8 = UINT8_MAX;
1440                   ui8 = UINT8_MAX;
1441                   typedef uint16_t        my_uint16_t;
1442                   my_uint16_t             ui16 = UINT16_MAX;
1443                   ui16 = UINT16_MAX;
1444                   typedef uint32_t        my_uint32_t;
1445                   my_uint32_t             ui32 = UINT32_MAX;
1446                   ui32 = UINT32_MAX;
1447                   typedef uint64_t        my_uint64_t;
1448                   my_uint64_t             ui64 = UINT64_MAX;
1449                   ui64 = UINT64_MAX;
1450                   typedef uint_fast8_t    my_uint_fast8_t;
1451                   my_uint_fast8_t         uif8 = UINT_FAST8_MAX;
1452                   uif8 = UINT_FAST8_MAX;
1453                   typedef uint_fast16_t   my_uint_fast16_t;
1454                   my_uint_fast16_t        uif16 = UINT_FAST16_MAX;
1455                   uif16 = UINT_FAST16_MAX;
1456                   typedef uint_fast32_t   my_uint_fast32_t;
1457                   my_uint_fast32_t        uif32 = UINT_FAST32_MAX;
1458                   uif32 = UINT_FAST32_MAX;
1459                   typedef uint_fast64_t   my_uint_fast64_t;
1460                   my_uint_fast64_t        uif64 = UINT_FAST64_MAX;
1461                   uif64 = UINT_FAST64_MAX;
1462                   typedef uint_least8_t   my_uint_least8_t;
1463                   my_uint_least8_t        uil8 = UINT_LEAST8_MAX;
1464                   uil8 = UINT_LEAST8_MAX;
1465                   typedef uint_least16_t  my_uint_least16_t;
1466                   my_uint_least16_t       uil16 = UINT_LEAST16_MAX;
1467                   uil16 = UINT_LEAST16_MAX;
1468                   typedef uint_least32_t  my_uint_least32_t;
1469                   my_uint_least32_t       uil32 = UINT_LEAST32_MAX;
1470                   uil32 = UINT_LEAST32_MAX;
1471                   typedef uint_least64_t  my_uint_least64_t;
1472                   my_uint_least64_t       uil64 = UINT_LEAST64_MAX;
1473                   uil64 = UINT_LEAST64_MAX;
1474                   typedef uintmax_t       my_uintmax_t;
1475                   my_uintmax_t            uim = UINTMAX_MAX;
1476                   uim = UINTMAX_MAX;
1477                   typedef uintptr_t       my_uintptr_t;
1478                   my_uintptr_t            uip = UINTPTR_MAX;
1479                   uip = UINTPTR_MAX;
1480                  ],[glibcxx_cv_c99_stdint_tr1=yes],
1481                    [glibcxx_cv_c99_stdint_tr1=no])
1482   ])
1483   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1484   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1485     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1486               [Define if C99 types in <stdint.h> should be imported in
1487               <tr1/cstdint> in namespace std::tr1.])
1488   fi
1489
1490   # Check for the existence of <math.h> functions.
1491   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1492   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1493   AC_TRY_COMPILE([#include <math.h>],
1494                  [typedef double_t  my_double_t;
1495                   typedef float_t   my_float_t;
1496                   acosh(0.0);
1497                   acoshf(0.0f);
1498                   acoshl(0.0l);
1499                   asinh(0.0);
1500                   asinhf(0.0f);
1501                   asinhl(0.0l);
1502                   atanh(0.0);
1503                   atanhf(0.0f);
1504                   atanhl(0.0l);
1505                   cbrt(0.0);
1506                   cbrtf(0.0f);
1507                   cbrtl(0.0l);
1508                   copysign(0.0, 0.0);
1509                   copysignf(0.0f, 0.0f);
1510                   copysignl(0.0l, 0.0l);
1511                   erf(0.0);
1512                   erff(0.0f);
1513                   erfl(0.0l);
1514                   erfc(0.0);
1515                   erfcf(0.0f);
1516                   erfcl(0.0l);
1517                   exp2(0.0);
1518                   exp2f(0.0f);
1519                   exp2l(0.0l);
1520                   expm1(0.0);
1521                   expm1f(0.0f);
1522                   expm1l(0.0l);
1523                   fdim(0.0, 0.0);
1524                   fdimf(0.0f, 0.0f);
1525                   fdiml(0.0l, 0.0l);
1526                   fma(0.0, 0.0, 0.0);
1527                   fmaf(0.0f, 0.0f, 0.0f);
1528                   fmal(0.0l, 0.0l, 0.0l);
1529                   fmax(0.0, 0.0);
1530                   fmaxf(0.0f, 0.0f);
1531                   fmaxl(0.0l, 0.0l);
1532                   fmin(0.0, 0.0);
1533                   fminf(0.0f, 0.0f);
1534                   fminl(0.0l, 0.0l);
1535                   hypot(0.0, 0.0);
1536                   hypotf(0.0f, 0.0f);
1537                   hypotl(0.0l, 0.0l);
1538                   ilogb(0.0);
1539                   ilogbf(0.0f);
1540                   ilogbl(0.0l);
1541                   lgamma(0.0);
1542                   lgammaf(0.0f);
1543                   lgammal(0.0l);
1544                   llrint(0.0);
1545                   llrintf(0.0f);
1546                   llrintl(0.0l);
1547                   llround(0.0);
1548                   llroundf(0.0f);
1549                   llroundl(0.0l);
1550                   log1p(0.0);
1551                   log1pf(0.0f);
1552                   log1pl(0.0l);
1553                   log2(0.0);
1554                   log2f(0.0f);
1555                   log2l(0.0l);
1556                   logb(0.0);
1557                   logbf(0.0f);
1558                   logbl(0.0l);
1559                   lrint(0.0);
1560                   lrintf(0.0f);
1561                   lrintl(0.0l);
1562                   lround(0.0);
1563                   lroundf(0.0f);
1564                   lroundl(0.0l);
1565                   nan(0);
1566                   nanf(0);
1567                   nanl(0);
1568                   nearbyint(0.0);
1569                   nearbyintf(0.0f);
1570                   nearbyintl(0.0l);
1571                   nextafter(0.0, 0.0);
1572                   nextafterf(0.0f, 0.0f);
1573                   nextafterl(0.0l, 0.0l);
1574                   nexttoward(0.0, 0.0);
1575                   nexttowardf(0.0f, 0.0f);
1576                   nexttowardl(0.0l, 0.0l);
1577                   remainder(0.0, 0.0);
1578                   remainderf(0.0f, 0.0f);
1579                   remainderl(0.0l, 0.0l);
1580                   remquo(0.0, 0.0, 0);
1581                   remquof(0.0f, 0.0f, 0);
1582                   remquol(0.0l, 0.0l, 0);
1583                   rint(0.0);
1584                   rintf(0.0f);
1585                   rintl(0.0l);
1586                   round(0.0);
1587                   roundf(0.0f);
1588                   roundl(0.0l);
1589                   scalbln(0.0, 0l);
1590                   scalblnf(0.0f, 0l);
1591                   scalblnl(0.0l, 0l);
1592                   scalbn(0.0, 0);
1593                   scalbnf(0.0f, 0);
1594                   scalbnl(0.0l, 0);
1595                   tgamma(0.0);
1596                   tgammaf(0.0f);
1597                   tgammal(0.0l);
1598                   trunc(0.0);
1599                   truncf(0.0f);
1600                   truncl(0.0l);
1601                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1602   ])
1603   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1604   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1605     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1606               [Define if C99 functions or macros in <math.h> should be imported
1607               in <tr1/cmath> in namespace std::tr1.])
1608   fi
1609
1610   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1611   # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1612   ac_c99_inttypes_tr1=no;
1613   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1614     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1615     AC_TRY_COMPILE([#include <inttypes.h>],
1616                    [intmax_t i, numer, denom, base;
1617                     const char* s;
1618                     char** endptr;
1619                     intmax_t ret = imaxabs(i);
1620                     imaxdiv_t dret = imaxdiv(numer, denom);
1621                     ret = strtoimax(s, endptr, base);
1622                     uintmax_t uret = strtoumax(s, endptr, base);
1623                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1624   fi
1625   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1626   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1627     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1628               [Define if C99 functions in <inttypes.h> should be imported in
1629               <tr1/cinttypes> in namespace std::tr1.])
1630   fi
1631
1632   # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1633   # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1634   ac_c99_inttypes_wchar_t_tr1=no;
1635   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1636     AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1637     AC_TRY_COMPILE([#include <inttypes.h>],
1638                    [intmax_t base;
1639                     const wchar_t* s;
1640                     wchar_t** endptr;
1641                     intmax_t ret = wcstoimax(s, endptr, base);
1642                     uintmax_t uret = wcstoumax(s, endptr, base);
1643                    ],[ac_c99_inttypes_wchar_t_tr1=yes],
1644                      [ac_c99_inttypes_wchar_t_tr1=no])
1645   fi
1646   AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1647   if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1648     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1649               [Define if wchar_t C99 functions in <inttypes.h> should be
1650               imported in <tr1/cinttypes> in namespace std::tr1.])
1651   fi
1652
1653   # Check for the existence of the <stdbool.h> header.
1654   AC_CHECK_HEADERS(stdbool.h)
1655
1656   # Check for the existence of the <stdalign.h> header.
1657   AC_CHECK_HEADERS(stdalign.h)
1658
1659   CXXFLAGS="$ac_save_CXXFLAGS"
1660   AC_LANG_RESTORE
1661 ])
1662
1663 dnl
1664 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1665 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1666 dnl
1667 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1668
1669   AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1670   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1671     if test -r /dev/random && test -r /dev/urandom; then
1672       glibcxx_cv_random_tr1=yes;
1673     else
1674       glibcxx_cv_random_tr1=no;
1675     fi
1676   ])
1677   AC_MSG_RESULT($glibcxx_cv_random_tr1)
1678
1679   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1680     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1681               [Define if /dev/random and /dev/urandom are available for
1682                the random_device of TR1 (Chapter 5.1).])
1683   fi
1684
1685 ])
1686
1687 dnl
1688 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
1689 dnl
1690 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
1691
1692   AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
1693   AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
1694                  [#include <stdio.h>],
1695                  [AC_MSG_ERROR([computing EOF failed])])
1696   ])
1697   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
1698                      [Define to the value of the EOF integer constant.])
1699
1700   AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
1701   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
1702                  [#include <stdio.h>],
1703                  [AC_MSG_ERROR([computing SEEK_CUR failed])])
1704   ])
1705   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
1706                      [Define to the value of the SEEK_CUR integer constant.])
1707
1708   AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
1709   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
1710                  [#include <stdio.h>],
1711                  [AC_MSG_ERROR([computing SEEK_END failed])])
1712   ])
1713   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
1714                      [Define to the value of the SEEK_END integer constant.])
1715 ])
1716
1717 dnl
1718 dnl Check whether required C++ overloads are present in <math.h>.
1719 dnl
1720
1721 AC_DEFUN([GLIBCXX_CHECK_MATH_PROTO], [
1722
1723   AC_LANG_SAVE
1724   AC_LANG_CPLUSPLUS
1725
1726   case "$host" in
1727     *-*-solaris2.*)
1728       # Solaris 8 FCS only had an overload for double std::abs(double) in
1729       # <iso/math_iso.h>.  Patches 111721-04 (SPARC) and 112757-01 (x86)
1730       # introduced the full set also found from Solaris 9 onwards.
1731       AC_MSG_CHECKING([for float std::abs(float) overload])
1732       AC_CACHE_VAL(glibcxx_cv_abs_float, [
1733         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1734           [#include <math.h>
1735            namespace std {
1736              inline float abs(float __x)
1737              {  return __builtin_fabsf(__x); }
1738            }
1739         ])],
1740         [glibcxx_cv_abs_float=no],
1741         [glibcxx_cv_abs_float=yes]
1742       )])
1743
1744       # autoheader cannot handle indented templates.
1745       AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO1],
1746         [/* Define if all C++ overloads are available in <math.h>.  */
1747 #if __cplusplus >= 199711L
1748 #undef __CORRECT_ISO_CPP_MATH_H_PROTO1
1749 #endif])
1750       AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO2],
1751         [/* Define if only double std::abs(double) is available in <math.h>.  */
1752 #if __cplusplus >= 199711L
1753 #undef __CORRECT_ISO_CPP_MATH_H_PROTO2
1754 #endif])
1755
1756       if test $glibcxx_cv_abs_float = yes; then
1757         AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO1)
1758       else
1759         AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO2)
1760       fi
1761       AC_MSG_RESULT($glibcxx_cv_abs_float)
1762       ;;
1763   esac
1764
1765   AC_LANG_RESTORE
1766 ])
1767
1768 dnl
1769 dnl Check whether required C++ overloads are present in <stdlib.h>.
1770 dnl
1771
1772 AC_DEFUN([GLIBCXX_CHECK_STDLIB_PROTO], [
1773
1774   AC_LANG_SAVE
1775   AC_LANG_CPLUSPLUS
1776
1777   case "$host" in
1778     *-*-solaris2.*)
1779       # Solaris 8 FCS lacked the overloads for long std::abs(long) and
1780       # ldiv_t std::div(long, long) in <iso/stdlib_iso.h>.  Patches 109607-02
1781       # (SPARC) and 109608-02 (x86) introduced them.
1782       AC_MSG_CHECKING([for long std::abs(long) overload])
1783       AC_CACHE_VAL(glibcxx_cv_abs_long, [
1784         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1785           [#include <stdlib.h>
1786            namespace std {
1787              inline long
1788              abs(long __i) { return labs(__i); }
1789            }
1790         ])],
1791         [glibcxx_cv_abs_long=no],
1792         [glibcxx_cv_abs_long=yes]
1793       )])
1794
1795       # autoheader cannot handle indented templates.
1796       AH_VERBATIM([__CORRECT_ISO_CPP_STDLIB_H_PROTO],
1797         [/* Define if all C++ overloads are available in <stdlib.h>.  */
1798 #if __cplusplus >= 199711L
1799 #undef __CORRECT_ISO_CPP_STDLIB_H_PROTO
1800 #endif])
1801       if test $glibcxx_cv_abs_long = yes; then
1802         AC_DEFINE(__CORRECT_ISO_CPP_STDLIB_H_PROTO, 1)
1803       fi
1804       AC_MSG_RESULT($glibcxx_cv_abs_long)
1805       ;;
1806   esac
1807
1808   AC_LANG_RESTORE
1809 ])
1810
1811 dnl
1812 dnl Check whether required C++ overloads are present in <stdio.h>.
1813 dnl
1814 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
1815
1816   AC_LANG_SAVE
1817   AC_LANG_CPLUSPLUS
1818
1819   AC_MSG_CHECKING([for gets declaration])
1820   AC_CACHE_VAL(glibcxx_cv_gets, [
1821   AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1822           [#include <stdio.h>
1823            namespace test 
1824            {
1825               using ::gets;
1826            }
1827         ])],
1828         [glibcxx_cv_gets=yes],
1829         [glibcxx_cv_gets=no]
1830       )])
1831
1832   if test $glibcxx_cv_gets = yes; then
1833     AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h>.])
1834   fi
1835   AC_MSG_RESULT($glibcxx_cv_gets)
1836
1837   AC_LANG_RESTORE
1838 ])
1839
1840 dnl
1841 dnl Check whether macros, etc are present for <system_error>
1842 dnl
1843 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1844
1845 m4_pushdef([n_syserr], [1])dnl
1846 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1847                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1848                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
1849                       ECHILD, ENOSPC, EPERM,
1850                       ETIMEDOUT, EWOULDBLOCK],
1851 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1852 AC_MSG_CHECKING([for syserr])
1853 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1854 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1855                                    [int i = syserr;])],
1856                   [glibcxx_cv_system_error[]n_syserr=yes],
1857                   [glibcxx_cv_system_error[]n_syserr=no])
1858 ])
1859 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1860 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1861   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1862 fi
1863 m4_define([n_syserr], m4_incr(n_syserr))dnl
1864 m4_popdef([SYSERR])dnl
1865 ])
1866 m4_popdef([n_syserr])dnl
1867 ])
1868
1869 dnl
1870 dnl Check for what type of C headers to use.
1871 dnl
1872 dnl --enable-cheaders= [does stuff].
1873 dnl --disable-cheaders [does not do anything, really].
1874 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1875 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1876 dnl
1877 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1878   GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
1879     [construct "C" headers for g++], [permit c|c_std|c_global])
1880   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1881
1882   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1883
1884   # Allow overrides to configure.host here.
1885   if test $enable_cheaders = c_global; then
1886      c_compatibility=yes
1887   fi
1888
1889   AC_SUBST(C_INCLUDE_DIR)
1890   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1891   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1892   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1893   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1894 ])
1895
1896
1897 dnl
1898 dnl Check for which locale library to use.  The choice is mapped to
1899 dnl a subdirectory of config/locale.
1900 dnl
1901 dnl Default is generic.
1902 dnl
1903 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1904   GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
1905     [use MODEL for target locale package],
1906     [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
1907
1908   # Deal with gettext issues.  Default to not using it (=no) until we detect
1909   # support for it later.  Let the user turn it off via --e/d, but let that
1910   # default to on for easier handling.
1911   USE_NLS=no
1912   AC_ARG_ENABLE(nls,
1913     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1914     [],
1915     [enable_nls=yes])
1916
1917   # Either a known package, or "auto"
1918   if test $enable_clocale = no || test $enable_clocale = yes; then
1919      enable_clocale=auto
1920   fi
1921   enable_clocale_flag=$enable_clocale
1922
1923   # Probe for locale model to use if none specified.
1924   # Default to "generic".
1925   if test $enable_clocale_flag = auto; then
1926     case ${target_os} in
1927       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1928         enable_clocale_flag=gnu
1929         ;;
1930       darwin* | freebsd*)
1931         enable_clocale_flag=darwin
1932         ;;
1933       *)
1934         if test x"$with_newlib" = x"yes"; then
1935           enable_clocale_flag=newlib
1936         else
1937           enable_clocale_flag=generic
1938         fi
1939         ;;
1940     esac
1941   fi
1942
1943   # Sanity check model, and test for special functionality.
1944   if test $enable_clocale_flag = gnu; then
1945     AC_EGREP_CPP([_GLIBCXX_ok], [
1946     #include <features.h>
1947     #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1948       _GLIBCXX_ok
1949     #endif
1950     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1951
1952     # Set it to scream when it hurts.
1953     ac_save_CFLAGS="$CFLAGS"
1954     CFLAGS="-Wimplicit-function-declaration -Werror"
1955
1956     # Use strxfrm_l if available.
1957     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1958                     #include <string.h>
1959                     #include <locale.h>],
1960                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1961                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1962                     [Define if strxfrm_l is available in <string.h>.]),)
1963
1964     # Use strerror_l if available.
1965     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1966                     #include <string.h>
1967                     #include <locale.h>],
1968                     [__locale_t loc; strerror_l(5, loc);],
1969                     AC_DEFINE(HAVE_STRERROR_L, 1,
1970                     [Define if strerror_l is available in <string.h>.]),)
1971
1972     CFLAGS="$ac_save_CFLAGS"
1973   fi
1974
1975   # Perhaps use strerror_r if available, and strerror_l isn't.
1976   ac_save_CFLAGS="$CFLAGS"
1977   CFLAGS="-Wimplicit-function-declaration -Werror"
1978   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1979                   #include <string.h>
1980                   #include <locale.h>],
1981                   [char s[128]; strerror_r(5, s, 128);],
1982                   AC_DEFINE(HAVE_STRERROR_R, 1,
1983                   [Define if strerror_r is available in <string.h>.]),)
1984   CFLAGS="$ac_save_CFLAGS"
1985
1986   # Set configure bits for specified locale package
1987   AC_MSG_CHECKING([for C locale to use])
1988   case ${enable_clocale_flag} in
1989     generic)
1990       AC_MSG_RESULT(generic)
1991
1992       CLOCALE_H=config/locale/generic/c_locale.h
1993       CLOCALE_CC=config/locale/generic/c_locale.cc
1994       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1995       CCOLLATE_CC=config/locale/generic/collate_members.cc
1996       CCTYPE_CC=config/locale/generic/ctype_members.cc
1997       CMESSAGES_H=config/locale/generic/messages_members.h
1998       CMESSAGES_CC=config/locale/generic/messages_members.cc
1999       CMONEY_CC=config/locale/generic/monetary_members.cc
2000       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2001       CTIME_H=config/locale/generic/time_members.h
2002       CTIME_CC=config/locale/generic/time_members.cc
2003       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2004       ;;
2005     darwin)
2006       AC_MSG_RESULT(darwin or freebsd)
2007
2008       CLOCALE_H=config/locale/generic/c_locale.h
2009       CLOCALE_CC=config/locale/generic/c_locale.cc
2010       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2011       CCOLLATE_CC=config/locale/generic/collate_members.cc
2012       CCTYPE_CC=config/locale/darwin/ctype_members.cc
2013       CMESSAGES_H=config/locale/generic/messages_members.h
2014       CMESSAGES_CC=config/locale/generic/messages_members.cc
2015       CMONEY_CC=config/locale/generic/monetary_members.cc
2016       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2017       CTIME_H=config/locale/generic/time_members.h
2018       CTIME_CC=config/locale/generic/time_members.cc
2019       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2020       ;;
2021
2022     gnu)
2023       AC_MSG_RESULT(gnu)
2024
2025       # Declare intention to use gettext, and add support for specific
2026       # languages.
2027       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2028       ALL_LINGUAS="de fr"
2029
2030       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2031       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2032       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2033         USE_NLS=yes
2034       fi
2035       # Export the build objects.
2036       for ling in $ALL_LINGUAS; do \
2037         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2038         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2039       done
2040       AC_SUBST(glibcxx_MOFILES)
2041       AC_SUBST(glibcxx_POFILES)
2042
2043       CLOCALE_H=config/locale/gnu/c_locale.h
2044       CLOCALE_CC=config/locale/gnu/c_locale.cc
2045       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2046       CCOLLATE_CC=config/locale/gnu/collate_members.cc
2047       CCTYPE_CC=config/locale/gnu/ctype_members.cc
2048       CMESSAGES_H=config/locale/gnu/messages_members.h
2049       CMESSAGES_CC=config/locale/gnu/messages_members.cc
2050       CMONEY_CC=config/locale/gnu/monetary_members.cc
2051       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2052       CTIME_H=config/locale/gnu/time_members.h
2053       CTIME_CC=config/locale/gnu/time_members.cc
2054       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2055       ;;
2056     ieee_1003.1-2001)
2057       AC_MSG_RESULT(IEEE 1003.1)
2058
2059       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2060       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2061       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2062       CCOLLATE_CC=config/locale/generic/collate_members.cc
2063       CCTYPE_CC=config/locale/generic/ctype_members.cc
2064       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2065       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2066       CMONEY_CC=config/locale/generic/monetary_members.cc
2067       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2068       CTIME_H=config/locale/generic/time_members.h
2069       CTIME_CC=config/locale/generic/time_members.cc
2070       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2071       ;;
2072     newlib)
2073       AC_MSG_RESULT(newlib)
2074
2075       CLOCALE_H=config/locale/generic/c_locale.h
2076       CLOCALE_CC=config/locale/generic/c_locale.cc
2077       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2078       CCOLLATE_CC=config/locale/generic/collate_members.cc
2079       CCTYPE_CC=config/locale/newlib/ctype_members.cc
2080       CMESSAGES_H=config/locale/generic/messages_members.h
2081       CMESSAGES_CC=config/locale/generic/messages_members.cc
2082       CMONEY_CC=config/locale/generic/monetary_members.cc
2083       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2084       CTIME_H=config/locale/generic/time_members.h
2085       CTIME_CC=config/locale/generic/time_members.cc
2086       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2087       ;;
2088   esac
2089
2090   # This is where the testsuite looks for locale catalogs, using the
2091   # -DLOCALEDIR define during testsuite compilation.
2092   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2093   AC_SUBST(glibcxx_localedir)
2094
2095   # A standalone libintl (e.g., GNU libintl) may be in use.
2096   if test $USE_NLS = yes; then
2097     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2098     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2099   fi
2100   if test $USE_NLS = yes; then
2101     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2102               [Define if NLS translations are to be used.])
2103   fi
2104
2105   AC_SUBST(USE_NLS)
2106   AC_SUBST(CLOCALE_H)
2107   AC_SUBST(CMESSAGES_H)
2108   AC_SUBST(CCODECVT_CC)
2109   AC_SUBST(CCOLLATE_CC)
2110   AC_SUBST(CCTYPE_CC)
2111   AC_SUBST(CMESSAGES_CC)
2112   AC_SUBST(CMONEY_CC)
2113   AC_SUBST(CNUMERIC_CC)
2114   AC_SUBST(CTIME_H)
2115   AC_SUBST(CTIME_CC)
2116   AC_SUBST(CLOCALE_CC)
2117   AC_SUBST(CLOCALE_INTERNAL_H)
2118 ])
2119
2120
2121 dnl
2122 dnl Check for which std::allocator base class to use.  The choice is
2123 dnl mapped from a subdirectory of include/ext.
2124 dnl
2125 dnl Default is new.
2126 dnl
2127 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2128   AC_MSG_CHECKING([for std::allocator base class])
2129   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2130     [use KIND for target std::allocator base],
2131     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2132
2133   # If they didn't use this option switch, or if they specified --enable
2134   # with no specific model, we'll have to look for one.  If they
2135   # specified --disable (???), do likewise.
2136   if test $enable_libstdcxx_allocator = no ||
2137      test $enable_libstdcxx_allocator = yes;
2138   then
2139      enable_libstdcxx_allocator=auto
2140   fi
2141
2142   # Either a known package, or "auto". Auto implies the default choice
2143   # for a particular platform.
2144   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2145
2146   # Probe for host-specific support if no specific model is specified.
2147   # Default to "new".
2148   if test $enable_libstdcxx_allocator_flag = auto; then
2149     case ${target_os} in
2150       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2151         enable_libstdcxx_allocator_flag=new
2152         ;;
2153       *)
2154         enable_libstdcxx_allocator_flag=new
2155         ;;
2156     esac
2157   fi
2158   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2159
2160
2161   # Set configure bits for specified locale package
2162   case ${enable_libstdcxx_allocator_flag} in
2163     bitmap)
2164       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2165       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2166       ;;
2167     malloc)
2168       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2169       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2170       ;;
2171     mt)
2172       ALLOCATOR_H=config/allocator/mt_allocator_base.h
2173       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2174       ;;
2175     new)
2176       ALLOCATOR_H=config/allocator/new_allocator_base.h
2177       ALLOCATOR_NAME=__gnu_cxx::new_allocator
2178       ;;
2179     pool)
2180       ALLOCATOR_H=config/allocator/pool_allocator_base.h
2181       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2182       ;;
2183   esac
2184
2185   AC_SUBST(ALLOCATOR_H)
2186   AC_SUBST(ALLOCATOR_NAME)
2187 ])
2188
2189
2190 dnl
2191 dnl Check for whether the Boost-derived checks should be turned on.
2192 dnl
2193 dnl --enable-concept-checks turns them on.
2194 dnl --disable-concept-checks leaves them off.
2195 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2196 dnl       Where DEFAULT is either `yes' or `no'.
2197 dnl
2198 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2199   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2200   if test $enable_concept_checks = yes; then
2201     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2202               [Define to use concept checking code from the boost libraries.])
2203   fi
2204 ])
2205
2206 dnl
2207 dnl Use extern templates.
2208 dnl
2209 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2210 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2211
2212 dnl  +  Usage:  GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2213 dnl       Where DEFAULT is `yes' or `no'.
2214 dnl
2215 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2216
2217   GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2218
2219   AC_MSG_CHECKING([for extern template support])
2220   AC_MSG_RESULT([$enable_extern_template])
2221
2222   GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2223 ])
2224
2225 dnl
2226 dnl Check for parallel mode pre-requisites, including OpenMP support.
2227 dnl
2228 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
2229 dnl
2230 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2231
2232   enable_parallel=no;
2233
2234   # See if configured libgomp/omp.h exists. (libgomp may be in
2235   # noconfigdirs but not explicitly disabled.)
2236   if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2237     enable_parallel=yes;
2238   else
2239     AC_MSG_NOTICE([target-libgomp not built])
2240   fi
2241
2242   AC_MSG_CHECKING([for parallel mode support])
2243   AC_MSG_RESULT([$enable_parallel])
2244   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2245 ])
2246
2247
2248 dnl
2249 dnl Check for which I/O library to use:  stdio, or something specific.
2250 dnl
2251 dnl Default is stdio.
2252 dnl
2253 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2254   AC_MSG_CHECKING([for underlying I/O to use])
2255   GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2256     [use target-specific I/O package], [permit stdio])
2257
2258   # Now that libio has been removed, you can have any color you want as long
2259   # as it's black.  This is one big no-op until other packages are added, but
2260   # showing the framework never hurts.
2261   case ${enable_cstdio} in
2262     stdio)
2263       CSTDIO_H=config/io/c_io_stdio.h
2264       BASIC_FILE_H=config/io/basic_file_stdio.h
2265       BASIC_FILE_CC=config/io/basic_file_stdio.cc
2266       AC_MSG_RESULT(stdio)
2267       ;;
2268   esac
2269
2270   AC_SUBST(CSTDIO_H)
2271   AC_SUBST(BASIC_FILE_H)
2272   AC_SUBST(BASIC_FILE_CC)
2273 ])
2274
2275
2276 dnl
2277 dnl Check for "unusual" flags to pass to the compiler while building.
2278 dnl
2279 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2280 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2281 dnl --disable-cxx-flags passes nothing.
2282 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2283 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2284 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2285 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2286 dnl       If "default flags" is an empty string, the effect is the same
2287 dnl       as --disable or --enable=no.
2288 dnl
2289 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2290   AC_MSG_CHECKING([for extra compiler flags for building])
2291   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2292     [pass compiler FLAGS when building library],
2293     [case "x$enable_cxx_flags" in
2294       xno | x)   enable_cxx_flags= ;;
2295       x-*)       ;;
2296       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2297      esac])
2298
2299   # Run through flags (either default or command-line) and set anything
2300   # extra (e.g., #defines) that must accompany particular g++ options.
2301   if test -n "$enable_cxx_flags"; then
2302     for f in $enable_cxx_flags; do
2303       case "$f" in
2304         -fhonor-std)  ;;
2305         -*)  ;;
2306         *)   # and we're trying to pass /what/ exactly?
2307              AC_MSG_ERROR([compiler flags start with a -]) ;;
2308       esac
2309     done
2310   fi
2311
2312   EXTRA_CXX_FLAGS="$enable_cxx_flags"
2313   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2314   AC_SUBST(EXTRA_CXX_FLAGS)
2315 ])
2316
2317
2318 dnl
2319 dnl Check to see if debugging libraries are to be built.
2320 dnl
2321 dnl --enable-libstdcxx-debug
2322 dnl builds a separate set of debugging libraries in addition to the
2323 dnl normal (shared, static) libstdc++ binaries.
2324 dnl
2325 dnl --disable-libstdcxx-debug
2326 dnl builds only one (non-debug) version of libstdc++.
2327 dnl
2328 dnl --enable-libstdcxx-debug-flags=FLAGS
2329 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2330 dnl
2331 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2332 dnl       Where DEFAULT is either `yes' or `no'.
2333 dnl
2334 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2335   AC_MSG_CHECKING([for additional debug build])
2336   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2337   AC_MSG_RESULT($enable_libstdcxx_debug)
2338   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2339 ])
2340
2341
2342 dnl
2343 dnl Check for explicit debug flags.
2344 dnl
2345 dnl --enable-libstdcxx-debug-flags='-O1'
2346 dnl is a general method for passing flags to be used when
2347 dnl building debug libraries with --enable-debug.
2348 dnl
2349 dnl --disable-libstdcxx-debug-flags does nothing.
2350 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2351 dnl       If "default flags" is an empty string, the effect is the same
2352 dnl       as --disable or --enable=no.
2353 dnl
2354 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2355   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2356     [pass compiler FLAGS when building debug library],
2357     [case "x$enable_libstdcxx_debug_flags" in
2358       xno | x)    enable_libstdcxx_debug_flags= ;;
2359       x-*)        ;;
2360       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2361      esac])
2362
2363   # Option parsed, now set things appropriately
2364   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2365   AC_SUBST(DEBUG_FLAGS)
2366
2367   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2368 ])
2369
2370
2371 dnl
2372 dnl Check if the user only wants a freestanding library implementation.
2373 dnl
2374 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2375 dnl installing only the headers required by [17.4.1.3] and the language
2376 dnl support library.  More than that will be built (to keep the Makefiles
2377 dnl conveniently clean), but not installed.
2378 dnl
2379 dnl Sets:
2380 dnl  is_hosted  (yes/no)
2381 dnl
2382 dnl Defines:
2383 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2384 dnl
2385 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2386   AC_ARG_ENABLE([hosted-libstdcxx],
2387     AC_HELP_STRING([--disable-hosted-libstdcxx],
2388                    [only build freestanding C++ runtime support]),,
2389     [case "$host" in
2390         arm*-*-symbianelf*)
2391             enable_hosted_libstdcxx=no
2392             ;;
2393         *)
2394             enable_hosted_libstdcxx=yes
2395             ;;
2396      esac])
2397   if test "$enable_hosted_libstdcxx" = no; then
2398     AC_MSG_NOTICE([Only freestanding libraries will be built])
2399     is_hosted=no
2400     hosted_define=0
2401     enable_abi_check=no
2402     enable_libstdcxx_pch=no
2403   else
2404     is_hosted=yes
2405     hosted_define=1
2406   fi
2407   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2408   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2409     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2410 ])
2411
2412
2413 dnl
2414 dnl Check for template specializations for the 'long long' type.
2415 dnl The result determines only whether 'long long' I/O is enabled; things
2416 dnl like numeric_limits<> specializations are always available.
2417 dnl
2418 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2419 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2420 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2421 dnl       Where DEFAULT is either `yes' or `no'.
2422 dnl
2423 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2424   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2425   if test $enable_long_long = yes; then
2426     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2427               [Define if code specialized for long long should be used.])
2428   fi
2429   AC_MSG_CHECKING([for enabled long long specializations])
2430   AC_MSG_RESULT([$enable_long_long])
2431 ])
2432
2433
2434 dnl
2435 dnl Check for decimal floating point.
2436 dnl See:
2437 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2438 dnl
2439 dnl This checks to see if the host supports decimal floating point types.
2440 dnl
2441 dnl Defines:
2442 dnl  _GLIBCXX_USE_DECIMAL_FLOAT
2443 dnl
2444 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2445
2446   # Fake what AC_TRY_COMPILE does, without linking as this is
2447   # unnecessary for this test.
2448
2449     cat > conftest.$ac_ext << EOF
2450 [#]line __oline__ "configure"
2451 int main()
2452 {
2453   _Decimal32 d1;
2454   _Decimal64 d2;
2455   _Decimal128 d3;
2456   return 0;
2457 }
2458 EOF
2459
2460     AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2461     if AC_TRY_EVAL(ac_compile); then
2462       AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2463       [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2464       enable_dfp=yes
2465     else
2466       enable_dfp=no
2467     fi
2468     AC_MSG_RESULT($enable_dfp)
2469     rm -f conftest*
2470 ])
2471
2472 dnl
2473 dnl Check for GNU 128-bit integer and floating point types.
2474 dnl
2475 dnl Note: also checks that the types aren't standard types.
2476 dnl
2477 dnl Defines:
2478 dnl  _GLIBCXX_USE_INT128
2479 dnl  _GLIBCXX_USE_FLOAT128
2480 dnl
2481 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
2482
2483   AC_LANG_SAVE
2484   AC_LANG_CPLUSPLUS
2485
2486   # Fake what AC_TRY_COMPILE does, without linking as this is
2487   # unnecessary for this test.
2488
2489     cat > conftest.$ac_ext << EOF
2490 [#]line __oline__ "configure"
2491 template<typename T1, typename T2>
2492   struct same
2493   { typedef T2 type; };
2494
2495 template<typename T>
2496   struct same<T, T>;
2497
2498 int main()
2499 {
2500   typename same<long, __int128>::type                i1;
2501   typename same<long long, __int128>::type           i2;
2502 }
2503 EOF
2504
2505     AC_MSG_CHECKING([for __int128])
2506     if AC_TRY_EVAL(ac_compile); then
2507       AC_DEFINE(_GLIBCXX_USE_INT128, 1,
2508       [Define if __int128 is supported on this host.])
2509       enable_int128=yes
2510     else
2511       enable_int128=no
2512     fi
2513     AC_MSG_RESULT($enable_int128)
2514     rm -f conftest*
2515
2516     cat > conftest.$ac_ext << EOF
2517 [#]line __oline__ "configure"
2518 template<typename T1, typename T2>
2519   struct same
2520   { typedef T2 type; };
2521
2522 template<typename T>
2523   struct same<T, T>;
2524
2525 int main()
2526 {
2527   typename same<double, __float128>::type      f1;
2528   typename same<long double, __float128>::type f2;
2529 }
2530 EOF
2531
2532     AC_MSG_CHECKING([for __float128])
2533     if AC_TRY_EVAL(ac_compile); then
2534       AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
2535       [Define if __float128 is supported on this host.])
2536       enable_float128=yes
2537     else
2538       enable_float128=no
2539     fi
2540     AC_MSG_RESULT($enable_float128)
2541     rm -f conftest*
2542
2543   AC_LANG_RESTORE
2544 ])
2545
2546 dnl
2547 dnl Check for template specializations for the 'wchar_t' type.
2548 dnl
2549 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2550 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2551 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2552 dnl       Where DEFAULT is either `yes' or `no'.
2553 dnl
2554 dnl Necessary support must also be present.
2555 dnl
2556 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2557   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2558
2559   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2560   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2561   AC_MSG_CHECKING([for mbstate_t])
2562   AC_TRY_COMPILE([#include <wchar.h>],
2563   [mbstate_t teststate;],
2564   have_mbstate_t=yes, have_mbstate_t=no)
2565   AC_MSG_RESULT($have_mbstate_t)
2566   if test x"$have_mbstate_t" = xyes; then
2567     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2568   fi
2569
2570   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2571   # ac_has_wchar_h.
2572   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2573
2574   if test x"$enable_wchar_t" = x"yes"; then
2575
2576     AC_LANG_SAVE
2577     AC_LANG_CPLUSPLUS
2578
2579     if test x"$ac_has_wchar_h" = xyes &&
2580        test x"$ac_has_wctype_h" = xyes; then
2581       AC_TRY_COMPILE([#include <wchar.h>
2582                       #include <stddef.h>
2583                       wint_t i;
2584                       long l = WEOF;
2585                       long j = WCHAR_MIN;
2586                       long k = WCHAR_MAX;
2587                       namespace test
2588                       {
2589                         using ::btowc;
2590                         using ::fgetwc;
2591                         using ::fgetws;
2592                         using ::fputwc;
2593                         using ::fputws;
2594                         using ::fwide;
2595                         using ::fwprintf;
2596                         using ::fwscanf;
2597                         using ::getwc;
2598                         using ::getwchar;
2599                         using ::mbrlen;
2600                         using ::mbrtowc;
2601                         using ::mbsinit;
2602                         using ::mbsrtowcs;
2603                         using ::putwc;
2604                         using ::putwchar;
2605                         using ::swprintf;
2606                         using ::swscanf;
2607                         using ::ungetwc;
2608                         using ::vfwprintf;
2609                         using ::vswprintf;
2610                         using ::vwprintf;
2611                         using ::wcrtomb;
2612                         using ::wcscat;
2613                         using ::wcschr;
2614                         using ::wcscmp;
2615                         using ::wcscoll;
2616                         using ::wcscpy;
2617                         using ::wcscspn;
2618                         using ::wcsftime;
2619                         using ::wcslen;
2620                         using ::wcsncat;
2621                         using ::wcsncmp;
2622                         using ::wcsncpy;
2623                         using ::wcspbrk;
2624                         using ::wcsrchr;
2625                         using ::wcsrtombs;
2626                         using ::wcsspn;
2627                         using ::wcsstr;
2628                         using ::wcstod;
2629                         using ::wcstok;
2630                         using ::wcstol;
2631                         using ::wcstoul;
2632                         using ::wcsxfrm;
2633                         using ::wctob;
2634                         using ::wmemchr;
2635                         using ::wmemcmp;
2636                         using ::wmemcpy;
2637                         using ::wmemmove;
2638                         using ::wmemset;
2639                         using ::wprintf;
2640                         using ::wscanf;
2641                       }
2642                      ],[],[], [enable_wchar_t=no])
2643     else
2644       enable_wchar_t=no
2645     fi
2646
2647     AC_LANG_RESTORE
2648   fi
2649
2650   if test x"$enable_wchar_t" = x"yes"; then
2651     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2652               [Define if code specialized for wchar_t should be used.])
2653   fi
2654
2655   AC_MSG_CHECKING([for enabled wchar_t specializations])
2656   AC_MSG_RESULT([$enable_wchar_t])
2657 ])
2658
2659
2660 dnl
2661 dnl Check to see if building and using a C++ precompiled header can be done.
2662 dnl
2663 dnl --enable-libstdcxx-pch=yes
2664 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2665 dnl may work, after some light-hearted attempts to puzzle out compiler
2666 dnl support, flip bits on in include/Makefile.am
2667 dnl
2668 dnl --disable-libstdcxx-pch
2669 dnl turns off attempts to use or build stdc++.h.gch.
2670 dnl
2671 dnl Substs:
2672 dnl  glibcxx_PCHFLAGS
2673 dnl
2674 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2675   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2676   if test $enable_libstdcxx_pch = yes; then
2677     AC_CACHE_CHECK([for compiler with PCH support],
2678       [glibcxx_cv_prog_CXX_pch],
2679       [ac_save_CXXFLAGS="$CXXFLAGS"
2680        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2681        AC_LANG_SAVE
2682        AC_LANG_CPLUSPLUS
2683        echo '#include <math.h>' > conftest.h
2684        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2685                           -o conftest.h.gch 1>&5 2>&1 &&
2686                 echo '#error "pch failed"' > conftest.h &&
2687           echo '#include "conftest.h"' > conftest.cc &&
2688                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2689        then
2690          glibcxx_cv_prog_CXX_pch=yes
2691        else
2692          glibcxx_cv_prog_CXX_pch=no
2693        fi
2694        rm -f conftest*
2695        CXXFLAGS=$ac_save_CXXFLAGS
2696        AC_LANG_RESTORE
2697       ])
2698     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2699   fi
2700
2701   AC_MSG_CHECKING([for enabled PCH])
2702   AC_MSG_RESULT([$enable_libstdcxx_pch])
2703
2704   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2705   if test $enable_libstdcxx_pch = yes; then
2706     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2707   else
2708     glibcxx_PCHFLAGS=""
2709   fi
2710   AC_SUBST(glibcxx_PCHFLAGS)
2711 ])
2712
2713
2714 dnl
2715 dnl Check for atomic builtins.
2716 dnl See:
2717 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
2718 dnl
2719 dnl This checks to see if the host supports the compiler-generated
2720 dnl builtins for atomic operations for various integral sizes. Note, this
2721 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2722 dnl that are used should be checked.
2723 dnl
2724 dnl Note:
2725 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2726 dnl
2727 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2728   AC_LANG_SAVE
2729   AC_LANG_CPLUSPLUS
2730   old_CXXFLAGS="$CXXFLAGS"
2731
2732   # Do link tests if possible, instead asm tests, limited to some platforms
2733   # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2734   # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2735   atomic_builtins_link_tests=no
2736   if test x$gcc_no_link != xyes; then
2737     # Can do link tests. Limit to some tested platforms
2738     case "$host" in
2739       *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2740         atomic_builtins_link_tests=yes
2741         ;;
2742     esac
2743   fi
2744
2745   if test x$atomic_builtins_link_tests = xyes; then
2746
2747   # Do link tests.
2748
2749   CXXFLAGS="$CXXFLAGS -fno-exceptions"
2750
2751   AC_MSG_CHECKING([for atomic builtins for bool])
2752   AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2753     AC_TRY_LINK(
2754       [ ],
2755       [typedef bool atomic_type;
2756        atomic_type c1;
2757        atomic_type c2;
2758        atomic_type c3(0);
2759        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2760        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2761                                    __ATOMIC_RELAXED);
2762        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2763        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2764       ],
2765       [glibcxx_cv_atomic_bool=yes],
2766       [glibcxx_cv_atomic_bool=no])
2767   ])
2768   AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2769
2770   AC_MSG_CHECKING([for atomic builtins for short])
2771   AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2772     AC_TRY_LINK(
2773       [ ],
2774       [typedef short atomic_type;
2775        atomic_type c1;
2776        atomic_type c2;
2777        atomic_type c3(0);
2778        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2779        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2780                                    __ATOMIC_RELAXED);
2781        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2782        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2783       ],
2784       [glibcxx_cv_atomic_short=yes],
2785       [glibcxx_cv_atomic_short=no])
2786   ])
2787   AC_MSG_RESULT($glibcxx_cv_atomic_short)
2788
2789   AC_MSG_CHECKING([for atomic builtins for int])
2790   AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2791     AC_TRY_LINK(
2792       [ ],
2793       [typedef int atomic_type;
2794        atomic_type c1;
2795        atomic_type c2;
2796        atomic_type c3(0);
2797        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2798        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2799                                    __ATOMIC_RELAXED);
2800        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2801        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2802       ],
2803       [glibcxx_cv_atomic_int=yes],
2804       [glibcxx_cv_atomic_int=no])
2805   ])
2806   AC_MSG_RESULT($glibcxx_cv_atomic_int)
2807
2808   AC_MSG_CHECKING([for atomic builtins for long long])
2809   AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2810     AC_TRY_LINK(
2811       [ ],
2812       [typedef long long atomic_type;
2813        atomic_type c1;
2814        atomic_type c2;
2815        atomic_type c3(0);
2816        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2817        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2818                                    __ATOMIC_RELAXED);
2819        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2820        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2821       ],
2822       [glibcxx_cv_atomic_long_long=yes],
2823       [glibcxx_cv_atomic_long_long=no])
2824   ])
2825   AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2826
2827   else
2828
2829   # Do asm tests.
2830
2831   # Compile unoptimized.
2832   CXXFLAGS='-O0 -S'
2833
2834   # Fake what AC_TRY_COMPILE does.
2835
2836     cat > conftest.$ac_ext << EOF
2837 [#]line __oline__ "configure"
2838 int main()
2839 {
2840   typedef bool atomic_type;
2841   atomic_type c1;
2842   atomic_type c2;
2843   atomic_type c3(0);
2844   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2845   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2846                               __ATOMIC_RELAXED);
2847   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2848   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2849
2850   return 0;
2851 }
2852 EOF
2853
2854     AC_MSG_CHECKING([for atomic builtins for bool])
2855     if AC_TRY_EVAL(ac_compile); then
2856       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2857         glibcxx_cv_atomic_bool=no
2858       else
2859         glibcxx_cv_atomic_bool=yes
2860       fi
2861     fi
2862     AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2863     rm -f conftest*
2864
2865     cat > conftest.$ac_ext << EOF
2866 [#]line __oline__ "configure"
2867 int main()
2868 {
2869   typedef short atomic_type;
2870   atomic_type c1;
2871   atomic_type c2;
2872   atomic_type c3(0);
2873   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2874   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2875                               __ATOMIC_RELAXED);
2876   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2877   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2878
2879   return 0;
2880 }
2881 EOF
2882
2883     AC_MSG_CHECKING([for atomic builtins for short])
2884     if AC_TRY_EVAL(ac_compile); then
2885       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2886         glibcxx_cv_atomic_short=no
2887       else
2888         glibcxx_cv_atomic_short=yes
2889       fi
2890     fi
2891     AC_MSG_RESULT($glibcxx_cv_atomic_short)
2892     rm -f conftest*
2893
2894     cat > conftest.$ac_ext << EOF
2895 [#]line __oline__ "configure"
2896 int main()
2897 {
2898   // NB: _Atomic_word not necessarily int.
2899   typedef int atomic_type;
2900   atomic_type c1;
2901   atomic_type c2;
2902   atomic_type c3(0);
2903   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2904   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2905                               __ATOMIC_RELAXED);
2906   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2907   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2908
2909   return 0;
2910 }
2911 EOF
2912
2913     AC_MSG_CHECKING([for atomic builtins for int])
2914     if AC_TRY_EVAL(ac_compile); then
2915       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2916         glibcxx_cv_atomic_int=no
2917       else
2918         glibcxx_cv_atomic_int=yes
2919       fi
2920     fi
2921     AC_MSG_RESULT($glibcxx_cv_atomic_int)
2922     rm -f conftest*
2923
2924     cat > conftest.$ac_ext << EOF
2925 [#]line __oline__ "configure"
2926 int main()
2927 {
2928   typedef long long atomic_type;
2929   atomic_type c1;
2930   atomic_type c2;
2931   atomic_type c3(0);
2932   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2933   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2934                               __ATOMIC_RELAXED);
2935   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2936   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2937
2938   return 0;
2939 }
2940 EOF
2941
2942     AC_MSG_CHECKING([for atomic builtins for long long])
2943     if AC_TRY_EVAL(ac_compile); then
2944       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2945         glibcxx_cv_atomic_long_long=no
2946       else
2947         glibcxx_cv_atomic_long_long=yes
2948       fi
2949     fi
2950     AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2951     rm -f conftest*
2952
2953   fi
2954
2955   CXXFLAGS="$old_CXXFLAGS"
2956   AC_LANG_RESTORE
2957
2958   # Set atomicity_dir to builtins if all but the long long test above passes.
2959   if test $glibcxx_cv_atomic_bool = yes \
2960      && test $glibcxx_cv_atomic_short = yes \
2961      && test $glibcxx_cv_atomic_int = yes; then
2962     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2963     [Define if the compiler supports C++11 atomics.])
2964     atomicity_dir=cpu/generic/atomicity_builtins
2965   fi
2966
2967   # If still generic, set to mutex.
2968   if test $atomicity_dir = "cpu/generic" ; then
2969     atomicity_dir=cpu/generic/atomicity_mutex
2970     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2971       if test "x$target_thread_file" = xsingle; then
2972         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2973         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2974       else
2975         AC_MSG_WARN([They will be faked using a mutex.])
2976         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2977       fi
2978   fi
2979
2980 ])
2981
2982
2983 dnl
2984 dnl Check for exception handling support.  If an explicit enable/disable
2985 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2986 dnl target may or may not support call frame exceptions.
2987 dnl
2988 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2989 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2990 dnl Neither one forces an attempt at detection.
2991 dnl
2992 dnl Defines:
2993 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2994 dnl
2995 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2996   AC_MSG_CHECKING([for exception model to use])
2997   AC_LANG_SAVE
2998   AC_LANG_CPLUSPLUS
2999   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
3000     [force use of builtin_setjmp for exceptions],
3001     [permit yes|no|auto])
3002
3003   if test $enable_sjlj_exceptions = auto; then
3004     # Botheration.  Now we've got to detect the exception model.  Link tests
3005     # against libgcc.a are problematic since we've not been given proper -L
3006     # bits for single-tree newlib and libgloss.
3007     #
3008     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
3009     cat > conftest.$ac_ext << EOF
3010 [#]line __oline__ "configure"
3011 struct S { ~S(); };
3012 void bar();
3013 void foo()
3014 {
3015   S s;
3016   bar();
3017 }
3018 EOF
3019     old_CXXFLAGS="$CXXFLAGS"
3020     CXXFLAGS=-S
3021     if AC_TRY_EVAL(ac_compile); then
3022       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
3023         enable_sjlj_exceptions=yes
3024       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
3025         enable_sjlj_exceptions=no
3026       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
3027         enable_sjlj_exceptions=no
3028       fi
3029     fi
3030     CXXFLAGS="$old_CXXFLAGS"
3031     rm -f conftest*
3032   fi
3033
3034   # This is a tad weird, for hysterical raisins.  We have to map
3035   # enable/disable to two different models.
3036   case $enable_sjlj_exceptions in
3037     yes)
3038       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
3039         [Define if the compiler is configured for setjmp/longjmp exceptions.])
3040       ac_exception_model_name=sjlj
3041       ;;
3042     no)
3043       ac_exception_model_name="call frame"
3044       ;;
3045     *)
3046       AC_MSG_ERROR([unable to detect exception model])
3047       ;;
3048   esac
3049  AC_LANG_RESTORE
3050  AC_MSG_RESULT($ac_exception_model_name)
3051 ])
3052
3053
3054 dnl
3055 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3056 dnl
3057 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3058 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3059 dnl  +  Usage:  GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3060 dnl       Where DEFAULT is 'yes'.
3061 dnl
3062 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3063 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3064
3065 if test x$enable_libstdcxx_visibility = xyes ; then
3066   dnl all hail libgfortran
3067   dnl Check whether the target supports hidden visibility.
3068   AC_CACHE_CHECK([whether the target supports hidden visibility],
3069                  glibcxx_cv_have_attribute_visibility, [
3070   save_CFLAGS="$CFLAGS"
3071   CFLAGS="$CFLAGS -Werror"
3072   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3073                  [], glibcxx_cv_have_attribute_visibility=yes,
3074                  glibcxx_cv_have_attribute_visibility=no)
3075   CFLAGS="$save_CFLAGS"])
3076   if test $glibcxx_cv_have_attribute_visibility = no; then
3077     enable_libstdcxx_visibility=no
3078   fi
3079 fi
3080
3081 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3082 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3083 ])
3084
3085
3086 dnl
3087 dnl Add version tags to symbols in shared library (or not), additionally
3088 dnl marking other symbols as private/local (or not).
3089 dnl
3090 dnl Sets libtool_VERSION, and determines shared library SONAME.
3091 dnl
3092 dnl  This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3093 dnl
3094 dnl --enable-symvers=style adds a version script to the linker call when
3095 dnl       creating the shared library.  The choice of version script is
3096 dnl       controlled by 'style'.
3097 dnl --disable-symvers does not.
3098 dnl
3099 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3100 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
3101 dnl       choose a default style based on linker characteristics.  Passing
3102 dnl       'no' disables versioning.
3103 dnl
3104 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3105
3106 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3107   [enables symbol versioning of the shared library],
3108   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3109
3110 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3111 # don't know enough about $LD to do tricks...
3112 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3113 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3114 # with extern "C++" in version scripts.
3115 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3116
3117 # Turn a 'yes' into a suitable default.
3118 if test x$enable_symvers = xyes ; then
3119   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3120     enable_symvers=no
3121   else
3122     if test $with_gnu_ld = yes ; then
3123       case ${target_os} in
3124         hpux*)
3125           enable_symvers=no ;;
3126         *)
3127           enable_symvers=gnu ;;
3128       esac
3129     else
3130       case ${target_os} in
3131         darwin*)
3132           enable_symvers=darwin ;;
3133         # Sun symbol versioning exists since Solaris 2.5.
3134         solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3135           # make_sunver.pl needs GNU c++filt to support extern "C++" in
3136           # version scripts, so disable symbol versioning if none can be
3137           # found.
3138           if test -z "$ac_cv_path_CXXFILT"; then
3139             AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3140             AC_MSG_WARN([=== no GNU c++filt could  be found.])
3141             AC_MSG_WARN([=== Symbol versioning will be disabled.])
3142             enable_symvers=no
3143           else
3144             enable_symvers=sun
3145           fi
3146           ;;
3147         *)
3148           enable_symvers=no ;;
3149       esac
3150     fi
3151   fi
3152 fi
3153
3154 # Check to see if 'darwin' or 'darwin-export' can win.
3155 if test x$enable_symvers = xdarwin-export ; then
3156     enable_symvers=darwin
3157 fi
3158
3159 # Check if 'sun' was requested on non-Solaris 2 platforms.
3160 if test x$enable_symvers = xsun ; then
3161   case ${target_os} in
3162     solaris2*)
3163       # All fine.
3164       ;;
3165     *)
3166       # Unlikely to work.
3167       AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3168       AC_MSG_WARN([=== you are not targetting Solaris 2.])
3169       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3170       enable_symvers=no
3171       ;;
3172   esac
3173 fi
3174
3175 # Check to see if 'gnu' can win.
3176 if test $enable_symvers = gnu ||
3177   test $enable_symvers = gnu-versioned-namespace ||
3178   test $enable_symvers = sun; then
3179   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3180   AC_MSG_CHECKING([for shared libgcc])
3181   ac_save_CFLAGS="$CFLAGS"
3182   CFLAGS=' -lgcc_s'
3183   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3184   CFLAGS="$ac_save_CFLAGS"
3185   if test $glibcxx_shared_libgcc = no; then
3186     cat > conftest.c <<EOF
3187 int main (void) { return 0; }
3188 EOF
3189 changequote(,)dnl
3190     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3191                              -shared -shared-libgcc -o conftest.so \
3192                              conftest.c -v 2>&1 >/dev/null \
3193                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3194 changequote([,])dnl
3195     rm -f conftest.c conftest.so
3196     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3197       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3198       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3199       CFLAGS="$ac_save_CFLAGS"
3200     fi
3201   fi
3202   AC_MSG_RESULT($glibcxx_shared_libgcc)
3203
3204   # For GNU ld, we need at least this version.  The format is described in
3205   # GLIBCXX_CHECK_LINKER_FEATURES above.
3206   glibcxx_min_gnu_ld_version=21400
3207
3208   # If no shared libgcc, can't win.
3209   if test $glibcxx_shared_libgcc != yes; then
3210       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3211       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3212       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3213       enable_symvers=no
3214   elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3215     : All interesting versions of Sun ld support sun style symbol versioning.
3216   elif test $with_gnu_ld != yes ; then
3217     # just fail for now
3218     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3219     AC_MSG_WARN([=== you are not using the GNU linker.])
3220     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3221     enable_symvers=no
3222   elif test $glibcxx_ld_is_gold = yes ; then
3223     : All versions of gold support symbol versioning.
3224   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3225     # The right tools, the right setup, but too old.  Fallbacks?
3226     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3227     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3228     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3229     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3230     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3231     enable_symvers=no
3232   fi
3233 fi
3234
3235 # For libtool versioning info, format is CURRENT:REVISION:AGE
3236 libtool_VERSION=6:17:0
3237
3238 # Everything parsed; figure out what files and settings to use.
3239 case $enable_symvers in
3240   no)
3241     SYMVER_FILE=config/abi/pre/none.ver
3242     ;;
3243   gnu)
3244     SYMVER_FILE=config/abi/pre/gnu.ver
3245     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3246               [Define to use GNU versioning in the shared library.])
3247     ;;
3248   gnu-versioned-namespace)
3249     libtool_VERSION=7:0:0
3250     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3251     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3252               [Define to use GNU namespace versioning in the shared library.])
3253     ;;
3254   darwin)
3255     SYMVER_FILE=config/abi/pre/gnu.ver
3256     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3257               [Define to use darwin versioning in the shared library.])
3258     ;;
3259   sun)
3260     SYMVER_FILE=config/abi/pre/gnu.ver
3261     AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3262               [Define to use Sun versioning in the shared library.])
3263     ;;
3264 esac
3265
3266 if test x$enable_symvers != xno ; then
3267   AC_DEFINE(_GLIBCXX_SYMVER, 1,
3268          [Define to use symbol versioning in the shared library.])
3269 fi
3270
3271 AC_CACHE_CHECK([whether the target supports .symver directive],
3272                glibcxx_cv_have_as_symver_directive, [
3273   AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3274                  [], glibcxx_cv_have_as_symver_directive=yes,
3275                  glibcxx_cv_have_as_symver_directive=no)])
3276 if test $glibcxx_cv_have_as_symver_directive = yes; then
3277   AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3278     [Define to 1 if the target assembler supports .symver directive.])
3279 fi
3280
3281 AC_SUBST(SYMVER_FILE)
3282 AC_SUBST(port_specific_symbol_files)
3283 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3284 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3285 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3286 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3287 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3288 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3289
3290 if test $enable_symvers != no ; then
3291    case ${target_os} in
3292      # The Solaris 2 runtime linker doesn't support the GNU extension of
3293      # binding the same symbol to different versions
3294      solaris2*)
3295        ;;
3296      # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3297      *)
3298        AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3299          [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3300        ;;
3301     esac
3302 fi
3303
3304 # Now, set up compatibility support, if any.
3305 # In addition, need this to deal with std::size_t mangling in
3306 # src/compatibility.cc.  In a perfect world, could use
3307 # typeid(std::size_t).name()[0] to do direct substitution.
3308 AC_MSG_CHECKING([for size_t as unsigned int])
3309 ac_save_CFLAGS="$CFLAGS"
3310 CFLAGS="-Werror"
3311 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3312                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3313 CFLAGS=$ac_save_CFLAGS
3314 if test "$glibcxx_size_t_is_i" = yes; then
3315   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3316 fi
3317 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3318
3319 AC_MSG_CHECKING([for ptrdiff_t as int])
3320 ac_save_CFLAGS="$CFLAGS"
3321 CFLAGS="-Werror"
3322 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3323                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3324 CFLAGS=$ac_save_CFLAGS
3325 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3326   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3327 fi
3328 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3329 ])
3330
3331
3332 dnl
3333 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3334 dnl We must stage the required headers so that they will be installed
3335 dnl with the library (unlike libgcc, the STL implementation is provided
3336 dnl solely within headers).  Since we must not inject random user-space
3337 dnl macro names into user-provided C++ code, we first stage into <file>-in
3338 dnl and process to <file> with an output command.  The reason for a two-
3339 dnl stage process here is to correctly handle $srcdir!=$objdir without
3340 dnl having to write complex code (the sed commands to clean the macro
3341 dnl namespace are complex and fragile enough as it is).  We must also
3342 dnl add a relative path so that -I- is supported properly.
3343 dnl
3344 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3345   AC_MSG_CHECKING([for thread model used by GCC])
3346   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3347   AC_MSG_RESULT([$target_thread_file])
3348 ])
3349
3350
3351 dnl
3352 dnl Check if gthread implementation defines the types and functions
3353 dnl required by the c++0x thread library.  Conforming gthread
3354 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3355 dnl
3356 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3357 dnl
3358 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3359   GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3360
3361   if test x$enable_libstdcxx_threads = xauto || 
3362      test x$enable_libstdcxx_threads = xyes; then
3363
3364   AC_LANG_SAVE
3365   AC_LANG_CPLUSPLUS
3366
3367   ac_save_CXXFLAGS="$CXXFLAGS"
3368   CXXFLAGS="$CXXFLAGS -fno-exceptions \
3369         -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3370
3371   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3372   case $target_thread_file in
3373     posix)
3374       CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3375   esac
3376
3377   AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3378
3379   AC_TRY_COMPILE([#include <unistd.h>],
3380     [
3381       // In case of POSIX threads check _POSIX_TIMEOUTS.
3382       #if (defined(_PTHREADS) \
3383           && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3384       #error
3385       #endif
3386     ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3387
3388   AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3389                      [Define to 1 if mutex_timedlock is available.])
3390
3391   if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3392   else res_mutex_timedlock=no ; fi
3393   AC_MSG_RESULT([$res_mutex_timedlock])
3394
3395   AC_MSG_CHECKING([for gthreads library])
3396
3397   AC_TRY_COMPILE([#include "gthr.h"],
3398     [
3399       #ifndef __GTHREADS_CXX0X
3400       #error
3401       #endif
3402     ], [case $target_os in
3403           # gthreads support breaks symbol versioning on Solaris 8/9 (PR
3404           # libstdc++/52189).
3405           solaris2.[[89]]*)
3406             if test x$enable_symvers = xno; then
3407               ac_has_gthreads=yes
3408             elif test x$enable_libstdcxx_threads = xyes; then
3409               AC_MSG_WARN([You have requested C++11 threads support, but])
3410               AC_MSG_WARN([this breaks symbol versioning.])
3411               ac_has_gthreads=yes
3412             else
3413               ac_has_gthreads=no
3414             fi
3415             ;;
3416           *)
3417             ac_has_gthreads=yes
3418             ;;
3419         esac],
3420        [ac_has_gthreads=no])
3421   else
3422     ac_has_gthreads=no
3423   fi
3424
3425   AC_MSG_RESULT([$ac_has_gthreads])