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