OSDN Git Service

2008-08-12 Paolo Carlini <paolo.carlini@oracle.com>
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / acinclude.m4
1
2 dnl
3 dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
4 dnl
5 dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
6 dnl end of configure.  This lets tested variables be reassigned, and the
7 dnl conditional will depend on the final state of the variable.  For a simple
8 dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
9 dnl
10 m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
11 AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
12   m4_divert_text([glibcxx_diversion],dnl
13    AM_CONDITIONAL([$1],[$2])
14   )dnl
15 ])dnl
16 AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
17
18
19 dnl
20 dnl Check to see what architecture and operating system we are compiling
21 dnl for.  Also, if architecture- or OS-specific flags are required for
22 dnl compilation, pick them up here.
23 dnl
24 AC_DEFUN([GLIBCXX_CHECK_HOST], [
25   . $glibcxx_srcdir/configure.host
26   AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
27   AC_MSG_NOTICE([OS config directory is $os_include_dir])
28 ])
29
30 dnl
31 dnl Initialize the rest of the library configury.  At this point we have
32 dnl variables like $host.
33 dnl
34 dnl Sets:
35 dnl  SUBDIRS
36 dnl Substs:
37 dnl  glibcxx_builddir     (absolute path)
38 dnl  glibcxx_srcdir       (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 libmath libsupc++ src 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_srcdir=${glibcxx_srcdir}/..
64   AC_SUBST(glibcxx_builddir)
65   AC_SUBST(glibcxx_srcdir)
66   AC_SUBST(toplevel_srcdir)
67
68   # We use these options to decide which functions to include.  They are
69   # set from the top level.
70   AC_ARG_WITH([target-subdir],
71     AC_HELP_STRING([--with-target-subdir=SUBDIR],
72                    [configuring in a subdirectory]))
73
74   AC_ARG_WITH([cross-host],
75     AC_HELP_STRING([--with-cross-host=HOST],
76                    [configuring with a cross compiler]))
77
78   AC_ARG_WITH([newlib],
79     AC_HELP_STRING([--with-newlib],
80                    [assume newlib as a system C library]))
81
82   # We're almost certainly being configured before anything else which uses
83   # C++, so all of our AC_PROG_* discoveries will be cached.  It's vital that
84   # we not cache the value of CXX that we "discover" here, because it's set
85   # to something unique for us and libjava.  Other target libraries need to
86   # find CXX for themselves.  We yank the rug out from under the normal AC_*
87   # process by sneakily renaming the cache variable.  This also lets us debug
88   # the value of "our" CXX in postmortems.
89   #
90   # We must also force CXX to /not/ be a precious variable, otherwise the
91   # wrong (non-multilib-adjusted) value will be used in multilibs.  This
92   # little trick also affects CPPFLAGS, CXXFLAGS, and LDFLAGS.  And as a side
93   # effect, CXXFLAGS is no longer automagically subst'd, so we have to do
94   # that ourselves.  Un-preciousing AC_PROG_CC also affects CC and CFLAGS.
95   #
96   # -fno-builtin must be present here so that a non-conflicting form of
97   # std::exit can be guessed by AC_PROG_CXX, and used in later tests.
98
99   m4_define([ac_cv_prog_CXX],[glibcxx_cv_prog_CXX])
100   m4_rename([_AC_ARG_VAR_PRECIOUS],[glibcxx_PRECIOUS])
101   m4_define([_AC_ARG_VAR_PRECIOUS],[])
102   save_CXXFLAGS="$CXXFLAGS"
103   CXXFLAGS="$CXXFLAGS -fno-builtin"
104   AC_PROG_CC
105   AC_PROG_CXX
106   CXXFLAGS="$save_CXXFLAGS"
107   m4_rename([glibcxx_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
108   AC_SUBST(CFLAGS)
109   AC_SUBST(CXXFLAGS)
110
111   # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
112   # available).  Uncomment the next line to force a particular method.
113   AC_PROG_LN_S
114   #LN_S='cp -p'
115
116   AC_CHECK_TOOL(AS, as)
117   AC_CHECK_TOOL(AR, ar)
118   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
119
120   AM_MAINTAINER_MODE
121
122   # Set up safe default values for all subsequent AM_CONDITIONAL tests
123   # which are themselves conditionally expanded.
124   ## (Right now, this only matters for enable_wchar_t, but nothing prevents
125   ## other macros from doing the same.  This should be automated.)  -pme
126   need_libmath=no
127
128   # Check for uClibc since Linux platforms use different configuration
129   # directories depending on the C library in use.
130   AC_EGREP_CPP([_using_uclibc], [
131   #include <stdio.h>
132   #if __UCLIBC__
133     _using_uclibc
134   #endif
135   ], uclibc=yes, uclibc=no)
136
137   # Find platform-specific directories containing configuration info.
138   # Also possibly modify flags used elsewhere, as needed by the platform.
139   GLIBCXX_CHECK_HOST
140 ])
141
142
143 dnl
144 dnl Tests for newer compiler features, or features that are present in newer
145 dnl compiler versions but not older compiler versions still in use, should
146 dnl be placed here.
147 dnl
148 dnl Defines:
149 dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
150 dnl   new inlining code or the new system_header pragma will die on -Werror.
151 dnl   Leave it out by default and use maint-mode to use it.
152 dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
153 dnl   compiler supports it and the user has not requested debug mode.
154 dnl
155 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
156   # All these tests are for C++; save the language and the compiler flags.
157   # The CXXFLAGS thing is suspicious, but based on similar bits previously
158   # found in GLIBCXX_CONFIGURE.
159   AC_LANG_SAVE
160   AC_LANG_CPLUSPLUS
161   ac_test_CXXFLAGS="${CXXFLAGS+set}"
162   ac_save_CXXFLAGS="$CXXFLAGS"
163
164   # Check for maintainer-mode bits.
165   if test x"$USE_MAINTAINER_MODE" = xno; then
166     WERROR=''
167   else
168     WERROR='-Werror'
169   fi
170
171   # Check for -ffunction-sections -fdata-sections
172   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
173   CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
174   AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
175   if test "$ac_test_CXXFLAGS" = set; then
176     CXXFLAGS="$ac_save_CXXFLAGS"
177   else
178     # this is the suspicious part
179     CXXFLAGS=''
180   fi
181   if test x"$ac_fdsections" = x"yes"; then
182     SECTION_FLAGS='-ffunction-sections -fdata-sections'
183   fi
184   AC_MSG_RESULT($ac_fdsections)
185
186   AC_LANG_RESTORE
187   AC_SUBST(WERROR)
188   AC_SUBST(SECTION_FLAGS)
189 ])
190
191
192 dnl
193 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
194 dnl the native linker is in use, all variables will be defined to something
195 dnl safe (like an empty string).
196 dnl
197 dnl Defines:
198 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
199 dnl  OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
200 dnl  LD (as a side effect of testing)
201 dnl Sets:
202 dnl  with_gnu_ld
203 dnl  glibcxx_ld_is_gold (set to "no" or "yes")
204 dnl  glibcxx_gnu_ld_version (possibly)
205 dnl
206 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
207 dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
208 dnl
209 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
210   # If we're not using GNU ld, then there's no point in even trying these
211   # tests.  Check for that first.  We should have already tested for gld
212   # by now (in libtool), but require it now just to be safe...
213   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
214   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
215   AC_REQUIRE([AC_PROG_LD])
216   AC_REQUIRE([AC_PROG_AWK])
217
218   # The name set by libtool depends on the version of libtool.  Shame on us
219   # for depending on an impl detail, but c'est la vie.  Older versions used
220   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
221   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
222   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
223   # set (hence we're using an older libtool), then set it.
224   if test x${with_gnu_ld+set} != xset; then
225     if test x${ac_cv_prog_gnu_ld+set} != xset; then
226       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
227       with_gnu_ld=no
228     else
229       with_gnu_ld=$ac_cv_prog_gnu_ld
230     fi
231   fi
232
233   # Start by getting the version number.  I think the libtool test already
234   # does some of this, but throws away the result.
235   glibcxx_ld_is_gold=no
236   if test x"$with_gnu_ld" = x"yes"; then
237     AC_MSG_CHECKING([for ld version])
238     changequote(,)
239     if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
240       glibcxx_ld_is_gold=yes
241     fi
242     ldver=`$LD --version 2>/dev/null | head -1 | \
243            sed -e 's/GNU \(go\)\{0,1\}ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\4/'`
244     changequote([,])
245     glibcxx_gnu_ld_version=`echo $ldver | \
246            $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
247     AC_MSG_RESULT($glibcxx_gnu_ld_version)
248   fi
249
250   # Set --gc-sections.
251   glibcxx_have_gc_sections=no
252   if test "$glibcxx_ld_is_gold" = "yes"; then
253     if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
254       glibcxx_have_gc_sections=yes
255     fi
256   else
257     glibcxx_gcsections_min_ld=21602
258     if test x"$with_gnu_ld" = x"yes" && 
259         test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
260       glibcxx_have_gc_sections=yes
261     fi
262   fi
263   if test "$glibcxx_have_gc_sections" = "yes"; then
264     # Sufficiently young GNU ld it is!  Joy and bunny rabbits!
265     # NB: This flag only works reliably after 2.16.1. Configure tests
266     # for this are difficult, so hard wire a value that should work.
267
268     ac_test_CFLAGS="${CFLAGS+set}"
269     ac_save_CFLAGS="$CFLAGS"
270     CFLAGS='-Wl,--gc-sections'
271
272     # Check for -Wl,--gc-sections
273     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
274     AC_TRY_LINK([ int one(void) { return 1; }
275      int two(void) { return 2; }
276         ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
277     if test "$ac_gcsections" = "yes"; then
278       rm -f conftest.c
279       touch conftest.c
280       if $CC -c conftest.c; then
281         if $LD --gc-sections -o conftest conftest.o 2>&1 | \
282            grep "Warning: gc-sections option ignored" > /dev/null; then
283           ac_gcsections=no
284         fi
285       fi
286       rm -f conftest.c conftest.o conftest
287     fi
288     if test "$ac_gcsections" = "yes"; then
289       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
290     fi
291     AC_MSG_RESULT($ac_gcsections)
292
293     if test "$ac_test_CFLAGS" = set; then
294       CFLAGS="$ac_save_CFLAGS"
295     else
296       # this is the suspicious part
297       CFLAGS=''
298     fi
299   fi
300
301   # Set -z,relro.
302   # Note this is only for shared objects.
303   ac_ld_relro=no
304   if test x"$with_gnu_ld" = x"yes"; then
305     AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
306     cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
307     if test -n "$cxx_z_relo"; then
308       OPT_LDFLAGS="-Wl,-z,relro"
309       ac_ld_relro=yes
310     fi
311     AC_MSG_RESULT($ac_ld_relro)
312   fi
313
314   # Set linker optimization flags.
315   if test x"$with_gnu_ld" = x"yes"; then
316     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
317   fi
318
319   AC_SUBST(SECTION_LDFLAGS)
320   AC_SUBST(OPT_LDFLAGS)
321 ])
322
323
324 dnl
325 dnl Check for headers for, and arguments to, the setrlimit() function.
326 dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
327 dnl
328 dnl Defines:
329 dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits 
330 dnl  various HAVE_LIMIT_* for individual limit names
331 dnl
332 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
333   AC_MSG_CHECKING([for RLIMIT_$1])
334   AC_TRY_COMPILE(
335     [#include <unistd.h>
336      #include <sys/time.h>
337      #include <sys/resource.h>
338     ],
339     [ int f = RLIMIT_$1 ; ],
340     [glibcxx_mresult=1], [glibcxx_mresult=0])
341   AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
342                      [Only used in build directory testsuite_hooks.h.])
343   if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
344   AC_MSG_RESULT($res)
345 ])
346
347 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
348   setrlimit_have_headers=yes
349   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
350                    [],
351                    [setrlimit_have_headers=no])
352   # If don't have the headers, then we can't run the tests now, and we
353   # won't be seeing any of these during testsuite compilation.
354   if test $setrlimit_have_headers = yes; then
355     # Can't do these in a loop, else the resulting syntax is wrong.
356     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
357     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
358     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
359     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
360     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
361
362     # Check for rlimit, setrlimit.
363     AC_CACHE_VAL(glibcxx_cv_setrlimit, [
364       AC_TRY_COMPILE(
365         [#include <unistd.h>
366          #include <sys/time.h>
367          #include <sys/resource.h>
368         ],
369         [struct rlimit r;
370          setrlimit(0, &r);],
371         [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
372     ])
373   fi
374
375   AC_MSG_CHECKING([for testsuite resource limits support])
376   if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
377     ac_res_limits=yes
378     AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
379               [Define if using setrlimit to set resource limits during
380               "make check"])
381   else
382     ac_res_limits=no
383   fi
384   AC_MSG_RESULT($ac_res_limits)
385 ])
386
387
388 dnl
389 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
390 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
391 dnl
392 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
393   AC_MSG_CHECKING([for S_ISREG or S_IFREG])
394   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
395     AC_TRY_LINK(
396       [#include <sys/stat.h>],
397       [struct stat buffer;
398        fstat(0, &buffer);
399        S_ISREG(buffer.st_mode);],
400       [glibcxx_cv_S_ISREG=yes],
401       [glibcxx_cv_S_ISREG=no])
402   ])
403   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
404     AC_TRY_LINK(
405       [#include <sys/stat.h>],
406       [struct stat buffer;
407        fstat(0, &buffer);
408        S_IFREG & buffer.st_mode;],
409       [glibcxx_cv_S_IFREG=yes],
410       [glibcxx_cv_S_IFREG=no])
411   ])
412   res=no
413   if test $glibcxx_cv_S_ISREG = yes; then
414     AC_DEFINE(HAVE_S_ISREG, 1, 
415               [Define if S_IFREG is available in <sys/stat.h>.])
416     res=S_ISREG
417   elif test $glibcxx_cv_S_IFREG = yes; then
418     AC_DEFINE(HAVE_S_IFREG, 1,
419               [Define if S_IFREG is available in <sys/stat.h>.])
420     res=S_IFREG
421   fi
422   AC_MSG_RESULT($res)
423 ])
424
425
426 dnl
427 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
428 dnl
429 AC_DEFUN([GLIBCXX_CHECK_POLL], [
430   AC_MSG_CHECKING([for poll])
431   AC_CACHE_VAL(glibcxx_cv_POLL, [
432     AC_TRY_LINK(
433       [#include <poll.h>],
434       [struct pollfd pfd[1];
435        pfd[0].events = POLLIN;
436        poll(pfd, 1, 0);],
437       [glibcxx_cv_POLL=yes],
438       [glibcxx_cv_POLL=no])
439   ])
440   if test $glibcxx_cv_POLL = yes; then
441     AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
442   fi
443   AC_MSG_RESULT($glibcxx_cv_POLL)
444 ])
445
446
447 dnl
448 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
449 dnl
450 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
451   AC_MSG_CHECKING([for writev])
452   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
453     AC_TRY_LINK(
454       [#include <sys/uio.h>],
455       [struct iovec iov[2];
456        writev(0, iov, 0);],
457       [glibcxx_cv_WRITEV=yes],
458       [glibcxx_cv_WRITEV=no])
459   ])
460   if test $glibcxx_cv_WRITEV = yes; then
461     AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
462   fi
463   AC_MSG_RESULT($glibcxx_cv_WRITEV)
464 ])
465
466
467 dnl
468 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
469 dnl Also check whether int64_t is actually a typedef to long or long long.
470 dnl
471 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
472
473   AC_LANG_SAVE
474   AC_LANG_CPLUSPLUS
475
476   AC_MSG_CHECKING([for int64_t])
477   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
478     AC_TRY_COMPILE(
479       [#include <stdint.h>],
480       [int64_t var;],
481       [glibcxx_cv_INT64_T=yes],
482       [glibcxx_cv_INT64_T=no])
483   ])
484
485   if test $glibcxx_cv_INT64_T = yes; then
486     AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
487     AC_MSG_RESULT($glibcxx_cv_INT64_T)
488
489     AC_MSG_CHECKING([for int64_t as long])
490     AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
491       AC_TRY_COMPILE(
492         [#include <stdint.h>
493         template<typename, typename> struct same { enum { value = -1 }; };
494         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
495         int array[same<int64_t, long>::value];], [],
496         [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
497     ])
498
499     if test $glibcxx_cv_int64_t_long = yes; then
500       AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
501       AC_MSG_RESULT($glibcxx_cv_int64_t_long)
502     fi
503
504     AC_MSG_CHECKING([for int64_t as long long])
505     AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
506       AC_TRY_COMPILE(
507         [#include <stdint.h>
508         template<typename, typename> struct same { enum { value = -1 }; };
509         template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
510         int array[same<int64_t, long long>::value];], [],
511         [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
512     ])
513
514     if test $glibcxx_cv_int64_t_long_long = yes; then
515       AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
516       AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
517     fi
518   fi
519
520   AC_LANG_RESTORE
521 ])
522
523
524 dnl
525 dnl Check whether LFS support is available.
526 dnl
527 AC_DEFUN([GLIBCXX_CHECK_LFS], [
528   AC_LANG_SAVE
529   AC_LANG_CPLUSPLUS
530   ac_save_CXXFLAGS="$CXXFLAGS"
531   CXXFLAGS="$CXXFLAGS -fno-exceptions"  
532   AC_MSG_CHECKING([for LFS support])
533   AC_CACHE_VAL(glibcxx_cv_LFS, [
534     AC_TRY_LINK(
535       [#include <unistd.h>
536        #include <stdio.h>
537        #include <sys/stat.h>
538       ],
539       [FILE* fp;
540        fopen64("t", "w");
541        fseeko64(fp, 0, SEEK_CUR);
542        ftello64(fp);
543        lseek64(1, 0, SEEK_CUR);
544        struct stat64 buf;
545        fstat64(1, &buf);],
546       [glibcxx_cv_LFS=yes],
547       [glibcxx_cv_LFS=no])
548   ])
549   if test $glibcxx_cv_LFS = yes; then
550     AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
551   fi
552   AC_MSG_RESULT($glibcxx_cv_LFS)
553   CXXFLAGS="$ac_save_CXXFLAGS"
554   AC_LANG_RESTORE
555 ])
556
557
558 dnl
559 dnl Check for whether a fully dynamic basic_string implementation should
560 dnl be turned on, that does not put empty objects in per-process static
561 dnl memory (mostly useful together with shared memory allocators, see PR
562 dnl libstdc++/16612 for details).
563 dnl
564 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
565 dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
566 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
567 dnl       Where DEFAULT is either `yes' or `no'.
568 dnl
569 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
570   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
571   if test $enable_fully_dynamic_string = yes; then
572     AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
573               [Define if a fully dynamic basic_string is wanted.])
574   fi
575 ])
576
577
578 dnl
579 dnl Does any necessary configuration of the testsuite directory.  Generates
580 dnl the testsuite_hooks.h header.
581 dnl
582 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
583 dnl
584 dnl Sets:
585 dnl  enable_abi_check 
586 dnl  GLIBCXX_TEST_WCHAR_T
587 dnl  GLIBCXX_TEST_THREAD
588 dnl Substs:
589 dnl  baseline_dir
590 dnl
591 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
592   if $GLIBCXX_IS_NATIVE ; then
593     # Do checks for resource limit functions.
594     GLIBCXX_CHECK_SETRLIMIT
595
596     # Look for setenv, so that extended locale tests can be performed.
597     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
598   fi
599
600   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
601      test $enable_symvers != no; then
602     case "$host" in
603       *-*-cygwin*)
604         enable_abi_check=no ;;
605       *)
606         enable_abi_check=yes ;;
607     esac
608   else
609     # Only build this as native, since automake does not understand
610     # CXX_FOR_BUILD.
611     enable_abi_check=no
612   fi
613   
614   # Export file names for ABI checking.
615   baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}\$(MULTISUBDIR)"
616   AC_SUBST(baseline_dir)
617 ])
618
619
620 dnl
621 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
622 dnl
623 dnl Substs:
624 dnl  GLIBCXX_INCLUDES
625 dnl  TOPLEVEL_INCLUDES
626 dnl
627 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
628   # Used for every C++ compile we perform.
629   GLIBCXX_INCLUDES="\
630 -I$glibcxx_builddir/include/$host_alias \
631 -I$glibcxx_builddir/include \
632 -I$glibcxx_srcdir/libsupc++"
633
634   # For Canadian crosses, pick this up too.
635   if test $CANADIAN = yes; then
636     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
637   fi
638
639   # Stuff in the actual top level.  Currently only used by libsupc++ to
640   # get unwind* headers from the gcc dir.
641   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
642   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
643
644   # Now, export this to all the little Makefiles....
645   AC_SUBST(GLIBCXX_INCLUDES)
646   AC_SUBST(TOPLEVEL_INCLUDES)
647 ])
648
649
650 dnl
651 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
652 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
653 dnl
654 dnl Substs:
655 dnl  OPTIMIZE_CXXFLAGS
656 dnl  WARN_FLAGS
657 dnl
658 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
659   # Optimization flags that are probably a good idea for thrill-seekers. Just
660   # uncomment the lines below and make, everything else is ready to go...
661   # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
662   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
663   AC_SUBST(OPTIMIZE_CXXFLAGS)
664
665   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
666   AC_SUBST(WARN_FLAGS)
667 ])
668
669
670 dnl
671 dnl All installation directory information is determined here.
672 dnl
673 dnl Substs:
674 dnl  gxx_install_dir
675 dnl  glibcxx_prefixdir
676 dnl  glibcxx_toolexecdir
677 dnl  glibcxx_toolexeclibdir
678 dnl
679 dnl Assumes cross_compiling bits already done, and with_cross_host in
680 dnl particular.
681 dnl
682 dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
683 dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
684 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
685   glibcxx_toolexecdir=no
686   glibcxx_toolexeclibdir=no
687   glibcxx_prefixdir=$prefix
688
689   AC_MSG_CHECKING([for gxx-include-dir])
690   AC_ARG_WITH([gxx-include-dir],
691     AC_HELP_STRING([--with-gxx-include-dir=DIR],
692                    [installation directory for include files]),
693     [case "$withval" in
694       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
695       no)  gxx_include_dir=no ;;
696       *)   gxx_include_dir=$withval ;;
697      esac],
698     [gxx_include_dir=no])
699   AC_MSG_RESULT($gxx_include_dir)
700
701   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
702   AC_ARG_ENABLE([version-specific-runtime-libs],
703     AC_HELP_STRING([--enable-version-specific-runtime-libs],
704                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
705     [case "$enableval" in
706       yes) version_specific_libs=yes ;;
707       no)  version_specific_libs=no ;;
708       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
709      esac],
710     [version_specific_libs=no])
711   AC_MSG_RESULT($version_specific_libs)
712
713   # Default case for install directory for include files.
714   if test $version_specific_libs = no && test $gxx_include_dir = no; then
715     gxx_include_dir='include/c++/${gcc_version}'
716     if test -n "$with_cross_host" && 
717        test x"$with_cross_host" != x"no"; then  
718       gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
719     else
720       gxx_include_dir='${prefix}/'"$gxx_include_dir"
721     fi
722   fi
723
724   # Version-specific runtime libs processing.
725   if test $version_specific_libs = yes; then
726     # Need the gcc compiler version to know where to install libraries
727     # and header files if --enable-version-specific-runtime-libs option
728     # is selected.  FIXME: these variables are misnamed, there are
729     # no executables installed in _toolexecdir or _toolexeclibdir.
730     if test x"$gxx_include_dir" = x"no"; then
731       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
732     fi
733     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
734     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
735   fi
736
737   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
738   # Install a library built with a cross compiler in tooldir, not libdir.
739   if test x"$glibcxx_toolexecdir" = x"no"; then
740     if test -n "$with_cross_host" &&
741        test x"$with_cross_host" != x"no"; then
742       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
743       glibcxx_toolexeclibdir='${toolexecdir}/lib'
744     else
745       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
746       glibcxx_toolexeclibdir='${libdir}'
747     fi
748     multi_os_directory=`$CXX -print-multi-os-directory`
749     case $multi_os_directory in
750       .) ;; # Avoid trailing /.
751       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
752     esac
753   fi
754
755   AC_MSG_CHECKING([for install location])
756   AC_MSG_RESULT($gxx_include_dir)
757
758   AC_SUBST(glibcxx_prefixdir)
759   AC_SUBST(gxx_include_dir)
760   AC_SUBST(glibcxx_toolexecdir)
761   AC_SUBST(glibcxx_toolexeclibdir)
762 ])
763
764
765 dnl
766 dnl GLIBCXX_ENABLE
767 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
768 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
769 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
770 dnl
771 dnl See docs/html/17_intro/configury.html#enable for documentation.
772 dnl
773 m4_define([GLIBCXX_ENABLE],[dnl
774 m4_define([_g_switch],[--enable-$1])dnl
775 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
776  AC_ARG_ENABLE($1,_g_help,
777   m4_bmatch([$5],
778    [^permit ],
779      [[
780       case "$enableval" in
781        m4_bpatsubst([$5],[permit ])) ;;
782        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
783           dnl Idea for future:  generate a URL pointing to
784           dnl "onlinedocs/configopts.html#whatever"
785       esac
786      ]],
787    [^$],
788      [[
789       case "$enableval" in
790        yes|no) ;;
791        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
792       esac
793      ]],
794    [[$5]]),
795   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
796 m4_undefine([_g_switch])dnl
797 m4_undefine([_g_help])dnl
798 ])
799
800
801 dnl
802 dnl Check for ISO/IEC 9899:1999 "C99" support.
803 dnl
804 dnl --enable-c99 defines _GLIBCXX_USE_C99
805 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
806 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
807 dnl       Where DEFAULT is either `yes' or `no'.
808 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
809 dnl
810 AC_DEFUN([GLIBCXX_ENABLE_C99], [
811   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
812
813   if test x"$enable_c99" = x"yes"; then
814
815   AC_LANG_SAVE
816   AC_LANG_CPLUSPLUS
817
818   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
819   # undefined and fake C99 facilities - like pre-standard snprintf - may be
820   # spuriously enabled.
821   # Long term, -std=c++0x could be even better, could manage to explicitely
822   # request C99 facilities to the underlying C headers.
823   ac_save_CXXFLAGS="$CXXFLAGS"
824   CXXFLAGS="$CXXFLAGS -std=c++98"
825   ac_save_LIBS="$LIBS"
826   ac_save_gcc_no_link="$gcc_no_link"
827
828   if test x$gcc_no_link != xyes; then
829     # Use -fno-exceptions to that the C driver can link these tests without
830     # hitting undefined references to personality routines.
831     CXXFLAGS="$CXXFLAGS -fno-exceptions"
832     AC_CHECK_LIB(m, sin, [
833       LIBS="$LIBS -lm"
834     ], [
835       # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
836       gcc_no_link=yes
837     ])
838   fi
839
840   # Check for the existence of <math.h> functions used if C99 is enabled.
841   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
842   AC_CACHE_VAL(glibcxx_cv_c99_math, [
843   GCC_TRY_COMPILE_OR_LINK(
844      [#include <math.h>
845       volatile double d1, d2;
846       volatile int i;],
847      [i = fpclassify(d1);
848       i = isfinite(d1);
849       i = isinf(d1);
850       i = isnan(d1);
851       i = isnormal(d1);
852       i = signbit(d1);
853       i = isgreater(d1, d2);
854       i = isgreaterequal(d1, d2);
855       i = isless(d1, d2);
856       i = islessequal(d1, d2);
857       i = islessgreater(d1, d2);
858       i = islessgreater(d1, d2);
859       i = isunordered(d1, d2);
860      ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
861   ])
862   AC_MSG_RESULT($glibcxx_cv_c99_math)
863   if test x"$glibcxx_cv_c99_math" = x"yes"; then
864     AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
865               [Define if C99 functions or macros in <math.h> should be imported
866               in <cmath> in namespace std.])
867   fi
868
869   # Check for the existence of <complex.h> complex math functions.
870   # This is necessary even though libstdc++ uses the builtin versions
871   # of these functions, because if the builtin cannot be used, a reference
872   # to the library function is emitted.
873   AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
874   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
875   glibcxx_cv_c99_complex=no;
876   if test x"$ac_has_complex_h" = x"yes"; then
877     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
878     GCC_TRY_COMPILE_OR_LINK(
879        [#include <complex.h>
880         typedef __complex__ float float_type;
881         typedef __complex__ double double_type;
882         typedef __complex__ long double ld_type;
883         volatile float_type tmpf;
884         volatile double_type tmpd;
885         volatile ld_type tmpld;
886         volatile float f;
887         volatile double d;
888         volatile long double ld;],
889        [f = cabsf(tmpf);
890         f = cargf(tmpf);
891         tmpf = ccosf(tmpf);
892         tmpf = ccoshf(tmpf);
893         tmpf = cexpf(tmpf);
894         tmpf = clogf(tmpf);
895         tmpf = csinf(tmpf);
896         tmpf = csinhf(tmpf);
897         tmpf = csqrtf(tmpf);
898         tmpf = ctanf(tmpf);
899         tmpf = ctanhf(tmpf);
900         tmpf = cpowf(tmpf, tmpf);
901         tmpf = cprojf(tmpf);
902         d = cabs(tmpd);
903         d = carg(tmpd);
904         tmpd = ccos(tmpd);
905         tmpd = ccosh(tmpd);
906         tmpd = cexp(tmpd);
907         tmpd = clog(tmpd);
908         tmpd = csin(tmpd);
909         tmpd = csinh(tmpd);
910         tmpd = csqrt(tmpd);
911         tmpd = ctan(tmpd);
912         tmpd = ctanh(tmpd);
913         tmpd = cpow(tmpd, tmpd);
914         tmpd = cproj(tmpd);
915         ld = cabsl(tmpld);
916         ld = cargl(tmpld);
917         tmpld = ccosl(tmpld);
918         tmpld = ccoshl(tmpld);
919         tmpld = cexpl(tmpld);
920         tmpld = clogl(tmpld);
921         tmpld = csinl(tmpld);
922         tmpld = csinhl(tmpld);
923         tmpld = csqrtl(tmpld);
924         tmpld = ctanl(tmpld);
925         tmpld = ctanhl(tmpld);
926         tmpld = cpowl(tmpld, tmpld);
927         tmpld = cprojl(tmpld);
928        ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
929   fi
930   AC_MSG_RESULT($glibcxx_cv_c99_complex)
931   if test x"$glibcxx_cv_c99_complex" = x"yes"; then
932     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
933               [Define if C99 functions in <complex.h> should be used in
934               <complex>. Using compiler builtins for these functions requires
935               corresponding C99 library functions to be present.])
936   fi
937
938   # Check for the existence in <stdio.h> of vscanf, et. al.
939   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
940   AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
941   GCC_TRY_COMPILE_OR_LINK(
942      [#include <stdio.h>
943       #include <stdarg.h>
944       void foo(char* fmt, ...)
945       {
946         va_list args; va_start(args, fmt);
947         vfscanf(stderr, "%i", args); 
948         vscanf("%i", args);
949         vsnprintf(fmt, 0, "%i", args);
950         vsscanf(fmt, "%i", args);
951       }],
952      [snprintf("12", 0, "%i");],
953      [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
954   ])
955   AC_MSG_RESULT($glibcxx_cv_c99_stdio)
956
957   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
958   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
959   AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
960   GCC_TRY_COMPILE_OR_LINK(
961      [#include <stdlib.h>
962       volatile float f;
963       volatile long double ld;
964       volatile unsigned long long ll;
965       lldiv_t mydivt;],
966      [char* tmp;
967       f = strtof("gnu", &tmp);
968       ld = strtold("gnu", &tmp);
969       ll = strtoll("gnu", &tmp, 10);
970       ll = strtoull("gnu", &tmp, 10);
971       ll = llabs(10);
972       mydivt = lldiv(10,1);
973       ll = mydivt.quot;
974       ll = mydivt.rem;
975       ll = atoll("10");
976       _Exit(0);
977       ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
978   ])
979   AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
980
981   # Check for the existence in <wchar.h> of wcstold, etc.
982   glibcxx_cv_c99_wchar=no;
983   if test x"$ac_has_wchar_h" = xyes &&
984      test x"$ac_has_wctype_h" = xyes; then
985     AC_MSG_CHECKING([for ISO C99 support in <wchar.h>]) 
986     AC_TRY_COMPILE([#include <wchar.h>
987                     namespace test
988                     {
989                       using ::wcstold;
990                       using ::wcstoll;
991                       using ::wcstoull;
992                     }
993                    ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
994
995     # Checks for wide character functions that may not be present.
996     # Injection of these is wrapped with guard macros.
997     # NB: only put functions here, instead of immediately above, if
998     # absolutely necessary.
999     AC_TRY_COMPILE([#include <wchar.h>
1000                     namespace test { using ::vfwscanf; } ], [],
1001                    [AC_DEFINE(HAVE_VFWSCANF,1,
1002                         [Defined if vfwscanf exists.])],[])
1003
1004     AC_TRY_COMPILE([#include <wchar.h>
1005                     namespace test { using ::vswscanf; } ], [],
1006                    [AC_DEFINE(HAVE_VSWSCANF,1,
1007                         [Defined if vswscanf exists.])],[])
1008
1009     AC_TRY_COMPILE([#include <wchar.h>
1010                     namespace test { using ::vwscanf; } ], [],
1011                    [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1012
1013     AC_TRY_COMPILE([#include <wchar.h>
1014                     namespace test { using ::wcstof; } ], [],
1015                    [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1016
1017     AC_TRY_COMPILE([#include <wctype.h>],
1018                    [ wint_t t; int i = iswblank(t);], 
1019                    [AC_DEFINE(HAVE_ISWBLANK,1,
1020                         [Defined if iswblank exists.])],[])
1021
1022     AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1023   fi
1024
1025   # Option parsed, now set things appropriately.
1026   if test x"$glibcxx_cv_c99_math" = x"no" ||
1027      test x"$glibcxx_cv_c99_complex" = x"no" ||
1028      test x"$glibcxx_cv_c99_stdio" = x"no" ||
1029      test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1030      test x"$glibcxx_cv_c99_wchar" = x"no"; then
1031     enable_c99=no;
1032   else
1033     AC_DEFINE(_GLIBCXX_USE_C99, 1,
1034     [Define if C99 functions or macros from <wchar.h>, <math.h>,
1035     <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1036   fi
1037
1038   gcc_no_link="$ac_save_gcc_no_link"
1039   LIBS="$ac_save_LIBS"
1040   CXXFLAGS="$ac_save_CXXFLAGS"
1041   AC_LANG_RESTORE
1042   fi    
1043
1044   AC_MSG_CHECKING([for fully enabled ISO C99 support])
1045   AC_MSG_RESULT($enable_c99)
1046 ])
1047
1048
1049 dnl
1050 dnl Check for IEEE Std 1003.1-2001 clock_gettime required for 
1051 dnl 20.8.5 [time.clock] in the current C++0X working draft.
1052 dnl
1053 AC_DEFUN([GLIBCXX_CHECK_CLOCK_GETTIME], [
1054
1055   AC_LANG_SAVE
1056   AC_LANG_CPLUSPLUS
1057   ac_save_CXXFLAGS="$CXXFLAGS"
1058   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1059   ac_save_LIBS="$LIBS"
1060
1061   AC_SEARCH_LIBS(clock_gettime, [posix4])
1062
1063   # Link to -lposix4.
1064   case "$ac_cv_search_clock_gettime" in
1065     -lposix4*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1066   esac
1067
1068   AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1069   
1070   ac_has_clock_monotonic=no;  
1071   ac_has_clock_realtime=no;  
1072   if test x"$ac_has_unistd_h" = x"yes"; then    
1073     AC_MSG_CHECKING([for monotonic clock])
1074     AC_TRY_LINK(
1075       [#include <unistd.h>
1076        #include <time.h>
1077       ],
1078       [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1079         timespec tp;     
1080        #endif
1081         clock_gettime(CLOCK_MONOTONIC, &tp);
1082       ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1083     
1084     AC_MSG_RESULT($ac_has_clock_monotonic)   
1085     
1086     AC_MSG_CHECKING([for realtime clock])
1087     AC_TRY_LINK(
1088       [#include <unistd.h>
1089        #include <time.h>
1090       ],
1091       [#if _POSIX_TIMERS > 0
1092         timespec tp;      
1093        #endif
1094         clock_gettime(CLOCK_REALTIME, &tp);
1095       ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1096     
1097     AC_MSG_RESULT($ac_has_clock_realtime)
1098   fi 
1099   
1100   if test x"$ac_has_clock_monotonic" = x"yes"; then
1101     AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1102       [ Defined if clock_gettime has monotonic clock support. ])
1103   fi
1104
1105   if test x"$ac_has_clock_realtime" = x"yes"; then
1106     AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1107       [ Defined if clock_gettime has realtime clock support. ])
1108   fi
1109
1110   AC_SUBST(GLIBCXX_LIBS)
1111
1112   CXXFLAGS="$ac_save_CXXFLAGS"
1113   LIBS="$ac_save_LIBS"
1114   AC_LANG_RESTORE
1115 ])
1116
1117 dnl
1118 dnl Check for IEEE Std 1003.1-2001 gettimeofday required for 
1119 dnl 20.8.5 [time.clock] in the current C++0X working draft.
1120 dnl
1121 AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1122   
1123   AC_LANG_SAVE
1124   AC_LANG_CPLUSPLUS
1125   ac_save_CXXFLAGS="$CXXFLAGS"
1126   CXXFLAGS="$CXXFLAGS -fno-exceptions"
1127   
1128   ac_has_gettimeofday=no;
1129   AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1130   if test x"$ac_has_sys_time_h" = x"yes"; then
1131     AC_MSG_CHECKING([for gettimeofday])
1132     AC_TRY_LINK([#include <sys/time.h>],
1133       [timeval tv; gettimeofday(&tv, 0);],
1134       [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1135     
1136     AC_MSG_RESULT($ac_has_gettimeofday)
1137   fi
1138   
1139   if test x"$ac_has_gettimeofday" = x"yes"; then
1140     AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1141       [ Defined if gettimeofday is available. ])
1142   fi
1143   
1144   CXXFLAGS="$ac_save_CXXFLAGS"
1145   AC_LANG_RESTORE
1146 ])
1147
1148 dnl
1149 dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1150 dnl facilities in Chapter 8, "C compatibility".
1151 dnl
1152 AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1153
1154   AC_LANG_SAVE
1155   AC_LANG_CPLUSPLUS
1156
1157   # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1158   # undefined and fake C99 facilities may be spuriously enabled.
1159   ac_save_CXXFLAGS="$CXXFLAGS"
1160   CXXFLAGS="$CXXFLAGS -std=c++98"
1161
1162   # Check for the existence of <complex.h> complex math functions used
1163   # by tr1/complex.
1164   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1165   ac_c99_complex_tr1=no;
1166   if test x"$ac_has_complex_h" = x"yes"; then
1167     AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1168     AC_TRY_COMPILE([#include <complex.h>],
1169                    [typedef __complex__ float float_type; float_type tmpf;
1170                     cacosf(tmpf);
1171                     casinf(tmpf);
1172                     catanf(tmpf);
1173                     cacoshf(tmpf);
1174                     casinhf(tmpf);
1175                     catanhf(tmpf);
1176                     typedef __complex__ double double_type; double_type tmpd;
1177                     cacos(tmpd);
1178                     casin(tmpd);
1179                     catan(tmpd);
1180                     cacosh(tmpd);
1181                     casinh(tmpd);
1182                     catanh(tmpd);
1183                     typedef __complex__ long double ld_type; ld_type tmpld;
1184                     cacosl(tmpld);
1185                     casinl(tmpld);
1186                     catanl(tmpld);
1187                     cacoshl(tmpld);
1188                     casinhl(tmpld);
1189                     catanhl(tmpld);
1190                    ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1191   fi
1192   AC_MSG_RESULT($ac_c99_complex_tr1)
1193   if test x"$ac_c99_complex_tr1" = x"yes"; then
1194     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1195               [Define if C99 functions in <complex.h> should be used in
1196               <tr1/complex>. Using compiler builtins for these functions
1197               requires corresponding C99 library functions to be present.])
1198   fi
1199
1200   # Check for the existence of <ctype.h> functions.
1201   AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1202   AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1203   AC_TRY_COMPILE([#include <ctype.h>],
1204                  [int ch;
1205                   int ret;
1206                   ret = isblank(ch);
1207                  ],[glibcxx_cv_c99_ctype_tr1=yes],
1208                    [glibcxx_cv_c99_ctype_tr1=no])
1209   ])
1210   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1211   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1212     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1213               [Define if C99 functions in <ctype.h> should be imported in
1214               <tr1/cctype> in namespace std::tr1.])
1215   fi
1216
1217   # Check for the existence of <fenv.h> functions.
1218   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1219   ac_c99_fenv_tr1=no;
1220   if test x"$ac_has_fenv_h" = x"yes"; then
1221     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1222     AC_TRY_COMPILE([#include <fenv.h>],
1223                    [int except, mode;
1224                     fexcept_t* pflag;
1225                     fenv_t* penv;
1226                     int ret;
1227                     ret = feclearexcept(except);
1228                     ret = fegetexceptflag(pflag, except);
1229                     ret = feraiseexcept(except);
1230                     ret = fesetexceptflag(pflag, except);
1231                     ret = fetestexcept(except);
1232                     ret = fegetround();
1233                     ret = fesetround(mode);
1234                     ret = fegetenv(penv);
1235                     ret = feholdexcept(penv);
1236                     ret = fesetenv(penv);
1237                     ret = feupdateenv(penv);
1238                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1239   fi
1240   AC_MSG_RESULT($ac_c99_fenv_tr1)
1241   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1242     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1243               [Define if C99 functions in <fenv.h> should be imported in
1244               <tr1/cfenv> in namespace std::tr1.])
1245   fi
1246
1247   # Check for the existence of <stdint.h> types.
1248   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1249   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1250   AC_TRY_COMPILE([#include <stdint.h>],
1251                  [typedef int8_t          my_int8_t;
1252                   typedef int16_t         my_int16_t;
1253                   typedef int32_t         my_int32_t;
1254                   typedef int64_t         my_int64_t;
1255                   typedef int_fast8_t     my_int_fast8_t;
1256                   typedef int_fast16_t    my_int_fast16_t;
1257                   typedef int_fast32_t    my_int_fast32_t;
1258                   typedef int_fast64_t    my_int_fast64_t;      
1259                   typedef int_least8_t    my_int_least8_t;
1260                   typedef int_least16_t   my_int_least16_t;
1261                   typedef int_least32_t   my_int_least32_t;
1262                   typedef int_least64_t   my_int_least64_t;
1263                   typedef intmax_t        my_intmax_t;
1264                   typedef intptr_t        my_intptr_t;
1265                   typedef uint8_t         my_uint8_t;
1266                   typedef uint16_t        my_uint16_t;
1267                   typedef uint32_t        my_uint32_t;
1268                   typedef uint64_t        my_uint64_t;
1269                   typedef uint_fast8_t    my_uint_fast8_t;
1270                   typedef uint_fast16_t   my_uint_fast16_t;
1271                   typedef uint_fast32_t   my_uint_fast32_t;
1272                   typedef uint_fast64_t   my_uint_fast64_t;     
1273                   typedef uint_least8_t   my_uint_least8_t;
1274                   typedef uint_least16_t  my_uint_least16_t;
1275                   typedef uint_least32_t  my_uint_least32_t;
1276                   typedef uint_least64_t  my_uint_least64_t;
1277                   typedef uintmax_t       my_uintmax_t;
1278                   typedef uintptr_t       my_uintptr_t;
1279                  ],[glibcxx_cv_c99_stdint_tr1=yes],
1280                    [glibcxx_cv_c99_stdint_tr1=no])
1281   ])
1282   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1283   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1284     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1285               [Define if C99 types in <stdint.h> should be imported in
1286               <tr1/cstdint> in namespace std::tr1.])
1287   fi
1288
1289   # Check for the existence of <math.h> functions.
1290   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1291   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1292   AC_TRY_COMPILE([#include <math.h>],
1293                  [typedef double_t  my_double_t;
1294                   typedef float_t   my_float_t;
1295                   acosh(0.0);
1296                   acoshf(0.0f);
1297                   acoshl(0.0l);
1298                   asinh(0.0);
1299                   asinhf(0.0f);
1300                   asinhl(0.0l);
1301                   atanh(0.0);
1302                   atanhf(0.0f);
1303                   atanhl(0.0l);
1304                   cbrt(0.0);
1305                   cbrtf(0.0f);
1306                   cbrtl(0.0l);
1307                   copysign(0.0, 0.0);
1308                   copysignf(0.0f, 0.0f);
1309                   copysignl(0.0l, 0.0l);
1310                   erf(0.0);
1311                   erff(0.0f);
1312                   erfl(0.0l);
1313                   erfc(0.0);
1314                   erfcf(0.0f);
1315                   erfcl(0.0l);
1316                   exp2(0.0);
1317                   exp2f(0.0f);
1318                   exp2l(0.0l);
1319                   expm1(0.0);
1320                   expm1f(0.0f);
1321                   expm1l(0.0l);
1322                   fdim(0.0, 0.0);
1323                   fdimf(0.0f, 0.0f);
1324                   fdiml(0.0l, 0.0l);
1325                   fma(0.0, 0.0, 0.0);
1326                   fmaf(0.0f, 0.0f, 0.0f);
1327                   fmal(0.0l, 0.0l, 0.0l);
1328                   fmax(0.0, 0.0);
1329                   fmaxf(0.0f, 0.0f);
1330                   fmaxl(0.0l, 0.0l);
1331                   fmin(0.0, 0.0);
1332                   fminf(0.0f, 0.0f);
1333                   fminl(0.0l, 0.0l);
1334                   hypot(0.0, 0.0);
1335                   hypotf(0.0f, 0.0f);
1336                   hypotl(0.0l, 0.0l);
1337                   ilogb(0.0);
1338                   ilogbf(0.0f);
1339                   ilogbl(0.0l);
1340                   lgamma(0.0);
1341                   lgammaf(0.0f);
1342                   lgammal(0.0l);
1343                   llrint(0.0);
1344                   llrintf(0.0f);
1345                   llrintl(0.0l);
1346                   llround(0.0);
1347                   llroundf(0.0f);
1348                   llroundl(0.0l);
1349                   log1p(0.0);
1350                   log1pf(0.0f);
1351                   log1pl(0.0l);
1352                   log2(0.0);
1353                   log2f(0.0f);
1354                   log2l(0.0l);
1355                   logb(0.0);
1356                   logbf(0.0f);
1357                   logbl(0.0l);
1358                   lrint(0.0);
1359                   lrintf(0.0f);
1360                   lrintl(0.0l);
1361                   lround(0.0);
1362                   lroundf(0.0f);
1363                   lroundl(0.0l);
1364                   nan(0);
1365                   nanf(0);
1366                   nanl(0);
1367                   nearbyint(0.0);
1368                   nearbyintf(0.0f);
1369                   nearbyintl(0.0l);
1370                   nextafter(0.0, 0.0);
1371                   nextafterf(0.0f, 0.0f);
1372                   nextafterl(0.0l, 0.0l);
1373                   nexttoward(0.0, 0.0);
1374                   nexttowardf(0.0f, 0.0f);
1375                   nexttowardl(0.0l, 0.0l);
1376                   remainder(0.0, 0.0);
1377                   remainderf(0.0f, 0.0f);
1378                   remainderl(0.0l, 0.0l);
1379                   remquo(0.0, 0.0, 0);
1380                   remquo(0.0f, 0.0f, 0);
1381                   remquo(0.0l, 0.0l, 0);
1382                   rint(0.0);
1383                   rintf(0.0f);
1384                   rintl(0.0l);
1385                   round(0.0);
1386                   roundf(0.0f);
1387                   roundl(0.0l);
1388                   scalbln(0.0, 0l);
1389                   scalblnf(0.0f, 0l);
1390                   scalblnl(0.0l, 0l);
1391                   scalbn(0.0, 0);
1392                   scalbnf(0.0f, 0);
1393                   scalbnl(0.0l, 0);
1394                   tgamma(0.0);
1395                   tgammaf(0.0f);
1396                   tgammal(0.0l);
1397                   trunc(0.0);
1398                   truncf(0.0f);
1399                   truncl(0.0l);
1400                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1401   ])
1402   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1403   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1404     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1405               [Define if C99 functions or macros in <math.h> should be imported
1406               in <tr1/cmath> in namespace std::tr1.])
1407   fi
1408
1409   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1410   # sense if the previous check fails, per C99, 7.8/1).
1411   ac_c99_inttypes_tr1=no;
1412   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1413     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1414     AC_TRY_COMPILE([#include <inttypes.h>],
1415                    [intmax_t i, numer, denom, base;
1416                     const char* s;
1417                     char** endptr;
1418                     intmax_t ret = imaxabs(i);
1419                     imaxdiv_t dret = imaxdiv(numer, denom);
1420                     ret = strtoimax(s, endptr, base);
1421                     uintmax_t uret = strtoumax(s, endptr, base);
1422                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1423   fi
1424   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1425   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1426     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1427               [Define if C99 functions in <inttypes.h> should be imported in
1428               <tr1/cinttypes> in namespace std::tr1.])
1429   fi
1430
1431   # Check for the existence of the <stdbool.h> header.  
1432   AC_CHECK_HEADERS(stdbool.h)
1433
1434   CXXFLAGS="$ac_save_CXXFLAGS"
1435   AC_LANG_RESTORE
1436 ])
1437
1438 dnl
1439 dnl Check whether "dev/random" and "dev/urandom" are available for the
1440 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1441 dnl
1442 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1443
1444   AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1445   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1446   AC_TRY_RUN([#include <stdio.h>
1447               int main()
1448               {
1449                 return !(fopen("/dev/random", "r")
1450                          && fopen("/dev/urandom", "r"));
1451               }       
1452              ],
1453              [glibcxx_cv_random_tr1=yes], [glibcxx_cv_random_tr1=no],
1454              [glibcxx_cv_random_tr1=no])
1455   ])
1456   AC_MSG_RESULT($glibcxx_cv_random_tr1)
1457   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1458     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1459               [Define if dev/random and dev/urandom are available for
1460                the random_device of TR1 (Chapter 5.1).])
1461   fi
1462
1463 ])
1464
1465 dnl
1466 dnl Check whether EOF, SEEK_CUR, and SEEK_END have the most common values:
1467 dnl in that case including <cstdio> in some C++ headers can be avoided.
1468 dnl
1469 AC_DEFUN([GLIBCXX_CHECK_STDIO_MACROS], [
1470
1471   AC_MSG_CHECKING([for EOF == -1, SEEK_CUR == 1, SEEK_END == 2])
1472   AC_CACHE_VAL(glibcxx_cv_stdio_macros, [
1473   AC_TRY_COMPILE([#include <stdio.h>],
1474                  [#if ((EOF != -1) || (SEEK_CUR != 1) || (SEEK_END != 2))
1475                     unusual values...
1476                   #endif
1477                  ], [glibcxx_cv_stdio_macros=yes],
1478                     [glibcxx_cv_stdio_macros=no])
1479   ])
1480   AC_MSG_RESULT($glibcxx_cv_stdio_macros)
1481   if test x"$glibcxx_cv_stdio_macros" = x"yes"; then
1482     AC_DEFINE(_GLIBCXX_STDIO_MACROS, 1,
1483               [Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2.])
1484   fi
1485
1486 ])
1487
1488 dnl
1489 dnl Check whether macros, etc are present for <system_error>
1490 dnl
1491 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1492
1493 m4_pushdef([n_syserr], [1])dnl
1494 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1495                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1496                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY],
1497 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1498 AC_MSG_CHECKING([for syserr])
1499 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1500 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1501                                    [int i = syserr;])],
1502                   [glibcxx_cv_system_error[]n_syserr=yes],
1503                   [glibcxx_cv_system_error[]n_syserr=no])
1504 ])
1505 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1506 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1507   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1508 fi
1509 m4_define([n_syserr], m4_incr(n_syserr))dnl
1510 m4_popdef([SYSERR])dnl
1511 ])
1512 m4_popdef([n_syserr])dnl
1513 ])
1514
1515 dnl
1516 dnl Check whether C++200x's standard layout types are supported. 
1517 dnl
1518 AC_DEFUN([GLIBCXX_CHECK_STANDARD_LAYOUT], [
1519
1520   AC_MSG_CHECKING([for ISO C++200x standard layout type support])
1521   AC_CACHE_VAL(ac_standard_layout, [
1522   AC_LANG_SAVE
1523   AC_LANG_CPLUSPLUS
1524   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1525   ac_save_CXXFLAGS="$CXXFLAGS"
1526   CXXFLAGS='-std=gnu++0x'
1527
1528   AC_TRY_COMPILE([struct b
1529                   {
1530                     bool t;
1531
1532                     // Need standard layout relaxation from POD
1533                     private:        
1534                     b& operator=(const b&);
1535                     b(const b&);
1536                     };
1537
1538                     int main()
1539                     {
1540                       b tst1 = { false };
1541                        return 0;
1542                     }],,
1543              [ac_standard_layout=yes], [ac_standard_layout=no])
1544
1545   CXXFLAGS="$ac_save_CXXFLAGS"
1546   AC_LANG_RESTORE
1547   ])
1548   AC_MSG_RESULT($ac_standard_layout)
1549   if test x"$ac_standard_layout" = x"yes"; then
1550     AC_DEFINE(_GLIBCXX_USE_STANDARD_LAYOUT, 1,
1551               [Define if standard layout types are supported in C++200x.])
1552   fi
1553 ])
1554
1555 dnl
1556 dnl Check for what type of C headers to use.
1557 dnl
1558 dnl --enable-cheaders= [does stuff].
1559 dnl --disable-cheaders [does not do anything, really].
1560 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1561 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1562 dnl
1563 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1564   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1565     [construct "C" headers for g++], [permit c|c_std|c_global])
1566   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1567
1568   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1569
1570   # Allow overrides to configure.host here.
1571   if test $enable_cheaders = c_global; then
1572      c_compatibility=yes
1573   fi
1574
1575   if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1576      c_extra=yes
1577   fi
1578
1579   AC_SUBST(C_INCLUDE_DIR)
1580   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1581   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1582   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1583   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1584   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1585 ])
1586
1587
1588 dnl
1589 dnl Check for which locale library to use.  The choice is mapped to
1590 dnl a subdirectory of config/locale.
1591 dnl
1592 dnl Default is generic.
1593 dnl
1594 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1595   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1596     [use MODEL for target locale package],
1597     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1598
1599   # Deal with gettext issues.  Default to not using it (=no) until we detect
1600   # support for it later.  Let the user turn it off via --e/d, but let that
1601   # default to on for easier handling.
1602   USE_NLS=no
1603   AC_ARG_ENABLE(nls,
1604     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1605     [],
1606     [enable_nls=yes])
1607   
1608   # Either a known packaage, or "auto"
1609   if test $enable_clocale = no || test $enable_clocale = yes; then
1610      enable_clocale=auto
1611   fi
1612   enable_clocale_flag=$enable_clocale
1613
1614   # Probe for locale model to use if none specified.
1615   # Default to "generic".
1616   if test $enable_clocale_flag = auto; then
1617     case ${target_os} in
1618       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1619         enable_clocale_flag=gnu 
1620         ;;
1621       darwin* | freebsd*)
1622         enable_clocale_flag=darwin
1623         ;;
1624       *)
1625         enable_clocale_flag=generic
1626         ;;
1627     esac
1628   fi
1629
1630   # Sanity check model, and test for special functionality.
1631   if test $enable_clocale_flag = gnu; then
1632     AC_EGREP_CPP([_GLIBCXX_ok], [
1633     #include <features.h>
1634     #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1635       _GLIBCXX_ok
1636     #endif
1637     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1638
1639     if test $enable_clocale = auto; then
1640       # Test for bugs early in glibc-2.2.x series
1641       AC_TRY_RUN([
1642       #define _GNU_SOURCE 1
1643       #include <locale.h>
1644       #include <string.h>
1645       #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1646       extern __typeof(newlocale) __newlocale;
1647       extern __typeof(duplocale) __duplocale;
1648       extern __typeof(strcoll_l) __strcoll_l;
1649       #endif
1650       int main()
1651       {
1652         const char __one[] = "Äuglein Augmen";
1653         const char __two[] = "Äuglein";
1654         int i;
1655         int j;
1656         __locale_t        loc;
1657         __locale_t        loc_dup;
1658         loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1659         loc_dup = __duplocale(loc);
1660         i = __strcoll_l(__one, __two, loc);
1661         j = __strcoll_l(__one, __two, loc_dup);
1662         return 0;
1663       }
1664       ],
1665       [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1666       [enable_clocale_flag=generic])
1667     fi
1668
1669     # Set it to scream when it hurts.
1670     ac_save_CFLAGS="$CFLAGS"    
1671     CFLAGS="-Wimplicit-function-declaration -Werror"
1672
1673     # Use strxfrm_l if available.
1674     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1675                     #include <string.h>
1676                     #include <locale.h>],
1677                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);], 
1678                     AC_DEFINE(HAVE_STRXFRM_L, 1, 
1679                     [Define if strxfrm_l is available in <string.h>.]),)
1680     
1681     # Use strerror_l if available.
1682     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1683                     #include <string.h>
1684                     #include <locale.h>],
1685                     [__locale_t loc; strerror_l(5, loc);], 
1686                     AC_DEFINE(HAVE_STRERROR_L, 1, 
1687                     [Define if strerror_l is available in <string.h>.]),)
1688
1689     CFLAGS="$ac_save_CFLAGS"
1690   fi
1691
1692   # Perhaps use strerror_r if available, and strerror_l isn't.
1693   ac_save_CFLAGS="$CFLAGS"      
1694   CFLAGS="-Wimplicit-function-declaration -Werror"
1695   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1696                   #include <string.h>
1697                   #include <locale.h>],
1698                   [char s[128]; strerror_r(5, s, 128);], 
1699                   AC_DEFINE(HAVE_STRERROR_R, 1, 
1700                   [Define if strerror_r is available in <string.h>.]),)
1701   CFLAGS="$ac_save_CFLAGS"
1702
1703   # Set configure bits for specified locale package
1704   AC_MSG_CHECKING([for C locale to use])
1705   case ${enable_clocale_flag} in
1706     generic)
1707       AC_MSG_RESULT(generic)
1708
1709       CLOCALE_H=config/locale/generic/c_locale.h
1710       CLOCALE_CC=config/locale/generic/c_locale.cc
1711       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1712       CCOLLATE_CC=config/locale/generic/collate_members.cc
1713       CCTYPE_CC=config/locale/generic/ctype_members.cc
1714       CMESSAGES_H=config/locale/generic/messages_members.h
1715       CMESSAGES_CC=config/locale/generic/messages_members.cc
1716       CMONEY_CC=config/locale/generic/monetary_members.cc
1717       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1718       CTIME_H=config/locale/generic/time_members.h
1719       CTIME_CC=config/locale/generic/time_members.cc
1720       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1721       ;;
1722     darwin)
1723       AC_MSG_RESULT(darwin or freebsd)
1724
1725       CLOCALE_H=config/locale/generic/c_locale.h
1726       CLOCALE_CC=config/locale/generic/c_locale.cc
1727       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1728       CCOLLATE_CC=config/locale/generic/collate_members.cc
1729       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1730       CMESSAGES_H=config/locale/generic/messages_members.h
1731       CMESSAGES_CC=config/locale/generic/messages_members.cc
1732       CMONEY_CC=config/locale/generic/monetary_members.cc
1733       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1734       CTIME_H=config/locale/generic/time_members.h
1735       CTIME_CC=config/locale/generic/time_members.cc
1736       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1737       ;;
1738         
1739     gnu)
1740       AC_MSG_RESULT(gnu)
1741
1742       # Declare intention to use gettext, and add support for specific
1743       # languages.
1744       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1745       ALL_LINGUAS="de fr"
1746
1747       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1748       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1749       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1750         USE_NLS=yes
1751       fi
1752       # Export the build objects.
1753       for ling in $ALL_LINGUAS; do \
1754         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1755         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1756       done
1757       AC_SUBST(glibcxx_MOFILES)
1758       AC_SUBST(glibcxx_POFILES)
1759
1760       CLOCALE_H=config/locale/gnu/c_locale.h
1761       CLOCALE_CC=config/locale/gnu/c_locale.cc
1762       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1763       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1764       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1765       CMESSAGES_H=config/locale/gnu/messages_members.h
1766       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1767       CMONEY_CC=config/locale/gnu/monetary_members.cc
1768       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1769       CTIME_H=config/locale/gnu/time_members.h
1770       CTIME_CC=config/locale/gnu/time_members.cc
1771       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1772       ;;
1773     ieee_1003.1-2001)
1774       AC_MSG_RESULT(IEEE 1003.1)
1775
1776       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1777       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1778       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1779       CCOLLATE_CC=config/locale/generic/collate_members.cc
1780       CCTYPE_CC=config/locale/generic/ctype_members.cc
1781       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1782       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1783       CMONEY_CC=config/locale/generic/monetary_members.cc
1784       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1785       CTIME_H=config/locale/generic/time_members.h
1786       CTIME_CC=config/locale/generic/time_members.cc
1787       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1788       ;;
1789   esac
1790
1791   # This is where the testsuite looks for locale catalogs, using the
1792   # -DLOCALEDIR define during testsuite compilation.
1793   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1794   AC_SUBST(glibcxx_localedir)
1795
1796   # A standalone libintl (e.g., GNU libintl) may be in use.
1797   if test $USE_NLS = yes; then
1798     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1799     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1800   fi
1801   if test $USE_NLS = yes; then
1802     AC_DEFINE(_GLIBCXX_USE_NLS, 1, 
1803               [Define if NLS translations are to be used.])
1804   fi
1805
1806   AC_SUBST(USE_NLS)
1807   AC_SUBST(CLOCALE_H)
1808   AC_SUBST(CMESSAGES_H)
1809   AC_SUBST(CCODECVT_CC)
1810   AC_SUBST(CCOLLATE_CC)
1811   AC_SUBST(CCTYPE_CC)
1812   AC_SUBST(CMESSAGES_CC)
1813   AC_SUBST(CMONEY_CC)
1814   AC_SUBST(CNUMERIC_CC)
1815   AC_SUBST(CTIME_H)
1816   AC_SUBST(CTIME_CC)
1817   AC_SUBST(CLOCALE_CC)
1818   AC_SUBST(CLOCALE_INTERNAL_H)
1819 ])
1820
1821
1822 dnl
1823 dnl Check for which std::allocator base class to use.  The choice is
1824 dnl mapped from a subdirectory of include/ext.
1825 dnl
1826 dnl Default is new.
1827 dnl
1828 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1829   AC_MSG_CHECKING([for std::allocator base class])
1830   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1831     [use KIND for target std::allocator base],
1832     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1833
1834   # If they didn't use this option switch, or if they specified --enable
1835   # with no specific model, we'll have to look for one.  If they
1836   # specified --disable (???), do likewise.
1837   if test $enable_libstdcxx_allocator = no ||
1838      test $enable_libstdcxx_allocator = yes;
1839   then
1840      enable_libstdcxx_allocator=auto
1841   fi
1842
1843   # Either a known package, or "auto". Auto implies the default choice
1844   # for a particular platform.
1845   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1846
1847   # Probe for host-specific support if no specific model is specified.
1848   # Default to "new".
1849   if test $enable_libstdcxx_allocator_flag = auto; then
1850     case ${target_os} in
1851       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1852         enable_libstdcxx_allocator_flag=new
1853         ;;
1854       *)
1855         enable_libstdcxx_allocator_flag=new
1856         ;;
1857     esac
1858   fi
1859   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1860   
1861
1862   # Set configure bits for specified locale package
1863   case ${enable_libstdcxx_allocator_flag} in
1864     bitmap)
1865       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1866       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1867       ;;
1868     malloc)
1869       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1870       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1871       ;;
1872     mt)
1873       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1874       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1875       ;;
1876     new)
1877       ALLOCATOR_H=config/allocator/new_allocator_base.h
1878       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1879       ;;
1880     pool)
1881       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1882       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1883       ;;        
1884   esac
1885
1886   AC_SUBST(ALLOCATOR_H)
1887   AC_SUBST(ALLOCATOR_NAME)
1888 ])
1889
1890
1891 dnl
1892 dnl Check for whether the Boost-derived checks should be turned on.
1893 dnl
1894 dnl --enable-concept-checks turns them on.
1895 dnl --disable-concept-checks leaves them off.
1896 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1897 dnl       Where DEFAULT is either `yes' or `no'.
1898 dnl
1899 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1900   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1901   if test $enable_concept_checks = yes; then
1902     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1903               [Define to use concept checking code from the boost libraries.])
1904   fi
1905 ])
1906
1907 dnl
1908 dnl Check for parallel mode pre-requisites, including OpenMP support.
1909 dnl
1910 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
1911 dnl
1912 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
1913
1914   enable_parallel=no;
1915
1916   # See if configured libgomp/omp.h exists. (libgomp may be in
1917   # noconfigdirs but not explicitly disabled.)
1918   if test -f $glibcxx_builddir/../libgomp/omp.h; then
1919     enable_parallel=yes;
1920   else
1921     AC_MSG_NOTICE([$glibcxx_builddir/../libgomp/omp.h not found])
1922   fi
1923
1924   AC_MSG_CHECKING([for parallel mode support])
1925   AC_MSG_RESULT([$enable_parallel])
1926   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
1927 ])
1928
1929
1930 dnl
1931 dnl Check for which I/O library to use:  stdio, or something specific.
1932 dnl
1933 dnl Default is stdio.
1934 dnl
1935 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1936   AC_MSG_CHECKING([for underlying I/O to use])
1937   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1938     [use target-specific I/O package], [permit stdio])
1939
1940   # Now that libio has been removed, you can have any color you want as long
1941   # as it's black.  This is one big no-op until other packages are added, but
1942   # showing the framework never hurts.
1943   case ${enable_cstdio} in
1944     stdio)
1945       CSTDIO_H=config/io/c_io_stdio.h
1946       BASIC_FILE_H=config/io/basic_file_stdio.h
1947       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1948       AC_MSG_RESULT(stdio)
1949       ;;
1950   esac
1951
1952   AC_SUBST(CSTDIO_H)
1953   AC_SUBST(BASIC_FILE_H)
1954   AC_SUBST(BASIC_FILE_CC)
1955 ])
1956
1957
1958 dnl
1959 dnl Check for "unusual" flags to pass to the compiler while building.
1960 dnl
1961 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1962 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1963 dnl --disable-cxx-flags passes nothing.
1964 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1965 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1966 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1967 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1968 dnl       If "default flags" is an empty string, the effect is the same
1969 dnl       as --disable or --enable=no.
1970 dnl
1971 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1972   AC_MSG_CHECKING([for extra compiler flags for building])
1973   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1974     [pass compiler FLAGS when building library],
1975     [case "x$enable_cxx_flags" in
1976       xno | x)   enable_cxx_flags= ;;
1977       x-*)       ;;
1978       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1979      esac])
1980
1981   # Run through flags (either default or command-line) and set anything
1982   # extra (e.g., #defines) that must accompany particular g++ options.
1983   if test -n "$enable_cxx_flags"; then
1984     for f in $enable_cxx_flags; do
1985       case "$f" in
1986         -fhonor-std)  ;;
1987         -*)  ;;
1988         *)   # and we're trying to pass /what/ exactly?
1989              AC_MSG_ERROR([compiler flags start with a -]) ;;
1990       esac
1991     done
1992   fi
1993
1994   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1995   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1996   AC_SUBST(EXTRA_CXX_FLAGS)
1997 ])
1998
1999
2000 dnl
2001 dnl Check to see if debugging libraries are to be built.
2002 dnl
2003 dnl --enable-libstdcxx-debug
2004 dnl builds a separate set of debugging libraries in addition to the
2005 dnl normal (shared, static) libstdc++ binaries.
2006 dnl
2007 dnl --disable-libstdcxx-debug
2008 dnl builds only one (non-debug) version of libstdc++.
2009 dnl
2010 dnl --enable-libstdcxx-debug-flags=FLAGS
2011 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2012 dnl
2013 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2014 dnl       Where DEFAULT is either `yes' or `no'.
2015 dnl
2016 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2017   AC_MSG_CHECKING([for additional debug build])
2018   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2019   AC_MSG_RESULT($enable_libstdcxx_debug)
2020   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2021 ])
2022
2023
2024 dnl
2025 dnl Check for explicit debug flags.
2026 dnl
2027 dnl --enable-libstdcxx-debug-flags='-O1'
2028 dnl is a general method for passing flags to be used when
2029 dnl building debug libraries with --enable-debug.
2030 dnl
2031 dnl --disable-libstdcxx-debug-flags does nothing.
2032 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2033 dnl       If "default flags" is an empty string, the effect is the same
2034 dnl       as --disable or --enable=no.
2035 dnl
2036 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2037   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2038     [pass compiler FLAGS when building debug library],
2039     [case "x$enable_libstdcxx_debug_flags" in
2040       xno | x)    enable_libstdcxx_debug_flags= ;;
2041       x-*)        ;;
2042       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2043      esac])
2044
2045   # Option parsed, now set things appropriately
2046   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2047   AC_SUBST(DEBUG_FLAGS)
2048
2049   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2050 ])
2051
2052
2053 dnl
2054 dnl Check if the user only wants a freestanding library implementation.
2055 dnl
2056 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2057 dnl installing only the headers required by [17.4.1.3] and the language
2058 dnl support library.  More than that will be built (to keep the Makefiles
2059 dnl conveniently clean), but not installed.
2060 dnl
2061 dnl Sets:
2062 dnl  is_hosted  (yes/no)
2063 dnl
2064 dnl Defines:
2065 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2066 dnl
2067 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2068   AC_ARG_ENABLE([hosted-libstdcxx],
2069     AC_HELP_STRING([--disable-hosted-libstdcxx],
2070                    [only build freestanding C++ runtime support]),,
2071     [case "$host" in
2072         arm*-*-symbianelf*) 
2073             enable_hosted_libstdcxx=no
2074             ;;
2075         *) 
2076             enable_hosted_libstdcxx=yes
2077             ;;
2078      esac])
2079   if test "$enable_hosted_libstdcxx" = no; then
2080     AC_MSG_NOTICE([Only freestanding libraries will be built])
2081     is_hosted=no
2082     hosted_define=0
2083     enable_abi_check=no
2084     enable_libstdcxx_pch=no
2085   else
2086     is_hosted=yes
2087     hosted_define=1
2088   fi
2089   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2090   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2091     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2092 ])
2093
2094
2095 dnl
2096 dnl Check for template specializations for the 'long long' type.
2097 dnl The result determines only whether 'long long' I/O is enabled; things
2098 dnl like numeric_limits<> specializations are always available.
2099 dnl
2100 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2101 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2102 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2103 dnl       Where DEFAULT is either `yes' or `no'.
2104 dnl
2105 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2106   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2107   if test $enable_long_long = yes; then
2108     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1, 
2109               [Define if code specialized for long long should be used.])
2110   fi
2111   AC_MSG_CHECKING([for enabled long long specializations])
2112   AC_MSG_RESULT([$enable_long_long])
2113 ])
2114
2115
2116 dnl
2117 dnl Check for template specializations for the 'wchar_t' type.
2118 dnl
2119 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2120 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2121 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2122 dnl       Where DEFAULT is either `yes' or `no'.
2123 dnl
2124 dnl Necessary support must also be present.
2125 dnl
2126 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2127   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2128
2129   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2130   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2131   AC_MSG_CHECKING([for mbstate_t])
2132   AC_TRY_COMPILE([#include <wchar.h>],
2133   [mbstate_t teststate;],
2134   have_mbstate_t=yes, have_mbstate_t=no)
2135   AC_MSG_RESULT($have_mbstate_t)
2136   if test x"$have_mbstate_t" = xyes; then
2137     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2138   fi
2139
2140   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2141   # ac_has_wchar_h.
2142   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2143   
2144   if test x"$enable_wchar_t" = x"yes"; then
2145
2146     AC_LANG_SAVE
2147     AC_LANG_CPLUSPLUS
2148     
2149     if test x"$ac_has_wchar_h" = xyes &&
2150        test x"$ac_has_wctype_h" = xyes; then
2151       AC_TRY_COMPILE([#include <wchar.h>
2152                       #include <stddef.h>
2153                       wint_t i;
2154                       long l = WEOF;
2155                       long j = WCHAR_MIN;
2156                       long k = WCHAR_MAX;
2157                       namespace test
2158                       {
2159                         using ::btowc;
2160                         using ::fgetwc;
2161                         using ::fgetws;
2162                         using ::fputwc;
2163                         using ::fputws;
2164                         using ::fwide;
2165                         using ::fwprintf; 
2166                         using ::fwscanf;
2167                         using ::getwc;
2168                         using ::getwchar;
2169                         using ::mbrlen; 
2170                         using ::mbrtowc; 
2171                         using ::mbsinit; 
2172                         using ::mbsrtowcs; 
2173                         using ::putwc;
2174                         using ::putwchar;
2175                         using ::swprintf; 
2176                         using ::swscanf; 
2177                         using ::ungetwc;
2178                         using ::vfwprintf; 
2179                         using ::vswprintf; 
2180                         using ::vwprintf; 
2181                         using ::wcrtomb; 
2182                         using ::wcscat; 
2183                         using ::wcschr; 
2184                         using ::wcscmp; 
2185                         using ::wcscoll; 
2186                         using ::wcscpy; 
2187                         using ::wcscspn; 
2188                         using ::wcsftime; 
2189                         using ::wcslen;
2190                         using ::wcsncat; 
2191                         using ::wcsncmp; 
2192                         using ::wcsncpy; 
2193                         using ::wcspbrk;
2194                         using ::wcsrchr; 
2195                         using ::wcsrtombs; 
2196                         using ::wcsspn; 
2197                         using ::wcsstr;
2198                         using ::wcstod; 
2199                         using ::wcstok; 
2200                         using ::wcstol;
2201                         using ::wcstoul; 
2202                         using ::wcsxfrm; 
2203                         using ::wctob; 
2204                         using ::wmemchr;
2205                         using ::wmemcmp;
2206                         using ::wmemcpy;
2207                         using ::wmemmove;
2208                         using ::wmemset;
2209                         using ::wprintf; 
2210                         using ::wscanf; 
2211                       }
2212                      ],[],[], [enable_wchar_t=no])
2213     else
2214       enable_wchar_t=no
2215     fi
2216
2217     AC_LANG_RESTORE
2218   fi
2219
2220   if test x"$enable_wchar_t" = x"yes"; then
2221     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2222               [Define if code specialized for wchar_t should be used.])
2223   fi
2224
2225   AC_MSG_CHECKING([for enabled wchar_t specializations])
2226   AC_MSG_RESULT([$enable_wchar_t])
2227 ])
2228
2229
2230 dnl
2231 dnl Check to see if building and using a C++ precompiled header can be done.
2232 dnl
2233 dnl --enable-libstdcxx-pch=yes
2234 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2235 dnl may work, after some light-hearted attempts to puzzle out compiler
2236 dnl support, flip bits on in include/Makefile.am
2237 dnl
2238 dnl --disable-libstdcxx-pch
2239 dnl turns off attempts to use or build stdc++.h.gch.
2240 dnl
2241 dnl Substs:
2242 dnl  glibcxx_PCHFLAGS
2243 dnl
2244 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2245   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2246   if test $enable_libstdcxx_pch = yes; then
2247     AC_CACHE_CHECK([for compiler with PCH support],
2248       [glibcxx_cv_prog_CXX_pch],
2249       [ac_save_CXXFLAGS="$CXXFLAGS"
2250        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2251        AC_LANG_SAVE
2252        AC_LANG_CPLUSPLUS
2253        echo '#include <math.h>' > conftest.h
2254        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2255                           -o conftest.h.gch 1>&5 2>&1 &&
2256                 echo '#error "pch failed"' > conftest.h &&
2257           echo '#include "conftest.h"' > conftest.cc &&
2258                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2259        then
2260          glibcxx_cv_prog_CXX_pch=yes
2261        else
2262          glibcxx_cv_prog_CXX_pch=no
2263        fi
2264        rm -f conftest*
2265        CXXFLAGS=$ac_save_CXXFLAGS
2266        AC_LANG_RESTORE
2267       ])
2268     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2269   fi
2270
2271   AC_MSG_CHECKING([for enabled PCH])
2272   AC_MSG_RESULT([$enable_libstdcxx_pch])
2273
2274   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2275   if test $enable_libstdcxx_pch = yes; then
2276     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2277   else
2278     glibcxx_PCHFLAGS=""
2279   fi
2280   AC_SUBST(glibcxx_PCHFLAGS)
2281 ])
2282
2283
2284 dnl
2285 dnl Check for atomic builtins.
2286 dnl See:
2287 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2288 dnl
2289 dnl This checks to see if the host supports the compiler-generated
2290 dnl builtins for atomic operations for various integral sizes. Note, this 
2291 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2292 dnl that are used should be checked.
2293 dnl
2294 dnl Note:
2295 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
2296 dnl see: CHECK_SYNC_FETCH_AND_ADD
2297 dnl
2298 dnl Defines:
2299 dnl  _GLIBCXX_ATOMIC_BUILTINS_1 
2300 dnl  _GLIBCXX_ATOMIC_BUILTINS_4
2301 dnl
2302 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2303   AC_LANG_SAVE
2304   AC_LANG_CPLUSPLUS
2305   old_CXXFLAGS="$CXXFLAGS"
2306   
2307   # Compile unoptimized.
2308   CXXFLAGS='-O0 -S'
2309
2310   # Fake what AC_TRY_COMPILE does, without linking as this is
2311   # unnecessary for a builtins test.
2312
2313     cat > conftest.$ac_ext << EOF
2314 [#]line __oline__ "configure"
2315 int main()
2316 {
2317   // NB: _Atomic_word not necessarily int. 
2318   typedef int atomic_type;
2319   atomic_type c1;
2320   atomic_type c2;
2321   const atomic_type c3(0);
2322   __sync_fetch_and_add(&c1, c2);
2323   __sync_val_compare_and_swap(&c1, c3, c2);
2324   __sync_lock_test_and_set(&c1, c3);
2325   __sync_lock_release(&c1);
2326   __sync_synchronize();
2327   return 0;
2328 }
2329 EOF
2330
2331     AC_MSG_CHECKING([for atomic builtins for int])
2332     if AC_TRY_EVAL(ac_compile); then
2333       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2334         enable_atomic_builtinsi=no
2335       else
2336       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2337         [Define if builtin atomic operations for int are supported on this host.])
2338         enable_atomic_builtinsi=yes
2339       fi
2340     fi
2341     AC_MSG_RESULT($enable_atomic_builtinsi)
2342     rm -f conftest*
2343
2344     cat > conftest.$ac_ext << EOF
2345 [#]line __oline__ "configure"
2346 int main()
2347 {
2348   typedef bool atomic_type;
2349   atomic_type c1;
2350   atomic_type c2;
2351   const atomic_type c3(0);
2352   __sync_fetch_and_add(&c1, c2);
2353   __sync_val_compare_and_swap(&c1, c3, c2);
2354   __sync_lock_test_and_set(&c1, c3);
2355   __sync_lock_release(&c1);
2356   __sync_synchronize();
2357   return 0;
2358 }
2359 EOF
2360
2361     AC_MSG_CHECKING([for atomic builtins for bool])
2362     if AC_TRY_EVAL(ac_compile); then
2363       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2364         enable_atomic_builtinsb=no
2365       else
2366       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2367       [Define if builtin atomic operations for bool are supported on this host.])
2368         enable_atomic_builtinsb=yes
2369       fi
2370     fi
2371     AC_MSG_RESULT($enable_atomic_builtinsb)
2372     rm -f conftest*
2373
2374   CXXFLAGS="$old_CXXFLAGS"
2375   AC_LANG_RESTORE
2376
2377   # Set atomicity_dir to builtins if either of above tests pass.
2378   if test $enable_atomic_builtinsi = yes || test $enable_atomic_builtinsb = yes ; then
2379     atomicity_dir=cpu/generic/atomicity_builtins
2380   fi
2381
2382   # If still generic, set to mutex.
2383   if test $atomicity_dir = "cpu/generic" ; then
2384     atomicity_dir=cpu/generic/atomicity_mutex
2385     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2386       if test $target_thread_file = single; then
2387         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2388         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2389       else
2390         AC_MSG_WARN([They will be faked using a mutex.])
2391         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2392       fi
2393   fi
2394
2395 ])
2396
2397
2398 dnl
2399 dnl Check for exception handling support.  If an explicit enable/disable
2400 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2401 dnl target may or may not support call frame exceptions.
2402 dnl
2403 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2404 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2405 dnl Neither one forces an attempt at detection.
2406 dnl
2407 dnl Defines:
2408 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2409 dnl
2410 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2411   AC_MSG_CHECKING([for exception model to use])
2412   AC_LANG_SAVE
2413   AC_LANG_CPLUSPLUS
2414   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2415     [force use of builtin_setjmp for exceptions],
2416     [permit yes|no|auto])
2417
2418   if test $enable_sjlj_exceptions = auto; then
2419     # Botheration.  Now we've got to detect the exception model.  Link tests
2420     # against libgcc.a are problematic since we've not been given proper -L
2421     # bits for single-tree newlib and libgloss.
2422     #
2423     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2424     cat > conftest.$ac_ext << EOF
2425 [#]line __oline__ "configure"
2426 struct S { ~S(); };
2427 void bar();
2428 void foo()
2429 {
2430   S s;
2431   bar();
2432 }
2433 EOF
2434     old_CXXFLAGS="$CXXFLAGS"
2435     CXXFLAGS=-S
2436     if AC_TRY_EVAL(ac_compile); then
2437       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2438         enable_sjlj_exceptions=yes
2439       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2440         enable_sjlj_exceptions=no
2441       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2442         enable_sjlj_exceptions=no
2443       fi
2444     fi
2445     CXXFLAGS="$old_CXXFLAGS"
2446     rm -f conftest*
2447   fi
2448
2449   # This is a tad weird, for hysterical raisins.  We have to map
2450   # enable/disable to two different models.
2451   case $enable_sjlj_exceptions in
2452     yes)
2453       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2454         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2455       ac_exception_model_name=sjlj
2456       ;;
2457     no)
2458       ac_exception_model_name="call frame"
2459       ;;
2460     *)
2461       AC_MSG_ERROR([unable to detect exception model])
2462       ;;
2463   esac
2464  AC_LANG_RESTORE
2465  AC_MSG_RESULT($ac_exception_model_name)
2466 ])
2467
2468
2469 dnl
2470 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2471 dnl
2472 dnl --enable-visibility enables attempt to use visibility attributes.
2473 dnl --disable-visibility turns off all use of visibility attributes.
2474 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2475 dnl       Where DEFAULT is 'yes'.
2476 dnl
2477 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2478 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2479
2480 if test x$enable_visibility = xyes ; then
2481   dnl all hail libgfortran
2482   dnl Check whether the target supports hidden visibility.
2483   AC_CACHE_CHECK([whether the target supports hidden visibility],
2484                  glibcxx_cv_have_attribute_visibility, [
2485   save_CFLAGS="$CFLAGS"
2486   CFLAGS="$CFLAGS -Werror"
2487   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2488                  [], glibcxx_cv_have_attribute_visibility=yes,
2489                  glibcxx_cv_have_attribute_visibility=no)
2490   CFLAGS="$save_CFLAGS"])
2491   if test $glibcxx_cv_have_attribute_visibility = no; then
2492     enable_visibility=no
2493   fi
2494 fi
2495
2496 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2497 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2498 ])
2499
2500
2501 dnl
2502 dnl Add version tags to symbols in shared library (or not), additionally
2503 dnl marking other symbols as private/local (or not).
2504 dnl
2505 dnl --enable-symvers=style adds a version script to the linker call when
2506 dnl       creating the shared library.  The choice of version script is
2507 dnl       controlled by 'style'.
2508 dnl --disable-symvers does not.
2509 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2510 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2511 dnl       choose a default style based on linker characteristics.  Passing
2512 dnl       'no' disables versioning.
2513 dnl
2514 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2515
2516 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2517   [enables symbol versioning of the shared library],
2518   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2519
2520 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2521 # don't know enough about $LD to do tricks...
2522 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2523
2524 # Turn a 'yes' into a suitable default.
2525 if test x$enable_symvers = xyes ; then
2526   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2527     enable_symvers=no
2528   else
2529     if test $with_gnu_ld = yes ; then
2530       enable_symvers=gnu
2531     else
2532       case ${target_os} in
2533         darwin*)
2534           enable_symvers=darwin ;;
2535         *)
2536           enable_symvers=no ;;
2537       esac
2538     fi
2539   fi
2540 fi
2541
2542 # Check to see if 'darwin' or 'darwin-export' can win.
2543 if test x$enable_symvers = xdarwin-export ; then
2544     enable_symvers=darwin
2545 fi
2546
2547 # Check to see if 'gnu' can win.
2548 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2549   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2550   AC_MSG_CHECKING([for shared libgcc])
2551   ac_save_CFLAGS="$CFLAGS"
2552   CFLAGS=' -lgcc_s'
2553   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2554   CFLAGS="$ac_save_CFLAGS"
2555   if test $glibcxx_shared_libgcc = no; then
2556     cat > conftest.c <<EOF
2557 int main (void) { return 0; }
2558 EOF
2559 changequote(,)dnl
2560     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2561                              -shared -shared-libgcc -o conftest.so \
2562                              conftest.c -v 2>&1 >/dev/null \
2563                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2564 changequote([,])dnl
2565     rm -f conftest.c conftest.so
2566     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2567       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2568       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2569       CFLAGS="$ac_save_CFLAGS"
2570     fi
2571   fi
2572   AC_MSG_RESULT($glibcxx_shared_libgcc)
2573
2574   # For GNU ld, we need at least this version.  The format is described in
2575   # GLIBCXX_CHECK_LINKER_FEATURES above.
2576   glibcxx_min_gnu_ld_version=21400
2577
2578   # If no shared libgcc, can't win.
2579   if test $glibcxx_shared_libgcc != yes; then
2580       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2581       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2582       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2583       enable_symvers=no
2584   elif test $with_gnu_ld != yes ; then
2585     # just fail for now
2586     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2587     AC_MSG_WARN([=== you are not using the GNU linker.])
2588     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2589     enable_symvers=no
2590   elif test $glibcxx_ld_is_gold = yes ; then
2591     : All versions of gold support symbol versioning.
2592   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2593     # The right tools, the right setup, but too old.  Fallbacks?
2594     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2595     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2596     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2597     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2598     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2599     enable_symvers=no
2600   fi
2601 fi
2602
2603 # Everything parsed; figure out what file to use.
2604 case $enable_symvers in
2605   no)
2606     SYMVER_FILE=config/abi/pre/none.ver
2607     ;;
2608   gnu)
2609     SYMVER_FILE=config/abi/pre/gnu.ver
2610     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1, 
2611               [Define to use GNU versioning in the shared library.])
2612     ;;
2613   gnu-versioned-namespace)
2614     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2615     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1, 
2616               [Define to use GNU namespace versioning in the shared library.])
2617     ;;
2618   darwin)
2619     SYMVER_FILE=config/abi/pre/gnu.ver
2620     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1, 
2621               [Define to use darwin versioning in the shared library.])
2622     ;;
2623 esac
2624
2625 if test x$enable_symvers != xno ; then
2626   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2627          [Define to use symbol versioning in the shared library.])
2628 fi
2629
2630 AC_SUBST(SYMVER_FILE)
2631 AC_SUBST(port_specific_symbol_files)
2632 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2633 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2634 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2635 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2636 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2637
2638 # Now, set up compatibility support, if any.
2639 # In addition, need this to deal with std::size_t mangling in
2640 # src/compatibility.cc.  In a perfect world, could use
2641 # typeid(std::size_t).name()[0] to do direct substitution.
2642 AC_MSG_CHECKING([for size_t as unsigned int])
2643 ac_save_CFLAGS="$CFLAGS"
2644 CFLAGS="-Werror"
2645 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;], 
2646                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2647 CFLAGS=$ac_save_CFLAGS
2648 if test "$glibcxx_size_t_is_i" = yes; then
2649   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2650 fi
2651 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2652
2653 AC_MSG_CHECKING([for ptrdiff_t as int])
2654 ac_save_CFLAGS="$CFLAGS"
2655 CFLAGS="-Werror"
2656 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;], 
2657                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2658 CFLAGS=$ac_save_CFLAGS
2659 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2660   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2661 fi
2662 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2663 ])
2664
2665
2666 dnl
2667 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2668 dnl We must stage the required headers so that they will be installed
2669 dnl with the library (unlike libgcc, the STL implementation is provided
2670 dnl solely within headers).  Since we must not inject random user-space
2671 dnl macro names into user-provided C++ code, we first stage into <file>-in
2672 dnl and process to <file> with an output command.  The reason for a two-
2673 dnl stage process here is to correctly handle $srcdir!=$objdir without
2674 dnl having to write complex code (the sed commands to clean the macro
2675 dnl namespace are complex and fragile enough as it is).  We must also
2676 dnl add a relative path so that -I- is supported properly.
2677 dnl
2678 dnl Substs:
2679 dnl  glibcxx_thread_h
2680 dnl
2681 dnl Defines:
2682 dnl  HAVE_GTHR_DEFAULT
2683 dnl
2684 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2685   AC_MSG_CHECKING([for thread model used by GCC])
2686   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2687   AC_MSG_RESULT([$target_thread_file])
2688
2689   if test $target_thread_file != single; then
2690     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2691               [Define if gthr-default.h exists 
2692               (meaning that threading support is enabled).])
2693   fi
2694
2695   glibcxx_thread_h=gthr-$target_thread_file.h
2696
2697   dnl Check for __GTHREADS define.
2698   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2699   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2700     enable_thread=yes
2701   else
2702    enable_thread=no
2703   fi
2704
2705   AC_SUBST(glibcxx_thread_h)
2706 ])
2707
2708
2709 # Check whether LC_MESSAGES is available in <locale.h>.
2710 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2711 #
2712 # This file file be copied and used freely without restrictions.  It can
2713 # be used in projects which are not available under the GNU Public License
2714 # but which still want to provide support for the GNU gettext functionality.
2715 # Please note that the actual code is *not* freely available.
2716 AC_DEFUN([AC_LC_MESSAGES], [
2717   AC_CHECK_HEADER(locale.h, [
2718     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2719       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2720        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2721     if test $ac_cv_val_LC_MESSAGES = yes; then
2722       AC_DEFINE(HAVE_LC_MESSAGES, 1, 
2723                 [Define if LC_MESSAGES is available in <locale.h>.])
2724     fi
2725   ])
2726 ])
2727
2728 # Macros from the top-level gcc directory.
2729 m4_include([../config/tls.m4])
2730