OSDN Git Service

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