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