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