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