OSDN Git Service

Daily bump.
[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 dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX
1136 dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test
1137 dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in
1138 dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD.
1139 dnl
1140 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1141
1142   AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1143   GLIBCXX_ENABLE(libstdcxx-time,$1,[[[=KIND]]],
1144     [use KIND for check type],
1145     [permit yes|no|rt])
1146
1147   AC_LANG_SAVE
1148   AC_LANG_CPLUSPLUS
1149   ac_save_CXXFLAGS="$CXXFLAGS"
1150   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1151   ac_save_LIBS="$LIBS"
1152
1153   ac_has_clock_monotonic=no
1154   ac_has_clock_realtime=no
1155   AC_MSG_RESULT($enable_libstdcxx_time)
1156
1157   if test x"$enable_libstdcxx_time" != x"no"; then
1158
1159     if test x"$enable_libstdcxx_time" = x"rt"; then
1160       AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1161       AC_SEARCH_LIBS(nanosleep, [rt posix4])
1162     else
1163       AC_SEARCH_LIBS(clock_gettime, [posix4])
1164       AC_SEARCH_LIBS(nanosleep, [posix4])
1165     fi
1166
1167     case "$ac_cv_search_clock_gettime" in
1168       -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1169       ;;
1170     esac
1171     case "$ac_cv_search_nanosleep" in
1172       -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1173       ;;
1174     esac
1175
1176     AC_SEARCH_LIBS(sched_yield, [rt posix4])
1177
1178     case "$ac_cv_search_sched_yield" in
1179       -lposix4*)
1180       GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1181       AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1182                 [ Defined if sched_yield is available. ])
1183       ;;
1184       -lrt*)
1185       if test x"$enable_libstdcxx_time" = x"rt"; then
1186         GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1187         AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1188                   [ Defined if sched_yield is available. ])
1189       fi
1190       ;;
1191       *)
1192       AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1193                 [ Defined if sched_yield is available. ])
1194       ;;
1195     esac
1196
1197     AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1198
1199     if test x"$ac_has_unistd_h" = x"yes"; then
1200       AC_MSG_CHECKING([for monotonic clock])
1201       AC_TRY_LINK(
1202         [#include <unistd.h>
1203          #include <time.h>
1204         ],
1205         [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1206           timespec tp;
1207          #endif
1208           clock_gettime(CLOCK_MONOTONIC, &tp);
1209         ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1210
1211       AC_MSG_RESULT($ac_has_clock_monotonic)
1212
1213       AC_MSG_CHECKING([for realtime clock])
1214       AC_TRY_LINK(
1215         [#include <unistd.h>
1216          #include <time.h>
1217         ],
1218         [#if _POSIX_TIMERS > 0
1219           timespec tp;
1220          #endif
1221           clock_gettime(CLOCK_REALTIME, &tp);
1222         ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1223
1224       AC_MSG_RESULT($ac_has_clock_realtime)
1225
1226       AC_MSG_CHECKING([for nanosleep])
1227       AC_TRY_LINK(
1228         [#include <unistd.h>
1229          #include <time.h>
1230         ],
1231         [#if _POSIX_TIMERS > 0
1232           timespec tp;
1233          #endif
1234           nanosleep(&tp, 0);
1235         ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1236
1237       AC_MSG_RESULT($ac_has_nanosleep)
1238     fi
1239   fi
1240
1241   if test x"$ac_has_clock_monotonic" = x"yes"; then
1242     AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1243       [ Defined if clock_gettime has monotonic clock support. ])
1244   fi
1245
1246   if test x"$ac_has_clock_realtime" = x"yes"; then
1247     AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1248       [ Defined if clock_gettime has realtime clock support. ])
1249   fi
1250
1251   if test x"$ac_has_nanosleep" = x"yes"; then
1252     AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1253       [ Defined if nanosleep is available. ])
1254   fi
1255
1256   AC_SUBST(GLIBCXX_LIBS)
1257
1258   CXXFLAGS="$ac_save_CXXFLAGS"
1259   LIBS="$ac_save_LIBS"
1260   AC_LANG_RESTORE
1261 ])
1262
1263 dnl
1264 dnl Check for gettimeofday, used in the implementation of 20.8.5
1265 dnl [time.clock] in the current C++0x working draft.
1266 dnl
1267 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1268
1269   AC_MSG_CHECKING([for gettimeofday])
1270
1271   AC_LANG_SAVE
1272   AC_LANG_CPLUSPLUS
1273   ac_save_CXXFLAGS="$CXXFLAGS"
1274   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1275
1276   ac_has_gettimeofday=no;
1277   AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1278   if test x"$ac_has_sys_time_h" = x"yes"; then
1279     AC_MSG_CHECKING([for gettimeofday])
1280     GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1281       [timeval tv; gettimeofday(&tv, 0);],
1282       [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1283
1284     AC_MSG_RESULT($ac_has_gettimeofday)
1285   fi
1286
1287   if test x"$ac_has_gettimeofday" = x"yes"; then
1288     AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1289       [ Defined if gettimeofday is available. ])
1290   fi
1291
1292   CXXFLAGS="$ac_save_CXXFLAGS"
1293   AC_LANG_RESTORE
1294 ])
1295
1296 dnl
1297 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1298 dnl facilities in Chapter 8, "C compatibility".
1299 dnl
1300 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1301
1302   AC_LANG_SAVE
1303   AC_LANG_CPLUSPLUS
1304
1305   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1306   # undefined and fake C99 facilities may be spuriously enabled.
1307   ac_save_CXXFLAGS="$CXXFLAGS"
1308   CXXFLAGS="$CXXFLAGS -std=c++98"
1309
1310   # Check for the existence of <complex.h> complex math functions used
1311   # by tr1/complex.
1312   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1313   ac_c99_complex_tr1=no;
1314   if test x"$ac_has_complex_h" = x"yes"; then
1315     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1316     AC_TRY_COMPILE([#include <complex.h>],
1317                    [typedef __complex__ float float_type; float_type tmpf;
1318                     cacosf(tmpf);
1319                     casinf(tmpf);
1320                     catanf(tmpf);
1321                     cacoshf(tmpf);
1322                     casinhf(tmpf);
1323                     catanhf(tmpf);
1324                     typedef __complex__ double double_type; double_type tmpd;
1325                     cacos(tmpd);
1326                     casin(tmpd);
1327                     catan(tmpd);
1328                     cacosh(tmpd);
1329                     casinh(tmpd);
1330                     catanh(tmpd);
1331                     typedef __complex__ long double ld_type; ld_type tmpld;
1332                     cacosl(tmpld);
1333                     casinl(tmpld);
1334                     catanl(tmpld);
1335                     cacoshl(tmpld);
1336                     casinhl(tmpld);
1337                     catanhl(tmpld);
1338                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1339   fi
1340   AC_MSG_RESULT($ac_c99_complex_tr1)
1341   if test x"$ac_c99_complex_tr1" = x"yes"; then
1342     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1343               [Define if C99 functions in <complex.h> should be used in
1344               <tr1/complex>. Using compiler builtins for these functions
1345               requires corresponding C99 library functions to be present.])
1346   fi
1347
1348   # Check for the existence of <ctype.h> functions.
1349   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1350   AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1351   AC_TRY_COMPILE([#include <ctype.h>],
1352                  [int ch;
1353                   int ret;
1354                   ret = isblank(ch);
1355                  ],[glibcxx_cv_c99_ctype_tr1=yes],
1356                    [glibcxx_cv_c99_ctype_tr1=no])
1357   ])
1358   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1359   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1360     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1361               [Define if C99 functions in <ctype.h> should be imported in
1362               <tr1/cctype> in namespace std::tr1.])
1363   fi
1364
1365   # Check for the existence of <fenv.h> functions.
1366   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1367   ac_c99_fenv_tr1=no;
1368   if test x"$ac_has_fenv_h" = x"yes"; then
1369     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1370     AC_TRY_COMPILE([#include <fenv.h>],
1371                    [int except, mode;
1372                     fexcept_t* pflag;
1373                     fenv_t* penv;
1374                     int ret;
1375                     ret = feclearexcept(except);
1376                     ret = fegetexceptflag(pflag, except);
1377                     ret = feraiseexcept(except);
1378                     ret = fesetexceptflag(pflag, except);
1379                     ret = fetestexcept(except);
1380                     ret = fegetround();
1381                     ret = fesetround(mode);
1382                     ret = fegetenv(penv);
1383                     ret = feholdexcept(penv);
1384                     ret = fesetenv(penv);
1385                     ret = feupdateenv(penv);
1386                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1387   fi
1388   AC_MSG_RESULT($ac_c99_fenv_tr1)
1389   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1390     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1391               [Define if C99 functions in <fenv.h> should be imported in
1392               <tr1/cfenv> in namespace std::tr1.])
1393   fi
1394
1395   # Check for the existence of <stdint.h> types.
1396   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1397   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1398   AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1399                   #define __STDC_CONSTANT_MACROS
1400                   #include <stdint.h>],
1401                  [typedef int8_t          my_int8_t;
1402                   my_int8_t               i8 = INT8_MIN;
1403                   i8 = INT8_MAX;
1404                   typedef int16_t         my_int16_t;
1405                   my_int16_t              i16 = INT16_MIN;
1406                   i16 = INT16_MAX;
1407                   typedef int32_t         my_int32_t;
1408                   my_int32_t              i32 = INT32_MIN;
1409                   i32 = INT32_MAX;
1410                   typedef int64_t         my_int64_t;
1411                   my_int64_t              i64 = INT64_MIN;
1412                   i64 = INT64_MAX;
1413                   typedef int_fast8_t     my_int_fast8_t;
1414                   my_int_fast8_t          if8 = INT_FAST8_MIN;
1415                   if8 = INT_FAST8_MAX;
1416                   typedef int_fast16_t    my_int_fast16_t;
1417                   my_int_fast16_t         if16 = INT_FAST16_MIN;
1418                   if16 = INT_FAST16_MAX;
1419                   typedef int_fast32_t    my_int_fast32_t;
1420                   my_int_fast32_t         if32 = INT_FAST32_MIN;
1421                   if32 = INT_FAST32_MAX;
1422                   typedef int_fast64_t    my_int_fast64_t;
1423                   my_int_fast64_t         if64 = INT_FAST64_MIN;
1424                   if64 = INT_FAST64_MAX;
1425                   typedef int_least8_t    my_int_least8_t;
1426                   my_int_least8_t         il8 = INT_LEAST8_MIN;
1427                   il8 = INT_LEAST8_MAX;
1428                   typedef int_least16_t   my_int_least16_t;
1429                   my_int_least16_t        il16 = INT_LEAST16_MIN;
1430                   il16 = INT_LEAST16_MAX;
1431                   typedef int_least32_t   my_int_least32_t;
1432                   my_int_least32_t        il32 = INT_LEAST32_MIN;
1433                   il32 = INT_LEAST32_MAX;
1434                   typedef int_least64_t   my_int_least64_t;
1435                   my_int_least64_t        il64 = INT_LEAST64_MIN;
1436                   il64 = INT_LEAST64_MAX;
1437                   typedef intmax_t        my_intmax_t;
1438                   my_intmax_t             im = INTMAX_MAX;
1439                   im = INTMAX_MIN;
1440                   typedef intptr_t        my_intptr_t;
1441                   my_intptr_t             ip = INTPTR_MAX;
1442                   ip = INTPTR_MIN;
1443                   typedef uint8_t         my_uint8_t;
1444                   my_uint8_t              ui8 = UINT8_MAX;
1445                   ui8 = UINT8_MAX;
1446                   typedef uint16_t        my_uint16_t;
1447                   my_uint16_t             ui16 = UINT16_MAX;
1448                   ui16 = UINT16_MAX;
1449                   typedef uint32_t        my_uint32_t;
1450                   my_uint32_t             ui32 = UINT32_MAX;
1451                   ui32 = UINT32_MAX;
1452                   typedef uint64_t        my_uint64_t;
1453                   my_uint64_t             ui64 = UINT64_MAX;
1454                   ui64 = UINT64_MAX;
1455                   typedef uint_fast8_t    my_uint_fast8_t;
1456                   my_uint_fast8_t         uif8 = UINT_FAST8_MAX;
1457                   uif8 = UINT_FAST8_MAX;
1458                   typedef uint_fast16_t   my_uint_fast16_t;
1459                   my_uint_fast16_t        uif16 = UINT_FAST16_MAX;
1460                   uif16 = UINT_FAST16_MAX;
1461                   typedef uint_fast32_t   my_uint_fast32_t;
1462                   my_uint_fast32_t        uif32 = UINT_FAST32_MAX;
1463                   uif32 = UINT_FAST32_MAX;
1464                   typedef uint_fast64_t   my_uint_fast64_t;
1465                   my_uint_fast64_t        uif64 = UINT_FAST64_MAX;
1466                   uif64 = UINT_FAST64_MAX;
1467                   typedef uint_least8_t   my_uint_least8_t;
1468                   my_uint_least8_t        uil8 = UINT_LEAST8_MAX;
1469                   uil8 = UINT_LEAST8_MAX;
1470                   typedef uint_least16_t  my_uint_least16_t;
1471                   my_uint_least16_t       uil16 = UINT_LEAST16_MAX;
1472                   uil16 = UINT_LEAST16_MAX;
1473                   typedef uint_least32_t  my_uint_least32_t;
1474                   my_uint_least32_t       uil32 = UINT_LEAST32_MAX;
1475                   uil32 = UINT_LEAST32_MAX;
1476                   typedef uint_least64_t  my_uint_least64_t;
1477                   my_uint_least64_t       uil64 = UINT_LEAST64_MAX;
1478                   uil64 = UINT_LEAST64_MAX;
1479                   typedef uintmax_t       my_uintmax_t;
1480                   my_uintmax_t            uim = UINTMAX_MAX;
1481                   uim = UINTMAX_MAX;
1482                   typedef uintptr_t       my_uintptr_t;
1483                   my_uintptr_t            uip = UINTPTR_MAX;
1484                   uip = UINTPTR_MAX;
1485                  ],[glibcxx_cv_c99_stdint_tr1=yes],
1486                    [glibcxx_cv_c99_stdint_tr1=no])
1487   ])
1488   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1489   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1490     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1491               [Define if C99 types in <stdint.h> should be imported in
1492               <tr1/cstdint> in namespace std::tr1.])
1493   fi
1494
1495   # Check for the existence of <math.h> functions.
1496   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1497   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1498   AC_TRY_COMPILE([#include <math.h>],
1499                  [typedef double_t  my_double_t;
1500                   typedef float_t   my_float_t;
1501                   acosh(0.0);
1502                   acoshf(0.0f);
1503                   acoshl(0.0l);
1504                   asinh(0.0);
1505                   asinhf(0.0f);
1506                   asinhl(0.0l);
1507                   atanh(0.0);
1508                   atanhf(0.0f);
1509                   atanhl(0.0l);
1510                   cbrt(0.0);
1511                   cbrtf(0.0f);
1512                   cbrtl(0.0l);
1513                   copysign(0.0, 0.0);
1514                   copysignf(0.0f, 0.0f);
1515                   copysignl(0.0l, 0.0l);
1516                   erf(0.0);
1517                   erff(0.0f);
1518                   erfl(0.0l);
1519                   erfc(0.0);
1520                   erfcf(0.0f);
1521                   erfcl(0.0l);
1522                   exp2(0.0);
1523                   exp2f(0.0f);
1524                   exp2l(0.0l);
1525                   expm1(0.0);
1526                   expm1f(0.0f);
1527                   expm1l(0.0l);
1528                   fdim(0.0, 0.0);
1529                   fdimf(0.0f, 0.0f);
1530                   fdiml(0.0l, 0.0l);
1531                   fma(0.0, 0.0, 0.0);
1532                   fmaf(0.0f, 0.0f, 0.0f);
1533                   fmal(0.0l, 0.0l, 0.0l);
1534                   fmax(0.0, 0.0);
1535                   fmaxf(0.0f, 0.0f);
1536                   fmaxl(0.0l, 0.0l);
1537                   fmin(0.0, 0.0);
1538                   fminf(0.0f, 0.0f);
1539                   fminl(0.0l, 0.0l);
1540                   hypot(0.0, 0.0);
1541                   hypotf(0.0f, 0.0f);
1542                   hypotl(0.0l, 0.0l);
1543                   ilogb(0.0);
1544                   ilogbf(0.0f);
1545                   ilogbl(0.0l);
1546                   lgamma(0.0);
1547                   lgammaf(0.0f);
1548                   lgammal(0.0l);
1549                   llrint(0.0);
1550                   llrintf(0.0f);
1551                   llrintl(0.0l);
1552                   llround(0.0);
1553                   llroundf(0.0f);
1554                   llroundl(0.0l);
1555                   log1p(0.0);
1556                   log1pf(0.0f);
1557                   log1pl(0.0l);
1558                   log2(0.0);
1559                   log2f(0.0f);
1560                   log2l(0.0l);
1561                   logb(0.0);
1562                   logbf(0.0f);
1563                   logbl(0.0l);
1564                   lrint(0.0);
1565                   lrintf(0.0f);
1566                   lrintl(0.0l);
1567                   lround(0.0);
1568                   lroundf(0.0f);
1569                   lroundl(0.0l);
1570                   nan(0);
1571                   nanf(0);
1572                   nanl(0);
1573                   nearbyint(0.0);
1574                   nearbyintf(0.0f);
1575                   nearbyintl(0.0l);
1576                   nextafter(0.0, 0.0);
1577                   nextafterf(0.0f, 0.0f);
1578                   nextafterl(0.0l, 0.0l);
1579                   nexttoward(0.0, 0.0);
1580                   nexttowardf(0.0f, 0.0f);
1581                   nexttowardl(0.0l, 0.0l);
1582                   remainder(0.0, 0.0);
1583                   remainderf(0.0f, 0.0f);
1584                   remainderl(0.0l, 0.0l);
1585                   remquo(0.0, 0.0, 0);
1586                   remquof(0.0f, 0.0f, 0);
1587                   remquol(0.0l, 0.0l, 0);
1588                   rint(0.0);
1589                   rintf(0.0f);
1590                   rintl(0.0l);
1591                   round(0.0);
1592                   roundf(0.0f);
1593                   roundl(0.0l);
1594                   scalbln(0.0, 0l);
1595                   scalblnf(0.0f, 0l);
1596                   scalblnl(0.0l, 0l);
1597                   scalbn(0.0, 0);
1598                   scalbnf(0.0f, 0);
1599                   scalbnl(0.0l, 0);
1600                   tgamma(0.0);
1601                   tgammaf(0.0f);
1602                   tgammal(0.0l);
1603                   trunc(0.0);
1604                   truncf(0.0f);
1605                   truncl(0.0l);
1606                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1607   ])
1608   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1609   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1610     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1611               [Define if C99 functions or macros in <math.h> should be imported
1612               in <tr1/cmath> in namespace std::tr1.])
1613   fi
1614
1615   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1616   # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1617   ac_c99_inttypes_tr1=no;
1618   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1619     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1620     AC_TRY_COMPILE([#include <inttypes.h>],
1621                    [intmax_t i, numer, denom, base;
1622                     const char* s;
1623                     char** endptr;
1624                     intmax_t ret = imaxabs(i);
1625                     imaxdiv_t dret = imaxdiv(numer, denom);
1626                     ret = strtoimax(s, endptr, base);
1627                     uintmax_t uret = strtoumax(s, endptr, base);
1628                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1629   fi
1630   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1631   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1632     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1633               [Define if C99 functions in <inttypes.h> should be imported in
1634               <tr1/cinttypes> in namespace std::tr1.])
1635   fi
1636
1637   # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1638   # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1639   ac_c99_inttypes_wchar_t_tr1=no;
1640   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1641     AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1642     AC_TRY_COMPILE([#include <inttypes.h>],
1643                    [intmax_t base;
1644                     const wchar_t* s;
1645                     wchar_t** endptr;
1646                     intmax_t ret = wcstoimax(s, endptr, base);
1647                     uintmax_t uret = wcstoumax(s, endptr, base);
1648                    ],[ac_c99_inttypes_wchar_t_tr1=yes],
1649                      [ac_c99_inttypes_wchar_t_tr1=no])
1650   fi
1651   AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1652   if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1653     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1654               [Define if wchar_t C99 functions in <inttypes.h> should be
1655               imported in <tr1/cinttypes> in namespace std::tr1.])
1656   fi
1657
1658   # Check for the existence of the <stdbool.h> header.
1659   AC_CHECK_HEADERS(stdbool.h)
1660
1661   # Check for the existence of the <stdalign.h> header.
1662   AC_CHECK_HEADERS(stdalign.h)
1663
1664   CXXFLAGS="$ac_save_CXXFLAGS"
1665   AC_LANG_RESTORE
1666 ])
1667
1668 dnl
1669 dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1670 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1671 dnl
1672 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1673
1674   AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1675   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1676     if test -r /dev/random && test -r /dev/urandom; then
1677       glibcxx_cv_random_tr1=yes;
1678     else
1679       glibcxx_cv_random_tr1=no;
1680     fi
1681   ])
1682   AC_MSG_RESULT($glibcxx_cv_random_tr1)
1683
1684   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1685     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1686               [Define if /dev/random and /dev/urandom are available for
1687                the random_device of TR1 (Chapter 5.1).])
1688   fi
1689
1690 ])
1691
1692 dnl
1693 dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
1694 dnl
1695 AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
1696
1697   AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
1698   AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
1699                  [#include <stdio.h>],
1700                  [AC_MSG_ERROR([computing EOF failed])])
1701   ])
1702   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
1703                      [Define to the value of the EOF integer constant.])
1704
1705   AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
1706   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
1707                  [#include <stdio.h>],
1708                  [AC_MSG_ERROR([computing SEEK_CUR failed])])
1709   ])
1710   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
1711                      [Define to the value of the SEEK_CUR integer constant.])
1712
1713   AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
1714   AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
1715                  [#include <stdio.h>],
1716                  [AC_MSG_ERROR([computing SEEK_END failed])])
1717   ])
1718   AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
1719                      [Define to the value of the SEEK_END integer constant.])
1720 ])
1721
1722 dnl
1723 dnl Check whether required C++ overloads are present in <math.h>.
1724 dnl
1725
1726 AC_DEFUN([GLIBCXX_CHECK_MATH_PROTO], [
1727
1728   AC_LANG_SAVE
1729   AC_LANG_CPLUSPLUS
1730
1731   case "$host" in
1732     *-*-solaris2.*)
1733       # Solaris 8 FCS only had an overload for double std::abs(double) in
1734       # <iso/math_iso.h>.  Patches 111721-04 (SPARC) and 112757-01 (x86)
1735       # introduced the full set also found from Solaris 9 onwards.
1736       AC_MSG_CHECKING([for float std::abs(float) overload])
1737       AC_CACHE_VAL(glibcxx_cv_abs_float, [
1738         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1739           [#include <math.h>
1740            namespace std {
1741              inline float abs(float __x)
1742              {  return __builtin_fabsf(__x); }
1743            }
1744         ])],
1745         [glibcxx_cv_abs_float=no],
1746         [glibcxx_cv_abs_float=yes]
1747       )])
1748
1749       # autoheader cannot handle indented templates.
1750       AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO1],
1751         [/* Define if all C++ overloads are available in <math.h>.  */
1752 #if __cplusplus >= 199711L
1753 #undef __CORRECT_ISO_CPP_MATH_H_PROTO1
1754 #endif])
1755       AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO2],
1756         [/* Define if only double std::abs(double) is available in <math.h>.  */
1757 #if __cplusplus >= 199711L
1758 #undef __CORRECT_ISO_CPP_MATH_H_PROTO2
1759 #endif])
1760
1761       if test $glibcxx_cv_abs_float = yes; then
1762         AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO1)
1763       else
1764         AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO2)
1765       fi
1766       AC_MSG_RESULT($glibcxx_cv_abs_float)
1767       ;;
1768   esac
1769
1770   AC_LANG_RESTORE
1771 ])
1772
1773 dnl
1774 dnl Check whether required C++ overloads are present in <stdlib.h>.
1775 dnl
1776
1777 AC_DEFUN([GLIBCXX_CHECK_STDLIB_PROTO], [
1778
1779   AC_LANG_SAVE
1780   AC_LANG_CPLUSPLUS
1781
1782   case "$host" in
1783     *-*-solaris2.*)
1784       # Solaris 8 FCS lacked the overloads for long std::abs(long) and
1785       # ldiv_t std::div(long, long) in <iso/stdlib_iso.h>.  Patches 109607-02
1786       # (SPARC) and 109608-02 (x86) introduced them.
1787       AC_MSG_CHECKING([for long std::abs(long) overload])
1788       AC_CACHE_VAL(glibcxx_cv_abs_long, [
1789         AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1790           [#include <stdlib.h>
1791            namespace std {
1792              inline long
1793              abs(long __i) { return labs(__i); }
1794            }
1795         ])],
1796         [glibcxx_cv_abs_long=no],
1797         [glibcxx_cv_abs_long=yes]
1798       )])
1799
1800       # autoheader cannot handle indented templates.
1801       AH_VERBATIM([__CORRECT_ISO_CPP_STDLIB_H_PROTO],
1802         [/* Define if all C++ overloads are available in <stdlib.h>.  */
1803 #if __cplusplus >= 199711L
1804 #undef __CORRECT_ISO_CPP_STDLIB_H_PROTO
1805 #endif])
1806       if test $glibcxx_cv_abs_long = yes; then
1807         AC_DEFINE(__CORRECT_ISO_CPP_STDLIB_H_PROTO, 1)
1808       fi
1809       AC_MSG_RESULT($glibcxx_cv_abs_long)
1810       ;;
1811   esac
1812
1813   AC_LANG_RESTORE
1814 ])
1815
1816 dnl
1817 dnl Check whether required C++ overloads are present in <stdio.h>.
1818 dnl
1819 AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
1820
1821   AC_LANG_SAVE
1822   AC_LANG_CPLUSPLUS
1823
1824   AC_MSG_CHECKING([for gets declaration])
1825   AC_CACHE_VAL(glibcxx_cv_gets, [
1826   AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1827           [#include <stdio.h>
1828            namespace test 
1829            {
1830               using ::gets;
1831            }
1832         ])],
1833         [glibcxx_cv_gets=yes],
1834         [glibcxx_cv_gets=no]
1835       )])
1836
1837   if test $glibcxx_cv_gets = yes; then
1838     AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h>.])
1839   fi
1840   AC_MSG_RESULT($glibcxx_cv_gets)
1841
1842   AC_LANG_RESTORE
1843 ])
1844
1845 dnl
1846 dnl Check whether macros, etc are present for <system_error>
1847 dnl
1848 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1849
1850 m4_pushdef([n_syserr], [1])dnl
1851 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1852                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1853                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
1854                       ECHILD, ENOSPC, EPERM,
1855                       ETIMEDOUT, EWOULDBLOCK],
1856 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1857 AC_MSG_CHECKING([for syserr])
1858 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1859 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1860                                    [int i = syserr;])],
1861                   [glibcxx_cv_system_error[]n_syserr=yes],
1862                   [glibcxx_cv_system_error[]n_syserr=no])
1863 ])
1864 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1865 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1866   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1867 fi
1868 m4_define([n_syserr], m4_incr(n_syserr))dnl
1869 m4_popdef([SYSERR])dnl
1870 ])
1871 m4_popdef([n_syserr])dnl
1872 ])
1873
1874 dnl
1875 dnl Check for what type of C headers to use.
1876 dnl
1877 dnl --enable-cheaders= [does stuff].
1878 dnl --disable-cheaders [does not do anything, really].
1879 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1880 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1881 dnl
1882 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1883   GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
1884     [construct "C" headers for g++], [permit c|c_std|c_global])
1885   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1886
1887   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1888
1889   # Allow overrides to configure.host here.
1890   if test $enable_cheaders = c_global; then
1891      c_compatibility=yes
1892   fi
1893
1894   AC_SUBST(C_INCLUDE_DIR)
1895   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1896   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1897   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1898   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1899 ])
1900
1901
1902 dnl
1903 dnl Check for which locale library to use.  The choice is mapped to
1904 dnl a subdirectory of config/locale.
1905 dnl
1906 dnl Default is generic.
1907 dnl
1908 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1909   GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
1910     [use MODEL for target locale package],
1911     [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
1912
1913   # Deal with gettext issues.  Default to not using it (=no) until we detect
1914   # support for it later.  Let the user turn it off via --e/d, but let that
1915   # default to on for easier handling.
1916   USE_NLS=no
1917   AC_ARG_ENABLE(nls,
1918     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1919     [],
1920     [enable_nls=yes])
1921
1922   # Either a known package, or "auto"
1923   if test $enable_clocale = no || test $enable_clocale = yes; then
1924      enable_clocale=auto
1925   fi
1926   enable_clocale_flag=$enable_clocale
1927
1928   # Probe for locale model to use if none specified.
1929   # Default to "generic".
1930   if test $enable_clocale_flag = auto; then
1931     case ${target_os} in
1932       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1933         enable_clocale_flag=gnu
1934         ;;
1935       darwin* | freebsd*)
1936         enable_clocale_flag=darwin
1937         ;;
1938       *)
1939         if test x"$with_newlib" = x"yes"; then
1940           enable_clocale_flag=newlib
1941         else
1942           enable_clocale_flag=generic
1943         fi
1944         ;;
1945     esac
1946   fi
1947
1948   # Sanity check model, and test for special functionality.
1949   if test $enable_clocale_flag = gnu; then
1950     AC_EGREP_CPP([_GLIBCXX_ok], [
1951     #include <features.h>
1952     #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1953       _GLIBCXX_ok
1954     #endif
1955     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1956
1957     # Set it to scream when it hurts.
1958     ac_save_CFLAGS="$CFLAGS"
1959     CFLAGS="-Wimplicit-function-declaration -Werror"
1960
1961     # Use strxfrm_l if available.
1962     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1963                     #include <string.h>
1964                     #include <locale.h>],
1965                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1966                     AC_DEFINE(HAVE_STRXFRM_L, 1,
1967                     [Define if strxfrm_l is available in <string.h>.]),)
1968
1969     # Use strerror_l if available.
1970     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1971                     #include <string.h>
1972                     #include <locale.h>],
1973                     [__locale_t loc; strerror_l(5, loc);],
1974                     AC_DEFINE(HAVE_STRERROR_L, 1,
1975                     [Define if strerror_l is available in <string.h>.]),)
1976
1977     CFLAGS="$ac_save_CFLAGS"
1978   fi
1979
1980   # Perhaps use strerror_r if available, and strerror_l isn't.
1981   ac_save_CFLAGS="$CFLAGS"
1982   CFLAGS="-Wimplicit-function-declaration -Werror"
1983   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1984                   #include <string.h>
1985                   #include <locale.h>],
1986                   [char s[128]; strerror_r(5, s, 128);],
1987                   AC_DEFINE(HAVE_STRERROR_R, 1,
1988                   [Define if strerror_r is available in <string.h>.]),)
1989   CFLAGS="$ac_save_CFLAGS"
1990
1991   # Set configure bits for specified locale package
1992   AC_MSG_CHECKING([for C locale to use])
1993   case ${enable_clocale_flag} in
1994     generic)
1995       AC_MSG_RESULT(generic)
1996
1997       CLOCALE_H=config/locale/generic/c_locale.h
1998       CLOCALE_CC=config/locale/generic/c_locale.cc
1999       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2000       CCOLLATE_CC=config/locale/generic/collate_members.cc
2001       CCTYPE_CC=config/locale/generic/ctype_members.cc
2002       CMESSAGES_H=config/locale/generic/messages_members.h
2003       CMESSAGES_CC=config/locale/generic/messages_members.cc
2004       CMONEY_CC=config/locale/generic/monetary_members.cc
2005       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2006       CTIME_H=config/locale/generic/time_members.h
2007       CTIME_CC=config/locale/generic/time_members.cc
2008       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2009       ;;
2010     darwin)
2011       AC_MSG_RESULT(darwin or freebsd)
2012
2013       CLOCALE_H=config/locale/generic/c_locale.h
2014       CLOCALE_CC=config/locale/generic/c_locale.cc
2015       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2016       CCOLLATE_CC=config/locale/generic/collate_members.cc
2017       CCTYPE_CC=config/locale/darwin/ctype_members.cc
2018       CMESSAGES_H=config/locale/generic/messages_members.h
2019       CMESSAGES_CC=config/locale/generic/messages_members.cc
2020       CMONEY_CC=config/locale/generic/monetary_members.cc
2021       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2022       CTIME_H=config/locale/generic/time_members.h
2023       CTIME_CC=config/locale/generic/time_members.cc
2024       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2025       ;;
2026
2027     gnu)
2028       AC_MSG_RESULT(gnu)
2029
2030       # Declare intention to use gettext, and add support for specific
2031       # languages.
2032       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
2033       ALL_LINGUAS="de fr"
2034
2035       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2036       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2037       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2038         USE_NLS=yes
2039       fi
2040       # Export the build objects.
2041       for ling in $ALL_LINGUAS; do \
2042         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2043         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2044       done
2045       AC_SUBST(glibcxx_MOFILES)
2046       AC_SUBST(glibcxx_POFILES)
2047
2048       CLOCALE_H=config/locale/gnu/c_locale.h
2049       CLOCALE_CC=config/locale/gnu/c_locale.cc
2050       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2051       CCOLLATE_CC=config/locale/gnu/collate_members.cc
2052       CCTYPE_CC=config/locale/gnu/ctype_members.cc
2053       CMESSAGES_H=config/locale/gnu/messages_members.h
2054       CMESSAGES_CC=config/locale/gnu/messages_members.cc
2055       CMONEY_CC=config/locale/gnu/monetary_members.cc
2056       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2057       CTIME_H=config/locale/gnu/time_members.h
2058       CTIME_CC=config/locale/gnu/time_members.cc
2059       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2060       ;;
2061     ieee_1003.1-2001)
2062       AC_MSG_RESULT(IEEE 1003.1)
2063
2064       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2065       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2066       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2067       CCOLLATE_CC=config/locale/generic/collate_members.cc
2068       CCTYPE_CC=config/locale/generic/ctype_members.cc
2069       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2070       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2071       CMONEY_CC=config/locale/generic/monetary_members.cc
2072       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2073       CTIME_H=config/locale/generic/time_members.h
2074       CTIME_CC=config/locale/generic/time_members.cc
2075       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2076       ;;
2077     newlib)
2078       AC_MSG_RESULT(newlib)
2079
2080       CLOCALE_H=config/locale/generic/c_locale.h
2081       CLOCALE_CC=config/locale/generic/c_locale.cc
2082       CCODECVT_CC=config/locale/generic/codecvt_members.cc
2083       CCOLLATE_CC=config/locale/generic/collate_members.cc
2084       CCTYPE_CC=config/locale/newlib/ctype_members.cc
2085       CMESSAGES_H=config/locale/generic/messages_members.h
2086       CMESSAGES_CC=config/locale/generic/messages_members.cc
2087       CMONEY_CC=config/locale/generic/monetary_members.cc
2088       CNUMERIC_CC=config/locale/generic/numeric_members.cc
2089       CTIME_H=config/locale/generic/time_members.h
2090       CTIME_CC=config/locale/generic/time_members.cc
2091       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2092       ;;
2093   esac
2094
2095   # This is where the testsuite looks for locale catalogs, using the
2096   # -DLOCALEDIR define during testsuite compilation.
2097   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2098   AC_SUBST(glibcxx_localedir)
2099
2100   # A standalone libintl (e.g., GNU libintl) may be in use.
2101   if test $USE_NLS = yes; then
2102     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2103     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2104   fi
2105   if test $USE_NLS = yes; then
2106     AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2107               [Define if NLS translations are to be used.])
2108   fi
2109
2110   AC_SUBST(USE_NLS)
2111   AC_SUBST(CLOCALE_H)
2112   AC_SUBST(CMESSAGES_H)
2113   AC_SUBST(CCODECVT_CC)
2114   AC_SUBST(CCOLLATE_CC)
2115   AC_SUBST(CCTYPE_CC)
2116   AC_SUBST(CMESSAGES_CC)
2117   AC_SUBST(CMONEY_CC)
2118   AC_SUBST(CNUMERIC_CC)
2119   AC_SUBST(CTIME_H)
2120   AC_SUBST(CTIME_CC)
2121   AC_SUBST(CLOCALE_CC)
2122   AC_SUBST(CLOCALE_INTERNAL_H)
2123 ])
2124
2125
2126 dnl
2127 dnl Check for which std::allocator base class to use.  The choice is
2128 dnl mapped from a subdirectory of include/ext.
2129 dnl
2130 dnl Default is new.
2131 dnl
2132 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2133   AC_MSG_CHECKING([for std::allocator base class])
2134   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2135     [use KIND for target std::allocator base],
2136     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2137
2138   # If they didn't use this option switch, or if they specified --enable
2139   # with no specific model, we'll have to look for one.  If they
2140   # specified --disable (???), do likewise.
2141   if test $enable_libstdcxx_allocator = no ||
2142      test $enable_libstdcxx_allocator = yes;
2143   then
2144      enable_libstdcxx_allocator=auto
2145   fi
2146
2147   # Either a known package, or "auto". Auto implies the default choice
2148   # for a particular platform.
2149   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2150
2151   # Probe for host-specific support if no specific model is specified.
2152   # Default to "new".
2153   if test $enable_libstdcxx_allocator_flag = auto; then
2154     case ${target_os} in
2155       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2156         enable_libstdcxx_allocator_flag=new
2157         ;;
2158       *)
2159         enable_libstdcxx_allocator_flag=new
2160         ;;
2161     esac
2162   fi
2163   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2164
2165
2166   # Set configure bits for specified locale package
2167   case ${enable_libstdcxx_allocator_flag} in
2168     bitmap)
2169       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2170       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2171       ;;
2172     malloc)
2173       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2174       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2175       ;;
2176     mt)
2177       ALLOCATOR_H=config/allocator/mt_allocator_base.h
2178       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2179       ;;
2180     new)
2181       ALLOCATOR_H=config/allocator/new_allocator_base.h
2182       ALLOCATOR_NAME=__gnu_cxx::new_allocator
2183       ;;
2184     pool)
2185       ALLOCATOR_H=config/allocator/pool_allocator_base.h
2186       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2187       ;;
2188   esac
2189
2190   AC_SUBST(ALLOCATOR_H)
2191   AC_SUBST(ALLOCATOR_NAME)
2192 ])
2193
2194
2195 dnl
2196 dnl Check for whether the Boost-derived checks should be turned on.
2197 dnl
2198 dnl --enable-concept-checks turns them on.
2199 dnl --disable-concept-checks leaves them off.
2200 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2201 dnl       Where DEFAULT is either `yes' or `no'.
2202 dnl
2203 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2204   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2205   if test $enable_concept_checks = yes; then
2206     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2207               [Define to use concept checking code from the boost libraries.])
2208   fi
2209 ])
2210
2211 dnl
2212 dnl Use extern templates.
2213 dnl
2214 dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2215 dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2216
2217 dnl  +  Usage:  GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2218 dnl       Where DEFAULT is `yes' or `no'.
2219 dnl
2220 AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2221
2222   GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2223
2224   AC_MSG_CHECKING([for extern template support])
2225   AC_MSG_RESULT([$enable_extern_template])
2226
2227   GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2228 ])
2229
2230 dnl
2231 dnl Check for parallel mode pre-requisites, including OpenMP support.
2232 dnl
2233 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
2234 dnl
2235 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2236
2237   enable_parallel=no;
2238
2239   # See if configured libgomp/omp.h exists. (libgomp may be in
2240   # noconfigdirs but not explicitly disabled.)
2241   if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2242     enable_parallel=yes;
2243   else
2244     AC_MSG_NOTICE([target-libgomp not built])
2245   fi
2246
2247   AC_MSG_CHECKING([for parallel mode support])
2248   AC_MSG_RESULT([$enable_parallel])
2249   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2250 ])
2251
2252
2253 dnl
2254 dnl Check for which I/O library to use:  stdio, or something specific.
2255 dnl
2256 dnl Default is stdio.
2257 dnl
2258 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2259   AC_MSG_CHECKING([for underlying I/O to use])
2260   GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2261     [use target-specific I/O package], [permit stdio])
2262
2263   # Now that libio has been removed, you can have any color you want as long
2264   # as it's black.  This is one big no-op until other packages are added, but
2265   # showing the framework never hurts.
2266   case ${enable_cstdio} in
2267     stdio)
2268       CSTDIO_H=config/io/c_io_stdio.h
2269       BASIC_FILE_H=config/io/basic_file_stdio.h
2270       BASIC_FILE_CC=config/io/basic_file_stdio.cc
2271       AC_MSG_RESULT(stdio)
2272       ;;
2273   esac
2274
2275   AC_SUBST(CSTDIO_H)
2276   AC_SUBST(BASIC_FILE_H)
2277   AC_SUBST(BASIC_FILE_CC)
2278 ])
2279
2280
2281 dnl
2282 dnl Check for "unusual" flags to pass to the compiler while building.
2283 dnl
2284 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2285 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2286 dnl --disable-cxx-flags passes nothing.
2287 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2288 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2289 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2290 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2291 dnl       If "default flags" is an empty string, the effect is the same
2292 dnl       as --disable or --enable=no.
2293 dnl
2294 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2295   AC_MSG_CHECKING([for extra compiler flags for building])
2296   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2297     [pass compiler FLAGS when building library],
2298     [case "x$enable_cxx_flags" in
2299       xno | x)   enable_cxx_flags= ;;
2300       x-*)       ;;
2301       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2302      esac])
2303
2304   # Run through flags (either default or command-line) and set anything
2305   # extra (e.g., #defines) that must accompany particular g++ options.
2306   if test -n "$enable_cxx_flags"; then
2307     for f in $enable_cxx_flags; do
2308       case "$f" in
2309         -fhonor-std)  ;;
2310         -*)  ;;
2311         *)   # and we're trying to pass /what/ exactly?
2312              AC_MSG_ERROR([compiler flags start with a -]) ;;
2313       esac
2314     done
2315   fi
2316
2317   EXTRA_CXX_FLAGS="$enable_cxx_flags"
2318   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2319   AC_SUBST(EXTRA_CXX_FLAGS)
2320 ])
2321
2322
2323 dnl
2324 dnl Check to see if debugging libraries are to be built.
2325 dnl
2326 dnl --enable-libstdcxx-debug
2327 dnl builds a separate set of debugging libraries in addition to the
2328 dnl normal (shared, static) libstdc++ binaries.
2329 dnl
2330 dnl --disable-libstdcxx-debug
2331 dnl builds only one (non-debug) version of libstdc++.
2332 dnl
2333 dnl --enable-libstdcxx-debug-flags=FLAGS
2334 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2335 dnl
2336 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2337 dnl       Where DEFAULT is either `yes' or `no'.
2338 dnl
2339 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2340   AC_MSG_CHECKING([for additional debug build])
2341   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2342   AC_MSG_RESULT($enable_libstdcxx_debug)
2343   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2344 ])
2345
2346
2347 dnl
2348 dnl Check for explicit debug flags.
2349 dnl
2350 dnl --enable-libstdcxx-debug-flags='-O1'
2351 dnl is a general method for passing flags to be used when
2352 dnl building debug libraries with --enable-debug.
2353 dnl
2354 dnl --disable-libstdcxx-debug-flags does nothing.
2355 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2356 dnl       If "default flags" is an empty string, the effect is the same
2357 dnl       as --disable or --enable=no.
2358 dnl
2359 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2360   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2361     [pass compiler FLAGS when building debug library],
2362     [case "x$enable_libstdcxx_debug_flags" in
2363       xno | x)    enable_libstdcxx_debug_flags= ;;
2364       x-*)        ;;
2365       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2366      esac])
2367
2368   # Option parsed, now set things appropriately
2369   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2370   AC_SUBST(DEBUG_FLAGS)
2371
2372   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2373 ])
2374
2375
2376 dnl
2377 dnl Check if the user only wants a freestanding library implementation.
2378 dnl
2379 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2380 dnl installing only the headers required by [17.4.1.3] and the language
2381 dnl support library.  More than that will be built (to keep the Makefiles
2382 dnl conveniently clean), but not installed.
2383 dnl
2384 dnl Sets:
2385 dnl  is_hosted  (yes/no)
2386 dnl
2387 dnl Defines:
2388 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2389 dnl
2390 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2391   AC_ARG_ENABLE([hosted-libstdcxx],
2392     AC_HELP_STRING([--disable-hosted-libstdcxx],
2393                    [only build freestanding C++ runtime support]),,
2394     [case "$host" in
2395         arm*-*-symbianelf*)
2396             enable_hosted_libstdcxx=no
2397             ;;
2398         *)
2399             enable_hosted_libstdcxx=yes
2400             ;;
2401      esac])
2402   if test "$enable_hosted_libstdcxx" = no; then
2403     AC_MSG_NOTICE([Only freestanding libraries will be built])
2404     is_hosted=no
2405     hosted_define=0
2406     enable_abi_check=no
2407     enable_libstdcxx_pch=no
2408   else
2409     is_hosted=yes
2410     hosted_define=1
2411   fi
2412   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2413   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2414     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2415 ])
2416
2417
2418 dnl
2419 dnl Check for template specializations for the 'long long' type.
2420 dnl The result determines only whether 'long long' I/O is enabled; things
2421 dnl like numeric_limits<> specializations are always available.
2422 dnl
2423 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2424 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2425 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2426 dnl       Where DEFAULT is either `yes' or `no'.
2427 dnl
2428 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2429   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2430   if test $enable_long_long = yes; then
2431     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2432               [Define if code specialized for long long should be used.])
2433   fi
2434   AC_MSG_CHECKING([for enabled long long specializations])
2435   AC_MSG_RESULT([$enable_long_long])
2436 ])
2437
2438
2439 dnl
2440 dnl Check for decimal floating point.
2441 dnl See:
2442 dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2443 dnl
2444 dnl This checks to see if the host supports decimal floating point types.
2445 dnl
2446 dnl Defines:
2447 dnl  _GLIBCXX_USE_DECIMAL_FLOAT
2448 dnl
2449 AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2450
2451   # Fake what AC_TRY_COMPILE does, without linking as this is
2452   # unnecessary for this test.
2453
2454     cat > conftest.$ac_ext << EOF
2455 [#]line __oline__ "configure"
2456 int main()
2457 {
2458   _Decimal32 d1;
2459   _Decimal64 d2;
2460   _Decimal128 d3;
2461   return 0;
2462 }
2463 EOF
2464
2465     AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2466     if AC_TRY_EVAL(ac_compile); then
2467       AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2468       [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2469       enable_dfp=yes
2470     else
2471       enable_dfp=no
2472     fi
2473     AC_MSG_RESULT($enable_dfp)
2474     rm -f conftest*
2475 ])
2476
2477 dnl
2478 dnl Check for GNU 128-bit integer and floating point types.
2479 dnl
2480 dnl Note: also checks that the types aren't standard types.
2481 dnl
2482 dnl Defines:
2483 dnl  _GLIBCXX_USE_INT128
2484 dnl  _GLIBCXX_USE_FLOAT128
2485 dnl
2486 AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
2487
2488   AC_LANG_SAVE
2489   AC_LANG_CPLUSPLUS
2490
2491   # Fake what AC_TRY_COMPILE does, without linking as this is
2492   # unnecessary for this test.
2493
2494     cat > conftest.$ac_ext << EOF
2495 [#]line __oline__ "configure"
2496 template<typename T1, typename T2>
2497   struct same
2498   { typedef T2 type; };
2499
2500 template<typename T>
2501   struct same<T, T>;
2502
2503 int main()
2504 {
2505   typename same<long, __int128>::type                i1;
2506   typename same<long long, __int128>::type           i2;
2507 }
2508 EOF
2509
2510     AC_MSG_CHECKING([for __int128])
2511     if AC_TRY_EVAL(ac_compile); then
2512       AC_DEFINE(_GLIBCXX_USE_INT128, 1,
2513       [Define if __int128 is supported on this host.])
2514       enable_int128=yes
2515     else
2516       enable_int128=no
2517     fi
2518     AC_MSG_RESULT($enable_int128)
2519     rm -f conftest*
2520
2521     cat > conftest.$ac_ext << EOF
2522 [#]line __oline__ "configure"
2523 template<typename T1, typename T2>
2524   struct same
2525   { typedef T2 type; };
2526
2527 template<typename T>
2528   struct same<T, T>;
2529
2530 int main()
2531 {
2532   typename same<double, __float128>::type      f1;
2533   typename same<long double, __float128>::type f2;
2534 }
2535 EOF
2536
2537     AC_MSG_CHECKING([for __float128])
2538     if AC_TRY_EVAL(ac_compile); then
2539       AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
2540       [Define if __float128 is supported on this host.])
2541       enable_float128=yes
2542     else
2543       enable_float128=no
2544     fi
2545     AC_MSG_RESULT($enable_float128)
2546     rm -f conftest*
2547
2548   AC_LANG_RESTORE
2549 ])
2550
2551 dnl
2552 dnl Check for template specializations for the 'wchar_t' type.
2553 dnl
2554 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2555 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2556 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2557 dnl       Where DEFAULT is either `yes' or `no'.
2558 dnl
2559 dnl Necessary support must also be present.
2560 dnl
2561 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2562   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2563
2564   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2565   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2566   AC_MSG_CHECKING([for mbstate_t])
2567   AC_TRY_COMPILE([#include <wchar.h>],
2568   [mbstate_t teststate;],
2569   have_mbstate_t=yes, have_mbstate_t=no)
2570   AC_MSG_RESULT($have_mbstate_t)
2571   if test x"$have_mbstate_t" = xyes; then
2572     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2573   fi
2574
2575   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2576   # ac_has_wchar_h.
2577   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2578
2579   if test x"$enable_wchar_t" = x"yes"; then
2580
2581     AC_LANG_SAVE
2582     AC_LANG_CPLUSPLUS
2583
2584     if test x"$ac_has_wchar_h" = xyes &&
2585        test x"$ac_has_wctype_h" = xyes; then
2586       AC_TRY_COMPILE([#include <wchar.h>
2587                       #include <stddef.h>
2588                       wint_t i;
2589                       long l = WEOF;
2590                       long j = WCHAR_MIN;
2591                       long k = WCHAR_MAX;
2592                       namespace test
2593                       {
2594                         using ::btowc;
2595                         using ::fgetwc;
2596                         using ::fgetws;
2597                         using ::fputwc;
2598                         using ::fputws;
2599                         using ::fwide;
2600                         using ::fwprintf;
2601                         using ::fwscanf;
2602                         using ::getwc;
2603                         using ::getwchar;
2604                         using ::mbrlen;
2605                         using ::mbrtowc;
2606                         using ::mbsinit;
2607                         using ::mbsrtowcs;
2608                         using ::putwc;
2609                         using ::putwchar;
2610                         using ::swprintf;
2611                         using ::swscanf;
2612                         using ::ungetwc;
2613                         using ::vfwprintf;
2614                         using ::vswprintf;
2615                         using ::vwprintf;
2616                         using ::wcrtomb;
2617                         using ::wcscat;
2618                         using ::wcschr;
2619                         using ::wcscmp;
2620                         using ::wcscoll;
2621                         using ::wcscpy;
2622                         using ::wcscspn;
2623                         using ::wcsftime;
2624                         using ::wcslen;
2625                         using ::wcsncat;
2626                         using ::wcsncmp;
2627                         using ::wcsncpy;
2628                         using ::wcspbrk;
2629                         using ::wcsrchr;
2630                         using ::wcsrtombs;
2631                         using ::wcsspn;
2632                         using ::wcsstr;
2633                         using ::wcstod;
2634                         using ::wcstok;
2635                         using ::wcstol;
2636                         using ::wcstoul;
2637                         using ::wcsxfrm;
2638                         using ::wctob;
2639                         using ::wmemchr;
2640                         using ::wmemcmp;
2641                         using ::wmemcpy;
2642                         using ::wmemmove;
2643                         using ::wmemset;
2644                         using ::wprintf;
2645                         using ::wscanf;
2646                       }
2647                      ],[],[], [enable_wchar_t=no])
2648     else
2649       enable_wchar_t=no
2650     fi
2651
2652     AC_LANG_RESTORE
2653   fi
2654
2655   if test x"$enable_wchar_t" = x"yes"; then
2656     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2657               [Define if code specialized for wchar_t should be used.])
2658   fi
2659
2660   AC_MSG_CHECKING([for enabled wchar_t specializations])
2661   AC_MSG_RESULT([$enable_wchar_t])
2662 ])
2663
2664
2665 dnl
2666 dnl Check to see if building and using a C++ precompiled header can be done.
2667 dnl
2668 dnl --enable-libstdcxx-pch=yes
2669 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2670 dnl may work, after some light-hearted attempts to puzzle out compiler
2671 dnl support, flip bits on in include/Makefile.am
2672 dnl
2673 dnl --disable-libstdcxx-pch
2674 dnl turns off attempts to use or build stdc++.h.gch.
2675 dnl
2676 dnl Substs:
2677 dnl  glibcxx_PCHFLAGS
2678 dnl
2679 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2680   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2681   if test $enable_libstdcxx_pch = yes; then
2682     AC_CACHE_CHECK([for compiler with PCH support],
2683       [glibcxx_cv_prog_CXX_pch],
2684       [ac_save_CXXFLAGS="$CXXFLAGS"
2685        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2686        AC_LANG_SAVE
2687        AC_LANG_CPLUSPLUS
2688        echo '#include <math.h>' > conftest.h
2689        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2690                           -o conftest.h.gch 1>&5 2>&1 &&
2691                 echo '#error "pch failed"' > conftest.h &&
2692           echo '#include "conftest.h"' > conftest.cc &&
2693                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2694        then
2695          glibcxx_cv_prog_CXX_pch=yes
2696        else
2697          glibcxx_cv_prog_CXX_pch=no
2698        fi
2699        rm -f conftest*
2700        CXXFLAGS=$ac_save_CXXFLAGS
2701        AC_LANG_RESTORE
2702       ])
2703     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2704   fi
2705
2706   AC_MSG_CHECKING([for enabled PCH])
2707   AC_MSG_RESULT([$enable_libstdcxx_pch])
2708
2709   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2710   if test $enable_libstdcxx_pch = yes; then
2711     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2712   else
2713     glibcxx_PCHFLAGS=""
2714   fi
2715   AC_SUBST(glibcxx_PCHFLAGS)
2716 ])
2717
2718
2719 dnl
2720 dnl Check for atomic builtins.
2721 dnl See:
2722 dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
2723 dnl
2724 dnl This checks to see if the host supports the compiler-generated
2725 dnl builtins for atomic operations for various integral sizes. Note, this
2726 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2727 dnl that are used should be checked.
2728 dnl
2729 dnl Note:
2730 dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2731 dnl
2732 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2733   AC_LANG_SAVE
2734   AC_LANG_CPLUSPLUS
2735   old_CXXFLAGS="$CXXFLAGS"
2736
2737   # Do link tests if possible, instead asm tests, limited to some platforms
2738   # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2739   # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2740   atomic_builtins_link_tests=no
2741   if test x$gcc_no_link != xyes; then
2742     # Can do link tests. Limit to some tested platforms
2743     case "$host" in
2744       *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2745         atomic_builtins_link_tests=yes
2746         ;;
2747     esac
2748   fi
2749
2750   if test x$atomic_builtins_link_tests = xyes; then
2751
2752   # Do link tests.
2753
2754   CXXFLAGS="$CXXFLAGS -fno-exceptions"
2755
2756   AC_MSG_CHECKING([for atomic builtins for bool])
2757   AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2758     AC_TRY_LINK(
2759       [ ],
2760       [typedef bool atomic_type;
2761        atomic_type c1;
2762        atomic_type c2;
2763        atomic_type c3(0);
2764        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2765        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2766                                    __ATOMIC_RELAXED);
2767        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2768        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2769       ],
2770       [glibcxx_cv_atomic_bool=yes],
2771       [glibcxx_cv_atomic_bool=no])
2772   ])
2773   AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2774
2775   AC_MSG_CHECKING([for atomic builtins for short])
2776   AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2777     AC_TRY_LINK(
2778       [ ],
2779       [typedef short atomic_type;
2780        atomic_type c1;
2781        atomic_type c2;
2782        atomic_type c3(0);
2783        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2784        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2785                                    __ATOMIC_RELAXED);
2786        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2787        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2788       ],
2789       [glibcxx_cv_atomic_short=yes],
2790       [glibcxx_cv_atomic_short=no])
2791   ])
2792   AC_MSG_RESULT($glibcxx_cv_atomic_short)
2793
2794   AC_MSG_CHECKING([for atomic builtins for int])
2795   AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2796     AC_TRY_LINK(
2797       [ ],
2798       [typedef int atomic_type;
2799        atomic_type c1;
2800        atomic_type c2;
2801        atomic_type c3(0);
2802        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2803        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2804                                    __ATOMIC_RELAXED);
2805        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2806        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2807       ],
2808       [glibcxx_cv_atomic_int=yes],
2809       [glibcxx_cv_atomic_int=no])
2810   ])
2811   AC_MSG_RESULT($glibcxx_cv_atomic_int)
2812
2813   AC_MSG_CHECKING([for atomic builtins for long long])
2814   AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2815     AC_TRY_LINK(
2816       [ ],
2817       [typedef long long atomic_type;
2818        atomic_type c1;
2819        atomic_type c2;
2820        atomic_type c3(0);
2821        __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2822        __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2823                                    __ATOMIC_RELAXED);
2824        __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2825        __atomic_load_n(&c1, __ATOMIC_RELAXED);
2826       ],
2827       [glibcxx_cv_atomic_long_long=yes],
2828       [glibcxx_cv_atomic_long_long=no])
2829   ])
2830   AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2831
2832   else
2833
2834   # Do asm tests.
2835
2836   # Compile unoptimized.
2837   CXXFLAGS='-O0 -S'
2838
2839   # Fake what AC_TRY_COMPILE does.
2840
2841     cat > conftest.$ac_ext << EOF
2842 [#]line __oline__ "configure"
2843 int main()
2844 {
2845   typedef bool atomic_type;
2846   atomic_type c1;
2847   atomic_type c2;
2848   atomic_type c3(0);
2849   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2850   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2851                               __ATOMIC_RELAXED);
2852   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2853   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2854
2855   return 0;
2856 }
2857 EOF
2858
2859     AC_MSG_CHECKING([for atomic builtins for bool])
2860     if AC_TRY_EVAL(ac_compile); then
2861       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2862         glibcxx_cv_atomic_bool=no
2863       else
2864         glibcxx_cv_atomic_bool=yes
2865       fi
2866     fi
2867     AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2868     rm -f conftest*
2869
2870     cat > conftest.$ac_ext << EOF
2871 [#]line __oline__ "configure"
2872 int main()
2873 {
2874   typedef short atomic_type;
2875   atomic_type c1;
2876   atomic_type c2;
2877   atomic_type c3(0);
2878   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2879   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2880                               __ATOMIC_RELAXED);
2881   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2882   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2883
2884   return 0;
2885 }
2886 EOF
2887
2888     AC_MSG_CHECKING([for atomic builtins for short])
2889     if AC_TRY_EVAL(ac_compile); then
2890       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2891         glibcxx_cv_atomic_short=no
2892       else
2893         glibcxx_cv_atomic_short=yes
2894       fi
2895     fi
2896     AC_MSG_RESULT($glibcxx_cv_atomic_short)
2897     rm -f conftest*
2898
2899     cat > conftest.$ac_ext << EOF
2900 [#]line __oline__ "configure"
2901 int main()
2902 {
2903   // NB: _Atomic_word not necessarily int.
2904   typedef int atomic_type;
2905   atomic_type c1;
2906   atomic_type c2;
2907   atomic_type c3(0);
2908   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2909   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2910                               __ATOMIC_RELAXED);
2911   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2912   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2913
2914   return 0;
2915 }
2916 EOF
2917
2918     AC_MSG_CHECKING([for atomic builtins for int])
2919     if AC_TRY_EVAL(ac_compile); then
2920       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2921         glibcxx_cv_atomic_int=no
2922       else
2923         glibcxx_cv_atomic_int=yes
2924       fi
2925     fi
2926     AC_MSG_RESULT($glibcxx_cv_atomic_int)
2927     rm -f conftest*
2928
2929     cat > conftest.$ac_ext << EOF
2930 [#]line __oline__ "configure"
2931 int main()
2932 {
2933   typedef long long atomic_type;
2934   atomic_type c1;
2935   atomic_type c2;
2936   atomic_type c3(0);
2937   __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2938   __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2939                               __ATOMIC_RELAXED);
2940   __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2941   __atomic_load_n(&c1, __ATOMIC_RELAXED);
2942
2943   return 0;
2944 }
2945 EOF
2946
2947     AC_MSG_CHECKING([for atomic builtins for long long])
2948     if AC_TRY_EVAL(ac_compile); then
2949       if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2950         glibcxx_cv_atomic_long_long=no
2951       else
2952         glibcxx_cv_atomic_long_long=yes
2953       fi
2954     fi
2955     AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2956     rm -f conftest*
2957
2958   fi
2959
2960   CXXFLAGS="$old_CXXFLAGS"
2961   AC_LANG_RESTORE
2962
2963   # Set atomicity_dir to builtins if all but the long long test above passes.
2964   if test $glibcxx_cv_atomic_bool = yes \
2965      && test $glibcxx_cv_atomic_short = yes \
2966      && test $glibcxx_cv_atomic_int = yes; then
2967     AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2968     [Define if the compiler supports C++11 atomics.])
2969     atomicity_dir=cpu/generic/atomicity_builtins
2970   fi
2971
2972   # If still generic, set to mutex.
2973   if test $atomicity_dir = "cpu/generic" ; then
2974     atomicity_dir=cpu/generic/atomicity_mutex
2975     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2976       if test "x$target_thread_file" = xsingle; then
2977         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2978         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2979       else
2980         AC_MSG_WARN([They will be faked using a mutex.])
2981         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2982       fi
2983   fi
2984
2985 ])
2986
2987
2988 dnl
2989 dnl Check for exception handling support.  If an explicit enable/disable
2990 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2991 dnl target may or may not support call frame exceptions.
2992 dnl
2993 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2994 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2995 dnl Neither one forces an attempt at detection.
2996 dnl
2997 dnl Defines:
2998 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2999 dnl
3000 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
3001   AC_MSG_CHECKING([for exception model to use])
3002   AC_LANG_SAVE
3003   AC_LANG_CPLUSPLUS
3004   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
3005     [force use of builtin_setjmp for exceptions],
3006     [permit yes|no|auto])
3007
3008   if test $enable_sjlj_exceptions = auto; then
3009     # Botheration.  Now we've got to detect the exception model.  Link tests
3010     # against libgcc.a are problematic since we've not been given proper -L
3011     # bits for single-tree newlib and libgloss.
3012     #
3013     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
3014     cat > conftest.$ac_ext << EOF
3015 [#]line __oline__ "configure"
3016 struct S { ~S(); };
3017 void bar();
3018 void foo()
3019 {
3020   S s;
3021   bar();
3022 }
3023 EOF
3024     old_CXXFLAGS="$CXXFLAGS"
3025     CXXFLAGS=-S
3026     if AC_TRY_EVAL(ac_compile); then
3027       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
3028         enable_sjlj_exceptions=yes
3029       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
3030         enable_sjlj_exceptions=no
3031       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
3032         enable_sjlj_exceptions=no
3033       fi
3034     fi
3035     CXXFLAGS="$old_CXXFLAGS"
3036     rm -f conftest*
3037   fi
3038
3039   # This is a tad weird, for hysterical raisins.  We have to map
3040   # enable/disable to two different models.
3041   case $enable_sjlj_exceptions in
3042     yes)
3043       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
3044         [Define if the compiler is configured for setjmp/longjmp exceptions.])
3045       ac_exception_model_name=sjlj
3046       ;;
3047     no)
3048       ac_exception_model_name="call frame"
3049       ;;
3050     *)
3051       AC_MSG_ERROR([unable to detect exception model])
3052       ;;
3053   esac
3054  AC_LANG_RESTORE
3055  AC_MSG_RESULT($ac_exception_model_name)
3056 ])
3057
3058
3059 dnl
3060 dnl Allow visibility attributes to be used on namespaces, objects, etc.
3061 dnl
3062 dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3063 dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3064 dnl  +  Usage:  GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3065 dnl       Where DEFAULT is 'yes'.
3066 dnl
3067 AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3068 GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3069
3070 if test x$enable_libstdcxx_visibility = xyes ; then
3071   dnl all hail libgfortran
3072   dnl Check whether the target supports hidden visibility.
3073   AC_CACHE_CHECK([whether the target supports hidden visibility],
3074                  glibcxx_cv_have_attribute_visibility, [
3075   save_CFLAGS="$CFLAGS"
3076   CFLAGS="$CFLAGS -Werror"
3077   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3078                  [], glibcxx_cv_have_attribute_visibility=yes,
3079                  glibcxx_cv_have_attribute_visibility=no)
3080   CFLAGS="$save_CFLAGS"])
3081   if test $glibcxx_cv_have_attribute_visibility = no; then
3082     enable_libstdcxx_visibility=no
3083   fi
3084 fi
3085
3086 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3087 AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3088 ])
3089
3090
3091 dnl
3092 dnl Add version tags to symbols in shared library (or not), additionally
3093 dnl marking other symbols as private/local (or not).
3094 dnl
3095 dnl Sets libtool_VERSION, and determines shared library SONAME.
3096 dnl
3097 dnl  This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3098 dnl
3099 dnl --enable-symvers=style adds a version script to the linker call when
3100 dnl       creating the shared library.  The choice of version script is
3101 dnl       controlled by 'style'.
3102 dnl --disable-symvers does not.
3103 dnl
3104 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3105 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
3106 dnl       choose a default style based on linker characteristics.  Passing
3107 dnl       'no' disables versioning.
3108 dnl
3109 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3110
3111 GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3112   [enables symbol versioning of the shared library],
3113   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3114
3115 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3116 # don't know enough about $LD to do tricks...
3117 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3118 # Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3119 # with extern "C++" in version scripts.
3120 AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3121
3122 # Turn a 'yes' into a suitable default.
3123 if test x$enable_symvers = xyes ; then
3124   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3125     enable_symvers=no
3126   else
3127     if test $with_gnu_ld = yes ; then
3128       case ${target_os} in
3129         hpux*)
3130           enable_symvers=no ;;
3131         *)
3132           enable_symvers=gnu ;;
3133       esac
3134     else
3135       case ${target_os} in
3136         darwin*)
3137           enable_symvers=darwin ;;
3138         # Sun symbol versioning exists since Solaris 2.5.
3139         solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3140           # make_sunver.pl needs GNU c++filt to support extern "C++" in
3141           # version scripts, so disable symbol versioning if none can be
3142           # found.
3143           if test -z "$ac_cv_path_CXXFILT"; then
3144             AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3145             AC_MSG_WARN([=== no GNU c++filt could  be found.])
3146             AC_MSG_WARN([=== Symbol versioning will be disabled.])
3147             enable_symvers=no
3148           else
3149             enable_symvers=sun
3150           fi
3151           ;;
3152         *)
3153           enable_symvers=no ;;
3154       esac
3155     fi
3156   fi
3157 fi
3158
3159 # Check to see if 'darwin' or 'darwin-export' can win.
3160 if test x$enable_symvers = xdarwin-export ; then
3161     enable_symvers=darwin
3162 fi
3163
3164 # Check if 'sun' was requested on non-Solaris 2 platforms.
3165 if test x$enable_symvers = xsun ; then
3166   case ${target_os} in
3167     solaris2*)
3168       # All fine.
3169       ;;
3170     *)
3171       # Unlikely to work.
3172       AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3173       AC_MSG_WARN([=== you are not targetting Solaris 2.])
3174       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3175       enable_symvers=no
3176       ;;
3177   esac
3178 fi
3179
3180 # Check to see if 'gnu' can win.
3181 if test $enable_symvers = gnu ||
3182   test $enable_symvers = gnu-versioned-namespace ||
3183   test $enable_symvers = sun; then
3184   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3185   AC_MSG_CHECKING([for shared libgcc])
3186   ac_save_CFLAGS="$CFLAGS"
3187   CFLAGS=' -lgcc_s'
3188   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3189   CFLAGS="$ac_save_CFLAGS"
3190   if test $glibcxx_shared_libgcc = no; then
3191     cat > conftest.c <<EOF
3192 int main (void) { return 0; }
3193 EOF
3194 changequote(,)dnl
3195     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3196                              -shared -shared-libgcc -o conftest.so \
3197                              conftest.c -v 2>&1 >/dev/null \
3198                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3199 changequote([,])dnl
3200     rm -f conftest.c conftest.so
3201     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3202       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3203       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3204       CFLAGS="$ac_save_CFLAGS"
3205     fi
3206   fi
3207   AC_MSG_RESULT($glibcxx_shared_libgcc)
3208
3209   # For GNU ld, we need at least this version.  The format is described in
3210   # GLIBCXX_CHECK_LINKER_FEATURES above.
3211   glibcxx_min_gnu_ld_version=21400
3212
3213   # If no shared libgcc, can't win.
3214   if test $glibcxx_shared_libgcc != yes; then
3215       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3216       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3217       AC_MSG_WARN([=== Symbol versioning will be disabled.])
3218       enable_symvers=no
3219   elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3220     : All interesting versions of Sun ld support sun style symbol versioning.
3221   elif test $with_gnu_ld != yes ; then
3222     # just fail for now
3223     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3224     AC_MSG_WARN([=== you are not using the GNU linker.])
3225     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3226     enable_symvers=no
3227   elif test $glibcxx_ld_is_gold = yes ; then
3228     : All versions of gold support symbol versioning.
3229   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3230     # The right tools, the right setup, but too old.  Fallbacks?
3231     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3232     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3233     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3234     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3235     AC_MSG_WARN([=== Symbol versioning will be disabled.])
3236     enable_symvers=no
3237   fi
3238 fi
3239
3240 # For libtool versioning info, format is CURRENT:REVISION:AGE
3241 libtool_VERSION=6:17:0
3242
3243 # Everything parsed; figure out what files and settings to use.
3244 case $enable_symvers in
3245   no)
3246     SYMVER_FILE=config/abi/pre/none.ver
3247     ;;
3248   gnu)
3249     SYMVER_FILE=config/abi/pre/gnu.ver
3250     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3251               [Define to use GNU versioning in the shared library.])
3252     ;;
3253   gnu-versioned-namespace)
3254     libtool_VERSION=7:0:0
3255     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3256     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3257               [Define to use GNU namespace versioning in the shared library.])
3258     ;;
3259   darwin)
3260     SYMVER_FILE=config/abi/pre/gnu.ver
3261     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3262               [Define to use darwin versioning in the shared library.])
3263     ;;
3264   sun)
3265     SYMVER_FILE=config/abi/pre/gnu.ver
3266     AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3267               [Define to use Sun versioning in the shared library.])
3268     ;;
3269 esac
3270
3271 if test x$enable_symvers != xno ; then
3272   AC_DEFINE(_GLIBCXX_SYMVER, 1,
3273          [Define to use symbol versioning in the shared library.])
3274 fi
3275
3276 AC_CACHE_CHECK([whether the target supports .symver directive],
3277                glibcxx_cv_have_as_symver_directive, [
3278   AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3279                  [], glibcxx_cv_have_as_symver_directive=yes,
3280                  glibcxx_cv_have_as_symver_directive=no)])
3281 if test $glibcxx_cv_have_as_symver_directive = yes; then
3282   AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3283     [Define to 1 if the target assembler supports .symver directive.])
3284 fi
3285
3286 AC_SUBST(SYMVER_FILE)
3287 AC_SUBST(port_specific_symbol_files)
3288 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3289 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3290 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3291 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3292 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3293 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3294
3295 if test $enable_symvers != no ; then
3296    case ${target_os} in
3297      # The Solaris 2 runtime linker doesn't support the GNU extension of
3298      # binding the same symbol to different versions
3299      solaris2*)
3300        ;;
3301      # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3302      *)
3303        AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3304          [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3305        ;;
3306     esac
3307 fi
3308
3309 # Now, set up compatibility support, if any.
3310 # In addition, need this to deal with std::size_t mangling in
3311 # src/compatibility.cc.  In a perfect world, could use
3312 # typeid(std::size_t).name()[0] to do direct substitution.
3313 AC_MSG_CHECKING([for size_t as unsigned int])
3314 ac_save_CFLAGS="$CFLAGS"
3315 CFLAGS="-Werror"
3316 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3317                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3318 CFLAGS=$ac_save_CFLAGS
3319 if test "$glibcxx_size_t_is_i" = yes; then
3320   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3321 fi
3322 AC_MSG_RESULT([$glibcxx_size_t_is_i])
3323
3324 AC_MSG_CHECKING([for ptrdiff_t as int])
3325 ac_save_CFLAGS="$CFLAGS"
3326 CFLAGS="-Werror"
3327 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3328                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3329 CFLAGS=$ac_save_CFLAGS
3330 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3331   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3332 fi
3333 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3334 ])
3335
3336
3337 dnl
3338 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3339 dnl We must stage the required headers so that they will be installed
3340 dnl with the library (unlike libgcc, the STL implementation is provided
3341 dnl solely within headers).  Since we must not inject random user-space
3342 dnl macro names into user-provided C++ code, we first stage into <file>-in
3343 dnl and process to <file> with an output command.  The reason for a two-
3344 dnl stage process here is to correctly handle $srcdir!=$objdir without
3345 dnl having to write complex code (the sed commands to clean the macro
3346 dnl namespace are complex and fragile enough as it is).  We must also
3347 dnl add a relative path so that -I- is supported properly.
3348 dnl
3349 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3350   AC_MSG_CHECKING([for thread model used by GCC])
3351   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3352   AC_MSG_RESULT([$target_thread_file])
3353 ])
3354
3355
3356 dnl
3357 dnl Check if gthread implementation defines the types and functions
3358 dnl required by the c++0x thread library.  Conforming gthread
3359 dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3360 dnl
3361 dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3362 dnl
3363 AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3364   GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3365
3366   if test x$enable_libstdcxx_threads = xauto || 
3367      test x$enable_libstdcxx_threads = xyes; then
3368
3369   AC_LANG_SAVE
3370   AC_LANG_CPLUSPLUS
3371
3372   ac_save_CXXFLAGS="$CXXFLAGS"
3373   CXXFLAGS="$CXXFLAGS -fno-exceptions \
3374         -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3375
3376   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3377   case $target_thread_file in
3378     posix)
3379       CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3380   esac
3381
3382   AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3383
3384   AC_TRY_COMPILE([#include <unistd.h>],
3385     [
3386       // In case of POSIX threads check _POSIX_TIMEOUTS.
3387       #if (defined(_PTHREADS) \
3388           && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3389       #error
3390       #endif
3391     ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3392
3393   AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3394                      [Define to 1 if mutex_timedlock is available.])
3395
3396   if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3397   else res_mutex_timedlock=no ; fi
3398   AC_MSG_RESULT([$res_mutex_timedlock])
3399
3400   AC_MSG_CHECKING([for gthreads library])
3401
3402   AC_TRY_COMPILE([#include "gthr.h"],
3403     [
3404       #ifndef __GTHREADS_CXX0X
3405       #error
3406       #endif
3407     ], [case $target_os in
3408           # gthreads support breaks symbol versioning on Solaris 8/9 (PR
3409           # libstdc++/52189).
3410           solaris2.[[89]]*)
3411             if test x$enable_symvers = xno; then
3412               ac_has_gthreads=yes
3413             elif test x$enable_libstdcxx_threads = xyes; then
3414               AC_MSG_WARN([You have requested C++11 threads support, but])
3415               AC_MSG_WARN([this breaks symbol versioning.])
3416               ac_has_gthreads=yes
3417             else
3418               ac_has_gthreads=no
3419             fi
3420             ;;
3421           *)
3422             ac_has_gthreads=yes
3423             ;;
3424         esac],