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