OSDN Git Service

3197682df8ff4749b4e47a3b4d4cc6407e667d25
[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], [glibcxx_cv_c99_ctype_tr1=no])
1208   ])
1209   AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1210   if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1211     AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1212               [Define if C99 functions in <ctype.h> should be imported in
1213               <tr1/cctype> in namespace std::tr1.])
1214   fi
1215
1216   # Check for the existence of <fenv.h> functions.
1217   AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1218   ac_c99_fenv_tr1=no;
1219   if test x"$ac_has_fenv_h" = x"yes"; then
1220     AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1221     AC_TRY_COMPILE([#include <fenv.h>],
1222                    [int except, mode;
1223                     fexcept_t* pflag;
1224                     fenv_t* penv;
1225                     int ret;
1226                     ret = feclearexcept(except);
1227                     ret = fegetexceptflag(pflag, except);
1228                     ret = feraiseexcept(except);
1229                     ret = fesetexceptflag(pflag, except);
1230                     ret = fetestexcept(except);
1231                     ret = fegetround();
1232                     ret = fesetround(mode);
1233                     ret = fegetenv(penv);
1234                     ret = feholdexcept(penv);
1235                     ret = fesetenv(penv);
1236                     ret = feupdateenv(penv);
1237                    ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1238   fi
1239   AC_MSG_RESULT($ac_c99_fenv_tr1)
1240   if test x"$ac_c99_fenv_tr1" = x"yes"; then
1241     AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1242               [Define if C99 functions in <fenv.h> should be imported in
1243               <tr1/cfenv> in namespace std::tr1.])
1244   fi
1245
1246   # Check for the existence of <stdint.h> types.
1247   AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1248   AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1249   AC_TRY_COMPILE([#include <stdint.h>],
1250                  [typedef int8_t          my_int8_t;
1251                   typedef int16_t         my_int16_t;
1252                   typedef int32_t         my_int32_t;
1253                   typedef int64_t         my_int64_t;
1254                   typedef int_fast8_t     my_int_fast8_t;
1255                   typedef int_fast16_t    my_int_fast16_t;
1256                   typedef int_fast32_t    my_int_fast32_t;
1257                   typedef int_fast64_t    my_int_fast64_t;      
1258                   typedef int_least8_t    my_int_least8_t;
1259                   typedef int_least16_t   my_int_least16_t;
1260                   typedef int_least32_t   my_int_least32_t;
1261                   typedef int_least64_t   my_int_least64_t;
1262                   typedef intmax_t        my_intmax_t;
1263                   typedef intptr_t        my_intptr_t;
1264                   typedef uint8_t         my_uint8_t;
1265                   typedef uint16_t        my_uint16_t;
1266                   typedef uint32_t        my_uint32_t;
1267                   typedef uint64_t        my_uint64_t;
1268                   typedef uint_fast8_t    my_uint_fast8_t;
1269                   typedef uint_fast16_t   my_uint_fast16_t;
1270                   typedef uint_fast32_t   my_uint_fast32_t;
1271                   typedef uint_fast64_t   my_uint_fast64_t;     
1272                   typedef uint_least8_t   my_uint_least8_t;
1273                   typedef uint_least16_t  my_uint_least16_t;
1274                   typedef uint_least32_t  my_uint_least32_t;
1275                   typedef uint_least64_t  my_uint_least64_t;
1276                   typedef uintmax_t       my_uintmax_t;
1277                   typedef uintptr_t       my_uintptr_t;
1278                  ],[glibcxx_cv_c99_stdint_tr1=yes], [glibcxx_cv_c99_stdint_tr1=no])
1279   ])
1280   AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1281   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1282     AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1283               [Define if C99 types in <stdint.h> should be imported in
1284               <tr1/cstdint> in namespace std::tr1.])
1285   fi
1286
1287   # Check for the existence of <math.h> functions.
1288   AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1289   AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1290   AC_TRY_COMPILE([#include <math.h>],
1291                  [typedef double_t  my_double_t;
1292                   typedef float_t   my_float_t;
1293                   acosh(0.0);
1294                   acoshf(0.0f);
1295                   acoshl(0.0l);
1296                   asinh(0.0);
1297                   asinhf(0.0f);
1298                   asinhl(0.0l);
1299                   atanh(0.0);
1300                   atanhf(0.0f);
1301                   atanhl(0.0l);
1302                   cbrt(0.0);
1303                   cbrtf(0.0f);
1304                   cbrtl(0.0l);
1305                   copysign(0.0, 0.0);
1306                   copysignf(0.0f, 0.0f);
1307                   copysignl(0.0l, 0.0l);
1308                   erf(0.0);
1309                   erff(0.0f);
1310                   erfl(0.0l);
1311                   erfc(0.0);
1312                   erfcf(0.0f);
1313                   erfcl(0.0l);
1314                   exp2(0.0);
1315                   exp2f(0.0f);
1316                   exp2l(0.0l);
1317                   expm1(0.0);
1318                   expm1f(0.0f);
1319                   expm1l(0.0l);
1320                   fdim(0.0, 0.0);
1321                   fdimf(0.0f, 0.0f);
1322                   fdiml(0.0l, 0.0l);
1323                   fma(0.0, 0.0, 0.0);
1324                   fmaf(0.0f, 0.0f, 0.0f);
1325                   fmal(0.0l, 0.0l, 0.0l);
1326                   fmax(0.0, 0.0);
1327                   fmaxf(0.0f, 0.0f);
1328                   fmaxl(0.0l, 0.0l);
1329                   fmin(0.0, 0.0);
1330                   fminf(0.0f, 0.0f);
1331                   fminl(0.0l, 0.0l);
1332                   hypot(0.0, 0.0);
1333                   hypotf(0.0f, 0.0f);
1334                   hypotl(0.0l, 0.0l);
1335                   ilogb(0.0);
1336                   ilogbf(0.0f);
1337                   ilogbl(0.0l);
1338                   lgamma(0.0);
1339                   lgammaf(0.0f);
1340                   lgammal(0.0l);
1341                   llrint(0.0);
1342                   llrintf(0.0f);
1343                   llrintl(0.0l);
1344                   llround(0.0);
1345                   llroundf(0.0f);
1346                   llroundl(0.0l);
1347                   log1p(0.0);
1348                   log1pf(0.0f);
1349                   log1pl(0.0l);
1350                   log2(0.0);
1351                   log2f(0.0f);
1352                   log2l(0.0l);
1353                   logb(0.0);
1354                   logbf(0.0f);
1355                   logbl(0.0l);
1356                   lrint(0.0);
1357                   lrintf(0.0f);
1358                   lrintl(0.0l);
1359                   lround(0.0);
1360                   lroundf(0.0f);
1361                   lroundl(0.0l);
1362                   nan(0);
1363                   nanf(0);
1364                   nanl(0);
1365                   nearbyint(0.0);
1366                   nearbyintf(0.0f);
1367                   nearbyintl(0.0l);
1368                   nextafter(0.0, 0.0);
1369                   nextafterf(0.0f, 0.0f);
1370                   nextafterl(0.0l, 0.0l);
1371                   nexttoward(0.0, 0.0);
1372                   nexttowardf(0.0f, 0.0f);
1373                   nexttowardl(0.0l, 0.0l);
1374                   remainder(0.0, 0.0);
1375                   remainderf(0.0f, 0.0f);
1376                   remainderl(0.0l, 0.0l);
1377                   remquo(0.0, 0.0, 0);
1378                   remquo(0.0f, 0.0f, 0);
1379                   remquo(0.0l, 0.0l, 0);
1380                   rint(0.0);
1381                   rintf(0.0f);
1382                   rintl(0.0l);
1383                   round(0.0);
1384                   roundf(0.0f);
1385                   roundl(0.0l);
1386                   scalbln(0.0, 0l);
1387                   scalblnf(0.0f, 0l);
1388                   scalblnl(0.0l, 0l);
1389                   scalbn(0.0, 0);
1390                   scalbnf(0.0f, 0);
1391                   scalbnl(0.0l, 0);
1392                   tgamma(0.0);
1393                   tgammaf(0.0f);
1394                   tgammal(0.0l);
1395                   trunc(0.0);
1396                   truncf(0.0f);
1397                   truncl(0.0l);
1398                  ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1399   ])
1400   AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1401   if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1402     AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1403               [Define if C99 functions or macros in <math.h> should be imported
1404               in <tr1/cmath> in namespace std::tr1.])
1405   fi
1406
1407   # Check for the existence of <inttypes.h> functions (NB: doesn't make
1408   # sense if the previous check fails, per C99, 7.8/1).
1409   ac_c99_inttypes_tr1=no;
1410   if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1411     AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1412     AC_TRY_COMPILE([#include <inttypes.h>],
1413                    [intmax_t i, numer, denom, base;
1414                     const char* s;
1415                     char** endptr;
1416                     intmax_t ret = imaxabs(i);
1417                     imaxdiv_t dret = imaxdiv(numer, denom);
1418                     ret = strtoimax(s, endptr, base);
1419                     uintmax_t uret = strtoumax(s, endptr, base);
1420                    ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1421   fi
1422   AC_MSG_RESULT($ac_c99_inttypes_tr1)
1423   if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1424     AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1425               [Define if C99 functions in <inttypes.h> should be imported in
1426               <tr1/cinttypes> in namespace std::tr1.])
1427   fi
1428
1429   # Check for the existence of the <stdbool.h> header.  
1430   AC_CHECK_HEADERS(stdbool.h)
1431
1432   CXXFLAGS="$ac_save_CXXFLAGS"
1433   AC_LANG_RESTORE
1434 ])
1435
1436 dnl
1437 dnl Check whether "dev/random" and "dev/urandom" are available for the
1438 dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1439 dnl
1440 AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1441
1442   AC_MSG_CHECKING([for "dev/random" and "dev/urandom" for TR1 random_device])
1443   AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1444   AC_TRY_RUN([#include <stdio.h>
1445               int main()
1446               {
1447                 return !(fopen("/dev/random", "r")
1448                          && fopen("/dev/urandom", "r"));
1449               }       
1450              ],
1451              [glibcxx_cv_random_tr1=yes], [glibcxx_cv_random_tr1=no],
1452              [glibcxx_cv_random_tr1=no])
1453   ])
1454   AC_MSG_RESULT($glibcxx_cv_random_tr1)
1455   if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1456     AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1457               [Define if dev/random and dev/urandom are available for
1458                the random_device of TR1 (Chapter 5.1).])
1459   fi
1460
1461 ])
1462
1463 dnl
1464 dnl Check whether EOF, SEEK_CUR, and SEEK_END have the most common values:
1465 dnl in that case including <cstdio> in some C++ headers can be avoided.
1466 dnl
1467 AC_DEFUN([GLIBCXX_CHECK_STDIO_MACROS], [
1468
1469   AC_MSG_CHECKING([for EOF == -1, SEEK_CUR == 1, SEEK_END == 2])
1470   AC_CACHE_VAL(glibcxx_cv_stdio_macros, [
1471   AC_TRY_COMPILE([#include <stdio.h>],
1472                  [#if ((EOF != -1) || (SEEK_CUR != 1) || (SEEK_END != 2))
1473                     unusual values...
1474                   #endif
1475                  ], [glibcxx_cv_stdio_macros=yes],
1476                     [glibcxx_cv_stdio_macros=no])
1477   ])
1478   AC_MSG_RESULT($glibcxx_cv_stdio_macros)
1479   if test x"$glibcxx_cv_stdio_macros" = x"yes"; then
1480     AC_DEFINE(_GLIBCXX_STDIO_MACROS, 1,
1481               [Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2.])
1482   fi
1483
1484 ])
1485
1486 dnl
1487 dnl Check whether macros, etc are present for <system_error>
1488 dnl
1489 AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1490
1491 m4_pushdef([n_syserr], [1])dnl
1492 m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1493                       ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1494                       EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY],
1495 [m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1496 AC_MSG_CHECKING([for syserr])
1497 AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1498 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1499                                    [int i = syserr;])],
1500                   [glibcxx_cv_system_error[]n_syserr=yes],
1501                   [glibcxx_cv_system_error[]n_syserr=no])
1502 ])
1503 AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1504 if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1505   AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1506 fi
1507 m4_define([n_syserr], m4_incr(n_syserr))dnl
1508 m4_popdef([SYSERR])dnl
1509 ])
1510 m4_popdef([n_syserr])dnl
1511 ])
1512
1513 dnl
1514 dnl Check whether C++200x's standard layout types are supported. 
1515 dnl
1516 AC_DEFUN([GLIBCXX_CHECK_STANDARD_LAYOUT], [
1517
1518   AC_MSG_CHECKING([for ISO C++200x standard layout type support])
1519   AC_CACHE_VAL(ac_standard_layout, [
1520   AC_LANG_SAVE
1521   AC_LANG_CPLUSPLUS
1522   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1523   ac_save_CXXFLAGS="$CXXFLAGS"
1524   CXXFLAGS='-std=gnu++0x'
1525
1526   AC_TRY_COMPILE([struct b
1527                   {
1528                     bool t;
1529
1530                     // Need standard layout relaxation from POD
1531                     private:        
1532                     b& operator=(const b&);
1533                     b(const b&);
1534                     };
1535
1536                     int main()
1537                     {
1538                       b tst1 = { false };
1539                        return 0;
1540                     }],,
1541              [ac_standard_layout=yes], [ac_standard_layout=no])
1542
1543   CXXFLAGS="$ac_save_CXXFLAGS"
1544   AC_LANG_RESTORE
1545   ])
1546   AC_MSG_RESULT($ac_standard_layout)
1547   if test x"$ac_standard_layout" = x"yes"; then
1548     AC_DEFINE(_GLIBCXX_USE_STANDARD_LAYOUT, 1,
1549               [Define if standard layout types are supported in C++200x.])
1550   fi
1551 ])
1552
1553 dnl
1554 dnl Check for what type of C headers to use.
1555 dnl
1556 dnl --enable-cheaders= [does stuff].
1557 dnl --disable-cheaders [does not do anything, really].
1558 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1559 dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1560 dnl
1561 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1562   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1563     [construct "C" headers for g++], [permit c|c_std|c_global])
1564   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1565
1566   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1567
1568   # Allow overrides to configure.host here.
1569   if test $enable_cheaders = c_global; then
1570      c_compatibility=yes
1571   fi
1572
1573   if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then
1574      c_extra=yes
1575   fi
1576
1577   AC_SUBST(C_INCLUDE_DIR)
1578   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1579   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1580   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1581   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1582   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes)
1583 ])
1584
1585
1586 dnl
1587 dnl Check for which locale library to use.  The choice is mapped to
1588 dnl a subdirectory of config/locale.
1589 dnl
1590 dnl Default is generic.
1591 dnl
1592 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1593   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1594     [use MODEL for target locale package],
1595     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1596
1597   # Deal with gettext issues.  Default to not using it (=no) until we detect
1598   # support for it later.  Let the user turn it off via --e/d, but let that
1599   # default to on for easier handling.
1600   USE_NLS=no
1601   AC_ARG_ENABLE(nls,
1602     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1603     [],
1604     [enable_nls=yes])
1605   
1606   # Either a known packaage, or "auto"
1607   if test $enable_clocale = no || test $enable_clocale = yes; then
1608      enable_clocale=auto
1609   fi
1610   enable_clocale_flag=$enable_clocale
1611
1612   # Probe for locale model to use if none specified.
1613   # Default to "generic".
1614   if test $enable_clocale_flag = auto; then
1615     case ${target_os} in
1616       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1617         enable_clocale_flag=gnu 
1618         ;;
1619       darwin* | freebsd*)
1620         enable_clocale_flag=darwin
1621         ;;
1622       *)
1623         enable_clocale_flag=generic
1624         ;;
1625     esac
1626   fi
1627
1628   # Sanity check model, and test for special functionality.
1629   if test $enable_clocale_flag = gnu; then
1630     AC_EGREP_CPP([_GLIBCXX_ok], [
1631     #include <features.h>
1632     #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1633       _GLIBCXX_ok
1634     #endif
1635     ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1636
1637     if test $enable_clocale = auto; then
1638       # Test for bugs early in glibc-2.2.x series
1639       AC_TRY_RUN([
1640       #define _GNU_SOURCE 1
1641       #include <locale.h>
1642       #include <string.h>
1643       #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1644       extern __typeof(newlocale) __newlocale;
1645       extern __typeof(duplocale) __duplocale;
1646       extern __typeof(strcoll_l) __strcoll_l;
1647       #endif
1648       int main()
1649       {
1650         const char __one[] = "Äuglein Augmen";
1651         const char __two[] = "Äuglein";
1652         int i;
1653         int j;
1654         __locale_t        loc;
1655         __locale_t        loc_dup;
1656         loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1657         loc_dup = __duplocale(loc);
1658         i = __strcoll_l(__one, __two, loc);
1659         j = __strcoll_l(__one, __two, loc_dup);
1660         return 0;
1661       }
1662       ],
1663       [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1664       [enable_clocale_flag=generic])
1665     fi
1666
1667     # Set it to scream when it hurts.
1668     ac_save_CFLAGS="$CFLAGS"    
1669     CFLAGS="-Wimplicit-function-declaration -Werror"
1670
1671     # Use strxfrm_l if available.
1672     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1673                     #include <string.h>
1674                     #include <locale.h>],
1675                     [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);], 
1676                     AC_DEFINE(HAVE_STRXFRM_L, 1, 
1677                     [Define if strxfrm_l is available in <string.h>.]),)
1678     
1679     # Use strerror_l if available.
1680     AC_TRY_COMPILE([#define _GNU_SOURCE 1
1681                     #include <string.h>
1682                     #include <locale.h>],
1683                     [__locale_t loc; strerror_l(5, loc);], 
1684                     AC_DEFINE(HAVE_STRERROR_L, 1, 
1685                     [Define if strerror_l is available in <string.h>.]),)
1686
1687     CFLAGS="$ac_save_CFLAGS"
1688   fi
1689
1690   # Perhaps use strerror_r if available, and strerror_l isn't.
1691   ac_save_CFLAGS="$CFLAGS"      
1692   CFLAGS="-Wimplicit-function-declaration -Werror"
1693   AC_TRY_COMPILE([#define _GNU_SOURCE 1
1694                   #include <string.h>
1695                   #include <locale.h>],
1696                   [char s[128]; strerror_r(5, s, 128);], 
1697                   AC_DEFINE(HAVE_STRERROR_R, 1, 
1698                   [Define if strerror_r is available in <string.h>.]),)
1699   CFLAGS="$ac_save_CFLAGS"
1700
1701   # Set configure bits for specified locale package
1702   AC_MSG_CHECKING([for C locale to use])
1703   case ${enable_clocale_flag} in
1704     generic)
1705       AC_MSG_RESULT(generic)
1706
1707       CLOCALE_H=config/locale/generic/c_locale.h
1708       CLOCALE_CC=config/locale/generic/c_locale.cc
1709       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1710       CCOLLATE_CC=config/locale/generic/collate_members.cc
1711       CCTYPE_CC=config/locale/generic/ctype_members.cc
1712       CMESSAGES_H=config/locale/generic/messages_members.h
1713       CMESSAGES_CC=config/locale/generic/messages_members.cc
1714       CMONEY_CC=config/locale/generic/monetary_members.cc
1715       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1716       CTIME_H=config/locale/generic/time_members.h
1717       CTIME_CC=config/locale/generic/time_members.cc
1718       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1719       ;;
1720     darwin)
1721       AC_MSG_RESULT(darwin or freebsd)
1722
1723       CLOCALE_H=config/locale/generic/c_locale.h
1724       CLOCALE_CC=config/locale/generic/c_locale.cc
1725       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1726       CCOLLATE_CC=config/locale/generic/collate_members.cc
1727       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1728       CMESSAGES_H=config/locale/generic/messages_members.h
1729       CMESSAGES_CC=config/locale/generic/messages_members.cc
1730       CMONEY_CC=config/locale/generic/monetary_members.cc
1731       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1732       CTIME_H=config/locale/generic/time_members.h
1733       CTIME_CC=config/locale/generic/time_members.cc
1734       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1735       ;;
1736         
1737     gnu)
1738       AC_MSG_RESULT(gnu)
1739
1740       # Declare intention to use gettext, and add support for specific
1741       # languages.
1742       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1743       ALL_LINGUAS="de fr"
1744
1745       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1746       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1747       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1748         USE_NLS=yes
1749       fi
1750       # Export the build objects.
1751       for ling in $ALL_LINGUAS; do \
1752         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1753         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1754       done
1755       AC_SUBST(glibcxx_MOFILES)
1756       AC_SUBST(glibcxx_POFILES)
1757
1758       CLOCALE_H=config/locale/gnu/c_locale.h
1759       CLOCALE_CC=config/locale/gnu/c_locale.cc
1760       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1761       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1762       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1763       CMESSAGES_H=config/locale/gnu/messages_members.h
1764       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1765       CMONEY_CC=config/locale/gnu/monetary_members.cc
1766       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1767       CTIME_H=config/locale/gnu/time_members.h
1768       CTIME_CC=config/locale/gnu/time_members.cc
1769       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1770       ;;
1771     ieee_1003.1-2001)
1772       AC_MSG_RESULT(IEEE 1003.1)
1773
1774       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1775       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1776       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1777       CCOLLATE_CC=config/locale/generic/collate_members.cc
1778       CCTYPE_CC=config/locale/generic/ctype_members.cc
1779       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1780       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1781       CMONEY_CC=config/locale/generic/monetary_members.cc
1782       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1783       CTIME_H=config/locale/generic/time_members.h
1784       CTIME_CC=config/locale/generic/time_members.cc
1785       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1786       ;;
1787   esac
1788
1789   # This is where the testsuite looks for locale catalogs, using the
1790   # -DLOCALEDIR define during testsuite compilation.
1791   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1792   AC_SUBST(glibcxx_localedir)
1793
1794   # A standalone libintl (e.g., GNU libintl) may be in use.
1795   if test $USE_NLS = yes; then
1796     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1797     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1798   fi
1799   if test $USE_NLS = yes; then
1800     AC_DEFINE(_GLIBCXX_USE_NLS, 1, 
1801               [Define if NLS translations are to be used.])
1802   fi
1803
1804   AC_SUBST(USE_NLS)
1805   AC_SUBST(CLOCALE_H)
1806   AC_SUBST(CMESSAGES_H)
1807   AC_SUBST(CCODECVT_CC)
1808   AC_SUBST(CCOLLATE_CC)
1809   AC_SUBST(CCTYPE_CC)
1810   AC_SUBST(CMESSAGES_CC)
1811   AC_SUBST(CMONEY_CC)
1812   AC_SUBST(CNUMERIC_CC)
1813   AC_SUBST(CTIME_H)
1814   AC_SUBST(CTIME_CC)
1815   AC_SUBST(CLOCALE_CC)
1816   AC_SUBST(CLOCALE_INTERNAL_H)
1817 ])
1818
1819
1820 dnl
1821 dnl Check for which std::allocator base class to use.  The choice is
1822 dnl mapped from a subdirectory of include/ext.
1823 dnl
1824 dnl Default is new.
1825 dnl
1826 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1827   AC_MSG_CHECKING([for std::allocator base class])
1828   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1829     [use KIND for target std::allocator base],
1830     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1831
1832   # If they didn't use this option switch, or if they specified --enable
1833   # with no specific model, we'll have to look for one.  If they
1834   # specified --disable (???), do likewise.
1835   if test $enable_libstdcxx_allocator = no ||
1836      test $enable_libstdcxx_allocator = yes;
1837   then
1838      enable_libstdcxx_allocator=auto
1839   fi
1840
1841   # Either a known package, or "auto". Auto implies the default choice
1842   # for a particular platform.
1843   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1844
1845   # Probe for host-specific support if no specific model is specified.
1846   # Default to "new".
1847   if test $enable_libstdcxx_allocator_flag = auto; then
1848     case ${target_os} in
1849       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1850         enable_libstdcxx_allocator_flag=new
1851         ;;
1852       *)
1853         enable_libstdcxx_allocator_flag=new
1854         ;;
1855     esac
1856   fi
1857   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1858   
1859
1860   # Set configure bits for specified locale package
1861   case ${enable_libstdcxx_allocator_flag} in
1862     bitmap)
1863       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1864       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1865       ;;
1866     malloc)
1867       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1868       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1869       ;;
1870     mt)
1871       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1872       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1873       ;;
1874     new)
1875       ALLOCATOR_H=config/allocator/new_allocator_base.h
1876       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1877       ;;
1878     pool)
1879       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1880       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1881       ;;        
1882   esac
1883
1884   AC_SUBST(ALLOCATOR_H)
1885   AC_SUBST(ALLOCATOR_NAME)
1886 ])
1887
1888
1889 dnl
1890 dnl Check for whether the Boost-derived checks should be turned on.
1891 dnl
1892 dnl --enable-concept-checks turns them on.
1893 dnl --disable-concept-checks leaves them off.
1894 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1895 dnl       Where DEFAULT is either `yes' or `no'.
1896 dnl
1897 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1898   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1899   if test $enable_concept_checks = yes; then
1900     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
1901               [Define to use concept checking code from the boost libraries.])
1902   fi
1903 ])
1904
1905 dnl
1906 dnl Check for parallel mode pre-requisites, including OpenMP support.
1907 dnl
1908 dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
1909 dnl
1910 AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
1911
1912   enable_parallel=no;
1913
1914   # See if configured libgomp/omp.h exists. (libgomp may be in
1915   # noconfigdirs but not explicitly disabled.)
1916   if test -f $glibcxx_builddir/../libgomp/omp.h; then
1917     enable_parallel=yes;
1918   else
1919     AC_MSG_NOTICE([$glibcxx_builddir/../libgomp/omp.h not found])
1920   fi
1921
1922   AC_MSG_CHECKING([for parallel mode support])
1923   AC_MSG_RESULT([$enable_parallel])
1924   GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
1925 ])
1926
1927
1928 dnl
1929 dnl Check for which I/O library to use:  stdio, or something specific.
1930 dnl
1931 dnl Default is stdio.
1932 dnl
1933 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1934   AC_MSG_CHECKING([for underlying I/O to use])
1935   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1936     [use target-specific I/O package], [permit stdio])
1937
1938   # Now that libio has been removed, you can have any color you want as long
1939   # as it's black.  This is one big no-op until other packages are added, but
1940   # showing the framework never hurts.
1941   case ${enable_cstdio} in
1942     stdio)
1943       CSTDIO_H=config/io/c_io_stdio.h
1944       BASIC_FILE_H=config/io/basic_file_stdio.h
1945       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1946       AC_MSG_RESULT(stdio)
1947       ;;
1948   esac
1949
1950   AC_SUBST(CSTDIO_H)
1951   AC_SUBST(BASIC_FILE_H)
1952   AC_SUBST(BASIC_FILE_CC)
1953 ])
1954
1955
1956 dnl
1957 dnl Check for "unusual" flags to pass to the compiler while building.
1958 dnl
1959 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1960 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1961 dnl --disable-cxx-flags passes nothing.
1962 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1963 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1964 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1965 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1966 dnl       If "default flags" is an empty string, the effect is the same
1967 dnl       as --disable or --enable=no.
1968 dnl
1969 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1970   AC_MSG_CHECKING([for extra compiler flags for building])
1971   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1972     [pass compiler FLAGS when building library],
1973     [case "x$enable_cxx_flags" in
1974       xno | x)   enable_cxx_flags= ;;
1975       x-*)       ;;
1976       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1977      esac])
1978
1979   # Run through flags (either default or command-line) and set anything
1980   # extra (e.g., #defines) that must accompany particular g++ options.
1981   if test -n "$enable_cxx_flags"; then
1982     for f in $enable_cxx_flags; do
1983       case "$f" in
1984         -fhonor-std)  ;;
1985         -*)  ;;
1986         *)   # and we're trying to pass /what/ exactly?
1987              AC_MSG_ERROR([compiler flags start with a -]) ;;
1988       esac
1989     done
1990   fi
1991
1992   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1993   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1994   AC_SUBST(EXTRA_CXX_FLAGS)
1995 ])
1996
1997
1998 dnl
1999 dnl Check to see if debugging libraries are to be built.
2000 dnl
2001 dnl --enable-libstdcxx-debug
2002 dnl builds a separate set of debugging libraries in addition to the
2003 dnl normal (shared, static) libstdc++ binaries.
2004 dnl
2005 dnl --disable-libstdcxx-debug
2006 dnl builds only one (non-debug) version of libstdc++.
2007 dnl
2008 dnl --enable-libstdcxx-debug-flags=FLAGS
2009 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2010 dnl
2011 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2012 dnl       Where DEFAULT is either `yes' or `no'.
2013 dnl
2014 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2015   AC_MSG_CHECKING([for additional debug build])
2016   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2017   AC_MSG_RESULT($enable_libstdcxx_debug)
2018   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2019 ])
2020
2021
2022 dnl
2023 dnl Check for explicit debug flags.
2024 dnl
2025 dnl --enable-libstdcxx-debug-flags='-O1'
2026 dnl is a general method for passing flags to be used when
2027 dnl building debug libraries with --enable-debug.
2028 dnl
2029 dnl --disable-libstdcxx-debug-flags does nothing.
2030 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2031 dnl       If "default flags" is an empty string, the effect is the same
2032 dnl       as --disable or --enable=no.
2033 dnl
2034 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2035   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2036     [pass compiler FLAGS when building debug library],
2037     [case "x$enable_libstdcxx_debug_flags" in
2038       xno | x)    enable_libstdcxx_debug_flags= ;;
2039       x-*)        ;;
2040       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2041      esac])
2042
2043   # Option parsed, now set things appropriately
2044   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2045   AC_SUBST(DEBUG_FLAGS)
2046
2047   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2048 ])
2049
2050
2051 dnl
2052 dnl Check if the user only wants a freestanding library implementation.
2053 dnl
2054 dnl --disable-hosted-libstdcxx will turn off most of the library build,
2055 dnl installing only the headers required by [17.4.1.3] and the language
2056 dnl support library.  More than that will be built (to keep the Makefiles
2057 dnl conveniently clean), but not installed.
2058 dnl
2059 dnl Sets:
2060 dnl  is_hosted  (yes/no)
2061 dnl
2062 dnl Defines:
2063 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2064 dnl
2065 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2066   AC_ARG_ENABLE([hosted-libstdcxx],
2067     AC_HELP_STRING([--disable-hosted-libstdcxx],
2068                    [only build freestanding C++ runtime support]),,
2069     [case "$host" in
2070         arm*-*-symbianelf*) 
2071             enable_hosted_libstdcxx=no
2072             ;;
2073         *) 
2074             enable_hosted_libstdcxx=yes
2075             ;;
2076      esac])
2077   if test "$enable_hosted_libstdcxx" = no; then
2078     AC_MSG_NOTICE([Only freestanding libraries will be built])
2079     is_hosted=no
2080     hosted_define=0
2081     enable_abi_check=no
2082     enable_libstdcxx_pch=no
2083   else
2084     is_hosted=yes
2085     hosted_define=1
2086   fi
2087   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2088   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2089     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2090 ])
2091
2092
2093 dnl
2094 dnl Check for template specializations for the 'long long' type.
2095 dnl The result determines only whether 'long long' I/O is enabled; things
2096 dnl like numeric_limits<> specializations are always available.
2097 dnl
2098 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2099 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2100 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2101 dnl       Where DEFAULT is either `yes' or `no'.
2102 dnl
2103 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2104   GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2105   if test $enable_long_long = yes; then
2106     AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1, 
2107               [Define if code specialized for long long should be used.])
2108   fi
2109   AC_MSG_CHECKING([for enabled long long specializations])
2110   AC_MSG_RESULT([$enable_long_long])
2111 ])
2112
2113
2114 dnl
2115 dnl Check for template specializations for the 'wchar_t' type.
2116 dnl
2117 dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2118 dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2119 dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2120 dnl       Where DEFAULT is either `yes' or `no'.
2121 dnl
2122 dnl Necessary support must also be present.
2123 dnl
2124 AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2125   GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2126
2127   # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2128   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2129   AC_MSG_CHECKING([for mbstate_t])
2130   AC_TRY_COMPILE([#include <wchar.h>],
2131   [mbstate_t teststate;],
2132   have_mbstate_t=yes, have_mbstate_t=no)
2133   AC_MSG_RESULT($have_mbstate_t)
2134   if test x"$have_mbstate_t" = xyes; then
2135     AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2136   fi
2137
2138   # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2139   # ac_has_wchar_h.
2140   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2141   
2142   if test x"$enable_wchar_t" = x"yes"; then
2143
2144     AC_LANG_SAVE
2145     AC_LANG_CPLUSPLUS
2146     
2147     if test x"$ac_has_wchar_h" = xyes &&
2148        test x"$ac_has_wctype_h" = xyes; then
2149       AC_TRY_COMPILE([#include <wchar.h>
2150                       #include <stddef.h>
2151                       wint_t i;
2152                       long l = WEOF;
2153                       long j = WCHAR_MIN;
2154                       long k = WCHAR_MAX;
2155                       namespace test
2156                       {
2157                         using ::btowc;
2158                         using ::fgetwc;
2159                         using ::fgetws;
2160                         using ::fputwc;
2161                         using ::fputws;
2162                         using ::fwide;
2163                         using ::fwprintf; 
2164                         using ::fwscanf;
2165                         using ::getwc;
2166                         using ::getwchar;
2167                         using ::mbrlen; 
2168                         using ::mbrtowc; 
2169                         using ::mbsinit; 
2170                         using ::mbsrtowcs; 
2171                         using ::putwc;
2172                         using ::putwchar;
2173                         using ::swprintf; 
2174                         using ::swscanf; 
2175                         using ::ungetwc;
2176                         using ::vfwprintf; 
2177                         using ::vswprintf; 
2178                         using ::vwprintf; 
2179                         using ::wcrtomb; 
2180                         using ::wcscat; 
2181                         using ::wcschr; 
2182                         using ::wcscmp; 
2183                         using ::wcscoll; 
2184                         using ::wcscpy; 
2185                         using ::wcscspn; 
2186                         using ::wcsftime; 
2187                         using ::wcslen;
2188                         using ::wcsncat; 
2189                         using ::wcsncmp; 
2190                         using ::wcsncpy; 
2191                         using ::wcspbrk;
2192                         using ::wcsrchr; 
2193                         using ::wcsrtombs; 
2194                         using ::wcsspn; 
2195                         using ::wcsstr;
2196                         using ::wcstod; 
2197                         using ::wcstok; 
2198                         using ::wcstol;
2199                         using ::wcstoul; 
2200                         using ::wcsxfrm; 
2201                         using ::wctob; 
2202                         using ::wmemchr;
2203                         using ::wmemcmp;
2204                         using ::wmemcpy;
2205                         using ::wmemmove;
2206                         using ::wmemset;
2207                         using ::wprintf; 
2208                         using ::wscanf; 
2209                       }
2210                      ],[],[], [enable_wchar_t=no])
2211     else
2212       enable_wchar_t=no
2213     fi
2214
2215     AC_LANG_RESTORE
2216   fi
2217
2218   if test x"$enable_wchar_t" = x"yes"; then
2219     AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2220               [Define if code specialized for wchar_t should be used.])
2221   fi
2222
2223   AC_MSG_CHECKING([for enabled wchar_t specializations])
2224   AC_MSG_RESULT([$enable_wchar_t])
2225 ])
2226
2227
2228 dnl
2229 dnl Check to see if building and using a C++ precompiled header can be done.
2230 dnl
2231 dnl --enable-libstdcxx-pch=yes
2232 dnl default, this shows intent to use stdc++.h.gch If it looks like it
2233 dnl may work, after some light-hearted attempts to puzzle out compiler
2234 dnl support, flip bits on in include/Makefile.am
2235 dnl
2236 dnl --disable-libstdcxx-pch
2237 dnl turns off attempts to use or build stdc++.h.gch.
2238 dnl
2239 dnl Substs:
2240 dnl  glibcxx_PCHFLAGS
2241 dnl
2242 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2243   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2244   if test $enable_libstdcxx_pch = yes; then
2245     AC_CACHE_CHECK([for compiler with PCH support],
2246       [glibcxx_cv_prog_CXX_pch],
2247       [ac_save_CXXFLAGS="$CXXFLAGS"
2248        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2249        AC_LANG_SAVE
2250        AC_LANG_CPLUSPLUS
2251        echo '#include <math.h>' > conftest.h
2252        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2253                           -o conftest.h.gch 1>&5 2>&1 &&
2254                 echo '#error "pch failed"' > conftest.h &&
2255           echo '#include "conftest.h"' > conftest.cc &&
2256                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2257        then
2258          glibcxx_cv_prog_CXX_pch=yes
2259        else
2260          glibcxx_cv_prog_CXX_pch=no
2261        fi
2262        rm -f conftest*
2263        CXXFLAGS=$ac_save_CXXFLAGS
2264        AC_LANG_RESTORE
2265       ])
2266     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2267   fi
2268
2269   AC_MSG_CHECKING([for enabled PCH])
2270   AC_MSG_RESULT([$enable_libstdcxx_pch])
2271
2272   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2273   if test $enable_libstdcxx_pch = yes; then
2274     glibcxx_PCHFLAGS="-include bits/stdc++.h"
2275   else
2276     glibcxx_PCHFLAGS=""
2277   fi
2278   AC_SUBST(glibcxx_PCHFLAGS)
2279 ])
2280
2281
2282 dnl
2283 dnl Check for atomic builtins.
2284 dnl See:
2285 dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins
2286 dnl
2287 dnl This checks to see if the host supports the compiler-generated
2288 dnl builtins for atomic operations for various integral sizes. Note, this 
2289 dnl is intended to be an all-or-nothing switch, so all the atomic operations
2290 dnl that are used should be checked.
2291 dnl
2292 dnl Note:
2293 dnl libgomp and libgfortran do this with a link test, instead of an asm test.
2294 dnl see: CHECK_SYNC_FETCH_AND_ADD
2295 dnl
2296 dnl Defines:
2297 dnl  _GLIBCXX_ATOMIC_BUILTINS_1 
2298 dnl  _GLIBCXX_ATOMIC_BUILTINS_4
2299 dnl
2300 AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2301   AC_LANG_SAVE
2302   AC_LANG_CPLUSPLUS
2303   old_CXXFLAGS="$CXXFLAGS"
2304   
2305   # Compile unoptimized.
2306   CXXFLAGS='-O0 -S'
2307
2308   # Fake what AC_TRY_COMPILE does, without linking as this is
2309   # unnecessary for a builtins test.
2310
2311     cat > conftest.$ac_ext << EOF
2312 [#]line __oline__ "configure"
2313 int main()
2314 {
2315   // NB: _Atomic_word not necessarily int. 
2316   typedef int atomic_type;
2317   atomic_type c1;
2318   atomic_type c2;
2319   const atomic_type c3(0);
2320   __sync_fetch_and_add(&c1, c2);
2321   __sync_val_compare_and_swap(&c1, c3, c2);
2322   __sync_lock_test_and_set(&c1, c3);
2323   __sync_lock_release(&c1);
2324   __sync_synchronize();
2325   return 0;
2326 }
2327 EOF
2328
2329     AC_MSG_CHECKING([for atomic builtins for int])
2330     if AC_TRY_EVAL(ac_compile); then
2331       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2332         enable_atomic_builtinsi=no
2333       else
2334       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1,
2335         [Define if builtin atomic operations for int are supported on this host.])
2336         enable_atomic_builtinsi=yes
2337       fi
2338     fi
2339     AC_MSG_RESULT($enable_atomic_builtinsi)
2340     rm -f conftest*
2341
2342     cat > conftest.$ac_ext << EOF
2343 [#]line __oline__ "configure"
2344 int main()
2345 {
2346   typedef bool atomic_type;
2347   atomic_type c1;
2348   atomic_type c2;
2349   const atomic_type c3(0);
2350   __sync_fetch_and_add(&c1, c2);
2351   __sync_val_compare_and_swap(&c1, c3, c2);
2352   __sync_lock_test_and_set(&c1, c3);
2353   __sync_lock_release(&c1);
2354   __sync_synchronize();
2355   return 0;
2356 }
2357 EOF
2358
2359     AC_MSG_CHECKING([for atomic builtins for bool])
2360     if AC_TRY_EVAL(ac_compile); then
2361       if grep __sync_ conftest.s >/dev/null 2>&1 ; then
2362         enable_atomic_builtinsb=no
2363       else
2364       AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1,
2365       [Define if builtin atomic operations for bool are supported on this host.])
2366         enable_atomic_builtinsb=yes
2367       fi
2368     fi
2369     AC_MSG_RESULT($enable_atomic_builtinsb)
2370     rm -f conftest*
2371
2372   CXXFLAGS="$old_CXXFLAGS"
2373   AC_LANG_RESTORE
2374
2375   # Set atomicity_dir to builtins if either of above tests pass.
2376   if test $enable_atomic_builtinsi = yes || test $enable_atomic_builtinsb = yes ; then
2377     atomicity_dir=cpu/generic/atomicity_builtins
2378   fi
2379
2380   # If still generic, set to mutex.
2381   if test $atomicity_dir = "cpu/generic" ; then
2382     atomicity_dir=cpu/generic/atomicity_mutex
2383     AC_MSG_WARN([No native atomic operations are provided for this platform.])
2384       if test $target_thread_file = single; then
2385         AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2386         AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2387       else
2388         AC_MSG_WARN([They will be faked using a mutex.])
2389         AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2390       fi
2391   fi
2392
2393 ])
2394
2395
2396 dnl
2397 dnl Check for exception handling support.  If an explicit enable/disable
2398 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2399 dnl target may or may not support call frame exceptions.
2400 dnl
2401 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2402 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2403 dnl Neither one forces an attempt at detection.
2404 dnl
2405 dnl Defines:
2406 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2407 dnl
2408 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2409   AC_MSG_CHECKING([for exception model to use])
2410   AC_LANG_SAVE
2411   AC_LANG_CPLUSPLUS
2412   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2413     [force use of builtin_setjmp for exceptions],
2414     [permit yes|no|auto])
2415
2416   if test $enable_sjlj_exceptions = auto; then
2417     # Botheration.  Now we've got to detect the exception model.  Link tests
2418     # against libgcc.a are problematic since we've not been given proper -L
2419     # bits for single-tree newlib and libgloss.
2420     #
2421     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2422     cat > conftest.$ac_ext << EOF
2423 [#]line __oline__ "configure"
2424 struct S { ~S(); };
2425 void bar();
2426 void foo()
2427 {
2428   S s;
2429   bar();
2430 }
2431 EOF
2432     old_CXXFLAGS="$CXXFLAGS"
2433     CXXFLAGS=-S
2434     if AC_TRY_EVAL(ac_compile); then
2435       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2436         enable_sjlj_exceptions=yes
2437       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2438         enable_sjlj_exceptions=no
2439       elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2440         enable_sjlj_exceptions=no
2441       fi
2442     fi
2443     CXXFLAGS="$old_CXXFLAGS"
2444     rm -f conftest*
2445   fi
2446
2447   # This is a tad weird, for hysterical raisins.  We have to map
2448   # enable/disable to two different models.
2449   case $enable_sjlj_exceptions in
2450     yes)
2451       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
2452         [Define if the compiler is configured for setjmp/longjmp exceptions.])
2453       ac_exception_model_name=sjlj
2454       ;;
2455     no)
2456       ac_exception_model_name="call frame"
2457       ;;
2458     *)
2459       AC_MSG_ERROR([unable to detect exception model])
2460       ;;
2461   esac
2462  AC_LANG_RESTORE
2463  AC_MSG_RESULT($ac_exception_model_name)
2464 ])
2465
2466
2467 dnl
2468 dnl Allow visibility attributes to be used on namespaces, objects, etc.
2469 dnl
2470 dnl --enable-visibility enables attempt to use visibility attributes.
2471 dnl --disable-visibility turns off all use of visibility attributes.
2472 dnl  +  Usage:  GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)]
2473 dnl       Where DEFAULT is 'yes'.
2474 dnl
2475 AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [
2476 GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage])
2477
2478 if test x$enable_visibility = xyes ; then
2479   dnl all hail libgfortran
2480   dnl Check whether the target supports hidden visibility.
2481   AC_CACHE_CHECK([whether the target supports hidden visibility],
2482                  glibcxx_cv_have_attribute_visibility, [
2483   save_CFLAGS="$CFLAGS"
2484   CFLAGS="$CFLAGS -Werror"
2485   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
2486                  [], glibcxx_cv_have_attribute_visibility=yes,
2487                  glibcxx_cv_have_attribute_visibility=no)
2488   CFLAGS="$save_CFLAGS"])
2489   if test $glibcxx_cv_have_attribute_visibility = no; then
2490     enable_visibility=no
2491   fi
2492 fi
2493
2494 GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes)
2495 AC_MSG_NOTICE([visibility supported: $enable_visibility])
2496 ])
2497
2498
2499 dnl
2500 dnl Add version tags to symbols in shared library (or not), additionally
2501 dnl marking other symbols as private/local (or not).
2502 dnl
2503 dnl --enable-symvers=style adds a version script to the linker call when
2504 dnl       creating the shared library.  The choice of version script is
2505 dnl       controlled by 'style'.
2506 dnl --disable-symvers does not.
2507 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
2508 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
2509 dnl       choose a default style based on linker characteristics.  Passing
2510 dnl       'no' disables versioning.
2511 dnl
2512 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
2513
2514 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
2515   [enables symbol versioning of the shared library],
2516   [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export])
2517
2518 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
2519 # don't know enough about $LD to do tricks...
2520 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
2521
2522 # Turn a 'yes' into a suitable default.
2523 if test x$enable_symvers = xyes ; then
2524   if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
2525     enable_symvers=no
2526   else
2527     if test $with_gnu_ld = yes ; then
2528       enable_symvers=gnu
2529     else
2530       case ${target_os} in
2531         darwin*)
2532           enable_symvers=darwin ;;
2533         *)
2534           enable_symvers=no ;;
2535       esac
2536     fi
2537   fi
2538 fi
2539
2540 # Check to see if 'darwin' or 'darwin-export' can win.
2541 if test x$enable_symvers = xdarwin-export ; then
2542     enable_symvers=darwin
2543 fi
2544
2545 # Check to see if 'gnu' can win.
2546 if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then
2547   # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2548   AC_MSG_CHECKING([for shared libgcc])
2549   ac_save_CFLAGS="$CFLAGS"
2550   CFLAGS=' -lgcc_s'
2551   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
2552   CFLAGS="$ac_save_CFLAGS"
2553   if test $glibcxx_shared_libgcc = no; then
2554     cat > conftest.c <<EOF
2555 int main (void) { return 0; }
2556 EOF
2557 changequote(,)dnl
2558     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
2559                              -shared -shared-libgcc -o conftest.so \
2560                              conftest.c -v 2>&1 >/dev/null \
2561                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
2562 changequote([,])dnl
2563     rm -f conftest.c conftest.so
2564     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
2565       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
2566       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
2567       CFLAGS="$ac_save_CFLAGS"
2568     fi
2569   fi
2570   AC_MSG_RESULT($glibcxx_shared_libgcc)
2571
2572   # For GNU ld, we need at least this version.  The format is described in
2573   # GLIBCXX_CHECK_LINKER_FEATURES above.
2574   glibcxx_min_gnu_ld_version=21400
2575
2576   # If no shared libgcc, can't win.
2577   if test $glibcxx_shared_libgcc != yes; then
2578       AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2579       AC_MSG_WARN([=== you are not building a shared libgcc_s.])
2580       AC_MSG_WARN([=== Symbol versioning will be disabled.])
2581       enable_symvers=no
2582   elif test $with_gnu_ld != yes ; then
2583     # just fail for now
2584     AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
2585     AC_MSG_WARN([=== you are not using the GNU linker.])
2586     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2587     enable_symvers=no
2588   elif test $glibcxx_ld_is_gold = yes ; then
2589     : All versions of gold support symbol versioning.
2590   elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
2591     # The right tools, the right setup, but too old.  Fallbacks?
2592     AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
2593     AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
2594     AC_MSG_WARN(=== You would need to upgrade your binutils to version)
2595     AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
2596     AC_MSG_WARN([=== Symbol versioning will be disabled.])
2597     enable_symvers=no
2598   fi
2599 fi
2600
2601 # Everything parsed; figure out what file to use.
2602 case $enable_symvers in
2603   no)
2604     SYMVER_FILE=config/abi/pre/none.ver
2605     ;;
2606   gnu)
2607     SYMVER_FILE=config/abi/pre/gnu.ver
2608     AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1, 
2609               [Define to use GNU versioning in the shared library.])
2610     ;;
2611   gnu-versioned-namespace)
2612     SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
2613     AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1, 
2614               [Define to use GNU namespace versioning in the shared library.])
2615     ;;
2616   darwin)
2617     SYMVER_FILE=config/abi/pre/gnu.ver
2618     AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1, 
2619               [Define to use darwin versioning in the shared library.])
2620     ;;
2621 esac
2622
2623 if test x$enable_symvers != xno ; then
2624   AC_DEFINE(_GLIBCXX_SYMVER, 1,
2625          [Define to use symbol versioning in the shared library.])
2626 fi
2627
2628 AC_SUBST(SYMVER_FILE)
2629 AC_SUBST(port_specific_symbol_files)
2630 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
2631 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
2632 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
2633 GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
2634 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
2635
2636 # Now, set up compatibility support, if any.
2637 # In addition, need this to deal with std::size_t mangling in
2638 # src/compatibility.cc.  In a perfect world, could use
2639 # typeid(std::size_t).name()[0] to do direct substitution.
2640 AC_MSG_CHECKING([for size_t as unsigned int])
2641 ac_save_CFLAGS="$CFLAGS"
2642 CFLAGS="-Werror"
2643 AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;], 
2644                  [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
2645 CFLAGS=$ac_save_CFLAGS
2646 if test "$glibcxx_size_t_is_i" = yes; then
2647   AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
2648 fi
2649 AC_MSG_RESULT([$glibcxx_size_t_is_i])
2650
2651 AC_MSG_CHECKING([for ptrdiff_t as int])
2652 ac_save_CFLAGS="$CFLAGS"
2653 CFLAGS="-Werror"
2654 AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;], 
2655                  [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
2656 CFLAGS=$ac_save_CFLAGS
2657 if test "$glibcxx_ptrdiff_t_is_i" = yes; then
2658   AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
2659 fi
2660 AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
2661 ])
2662
2663
2664 dnl
2665 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
2666 dnl We must stage the required headers so that they will be installed
2667 dnl with the library (unlike libgcc, the STL implementation is provided
2668 dnl solely within headers).  Since we must not inject random user-space
2669 dnl macro names into user-provided C++ code, we first stage into <file>-in
2670 dnl and process to <file> with an output command.  The reason for a two-
2671 dnl stage process here is to correctly handle $srcdir!=$objdir without
2672 dnl having to write complex code (the sed commands to clean the macro
2673 dnl namespace are complex and fragile enough as it is).  We must also
2674 dnl add a relative path so that -I- is supported properly.
2675 dnl
2676 dnl Substs:
2677 dnl  glibcxx_thread_h
2678 dnl
2679 dnl Defines:
2680 dnl  HAVE_GTHR_DEFAULT
2681 dnl
2682 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
2683   AC_MSG_CHECKING([for thread model used by GCC])
2684   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
2685   AC_MSG_RESULT([$target_thread_file])
2686
2687   if test $target_thread_file != single; then
2688     AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
2689               [Define if gthr-default.h exists 
2690               (meaning that threading support is enabled).])
2691   fi
2692
2693   glibcxx_thread_h=gthr-$target_thread_file.h
2694
2695   dnl Check for __GTHREADS define.
2696   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
2697   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
2698     enable_thread=yes
2699   else
2700    enable_thread=no
2701   fi
2702
2703   AC_SUBST(glibcxx_thread_h)
2704 ])
2705
2706
2707 # Check whether LC_MESSAGES is available in <locale.h>.
2708 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2709 #
2710 # This file file be copied and used freely without restrictions.  It can
2711 # be used in projects which are not available under the GNU Public License
2712 # but which still want to provide support for the GNU gettext functionality.
2713 # Please note that the actual code is *not* freely available.
2714 AC_DEFUN([AC_LC_MESSAGES], [
2715   AC_CHECK_HEADER(locale.h, [
2716     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2717       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2718        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2719     if test $ac_cv_val_LC_MESSAGES = yes; then
2720       AC_DEFINE(HAVE_LC_MESSAGES, 1, 
2721                 [Define if LC_MESSAGES is available in <locale.h>.])
2722     fi
2723   ])
2724 ])
2725
2726 # Macros from the top-level gcc directory.
2727 m4_include([../config/tls.m4])
2728