OSDN Git Service

737507ce96719e34ec0e897429bfa1b3f4b10237
[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   enable_wchar_t=no
128   #enable_libstdcxx_debug=no
129   #enable_libstdcxx_pch=no
130   #enable_cheaders=c
131   #c_compatibility=no
132   #enable_abi_check=no
133   #enable_symvers=no
134   #enable_hosted_libstdcxx=yes
135
136   # Find platform-specific directories containing configuration info.
137   # Also possibly modify flags used elsewhere, as needed by the platform.
138   GLIBCXX_CHECK_HOST
139 ])
140
141
142 m4_include([linkage.m4])
143 m4_include([../config/no-executables.m4])
144
145
146 dnl
147 dnl Tests for newer compiler features, or features that are present in newer
148 dnl compiler versions but not older compiler versions still in use, should
149 dnl be placed here.
150 dnl
151 dnl Defines:
152 dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
153 dnl   new inlining code or the new system_header pragma will die on -Werror.
154 dnl   Leave it out by default and use maint-mode to use it.
155 dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
156 dnl   compiler supports it and the user has not requested debug mode.
157 dnl
158 AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
159   # All these tests are for C++; save the language and the compiler flags.
160   # The CXXFLAGS thing is suspicious, but based on similar bits previously
161   # found in GLIBCXX_CONFIGURE.
162   AC_LANG_SAVE
163   AC_LANG_CPLUSPLUS
164   ac_test_CXXFLAGS="${CXXFLAGS+set}"
165   ac_save_CXXFLAGS="$CXXFLAGS"
166
167   # Check for maintainer-mode bits.
168   if test x"$USE_MAINTAINER_MODE" = xno; then
169     WERROR=''
170   else
171     WERROR='-Werror'
172   fi
173
174   # Check for -ffunction-sections -fdata-sections
175   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
176   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
177   AC_TRY_COMPILE(, [int foo;], [ac_fdsections=yes], [ac_fdsections=no])
178   if test "$ac_test_CXXFLAGS" = set; then
179     CXXFLAGS="$ac_save_CXXFLAGS"
180   else
181     # this is the suspicious part
182     CXXFLAGS=''
183   fi
184   if test x"$ac_fdsections" = x"yes"; then
185     SECTION_FLAGS='-ffunction-sections -fdata-sections'
186   fi
187   AC_MSG_RESULT($ac_fdsections)
188
189   AC_LANG_RESTORE
190   AC_SUBST(WERROR)
191   AC_SUBST(SECTION_FLAGS)
192 ])
193
194
195 dnl
196 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
197 dnl the native linker is in use, all variables will be defined to something
198 dnl safe (like an empty string).
199 dnl
200 dnl Defines:
201 dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
202 dnl  OPT_LDFLAGS='-Wl,-O1' if possible
203 dnl  LD (as a side effect of testing)
204 dnl Sets:
205 dnl  with_gnu_ld
206 dnl  glibcxx_gnu_ld_version (possibly)
207 dnl
208 dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
209 dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
210 dnl
211 AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
212   # If we're not using GNU ld, then there's no point in even trying these
213   # tests.  Check for that first.  We should have already tested for gld
214   # by now (in libtool), but require it now just to be safe...
215   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
216   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
217   AC_REQUIRE([AC_PROG_LD])
218   AC_REQUIRE([AC_PROG_AWK])
219
220   # The name set by libtool depends on the version of libtool.  Shame on us
221   # for depending on an impl detail, but c'est la vie.  Older versions used
222   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
223   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
224   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
225   # set (hence we're using an older libtool), then set it.
226   if test x${with_gnu_ld+set} != xset; then
227     if test x${ac_cv_prog_gnu_ld+set} != xset; then
228       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
229       with_gnu_ld=no
230     else
231       with_gnu_ld=$ac_cv_prog_gnu_ld
232     fi
233   fi
234
235   # Start by getting the version number.  I think the libtool test already
236   # does some of this, but throws away the result.
237   changequote(,)
238   ldver=`$LD --version 2>/dev/null | head -1 | \
239          sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
240   changequote([,])
241   glibcxx_gnu_ld_version=`echo $ldver | \
242          $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
243
244   # Set --gc-sections.
245   if test "$with_gnu_ld" = "notbroken"; then
246     # GNU ld it is!  Joy and bunny rabbits!
247
248     # All these tests are for C++; save the language and the compiler flags.
249     # Need to do this so that g++ won't try to link in libstdc++
250     ac_test_CFLAGS="${CFLAGS+set}"
251     ac_save_CFLAGS="$CFLAGS"
252     CFLAGS='-x c++  -Wl,--gc-sections'
253
254     # Check for -Wl,--gc-sections
255     # XXX This test is broken at the moment, as symbols required for linking
256     # are now in libsupc++ (not built yet).  In addition, this test has
257     # cored on solaris in the past.  In addition, --gc-sections doesn't
258     # really work at the moment (keeps on discarding used sections, first
259     # .eh_frame and now some of the glibc sections for iconv).
260     # Bzzzzt.  Thanks for playing, maybe next time.
261     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
262     AC_TRY_RUN([
263      int main(void)
264      {
265        try { throw 1; }
266        catch (...) { };
267        return 0;
268      }
269     ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
270     if test "$ac_test_CFLAGS" = set; then
271       CFLAGS="$ac_save_CFLAGS"
272     else
273       # this is the suspicious part
274       CFLAGS=''
275     fi
276     if test "$ac_sectionLDflags" = "yes"; then
277       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
278     fi
279     AC_MSG_RESULT($ac_sectionLDflags)
280   fi
281
282   # Set linker optimization flags.
283   if test x"$with_gnu_ld" = x"yes"; then
284     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
285   fi
286
287   AC_SUBST(SECTION_LDFLAGS)
288   AC_SUBST(OPT_LDFLAGS)
289 ])
290
291
292 dnl
293 dnl Check to see if this target can enable the wchar_t parts.
294 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
295 dnl must have been previously checked.)  By default, wide characters are
296 dnl disabled.
297 dnl
298 dnl Defines:
299 dnl  HAVE_MBSTATE_T if mbstate_t is not in wchar.h
300 dnl  _GLIBCXX_USE_WCHAR_T if all the bits are found.
301 dnl Substs:
302 dnl  LIBICONV to a -l string containing the iconv library, if needed.
303 dnl
304 AC_DEFUN([GLIBCXX_CHECK_WCHAR_T_SUPPORT], [
305   # Test wchar.h for mbstate_t, which is needed for char_traits and
306   # others even if wchar_t support is not on.
307   AC_MSG_CHECKING([for mbstate_t])
308   AC_TRY_COMPILE([#include <wchar.h>],
309   [mbstate_t teststate;],
310   have_mbstate_t=yes, have_mbstate_t=no)
311   AC_MSG_RESULT($have_mbstate_t)
312   if test x"$have_mbstate_t" = xyes; then
313     AC_DEFINE(HAVE_MBSTATE_T)
314   fi
315
316   # Sanity check for existence of ISO C99 headers for extended encoding.
317   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
318   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
319
320   # Only continue checking if the ISO C99 headers exist and support is on.
321   if test x"$ac_has_wchar_h" = xyes &&
322      test x"$ac_has_wctype_h" = xyes &&
323      test x"$enable_c_mbchar" != xno; then
324
325     # Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
326     # numeric_limits can instantiate type_traits<wchar_t>
327     AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
328     AC_TRY_COMPILE([#include <wchar.h>],
329     [int i = WCHAR_MIN; int j = WCHAR_MAX;],
330     has_wchar_minmax=yes, has_wchar_minmax=no)
331     AC_MSG_RESULT($has_wchar_minmax)
332
333     # Test wchar.h for WEOF, which is what we use to determine whether
334     # to specialize for char_traits<wchar_t> or not.
335     AC_MSG_CHECKING([for WEOF])
336     AC_TRY_COMPILE([
337       #include <wchar.h>
338       #include <stddef.h>],
339     [wint_t i = WEOF;],
340     has_weof=yes, has_weof=no)
341     AC_MSG_RESULT($has_weof)
342
343     # Tests for wide character functions used in char_traits<wchar_t>.
344     ac_wfuncs=yes
345     AC_CHECK_FUNCS([wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset],
346     [],[ac_wfuncs=no])
347
348     # Checks for names injected into std:: by the c_std headers.
349     AC_CHECK_FUNCS([btowc wctob fgetwc fgetws fputwc fputws fwide \
350     fwprintf fwscanf swprintf swscanf vfwprintf vswprintf \
351     vwprintf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
352     mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstol \
353     wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
354     wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr],
355     [],[ac_wfuncs=no])
356
357     # Checks for wide character functions that are not required
358     # for basic wchar_t support.  Don't disable support if they are missing.
359     # Injection of these is wrapped with guard macros.
360     AC_CHECK_FUNCS([vfwscanf vswscanf vwscanf wcstof iswblank],[],[])
361
362     AC_MSG_CHECKING([for ISO C99 wchar_t support])
363     if test x"$has_weof" = xyes &&
364        test x"$has_wchar_minmax" = xyes &&
365        test x"$ac_wfuncs" = xyes;
366     then
367       ac_isoC99_wchar_t=yes
368     else
369       ac_isoC99_wchar_t=no
370     fi
371     AC_MSG_RESULT($ac_isoC99_wchar_t)
372
373     # Use iconv for wchar_t to char conversions. As such, check for
374     # X/Open Portability Guide, version 2 features (XPG2).
375     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
376     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
377
378     # Check for existence of libiconv.a providing XPG2 wchar_t support.
379     AC_CHECK_LIB(iconv, iconv, LIBICONV="-liconv")
380     ac_save_LIBS="$LIBS"
381     LIBS="$LIBS $LIBICONV"
382     AC_SUBST(LIBICONV)
383
384     AC_CHECK_FUNCS([iconv_open iconv_close iconv nl_langinfo],
385     [ac_XPG2funcs=yes], [ac_XPG2funcs=no])
386
387     LIBS="$ac_save_LIBS"
388
389     AC_MSG_CHECKING([for XPG2 wchar_t support])
390     if test x"$ac_has_iconv_h" = xyes &&
391        test x"$ac_has_langinfo_h" = xyes &&
392        test x"$ac_XPG2funcs" = xyes;
393     then
394       ac_XPG2_wchar_t=yes
395     else
396       ac_XPG2_wchar_t=no
397     fi
398     AC_MSG_RESULT($ac_XPG2_wchar_t)
399
400     # At the moment, only enable wchar_t specializations if all the
401     # above support is present.
402     if test x"$ac_isoC99_wchar_t" = xyes &&
403        test x"$ac_XPG2_wchar_t" = xyes;
404     then
405       AC_DEFINE(_GLIBCXX_USE_WCHAR_T)
406       enable_wchar_t=yes
407     fi
408   fi
409   AC_MSG_CHECKING([for enabled wchar_t specializations])
410   AC_MSG_RESULT($enable_wchar_t)
411 ])
412
413
414 dnl
415 dnl Check for headers for, and arguments to, the setrlimit() function.
416 dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
417 dnl
418 dnl Defines:
419 dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits 
420 dnl  various HAVE_LIMIT_* for individual limit names
421 dnl
422 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
423   AC_TRY_COMPILE(
424     [#include <unistd.h>
425      #include <sys/time.h>
426      #include <sys/resource.h>
427     ],
428     [ int f = RLIMIT_$1 ; ],
429     [glibcxx_mresult=1], [glibcxx_mresult=0])
430   AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
431                      [Only used in build directory testsuite_hooks.h.])
432 ])
433
434 AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
435   setrlimit_have_headers=yes
436   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
437                    [],
438                    [setrlimit_have_headers=no])
439   # If don't have the headers, then we can't run the tests now, and we
440   # won't be seeing any of these during testsuite compilation.
441   if test $setrlimit_have_headers = yes; then
442     # Can't do these in a loop, else the resulting syntax is wrong.
443     GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
444     GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
445     GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
446     GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
447     GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
448
449     # Check for rlimit, setrlimit.
450     AC_CACHE_VAL(ac_setrlimit, [
451       AC_TRY_COMPILE(
452         [#include <unistd.h>
453          #include <sys/time.h>
454          #include <sys/resource.h>
455         ],
456         [struct rlimit r;
457          setrlimit(0, &r);],
458         [ac_setrlimit=yes], [ac_setrlimit=no])
459     ])
460   fi
461
462   AC_MSG_CHECKING([for testsuite resource limits support])
463   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
464     ac_res_limits=yes
465     AC_DEFINE(_GLIBCXX_RES_LIMITS)
466   else
467     ac_res_limits=no
468   fi
469   AC_MSG_RESULT($ac_res_limits)
470 ])
471
472
473 dnl
474 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
475 dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
476 dnl
477 AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
478   AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
479     AC_TRY_LINK(
480       [#include <sys/stat.h>],
481       [struct stat buffer;
482        fstat(0, &buffer);
483        S_ISREG(buffer.st_mode);],
484       [glibcxx_cv_S_ISREG=yes],
485       [glibcxx_cv_S_ISREG=no])
486   ])
487   AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
488     AC_TRY_LINK(
489       [#include <sys/stat.h>],
490       [struct stat buffer;
491        fstat(0, &buffer);
492        S_IFREG & buffer.st_mode;],
493       [glibcxx_cv_S_IFREG=yes],
494       [glibcxx_cv_S_IFREG=no])
495   ])
496   if test $glibcxx_cv_S_ISREG = yes; then
497     AC_DEFINE(HAVE_S_ISREG)
498   elif test $glibcxx_cv_S_IFREG = yes; then
499     AC_DEFINE(HAVE_S_IFREG)
500   fi
501 ])
502
503
504 dnl
505 dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
506 dnl
507 AC_DEFUN([GLIBCXX_CHECK_POLL], [
508   AC_CACHE_VAL(glibcxx_cv_POLL, [
509     AC_TRY_LINK(
510       [#include <poll.h>],
511       [struct pollfd pfd[1];
512        pfd[0].events = POLLIN;
513        poll(pfd, 1, 0);],
514       [glibcxx_cv_POLL=yes],
515       [glibcxx_cv_POLL=no])
516   ])
517   if test $glibcxx_cv_POLL = yes; then
518     AC_DEFINE(HAVE_POLL)
519   fi
520 ])
521
522
523 dnl
524 dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
525 dnl
526 AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
527   AC_CACHE_VAL(glibcxx_cv_WRITEV, [
528     AC_TRY_LINK(
529       [#include <sys/uio.h>],
530       [struct iovec iov[2];
531        writev(0, iov, 0);],
532       [glibcxx_cv_WRITEV=yes],
533       [glibcxx_cv_WRITEV=no])
534   ])
535   if test $glibcxx_cv_WRITEV = yes; then
536     AC_DEFINE(HAVE_WRITEV)
537   fi
538 ])
539
540
541 dnl
542 dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
543 dnl
544 AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
545   AC_CACHE_VAL(glibcxx_cv_INT64_T, [
546     AC_TRY_COMPILE(
547       [#include <stdint.h>],
548       [int64_t var;],
549       [glibcxx_cv_INT64_T=yes],
550       [glibcxx_cv_INT64_T=no])
551   ])
552   if test $glibcxx_cv_INT64_T = yes; then
553     AC_DEFINE(HAVE_INT64_T)
554   fi
555 ])
556
557
558 dnl
559 dnl Check whether LFS support is available.
560 dnl
561 AC_DEFUN([GLIBCXX_CHECK_LFS], [
562   AC_LANG_SAVE
563   AC_LANG_CPLUSPLUS
564   ac_save_CXXFLAGS="$CXXFLAGS"
565   CXXFLAGS="$CXXFLAGS -fno-exceptions"  
566   AC_CACHE_VAL(glibcxx_cv_LFS, [
567     AC_TRY_LINK(
568       [#include <unistd.h>
569        #include <stdio.h>
570        #include <sys/stat.h>
571       ],
572       [FILE* fp;
573        fopen64("t", "w");
574        fseeko64(fp, 0, SEEK_CUR);
575        ftello64(fp);
576        lseek64(1, 0, SEEK_CUR);
577        struct stat64 buf;
578        fstat64(1, &buf);],
579       [glibcxx_cv_LFS=yes],
580       [glibcxx_cv_LFS=no])
581   ])
582   if test $glibcxx_cv_LFS = yes; then
583     AC_DEFINE(_GLIBCXX_USE_LFS)
584   fi
585   CXXFLAGS="$ac_save_CXXFLAGS"
586   AC_LANG_RESTORE
587 ])
588
589
590 dnl
591 dnl Check for whether a fully dynamic basic_string implementation should
592 dnl be turned on, that does not put empty objects in per-process static
593 dnl memory (mostly useful together with shared memory allocators, see PR
594 dnl libstdc++/16612 for details).
595 dnl
596 dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
597 dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
598 dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
599 dnl       Where DEFAULT is either `yes' or `no'.
600 dnl
601 AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
602   GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
603   if test $enable_fully_dynamic_string = yes; then
604     AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING)
605   fi
606 ])
607
608
609 dnl
610 dnl Does any necessary configuration of the testsuite directory.  Generates
611 dnl the testsuite_hooks.h header.
612 dnl
613 dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
614 dnl
615 dnl Sets:
616 dnl  enable_abi_check / GLIBCXX_TEST_ABI
617 dnl  GLIBCXX_TEST_WCHAR_T
618 dnl  GLIBCXX_TEST_THREAD
619 dnl Substs:
620 dnl  baseline_dir
621 dnl
622 AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
623   if $GLIBCXX_IS_NATIVE && test $is_hosted = yes; then
624     # Do checks for resource limit functions.
625     GLIBCXX_CHECK_SETRLIMIT
626
627     # Look for setenv, so that extended locale tests can be performed.
628     GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
629
630     if test $enable_symvers = no; then
631       enable_abi_check=no
632     else
633       case "$host" in
634         *-*-cygwin*)
635           enable_abi_check=no ;;
636         *)
637           enable_abi_check=yes ;;
638       esac
639     fi
640   else
641     # Only build this as native, since automake does not understand
642     # CXX_FOR_BUILD.
643     enable_abi_check=no
644   fi
645
646   # Export file names for ABI checking.
647   baseline_dir="$glibcxx_srcdir/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
648   AC_SUBST(baseline_dir)
649
650   GLIBCXX_CONDITIONAL(GLIBCXX_TEST_WCHAR_T, test $enable_wchar_t = yes)
651   GLIBCXX_CONDITIONAL(GLIBCXX_TEST_THREAD, test $enable_thread = yes)
652   GLIBCXX_CONDITIONAL(GLIBCXX_TEST_ABI, test $enable_abi_check = yes)
653 ])
654
655
656 dnl
657 dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
658 dnl
659 dnl Substs:
660 dnl  GLIBCXX_INCLUDES
661 dnl  TOPLEVEL_INCLUDES
662 dnl
663 AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
664   # Used for every C++ compile we perform.
665   GLIBCXX_INCLUDES="\
666 -I$glibcxx_builddir/include/$host_alias \
667 -I$glibcxx_builddir/include \
668 -I$glibcxx_srcdir/libsupc++"
669
670   # For Canadian crosses, pick this up too.
671   if test $CANADIAN = yes; then
672     GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
673   fi
674
675   # Stuff in the actual top level.  Currently only used by libsupc++ to
676   # get unwind* headers from the gcc dir.
677   #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include'
678   TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc'
679
680   # Now, export this to all the little Makefiles....
681   AC_SUBST(GLIBCXX_INCLUDES)
682   AC_SUBST(TOPLEVEL_INCLUDES)
683 ])
684
685
686 dnl
687 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
688 dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
689 dnl
690 dnl Substs:
691 dnl  OPTIMIZE_CXXFLAGS
692 dnl  WARN_FLAGS
693 dnl
694 AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
695   # Optimization flags that are probably a good idea for thrill-seekers. Just
696   # uncomment the lines below and make, everything else is ready to go...
697   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
698   OPTIMIZE_CXXFLAGS=
699   AC_SUBST(OPTIMIZE_CXXFLAGS)
700
701   WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
702   AC_SUBST(WARN_FLAGS)
703 ])
704
705
706 dnl
707 dnl All installation directory information is determined here.
708 dnl
709 dnl Substs:
710 dnl  gxx_install_dir
711 dnl  glibcxx_prefixdir
712 dnl  glibcxx_toolexecdir
713 dnl  glibcxx_toolexeclibdir
714 dnl
715 dnl Assumes cross_compiling bits already done, and with_cross_host in
716 dnl particular.
717 dnl
718 AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
719   glibcxx_toolexecdir=no
720   glibcxx_toolexeclibdir=no
721   glibcxx_prefixdir=$prefix
722
723   AC_MSG_CHECKING([for gxx-include-dir])
724   AC_ARG_WITH([gxx-include-dir],
725     AC_HELP_STRING([--with-gxx-include-dir=DIR],
726                    [installation directory for include files]),
727     [case "$withval" in
728       yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
729       no)  gxx_include_dir=no ;;
730       *)   gxx_include_dir=$withval ;;
731      esac],
732     [gxx_include_dir=no])
733   AC_MSG_RESULT($gxx_include_dir)
734
735   AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
736   AC_ARG_ENABLE([version-specific-runtime-libs],
737     AC_HELP_STRING([--enable-version-specific-runtime-libs],
738                    [Specify that runtime libraries should be installed in a compiler-specific directory]),
739     [case "$enableval" in
740       yes) version_specific_libs=yes ;;
741       no)  version_specific_libs=no ;;
742       *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
743      esac],
744     [version_specific_libs=no])
745   AC_MSG_RESULT($version_specific_libs)
746
747   # Default case for install directory for include files.
748   if test $version_specific_libs = no && test $gxx_include_dir = no; then
749     gxx_include_dir='${prefix}/include/c++/${gcc_version}'
750   fi
751
752   # Version-specific runtime libs processing.
753   if test $version_specific_libs = yes; then
754     # Need the gcc compiler version to know where to install libraries
755     # and header files if --enable-version-specific-runtime-libs option
756     # is selected.  FIXME: these variables are misnamed, there are
757     # no executables installed in _toolexecdir or _toolexeclibdir.
758     if test x"$gxx_include_dir" = x"no"; then
759       gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
760     fi
761     glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
762     glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
763   fi
764
765   # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
766   # Install a library built with a cross compiler in tooldir, not libdir.
767   if test x"$glibcxx_toolexecdir" = x"no"; then
768     if test -n "$with_cross_host" &&
769        test x"$with_cross_host" != x"no"; then
770       glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
771       glibcxx_toolexeclibdir='${toolexecdir}/lib'
772     else
773       glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
774       glibcxx_toolexeclibdir='${libdir}'
775     fi
776     multi_os_directory=`$CXX -print-multi-os-directory`
777     case $multi_os_directory in
778       .) ;; # Avoid trailing /.
779       *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
780     esac
781   fi
782
783   AC_MSG_CHECKING([for install location])
784   AC_MSG_RESULT($gxx_include_dir)
785
786   AC_SUBST(glibcxx_prefixdir)
787   AC_SUBST(gxx_include_dir)
788   AC_SUBST(glibcxx_toolexecdir)
789   AC_SUBST(glibcxx_toolexeclibdir)
790 ])
791
792
793 dnl
794 dnl GLIBCXX_ENABLE
795 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
796 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
797 dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
798 dnl
799 dnl See docs/html/17_intro/configury.html#enable for documentation.
800 dnl
801 m4_define([GLIBCXX_ENABLE],[dnl
802 m4_define([_g_switch],[--enable-$1])dnl
803 m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
804  AC_ARG_ENABLE($1,_g_help,
805   m4_bmatch([$5],
806    [^permit ],
807      [[
808       case "$enableval" in
809        m4_bpatsubst([$5],[permit ])) ;;
810        *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
811           dnl Idea for future:  generate a URL pointing to
812           dnl "onlinedocs/configopts.html#whatever"
813       esac
814      ]],
815    [^$],
816      [[
817       case "$enableval" in
818        yes|no) ;;
819        *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
820       esac
821      ]],
822    [[$5]]),
823   [enable_]m4_bpatsubst([$1],-,_)[=][$2])
824 m4_undefine([_g_switch])dnl
825 m4_undefine([_g_help])dnl
826 ])
827
828
829 dnl
830 dnl Check for ISO/IEC 9899:1999 "C99" support.
831 dnl
832 dnl --enable-c99 defines _GLIBCXX_USE_C99
833 dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
834 dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
835 dnl       Where DEFAULT is either `yes' or `no'.
836 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
837 dnl
838 AC_DEFUN([GLIBCXX_ENABLE_C99], [
839   GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
840
841   AC_LANG_SAVE
842   AC_LANG_CPLUSPLUS
843
844   # Check for the existence of <math.h> functions used if C99 is enabled.
845   ac_c99_math=yes;
846   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
847   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
848   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
849   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
850   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
851   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
852   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
853   AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
854   AC_TRY_COMPILE([#include <math.h>],
855                  [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
856   AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
857   AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
858   AC_TRY_COMPILE([#include <math.h>],
859                  [islessgreater(0.0,0.0);],, [ac_c99_math=no])
860   AC_TRY_COMPILE([#include <math.h>],
861                  [isunordered(0.0,0.0);],, [ac_c99_math=no])
862   AC_MSG_RESULT($ac_c99_math)
863
864   if test x"$ac_c99_math" = x"yes"; then
865     AC_DEFINE(_GLIBCXX_USE_C99_MATH)
866   fi
867
868   # Check for the existence of <complex.h> complex functions.
869   # This is necessary even though libstdc++ uses the builtin versions
870   # of these functions, because if the builtin cannot be used, a reference
871   # to the library function is emitted.
872   AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
873   ac_c99_complex=no;
874   if test x"$ac_has_complex_h" = x"yes"; then
875     ac_c99_complex=yes;
876     AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
877     AC_TRY_COMPILE([#include <complex.h>],
878                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
879                     cabsf(tmp);],, [ac_c99_complex=no])
880     AC_TRY_COMPILE([#include <complex.h>],
881                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
882                     cabs(tmp);],, [ac_c99_complex=no])
883     AC_TRY_COMPILE([#include <complex.h>],
884                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
885                     cabsl(tmp);],, [ac_c99_complex=no])
886     AC_TRY_COMPILE([#include <complex.h>],
887                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
888                     cargf(tmp);],, [ac_c99_complex=no])
889     AC_TRY_COMPILE([#include <complex.h>],
890                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
891                     carg(tmp);],, [ac_c99_complex=no])
892     AC_TRY_COMPILE([#include <complex.h>],
893                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
894                     cargl(tmp);],, [ac_c99_complex=no])
895     AC_TRY_COMPILE([#include <complex.h>],
896                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
897                     ccosf(tmp);],, [ac_c99_complex=no])
898     AC_TRY_COMPILE([#include <complex.h>],
899                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
900                     ccos(tmp);],, [ac_c99_complex=no])
901     AC_TRY_COMPILE([#include <complex.h>],
902                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
903                     ccosl(tmp);],, [ac_c99_complex=no])
904     AC_TRY_COMPILE([#include <complex.h>],
905                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
906                     ccoshf(tmp);],, [ac_c99_complex=no])
907     AC_TRY_COMPILE([#include <complex.h>],
908                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
909                     ccosh(tmp);],, [ac_c99_complex=no])
910     AC_TRY_COMPILE([#include <complex.h>],
911                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
912                     ccoshl(tmp);],, [ac_c99_complex=no])
913     AC_TRY_COMPILE([#include <complex.h>],
914                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
915                     cexpf(tmp);],, [ac_c99_complex=no])
916     AC_TRY_COMPILE([#include <complex.h>],
917                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
918                     cexp(tmp);],, [ac_c99_complex=no])
919     AC_TRY_COMPILE([#include <complex.h>],
920                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
921                     cexpl(tmp);],, [ac_c99_complex=no])
922     AC_TRY_COMPILE([#include <complex.h>],
923                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
924                     csinf(tmp);],, [ac_c99_complex=no])
925     AC_TRY_COMPILE([#include <complex.h>],
926                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
927                     csin(tmp);],, [ac_c99_complex=no])
928     AC_TRY_COMPILE([#include <complex.h>],
929                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
930                     csinl(tmp);],, [ac_c99_complex=no])
931     AC_TRY_COMPILE([#include <complex.h>],
932                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
933                     csinhf(tmp);],, [ac_c99_complex=no])
934     AC_TRY_COMPILE([#include <complex.h>],
935                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
936                     csinh(tmp);],, [ac_c99_complex=no])
937     AC_TRY_COMPILE([#include <complex.h>],
938                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
939                     csinhl(tmp);],, [ac_c99_complex=no])
940     AC_TRY_COMPILE([#include <complex.h>],
941                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
942                     csqrtf(tmp);],, [ac_c99_complex=no])
943     AC_TRY_COMPILE([#include <complex.h>],
944                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
945                     csqrt(tmp);],, [ac_c99_complex=no])
946     AC_TRY_COMPILE([#include <complex.h>],
947                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
948                     csqrtl(tmp);],, [ac_c99_complex=no])
949     AC_TRY_COMPILE([#include <complex.h>],
950                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
951                     ctanf(tmp);],, [ac_c99_complex=no])
952     AC_TRY_COMPILE([#include <complex.h>],
953                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
954                     ctan(tmp);],, [ac_c99_complex=no])
955     AC_TRY_COMPILE([#include <complex.h>],
956                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
957                     ctanl(tmp);],, [ac_c99_complex=no])
958     AC_TRY_COMPILE([#include <complex.h>],
959                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
960                     ctanhf(tmp);],, [ac_c99_complex=no])
961     AC_TRY_COMPILE([#include <complex.h>],
962                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
963                     ctanh(tmp);],, [ac_c99_complex=no])
964     AC_TRY_COMPILE([#include <complex.h>],
965                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
966                     ctanhl(tmp);],, [ac_c99_complex=no])
967     AC_TRY_COMPILE([#include <complex.h>],
968                    [typedef __complex__ float _ComplexT; _ComplexT tmp;
969                     cpowf(tmp, tmp);],, [ac_c99_complex=no])
970     AC_TRY_COMPILE([#include <complex.h>],
971                    [typedef __complex__ double _ComplexT; _ComplexT tmp;
972                     cpow(tmp, tmp);],, [ac_c99_complex=no])
973     AC_TRY_COMPILE([#include <complex.h>],
974                    [typedef __complex__ long double _ComplexT; _ComplexT tmp;
975                     cpowl(tmp, tmp);],, [ac_c99_complex=no])
976   fi
977   AC_MSG_RESULT($ac_c99_complex)
978
979   if test x"$ac_c99_complex" = x"yes"; then
980     AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX)
981   fi
982
983   # Check for the existence in <stdio.h> of vscanf, et. al.
984   ac_c99_stdio=yes;
985   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
986   AC_TRY_COMPILE([#include <stdio.h>],
987                  [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
988   AC_TRY_COMPILE([#include <stdio.h>
989                   #include <stdarg.h>
990                   void foo(char* fmt, ...)
991                   {va_list args; va_start(args, fmt);
992                   vfscanf(stderr, "%i", args);}],
993                   [],, [ac_c99_stdio=no])
994   AC_TRY_COMPILE([#include <stdio.h>
995                   #include <stdarg.h>
996                   void foo(char* fmt, ...)
997                   {va_list args; va_start(args, fmt);
998                   vscanf("%i", args);}],
999                   [],, [ac_c99_stdio=no])
1000   AC_TRY_COMPILE([#include <stdio.h>
1001                   #include <stdarg.h>
1002                   void foo(char* fmt, ...)
1003                   {va_list args; va_start(args, fmt);
1004                   vsnprintf(fmt, 0, "%i", args);}],
1005                   [],, [ac_c99_stdio=no])
1006   AC_TRY_COMPILE([#include <stdio.h>
1007                   #include <stdarg.h>
1008                   void foo(char* fmt, ...)
1009                   {va_list args; va_start(args, fmt);
1010                   vsscanf(fmt, "%i", args);}],
1011                   [],, [ac_c99_stdio=no])
1012   AC_MSG_RESULT($ac_c99_stdio)
1013
1014   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1015   ac_c99_stdlib=yes;
1016   AC_MSG_CHECKING([for lldiv_t declaration])
1017   AC_CACHE_VAL(ac_c99_lldiv_t, [
1018   AC_TRY_COMPILE([#include <stdlib.h>],
1019                    [ lldiv_t mydivt;],
1020                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1021   ])
1022   AC_MSG_RESULT($ac_c99_lldiv_t)
1023
1024   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1025   AC_TRY_COMPILE([#include <stdlib.h>],
1026                  [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
1027   AC_TRY_COMPILE([#include <stdlib.h>],
1028                  [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
1029   AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
1030   AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
1031   AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
1032   AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
1033   if test x"$ac_c99_lldiv_t" = x"no"; then
1034     ac_c99_stdlib=no;
1035   fi;
1036   AC_MSG_RESULT($ac_c99_stdlib)
1037
1038   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1039   # XXX the wchar.h checks should be rolled into the general C99 bits.
1040   ac_c99_wchar=yes;
1041   AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
1042   AC_TRY_COMPILE([#include <wchar.h>],
1043                  [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
1044   AC_TRY_COMPILE([#include <wchar.h>],
1045                  [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
1046   AC_TRY_COMPILE([#include <wchar.h>],
1047                  [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
1048   AC_MSG_RESULT($ac_c99_wchar)
1049
1050   AC_MSG_CHECKING([for enabled ISO C99 support])
1051   if test x"$ac_c99_math" = x"no" ||
1052      test x"$ac_c99_complex" = x"no" ||
1053      test x"$ac_c99_stdio" = x"no" ||
1054      test x"$ac_c99_stdlib" = x"no" ||
1055      test x"$ac_c99_wchar" = x"no"; then
1056     enable_c99=no;
1057   fi;
1058   AC_MSG_RESULT($enable_c99)
1059
1060   # Option parsed, now set things appropriately
1061   if test x"$enable_c99" = x"yes"; then
1062     AC_DEFINE(_GLIBCXX_USE_C99)
1063   fi
1064
1065   AC_LANG_RESTORE
1066 ])
1067
1068
1069 dnl
1070 dnl Check for what type of C headers to use.
1071 dnl
1072 dnl --enable-cheaders= [does stuff].
1073 dnl --disable-cheaders [does not do anything, really].
1074 dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1075 dnl       Where DEFAULT is either `c' or `c_std'.
1076 dnl
1077 AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1078   GLIBCXX_ENABLE(cheaders,$1,[=KIND],
1079     [construct "C" headers for g++], [permit c|c_std])
1080   AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1081
1082   C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1083
1084   AC_SUBST(C_INCLUDE_DIR)
1085   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1086   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1087   GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1088 ])
1089
1090
1091 dnl
1092 dnl Check for which locale library to use.  The choice is mapped to
1093 dnl a subdirectory of config/locale.
1094 dnl
1095 dnl Default is generic.
1096 dnl
1097 AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1098   AC_MSG_CHECKING([for C locale to use])
1099   GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@],
1100     [use MODEL for target locale package],
1101     [permit generic|gnu|ieee_1003.1-2001|yes|no|auto])
1102   
1103   # If they didn't use this option switch, or if they specified --enable
1104   # with no specific model, we'll have to look for one.  If they
1105   # specified --disable (???), do likewise.
1106   if test $enable_clocale = no || test $enable_clocale = yes; then
1107      enable_clocale=auto
1108   fi
1109
1110   # Either a known package, or "auto"
1111   enable_clocale_flag=$enable_clocale
1112
1113   # Probe for locale support if no specific model is specified.
1114   # Default to "generic".
1115   if test $enable_clocale_flag = auto; then
1116     case ${target_os} in
1117       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1118         AC_EGREP_CPP([_GLIBCXX_ok], [
1119         #include <features.h>
1120         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1121           _GLIBCXX_ok
1122         #endif
1123         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1124
1125         # Test for bugs early in glibc-2.2.x series
1126           if test $enable_clocale_flag = gnu; then
1127           AC_TRY_RUN([
1128           #define _GNU_SOURCE 1
1129           #include <locale.h>
1130           #include <string.h>
1131           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1132           extern __typeof(newlocale) __newlocale;
1133           extern __typeof(duplocale) __duplocale;
1134           extern __typeof(strcoll_l) __strcoll_l;
1135           #endif
1136           int main()
1137           {
1138               const char __one[] = "Äuglein Augmen";
1139               const char __two[] = "Äuglein";
1140               int i;
1141               int j;
1142               __locale_t        loc;
1143                __locale_t        loc_dup;
1144               loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1145               loc_dup = __duplocale(loc);
1146               i = __strcoll_l(__one, __two, loc);
1147               j = __strcoll_l(__one, __two, loc_dup);
1148               return 0;
1149           }
1150           ],
1151           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1152           [enable_clocale_flag=generic])
1153           fi
1154
1155         # ... at some point put __strxfrm_l tests in as well.
1156         ;;
1157       darwin* | freebsd*)
1158         enable_clocale_flag=darwin
1159         ;;
1160       *)
1161         enable_clocale_flag=generic
1162         ;;
1163     esac
1164   fi
1165
1166   # Deal with gettext issues.  Default to not using it (=no) until we detect
1167   # support for it later.  Let the user turn it off via --e/d, but let that
1168   # default to on for easier handling.
1169   USE_NLS=no
1170   AC_ARG_ENABLE(nls,
1171     AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1172     [],
1173     [enable_nls=yes])
1174
1175   # Set configure bits for specified locale package
1176   case ${enable_clocale_flag} in
1177     generic)
1178       AC_MSG_RESULT(generic)
1179
1180       CLOCALE_H=config/locale/generic/c_locale.h
1181       CLOCALE_CC=config/locale/generic/c_locale.cc
1182       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1183       CCOLLATE_CC=config/locale/generic/collate_members.cc
1184       CCTYPE_CC=config/locale/generic/ctype_members.cc
1185       CMESSAGES_H=config/locale/generic/messages_members.h
1186       CMESSAGES_CC=config/locale/generic/messages_members.cc
1187       CMONEY_CC=config/locale/generic/monetary_members.cc
1188       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1189       CTIME_H=config/locale/generic/time_members.h
1190       CTIME_CC=config/locale/generic/time_members.cc
1191       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1192       ;;
1193     darwin)
1194       AC_MSG_RESULT(darwin or freebsd)
1195
1196       CLOCALE_H=config/locale/generic/c_locale.h
1197       CLOCALE_CC=config/locale/generic/c_locale.cc
1198       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1199       CCOLLATE_CC=config/locale/generic/collate_members.cc
1200       CCTYPE_CC=config/locale/darwin/ctype_members.cc
1201       CMESSAGES_H=config/locale/generic/messages_members.h
1202       CMESSAGES_CC=config/locale/generic/messages_members.cc
1203       CMONEY_CC=config/locale/generic/monetary_members.cc
1204       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1205       CTIME_H=config/locale/generic/time_members.h
1206       CTIME_CC=config/locale/generic/time_members.cc
1207       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1208       ;;
1209         
1210     gnu)
1211       AC_MSG_RESULT(gnu)
1212
1213       # Declare intention to use gettext, and add support for specific
1214       # languages.
1215       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1216       ALL_LINGUAS="de fr"
1217
1218       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1219       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1220       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1221         USE_NLS=yes
1222       fi
1223       # Export the build objects.
1224       for ling in $ALL_LINGUAS; do \
1225         glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
1226         glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
1227       done
1228       AC_SUBST(glibcxx_MOFILES)
1229       AC_SUBST(glibcxx_POFILES)
1230
1231       CLOCALE_H=config/locale/gnu/c_locale.h
1232       CLOCALE_CC=config/locale/gnu/c_locale.cc
1233       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1234       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1235       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1236       CMESSAGES_H=config/locale/gnu/messages_members.h
1237       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1238       CMONEY_CC=config/locale/gnu/monetary_members.cc
1239       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1240       CTIME_H=config/locale/gnu/time_members.h
1241       CTIME_CC=config/locale/gnu/time_members.cc
1242       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1243       ;;
1244     ieee_1003.1-2001)
1245       AC_MSG_RESULT(IEEE 1003.1)
1246
1247       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1248       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1249       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1250       CCOLLATE_CC=config/locale/generic/collate_members.cc
1251       CCTYPE_CC=config/locale/generic/ctype_members.cc
1252       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1253       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1254       CMONEY_CC=config/locale/generic/monetary_members.cc
1255       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1256       CTIME_H=config/locale/generic/time_members.h
1257       CTIME_CC=config/locale/generic/time_members.cc
1258       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1259       ;;
1260   esac
1261
1262   # This is where the testsuite looks for locale catalogs, using the
1263   # -DLOCALEDIR define during testsuite compilation.
1264   glibcxx_localedir=${glibcxx_builddir}/po/share/locale
1265   AC_SUBST(glibcxx_localedir)
1266
1267   # A standalone libintl (e.g., GNU libintl) may be in use.
1268   if test $USE_NLS = yes; then
1269     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1270     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1271   fi
1272   if test $USE_NLS = yes; then
1273     AC_DEFINE(_GLIBCXX_USE_NLS)
1274   fi
1275
1276   AC_SUBST(USE_NLS)
1277   AC_SUBST(CLOCALE_H)
1278   AC_SUBST(CMESSAGES_H)
1279   AC_SUBST(CCODECVT_CC)
1280   AC_SUBST(CCOLLATE_CC)
1281   AC_SUBST(CCTYPE_CC)
1282   AC_SUBST(CMESSAGES_CC)
1283   AC_SUBST(CMONEY_CC)
1284   AC_SUBST(CNUMERIC_CC)
1285   AC_SUBST(CTIME_H)
1286   AC_SUBST(CTIME_CC)
1287   AC_SUBST(CLOCALE_CC)
1288   AC_SUBST(CLOCALE_INTERNAL_H)
1289 ])
1290
1291
1292 dnl
1293 dnl Check for which std::allocator base class to use.  The choice is
1294 dnl mapped from a subdirectory of include/ext.
1295 dnl
1296 dnl Default is new.
1297 dnl
1298 AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
1299   AC_MSG_CHECKING([for std::allocator base class to use])
1300   GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
1301     [use KIND for target std::allocator base],
1302     [permit new|malloc|mt|bitmap|pool|yes|no|auto])
1303
1304   # If they didn't use this option switch, or if they specified --enable
1305   # with no specific model, we'll have to look for one.  If they
1306   # specified --disable (???), do likewise.
1307   if test $enable_libstdcxx_allocator = no ||
1308      test $enable_libstdcxx_allocator = yes;
1309   then
1310      enable_libstdcxx_allocator=auto
1311   fi
1312
1313   # Either a known package, or "auto". Auto implies the default choice
1314   # for a particular platform.
1315   enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
1316
1317   # Probe for host-specific support if no specific model is specified.
1318   # Default to "new".
1319   if test $enable_libstdcxx_allocator_flag = auto; then
1320     case ${target_os} in
1321       linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1322         enable_libstdcxx_allocator_flag=mt
1323         ;;
1324       *)
1325         enable_libstdcxx_allocator_flag=new
1326         ;;
1327     esac
1328   fi
1329   AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
1330   
1331
1332   # Set configure bits for specified locale package
1333   case ${enable_libstdcxx_allocator_flag} in
1334     bitmap)
1335       ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
1336       ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
1337       ;;
1338     malloc)
1339       ALLOCATOR_H=config/allocator/malloc_allocator_base.h
1340       ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
1341       ;;
1342     mt)
1343       ALLOCATOR_H=config/allocator/mt_allocator_base.h
1344       ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
1345       ;;
1346     new)
1347       ALLOCATOR_H=config/allocator/new_allocator_base.h
1348       ALLOCATOR_NAME=__gnu_cxx::new_allocator
1349       ;;
1350     pool)
1351       ALLOCATOR_H=config/allocator/pool_allocator_base.h
1352       ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
1353       ;;        
1354   esac
1355
1356   AC_SUBST(ALLOCATOR_H)
1357   AC_SUBST(ALLOCATOR_NAME)
1358 ])
1359
1360
1361 dnl
1362 dnl Check for whether the Boost-derived checks should be turned on.
1363 dnl
1364 dnl --enable-concept-checks turns them on.
1365 dnl --disable-concept-checks leaves them off.
1366 dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
1367 dnl       Where DEFAULT is either `yes' or `no'.
1368 dnl
1369 AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
1370   GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
1371   if test $enable_concept_checks = yes; then
1372     AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS)
1373   fi
1374 ])
1375
1376
1377 dnl
1378 dnl Check for which I/O library to use:  stdio, or something specific.
1379 dnl
1380 dnl Default is stdio.
1381 dnl
1382 AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
1383   AC_MSG_CHECKING([for underlying I/O to use])
1384   GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE],
1385     [use target-specific I/O package], [permit stdio])
1386
1387   # Now that libio has been removed, you can have any color you want as long
1388   # as it's black.  This is one big no-op until other packages are added, but
1389   # showing the framework never hurts.
1390   case ${enable_cstdio} in
1391     stdio)
1392       CSTDIO_H=config/io/c_io_stdio.h
1393       BASIC_FILE_H=config/io/basic_file_stdio.h
1394       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1395       AC_MSG_RESULT(stdio)
1396       ;;
1397   esac
1398
1399   AC_SUBST(CSTDIO_H)
1400   AC_SUBST(BASIC_FILE_H)
1401   AC_SUBST(BASIC_FILE_CC)
1402 ])
1403
1404
1405 dnl
1406 dnl Check for "unusual" flags to pass to the compiler while building.
1407 dnl
1408 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1409 dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
1410 dnl --disable-cxx-flags passes nothing.
1411 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1412 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1413 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1414 dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
1415 dnl       If "default flags" is an empty string, the effect is the same
1416 dnl       as --disable or --enable=no.
1417 dnl
1418 AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
1419   AC_MSG_CHECKING([for extra compiler flags for building])
1420   GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
1421     [pass compiler FLAGS when building library],
1422     [case "x$enable_cxx_flags" in
1423       xno | x)   enable_cxx_flags= ;;
1424       x-*)       ;;
1425       *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1426      esac])
1427
1428   # Run through flags (either default or command-line) and set anything
1429   # extra (e.g., #defines) that must accompany particular g++ options.
1430   if test -n "$enable_cxx_flags"; then
1431     for f in $enable_cxx_flags; do
1432       case "$f" in
1433         -fhonor-std)  ;;
1434         -*)  ;;
1435         *)   # and we're trying to pass /what/ exactly?
1436              AC_MSG_ERROR([compiler flags start with a -]) ;;
1437       esac
1438     done
1439   fi
1440
1441   EXTRA_CXX_FLAGS="$enable_cxx_flags"
1442   AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1443   AC_SUBST(EXTRA_CXX_FLAGS)
1444 ])
1445
1446
1447 dnl
1448 dnl Check for wide character support.  Has the same effect as the option
1449 dnl in gcc's configure, but in a form that autoconf can mess with.
1450 dnl
1451 dnl --enable-c-mbchar requests all the wchar_t stuff.
1452 dnl --disable-c-mbchar doesn't.
1453 dnl  +  Usage:  GLIBCXX_ENABLE_C_MBCHAR[(DEFAULT)]
1454 dnl       Where DEFAULT is either `yes' or `no'.
1455 dnl
1456 AC_DEFUN([GLIBCXX_ENABLE_C_MBCHAR], [
1457   GLIBCXX_ENABLE(c-mbchar,$1,,[enable multibyte (wide) characters])
1458   # Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1459 ])
1460
1461
1462 dnl
1463 dnl Check to see if debugging libraries are to be built.
1464 dnl
1465 dnl --enable-libstdcxx-debug
1466 dnl builds a separate set of debugging libraries in addition to the
1467 dnl normal (shared, static) libstdc++ binaries.
1468 dnl
1469 dnl --disable-libstdcxx-debug
1470 dnl builds only one (non-debug) version of libstdc++.
1471 dnl
1472 dnl --enable-libstdcxx-debug-flags=FLAGS
1473 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1474 dnl
1475 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
1476 dnl       Where DEFAULT is either `yes' or `no'.
1477 dnl
1478 AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
1479   AC_MSG_CHECKING([for additional debug build])
1480   GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
1481   AC_MSG_RESULT($enable_libstdcxx_debug)
1482   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
1483 ])
1484
1485
1486 dnl
1487 dnl Check for explicit debug flags.
1488 dnl
1489 dnl --enable-libstdcxx-debug-flags='-O1'
1490 dnl is a general method for passing flags to be used when
1491 dnl building debug libraries with --enable-debug.
1492 dnl
1493 dnl --disable-libstdcxx-debug-flags does nothing.
1494 dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
1495 dnl       If "default flags" is an empty string, the effect is the same
1496 dnl       as --disable or --enable=no.
1497 dnl
1498 AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
1499   GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
1500     [pass compiler FLAGS when building debug library],
1501     [case "x$enable_libstdcxx_debug_flags" in
1502       xno | x)    enable_libstdcxx_debug_flags= ;;
1503       x-*)        ;;
1504       *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
1505      esac])
1506
1507   # Option parsed, now set things appropriately
1508   DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
1509   AC_SUBST(DEBUG_FLAGS)
1510
1511   AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
1512 ])
1513
1514
1515 dnl
1516 dnl Check if the user only wants a freestanding library implementation.
1517 dnl
1518 dnl --disable-hosted-libstdcxx will turn off most of the library build,
1519 dnl installing only the headers required by [17.4.1.3] and the language
1520 dnl support library.  More than that will be built (to keep the Makefiles
1521 dnl conveniently clean), but not installed.
1522 dnl
1523 dnl Sets:
1524 dnl  is_hosted  (yes/no)
1525 dnl
1526 dnl Defines:
1527 dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
1528 dnl
1529 AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
1530   AC_ARG_ENABLE([hosted-libstdcxx],
1531     AC_HELP_STRING([--disable-hosted-libstdcxx],
1532                    [only build freestanding C++ runtime support]),,
1533     [case "$host" in
1534         arm*-*-symbianelf*) 
1535             enable_hosted_libstdcxx=no
1536             ;;
1537         *) 
1538             enable_hosted_libstdcxx=yes
1539             ;;
1540      esac])
1541   if test "$enable_hosted_libstdcxx" = no; then
1542     AC_MSG_NOTICE([Only freestanding libraries will be built])
1543     is_hosted=no
1544     hosted_define=0
1545     enable_abi_check=no
1546     enable_libstdcxx_pch=no
1547   else
1548     is_hosted=yes
1549     hosted_define=1
1550   fi
1551   GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
1552   AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
1553     [Define to 1 if a full hosted library is built, or 0 if freestanding.])
1554 ])
1555
1556
1557 dnl
1558 dnl Check for template specializations for the 'long long' type extension.
1559 dnl The result determines only whether 'long long' I/O is enabled; things
1560 dnl like numeric_limits<> specializations are always available.
1561 dnl
1562 dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
1563 dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
1564 dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
1565 dnl       Where DEFAULT is either `yes' or `no'.
1566 dnl
1567 AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
1568   GLIBCXX_ENABLE(long-long,$1,,[enables I/O support for 'long long'])
1569   if test $enable_long_long = yes; then
1570     AC_DEFINE(_GLIBCXX_USE_LONG_LONG)
1571   fi
1572 ])
1573
1574
1575 dnl
1576 dnl Check to see if building and using a C++ precompiled header can be done.
1577 dnl
1578 dnl --enable-libstdcxx-pch=yes
1579 dnl default, this shows intent to use stdc++.h.gch If it looks like it
1580 dnl may work, after some light-hearted attempts to puzzle out compiler
1581 dnl support, flip bits on in include/Makefile.am
1582 dnl
1583 dnl --disable-libstdcxx-pch
1584 dnl turns off attempts to use or build stdc++.h.gch.
1585 dnl
1586 dnl Substs:
1587 dnl  glibcxx_PCHFLAGS
1588 dnl
1589 AC_DEFUN([GLIBCXX_ENABLE_PCH], [
1590   AC_MSG_CHECKING([for enabled PCH])
1591   GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
1592   AC_MSG_RESULT([$enable_libstdcxx_pch])
1593
1594   if test $enable_libstdcxx_pch = yes; then
1595     AC_CACHE_CHECK([for compiler with PCH support],
1596       [glibcxx_cv_prog_CXX_pch],
1597       [ac_save_CXXFLAGS="$CXXFLAGS"
1598        CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
1599        AC_LANG_SAVE
1600        AC_LANG_CPLUSPLUS
1601        echo '#include <math.h>' > conftest.h
1602        if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
1603                           -o conftest.h.gch 1>&5 2>&1 &&
1604                 echo '#error "pch failed"' > conftest.h &&
1605           echo '#include "conftest.h"' > conftest.cc &&
1606                $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
1607        then
1608          glibcxx_cv_prog_CXX_pch=yes
1609        else
1610          glibcxx_cv_prog_CXX_pch=no
1611        fi
1612        rm -f conftest*
1613        CXXFLAGS=$ac_save_CXXFLAGS
1614        AC_LANG_RESTORE
1615       ])
1616     enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
1617   fi
1618
1619   GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
1620   if test $enable_libstdcxx_pch = yes; then
1621     glibcxx_PCHFLAGS="-include bits/stdc++.h"
1622   else
1623     glibcxx_PCHFLAGS=""
1624   fi
1625   AC_SUBST(glibcxx_PCHFLAGS)
1626 ])
1627
1628
1629 dnl
1630 dnl Check for exception handling support.  If an explicit enable/disable
1631 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1632 dnl target may or may not support call frame exceptions.
1633 dnl
1634 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1635 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1636 dnl Neither one forces an attempt at detection.
1637 dnl
1638 dnl Defines:
1639 dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
1640 dnl
1641 AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
1642   AC_MSG_CHECKING([for exception model to use])
1643   AC_LANG_SAVE
1644   AC_LANG_CPLUSPLUS
1645   GLIBCXX_ENABLE(sjlj-exceptions,auto,,
1646     [force use of builtin_setjmp for exceptions],
1647     [permit yes|no|auto])
1648
1649   if test $enable_sjlj_exceptions = auto; then
1650     # Botheration.  Now we've got to detect the exception model.  Link tests
1651     # against libgcc.a are problematic since we've not been given proper -L
1652     # bits for single-tree newlib and libgloss.
1653     #
1654     # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
1655     cat > conftest.$ac_ext << EOF
1656 [#]line __oline__ "configure"
1657 struct S { ~S(); };
1658 void bar();
1659 void foo()
1660 {
1661   S s;
1662   bar();
1663 }
1664 EOF
1665     old_CXXFLAGS="$CXXFLAGS"
1666     CXXFLAGS=-S
1667     if AC_TRY_EVAL(ac_compile); then
1668       if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1669         enable_sjlj_exceptions=yes
1670       elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1671         enable_sjlj_exceptions=no
1672       fi
1673     fi
1674     CXXFLAGS="$old_CXXFLAGS"
1675     rm -f conftest*
1676   fi
1677
1678   # This is a tad weird, for hysterical raisins.  We have to map enable/disable 
1679   # to two different models.
1680   case $enable_sjlj_exceptions in
1681     yes)
1682       AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
1683         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1684       ac_exception_model_name=sjlj
1685       ;;
1686     no)
1687       ac_exception_model_name="call frame"
1688       ;;
1689     *)
1690       AC_MSG_ERROR([unable to detect exception model])
1691       ;;
1692   esac
1693  AC_LANG_RESTORE
1694  AC_MSG_RESULT($ac_exception_model_name)
1695 ])
1696
1697
1698 dnl
1699 dnl Add version tags to symbols in shared library (or not), additionally
1700 dnl marking other symbols as private/local (or not).
1701 dnl
1702 dnl --enable-symvers=style adds a version script to the linker call when
1703 dnl       creating the shared library.  The choice of version script is
1704 dnl       controlled by 'style'.
1705 dnl --disable-symvers does not.
1706 dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
1707 dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
1708 dnl       choose a default style based on linker characteristics.  Passing
1709 dnl       'no' disables versioning.
1710 dnl
1711 AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
1712
1713 GLIBCXX_ENABLE(symvers,$1,[=STYLE],
1714   [enables symbol versioning of the shared library],
1715   [permit yes|no|gnu])
1716
1717 # If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
1718 # don't know enough about $LD to do tricks...
1719 AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
1720 # FIXME  The following test is too strict, in theory.
1721 if test $enable_shared = no ||
1722         test "x$LD" = x ||
1723         test x$glibcxx_gnu_ld_version = x; then
1724   enable_symvers=no
1725 fi
1726
1727 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
1728 if test $enable_symvers != no; then
1729   AC_MSG_CHECKING([for shared libgcc])
1730   ac_save_CFLAGS="$CFLAGS"
1731   CFLAGS=' -lgcc_s'
1732   AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
1733   CFLAGS="$ac_save_CFLAGS"
1734   if test $glibcxx_shared_libgcc = no; then
1735     cat > conftest.c <<EOF
1736 int main (void) { return 0; }
1737 EOF
1738 changequote(,)dnl
1739     glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
1740                              -shared -shared-libgcc -o conftest.so \
1741                              conftest.c -v 2>&1 >/dev/null \
1742                              | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
1743 changequote([,])dnl
1744     rm -f conftest.c conftest.so
1745     if test x${glibcxx_libgcc_s_suffix+set} = xset; then
1746       CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
1747       AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
1748       CFLAGS="$ac_save_CFLAGS"
1749     fi
1750   fi
1751   AC_MSG_RESULT($glibcxx_shared_libgcc)
1752 fi
1753
1754 # For GNU ld, we need at least this version.  The format is described in
1755 # GLIBCXX_CHECK_LINKER_FEATURES above.
1756 glibcxx_min_gnu_ld_version=21400
1757 # XXXXXXXXXXX glibcxx_gnu_ld_version=21390
1758
1759 # Check to see if unspecified "yes" value can win, given results above.
1760 # Change "yes" into either "no" or a style name.
1761 if test $enable_symvers = yes; then
1762   if test $with_gnu_ld = yes &&
1763      test $glibcxx_shared_libgcc = yes;
1764   then
1765     if test $glibcxx_gnu_ld_version -ge $glibcxx_min_gnu_ld_version ; then
1766       enable_symvers=gnu
1767     else
1768       # The right tools, the right setup, but too old.  Fallbacks?
1769       AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
1770       AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
1771       AC_MSG_WARN(=== You would need to upgrade your binutils to version)
1772       AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
1773       if test $glibcxx_gnu_ld_version -ge 21200 ; then
1774         # Globbing fix is present, proper block support is not.
1775         dnl AC_MSG_WARN([=== Dude, you are soooo close.  Maybe we can fake it.])
1776         dnl enable_symvers=???
1777         AC_MSG_WARN([=== Symbol versioning will be disabled.])
1778         enable_symvers=no
1779       else
1780         # 2.11 or older.
1781         AC_MSG_WARN([=== Symbol versioning will be disabled.])
1782         enable_symvers=no
1783       fi
1784     fi
1785   else
1786     # just fail for now
1787     AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
1788     AC_MSG_WARN([=== either you are not using a supported linker, or you are])
1789     AC_MSG_WARN([=== not building a shared libgcc_s (which is required).])
1790     AC_MSG_WARN([=== Symbol versioning will be disabled.])
1791     enable_symvers=no
1792   fi
1793 fi
1794
1795 # Everything parsed; figure out what file to use.
1796 case $enable_symvers in
1797   no)
1798     SYMVER_MAP=config/linker-map.dummy
1799     ;;
1800   gnu)
1801     SYMVER_MAP=config/linker-map.gnu
1802     AC_DEFINE(_GLIBCXX_SYMVER)
1803     ;;
1804 esac
1805
1806 AC_SUBST(SYMVER_MAP)
1807 AC_SUBST(port_specific_symbol_files)
1808 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
1809 AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
1810 ])
1811
1812
1813 dnl
1814 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1815 dnl We must stage the required headers so that they will be installed
1816 dnl with the library (unlike libgcc, the STL implementation is provided
1817 dnl solely within headers).  Since we must not inject random user-space
1818 dnl macro names into user-provided C++ code, we first stage into <file>-in
1819 dnl and process to <file> with an output command.  The reason for a two-
1820 dnl stage process here is to correctly handle $srcdir!=$objdir without
1821 dnl having to write complex code (the sed commands to clean the macro
1822 dnl namespace are complex and fragile enough as it is).  We must also
1823 dnl add a relative path so that -I- is supported properly.
1824 dnl
1825 dnl Substs:
1826 dnl  glibcxx_thread_h
1827 dnl
1828 dnl Defines:
1829 dnl  HAVE_GTHR_DEFAULT
1830 dnl
1831 AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
1832   AC_MSG_CHECKING([for thread model used by GCC])
1833   target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
1834   AC_MSG_RESULT([$target_thread_file])
1835
1836   if test $target_thread_file != single; then
1837     AC_DEFINE(HAVE_GTHR_DEFAULT)
1838   fi
1839
1840   glibcxx_thread_h=gthr-$target_thread_file.h
1841
1842   dnl Check for __GTHREADS define.
1843   gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
1844   if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
1845     enable_thread=yes
1846   else
1847    enable_thread=no
1848   fi
1849
1850   AC_SUBST(glibcxx_thread_h)
1851 ])
1852
1853
1854 # Check whether LC_MESSAGES is available in <locale.h>.
1855 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1856 #
1857 # This file file be copied and used freely without restrictions.  It can
1858 # be used in projects which are not available under the GNU Public License
1859 # but which still want to provide support for the GNU gettext functionality.
1860 # Please note that the actual code is *not* freely available.
1861
1862 # serial 1
1863 AC_DEFUN([AC_LC_MESSAGES], [
1864   AC_CHECK_HEADER(locale.h, [
1865     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1866       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1867        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1868     if test $ac_cv_val_LC_MESSAGES = yes; then
1869       AC_DEFINE(HAVE_LC_MESSAGES)
1870     fi
1871   ])
1872 ])
1873
1874
1875 sinclude([../libtool.m4])
1876 dnl The lines below arrange for aclocal not to bring an installed
1877 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
1878 dnl add a definition of LIBTOOL to Makefile.in.
1879 ifelse(,,,[AC_SUBST(LIBTOOL)
1880 AC_DEFUN([AM_PROG_LIBTOOL])
1881 AC_DEFUN([AC_LIBTOOL_DLOPEN])
1882 AC_DEFUN([AC_PROG_LD])
1883 ])
1884
1885 dnl vim:et:ts=2:sw=2