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