1dnl 2dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST) 3dnl 4dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the 5dnl end of configure. This lets tested variables be reassigned, and the 6dnl conditional will depend on the final state of the variable. For a simple 7dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED. 8dnl 9m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl 10AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl 11 m4_divert_text([glibcxx_diversion],dnl 12 AM_CONDITIONAL([$1],[$2]) 13 )dnl 14])dnl 15AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl 16 17 18dnl 19dnl Check to see what architecture and operating system we are compiling 20dnl for. Also, if architecture- or OS-specific flags are required for 21dnl compilation, pick them up here. 22dnl 23AC_DEFUN([GLIBCXX_CHECK_HOST], [ 24 . $glibcxx_srcdir/configure.host 25 AC_MSG_NOTICE([CPU config directory is $cpu_include_dir]) 26 AC_MSG_NOTICE([OS config directory is $os_include_dir]) 27]) 28 29dnl 30dnl Initialize the rest of the library configury. At this point we have 31dnl variables like $host. 32dnl 33dnl Sets: 34dnl SUBDIRS 35dnl Substs: 36dnl glibcxx_builddir (absolute path) 37dnl glibcxx_srcdir (absolute path) 38dnl toplevel_builddir (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 libsupc++ src src/c++98 src/c++11 src/filesystem doc python]) 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_builddir=${glibcxx_builddir}/.. 64 toplevel_srcdir=${glibcxx_srcdir}/.. 65 AC_SUBST(glibcxx_builddir) 66 AC_SUBST(glibcxx_srcdir) 67 AC_SUBST(toplevel_builddir) 68 AC_SUBST(toplevel_srcdir) 69 70 # We use these options to decide which functions to include. They are 71 # set from the top level. 72 AC_ARG_WITH([target-subdir], 73 AC_HELP_STRING([--with-target-subdir=SUBDIR], 74 [configuring in a subdirectory])) 75 76 AC_ARG_WITH([cross-host], 77 AC_HELP_STRING([--with-cross-host=HOST], 78 [configuring with a cross compiler])) 79 80 AC_ARG_WITH([newlib], 81 AC_HELP_STRING([--with-newlib], 82 [assume newlib as a system C library])) 83 84 # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't 85 # available). Uncomment the next line to force a particular method. 86 AC_PROG_LN_S 87 #LN_S='cp -p' 88 89 AC_CHECK_TOOL(AS, as) 90 AC_CHECK_TOOL(AR, ar) 91 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error) 92 93 AM_MAINTAINER_MODE 94 95 # Set up safe default values for all subsequent AM_CONDITIONAL tests 96 # which are themselves conditionally expanded. 97 ## (Right now, this only matters for enable_wchar_t, but nothing prevents 98 ## other macros from doing the same. This should be automated.) -pme 99 100 # Check for C library flavor since GNU/Linux platforms use different 101 # configuration directories depending on the C library in use. 102 AC_EGREP_CPP([_using_uclibc], [ 103 #include <stdio.h> 104 #if __UCLIBC__ 105 _using_uclibc 106 #endif 107 ], uclibc=yes, uclibc=no) 108 109 AC_EGREP_CPP([_using_bionic], [ 110 #include <stdio.h> 111 #if __BIONIC__ 112 _using_bionic 113 #endif 114 ], bionic=yes, bionic=no) 115 116 # Find platform-specific directories containing configuration info. 117 # Also possibly modify flags used elsewhere, as needed by the platform. 118 GLIBCXX_CHECK_HOST 119]) 120 121 122dnl 123dnl Tests for newer compiler features, or features that are present in newer 124dnl compiler versions but not older compiler versions still in use, should 125dnl be placed here. 126dnl 127dnl Defines: 128dnl WERROR='-Werror' if requested and possible; g++'s that lack the 129dnl new inlining code or the new system_header pragma will die on -Werror. 130dnl Leave it out by default and use maint-mode to use it. 131dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if 132dnl compiler supports it and the user has not requested debug mode. 133dnl 134AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [ 135 # All these tests are for C++; save the language and the compiler flags. 136 # The CXXFLAGS thing is suspicious, but based on similar bits previously 137 # found in GLIBCXX_CONFIGURE. 138 AC_LANG_SAVE 139 AC_LANG_CPLUSPLUS 140 ac_test_CXXFLAGS="${CXXFLAGS+set}" 141 ac_save_CXXFLAGS="$CXXFLAGS" 142 143 # Check for maintainer-mode bits. 144 if test x"$USE_MAINTAINER_MODE" = xno; then 145 WERROR='' 146 else 147 WERROR='-Werror' 148 fi 149 150 # Check for -ffunction-sections -fdata-sections 151 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections]) 152 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections' 153 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no]) 154 if test "$ac_test_CXXFLAGS" = set; then 155 CXXFLAGS="$ac_save_CXXFLAGS" 156 else 157 # this is the suspicious part 158 CXXFLAGS='' 159 fi 160 if test x"$ac_fdsections" = x"yes"; then 161 SECTION_FLAGS='-ffunction-sections -fdata-sections' 162 fi 163 AC_MSG_RESULT($ac_fdsections) 164 165 AC_LANG_RESTORE 166 AC_SUBST(WERROR) 167 AC_SUBST(SECTION_FLAGS) 168]) 169 170 171dnl 172dnl Check if the assembler used supports disabling generation of hardware 173dnl capabilities. This is only supported by Sun as at the moment. 174dnl 175dnl Defines: 176dnl HWCAP_FLAGS='-Wa,-nH' if possible. 177dnl 178AC_DEFUN([GLIBCXX_CHECK_ASSEMBLER_HWCAP], [ 179 test -z "$HWCAP_FLAGS" && HWCAP_FLAGS='' 180 181 # Restrict the test to Solaris, other assemblers (e.g. AIX as) have -nH 182 # with a different meaning. 183 case ${target_os} in 184 solaris2*) 185 ac_save_CFLAGS="$CFLAGS" 186 CFLAGS="$CFLAGS -Wa,-nH" 187 188 AC_MSG_CHECKING([for as that supports -Wa,-nH]) 189 AC_TRY_COMPILE([], [return 0;], [ac_hwcap_flags=yes],[ac_hwcap_flags=no]) 190 if test "$ac_hwcap_flags" = "yes"; then 191 HWCAP_FLAGS="-Wa,-nH $HWCAP_FLAGS" 192 fi 193 AC_MSG_RESULT($ac_hwcap_flags) 194 195 CFLAGS="$ac_save_CFLAGS" 196 ;; 197 esac 198 199 AC_SUBST(HWCAP_FLAGS) 200]) 201 202 203dnl 204dnl If GNU ld is in use, check to see if tricky linker opts can be used. If 205dnl the native linker is in use, all variables will be defined to something 206dnl safe (like an empty string). 207dnl 208dnl Defines: 209dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible 210dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible 211dnl LD (as a side effect of testing) 212dnl Sets: 213dnl with_gnu_ld 214dnl glibcxx_ld_is_gold (set to "no" or "yes") 215dnl glibcxx_gnu_ld_version (possibly) 216dnl 217dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will 218dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems. 219dnl 220AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [ 221 # If we're not using GNU ld, then there's no point in even trying these 222 # tests. Check for that first. We should have already tested for gld 223 # by now (in libtool), but require it now just to be safe... 224 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS='' 225 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS='' 226 AC_REQUIRE([AC_PROG_LD]) 227 AC_REQUIRE([AC_PROG_AWK]) 228 229 # The name set by libtool depends on the version of libtool. Shame on us 230 # for depending on an impl detail, but c'est la vie. Older versions used 231 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on 232 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually 233 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't 234 # set (hence we're using an older libtool), then set it. 235 if test x${with_gnu_ld+set} != xset; then 236 if test x${ac_cv_prog_gnu_ld+set} != xset; then 237 # We got through "ac_require(ac_prog_ld)" and still not set? Huh? 238 with_gnu_ld=no 239 else 240 with_gnu_ld=$ac_cv_prog_gnu_ld 241 fi 242 fi 243 244 # Start by getting the version number. I think the libtool test already 245 # does some of this, but throws away the result. 246 glibcxx_ld_is_gold=no 247 if test x"$with_gnu_ld" = x"yes"; then 248 AC_MSG_CHECKING([for ld version]) 249 changequote(,) 250 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then 251 glibcxx_ld_is_gold=yes 252 fi 253 ldver=`$LD --version 2>/dev/null | 254 sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'` 255 changequote([,]) 256 glibcxx_gnu_ld_version=`echo $ldver | \ 257 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'` 258 AC_MSG_RESULT($glibcxx_gnu_ld_version) 259 fi 260 261 # Set --gc-sections. 262 glibcxx_have_gc_sections=no 263 if test "$glibcxx_ld_is_gold" = "yes"; then 264 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then 265 glibcxx_have_gc_sections=yes 266 fi 267 else 268 glibcxx_gcsections_min_ld=21602 269 if test x"$with_gnu_ld" = x"yes" && 270 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then 271 glibcxx_have_gc_sections=yes 272 fi 273 fi 274 if test "$glibcxx_have_gc_sections" = "yes"; then 275 # Sufficiently young GNU ld it is! Joy and bunny rabbits! 276 # NB: This flag only works reliably after 2.16.1. Configure tests 277 # for this are difficult, so hard wire a value that should work. 278 279 ac_test_CFLAGS="${CFLAGS+set}" 280 ac_save_CFLAGS="$CFLAGS" 281 CFLAGS='-Wl,--gc-sections' 282 283 # Check for -Wl,--gc-sections 284 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections]) 285 AC_TRY_LINK([ int one(void) { return 1; } 286 int two(void) { return 2; } 287 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no]) 288 if test "$ac_gcsections" = "yes"; then 289 rm -f conftest.c 290 touch conftest.c 291 if $CC -c conftest.c; then 292 if $LD --gc-sections -o conftest conftest.o 2>&1 | \ 293 grep "Warning: gc-sections option ignored" > /dev/null; then 294 ac_gcsections=no 295 fi 296 fi 297 rm -f conftest.c conftest.o conftest 298 fi 299 if test "$ac_gcsections" = "yes"; then 300 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS" 301 fi 302 AC_MSG_RESULT($ac_gcsections) 303 304 if test "$ac_test_CFLAGS" = set; then 305 CFLAGS="$ac_save_CFLAGS" 306 else 307 # this is the suspicious part 308 CFLAGS='' 309 fi 310 fi 311 312 # Set -z,relro. 313 # Note this is only for shared objects. 314 ac_ld_relro=no 315 if test x"$with_gnu_ld" = x"yes"; then 316 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro]) 317 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"` 318 if test -n "$cxx_z_relo"; then 319 OPT_LDFLAGS="-Wl,-z,relro" 320 ac_ld_relro=yes 321 fi 322 AC_MSG_RESULT($ac_ld_relro) 323 fi 324 325 # Set linker optimization flags. 326 if test x"$with_gnu_ld" = x"yes"; then 327 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS" 328 fi 329 330 AC_SUBST(SECTION_LDFLAGS) 331 AC_SUBST(OPT_LDFLAGS) 332]) 333 334 335dnl 336dnl Check for headers for, and arguments to, the setrlimit() function. 337dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE. 338dnl 339dnl Defines: 340dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits 341dnl various HAVE_LIMIT_* for individual limit names 342dnl 343AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [ 344 AC_MSG_CHECKING([for RLIMIT_$1]) 345 AC_TRY_COMPILE( 346 [#include <unistd.h> 347 #include <sys/time.h> 348 #include <sys/resource.h> 349 ], 350 [ int f = RLIMIT_$1 ; ], 351 [glibcxx_mresult=1], [glibcxx_mresult=0]) 352 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult, 353 [Only used in build directory testsuite_hooks.h.]) 354 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi 355 AC_MSG_RESULT($res) 356]) 357 358AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [ 359 setrlimit_have_headers=yes 360 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h, 361 [], 362 [setrlimit_have_headers=no]) 363 # If don't have the headers, then we can't run the tests now, and we 364 # won't be seeing any of these during testsuite compilation. 365 if test $setrlimit_have_headers = yes; then 366 # Can't do these in a loop, else the resulting syntax is wrong. 367 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA) 368 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS) 369 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM) 370 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS) 371 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE) 372 373 # Check for rlimit, setrlimit. 374 AC_CACHE_VAL(glibcxx_cv_setrlimit, [ 375 AC_TRY_COMPILE( 376 [#include <unistd.h> 377 #include <sys/time.h> 378 #include <sys/resource.h> 379 ], 380 [struct rlimit r; 381 setrlimit(0, &r);], 382 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no]) 383 ]) 384 fi 385 386 AC_MSG_CHECKING([for testsuite resource limits support]) 387 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then 388 ac_res_limits=yes 389 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1, 390 [Define if using setrlimit to set resource limits during 391 "make check"]) 392 else 393 ac_res_limits=no 394 fi 395 AC_MSG_RESULT($ac_res_limits) 396]) 397 398 399dnl 400dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>. 401dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately. 402dnl 403AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [ 404 405 AC_LANG_SAVE 406 AC_LANG_CPLUSPLUS 407 ac_save_CXXFLAGS="$CXXFLAGS" 408 CXXFLAGS="$CXXFLAGS -fno-exceptions" 409 410 AC_MSG_CHECKING([for S_ISREG or S_IFREG]) 411 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [ 412 GCC_TRY_COMPILE_OR_LINK( 413 [#include <sys/stat.h>], 414 [struct stat buffer; 415 fstat(0, &buffer); 416 S_ISREG(buffer.st_mode);], 417 [glibcxx_cv_S_ISREG=yes], 418 [glibcxx_cv_S_ISREG=no]) 419 ]) 420 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [ 421 GCC_TRY_COMPILE_OR_LINK( 422 [#include <sys/stat.h>], 423 [struct stat buffer; 424 fstat(0, &buffer); 425 S_IFREG & buffer.st_mode;], 426 [glibcxx_cv_S_IFREG=yes], 427 [glibcxx_cv_S_IFREG=no]) 428 ]) 429 res=no 430 if test $glibcxx_cv_S_ISREG = yes; then 431 AC_DEFINE(HAVE_S_ISREG, 1, 432 [Define if S_IFREG is available in <sys/stat.h>.]) 433 res=S_ISREG 434 elif test $glibcxx_cv_S_IFREG = yes; then 435 AC_DEFINE(HAVE_S_IFREG, 1, 436 [Define if S_IFREG is available in <sys/stat.h>.]) 437 res=S_IFREG 438 fi 439 AC_MSG_RESULT($res) 440 441 CXXFLAGS="$ac_save_CXXFLAGS" 442 AC_LANG_RESTORE 443]) 444 445 446dnl 447dnl Check whether poll is available in <poll.h>, and define HAVE_POLL. 448dnl 449AC_DEFUN([GLIBCXX_CHECK_POLL], [ 450 451 AC_LANG_SAVE 452 AC_LANG_CPLUSPLUS 453 ac_save_CXXFLAGS="$CXXFLAGS" 454 CXXFLAGS="$CXXFLAGS -fno-exceptions" 455 456 AC_MSG_CHECKING([for poll]) 457 AC_CACHE_VAL(glibcxx_cv_POLL, [ 458 GCC_TRY_COMPILE_OR_LINK( 459 [#include <poll.h>], 460 [struct pollfd pfd[1]; 461 pfd[0].events = POLLIN; 462 poll(pfd, 1, 0);], 463 [glibcxx_cv_POLL=yes], 464 [glibcxx_cv_POLL=no]) 465 ]) 466 if test $glibcxx_cv_POLL = yes; then 467 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.]) 468 fi 469 AC_MSG_RESULT($glibcxx_cv_POLL) 470 471 CXXFLAGS="$ac_save_CXXFLAGS" 472 AC_LANG_RESTORE 473]) 474 475 476dnl 477dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV. 478dnl 479AC_DEFUN([GLIBCXX_CHECK_WRITEV], [ 480 481 AC_LANG_SAVE 482 AC_LANG_CPLUSPLUS 483 ac_save_CXXFLAGS="$CXXFLAGS" 484 CXXFLAGS="$CXXFLAGS -fno-exceptions" 485 486 AC_MSG_CHECKING([for writev]) 487 AC_CACHE_VAL(glibcxx_cv_WRITEV, [ 488 GCC_TRY_COMPILE_OR_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 CXXFLAGS="$ac_save_CXXFLAGS" 501 AC_LANG_RESTORE 502]) 503 504 505dnl 506dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T. 507dnl Also check whether int64_t is actually a typedef to long or long long. 508dnl 509AC_DEFUN([GLIBCXX_CHECK_INT64_T], [ 510 511 AC_LANG_SAVE 512 AC_LANG_CPLUSPLUS 513 514 AC_MSG_CHECKING([for int64_t]) 515 AC_CACHE_VAL(glibcxx_cv_INT64_T, [ 516 AC_TRY_COMPILE( 517 [#include <stdint.h>], 518 [int64_t var;], 519 [glibcxx_cv_INT64_T=yes], 520 [glibcxx_cv_INT64_T=no]) 521 ]) 522 523 if test $glibcxx_cv_INT64_T = yes; then 524 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.]) 525 AC_MSG_RESULT($glibcxx_cv_INT64_T) 526 527 AC_MSG_CHECKING([for int64_t as long]) 528 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [ 529 AC_TRY_COMPILE( 530 [#include <stdint.h> 531 template<typename, typename> struct same { enum { value = -1 }; }; 532 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; }; 533 int array[same<int64_t, long>::value];], [], 534 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no]) 535 ]) 536 537 if test $glibcxx_cv_int64_t_long = yes; then 538 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.]) 539 AC_MSG_RESULT($glibcxx_cv_int64_t_long) 540 fi 541 542 AC_MSG_CHECKING([for int64_t as long long]) 543 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [ 544 AC_TRY_COMPILE( 545 [#include <stdint.h> 546 template<typename, typename> struct same { enum { value = -1 }; }; 547 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; }; 548 int array[same<int64_t, long long>::value];], [], 549 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no]) 550 ]) 551 552 if test $glibcxx_cv_int64_t_long_long = yes; then 553 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.]) 554 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long) 555 fi 556 fi 557 558 AC_LANG_RESTORE 559]) 560 561 562dnl 563dnl Check whether LFS support is available. 564dnl 565AC_DEFUN([GLIBCXX_CHECK_LFS], [ 566 AC_LANG_SAVE 567 AC_LANG_CPLUSPLUS 568 ac_save_CXXFLAGS="$CXXFLAGS" 569 CXXFLAGS="$CXXFLAGS -fno-exceptions" 570 AC_MSG_CHECKING([for LFS support]) 571 AC_CACHE_VAL(glibcxx_cv_LFS, [ 572 GCC_TRY_COMPILE_OR_LINK( 573 [#include <unistd.h> 574 #include <stdio.h> 575 #include <sys/stat.h> 576 ], 577 [FILE* fp; 578 fopen64("t", "w"); 579 fseeko64(fp, 0, SEEK_CUR); 580 ftello64(fp); 581 lseek64(1, 0, SEEK_CUR); 582 struct stat64 buf; 583 fstat64(1, &buf);], 584 [glibcxx_cv_LFS=yes], 585 [glibcxx_cv_LFS=no]) 586 ]) 587 if test $glibcxx_cv_LFS = yes; then 588 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.]) 589 fi 590 AC_MSG_RESULT($glibcxx_cv_LFS) 591 CXXFLAGS="$ac_save_CXXFLAGS" 592 AC_LANG_RESTORE 593]) 594 595 596dnl 597dnl Check for whether a fully dynamic basic_string implementation should 598dnl be turned on, that does not put empty objects in per-process static 599dnl memory (mostly useful together with shared memory allocators, see PR 600dnl libstdc++/16612 for details). 601dnl 602dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1 603dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0 604dnl otherwise undefined 605dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)] 606dnl Where DEFAULT is either `yes' or `no'. 607dnl 608AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [ 609 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory]) 610 if test $enable_fully_dynamic_string = yes; then 611 enable_fully_dynamic_string_def=1 612 else 613 enable_fully_dynamic_string_def=0 614 fi 615 AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}], 616 [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults]) 617]) 618 619 620dnl 621dnl Does any necessary configuration of the testsuite directory. Generates 622dnl the testsuite_hooks.h header. 623dnl 624dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this. 625dnl 626dnl Sets: 627dnl enable_abi_check 628dnl GLIBCXX_TEST_WCHAR_T 629dnl GLIBCXX_TEST_THREAD 630dnl Substs: 631dnl baseline_dir 632dnl baseline_subdir_switch 633dnl 634AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [ 635 if $GLIBCXX_IS_NATIVE ; then 636 # Do checks for resource limit functions. 637 GLIBCXX_CHECK_SETRLIMIT 638 639 # Look for setenv, so that extended locale tests can be performed. 640 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv) 641 fi 642 643 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes && 644 test $enable_symvers != no; then 645 case "$host" in 646 *-*-cygwin*) 647 enable_abi_check=no ;; 648 *) 649 enable_abi_check=yes ;; 650 esac 651 else 652 # Only build this as native, since automake does not understand 653 # CXX_FOR_BUILD. 654 enable_abi_check=no 655 fi 656 657 # Export file names for ABI checking. 658 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}" 659 AC_SUBST(baseline_dir) 660 baseline_subdir_switch="$abi_baseline_subdir_switch" 661 AC_SUBST(baseline_subdir_switch) 662]) 663 664 665dnl 666dnl Does any necessary configuration for docbook in the docs directory. 667dnl 668dnl XSLTPROC must be set before this 669dnl 670dnl Sets: 671dnl glibcxx_stylesheets 672dnl Substs: 673dnl XSL_STYLE_DIR 674dnl 675AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [ 676 677AC_MSG_CHECKING([for docbook stylesheets for documentation creation]) 678glibcxx_stylesheets=no 679if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then 680 glibcxx_stylesheets=yes 681fi 682AC_MSG_RESULT($glibcxx_stylesheets) 683 684AC_MSG_CHECKING([for local stylesheet directory]) 685glibcxx_local_stylesheets=no 686if test x"$glibcxx_stylesheets" = x"yes"; then 687 if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then 688 glibcxx_local_stylesheets=yes 689 XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets 690 fi 691 if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then 692 glibcxx_local_stylesheets=yes 693 XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns 694 fi 695 if test -d /usr/share/xml/docbook/stylesheet/nwalsh5/current; then 696 glibcxx_local_stylesheets=yes 697 XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/nwalsh5/current 698 fi 699fi 700AC_MSG_RESULT($glibcxx_local_stylesheets) 701 702if test x"$glibcxx_local_stylesheets" = x"yes"; then 703 AC_SUBST(XSL_STYLE_DIR) 704 AC_MSG_NOTICE($XSL_STYLE_DIR) 705else 706 glibcxx_stylesheets=no 707fi 708 709# Check for epub3 dependencies. 710AC_MSG_CHECKING([for epub3 stylesheets for documentation creation]) 711glibcxx_epub_stylesheets=no 712if test x"$glibcxx_local_stylesheets" = x"yes"; then 713 if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then 714 glibcxx_epub_stylesheets=yes 715 fi 716fi 717AC_MSG_RESULT($glibcxx_epub_stylesheets) 718AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes") 719 720]) 721 722 723dnl 724dnl Set up *_INCLUDES variables for all sundry Makefile.am's. 725dnl 726dnl Substs: 727dnl GLIBCXX_INCLUDES 728dnl TOPLEVEL_INCLUDES 729dnl 730AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [ 731 # Used for every C++ compile we perform. 732 GLIBCXX_INCLUDES="\ 733-I$glibcxx_builddir/include/$host_alias \ 734-I$glibcxx_builddir/include \ 735-I$glibcxx_srcdir/libsupc++" 736 737 # For Canadian crosses, pick this up too. 738 if test $CANADIAN = yes; then 739 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}" 740 fi 741 742 # Stuff in the actual top level. Currently only used by libsupc++ to 743 # get unwind* headers from the libgcc dir. 744 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include' 745 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc' 746 747 # Now, export this to all the little Makefiles.... 748 AC_SUBST(GLIBCXX_INCLUDES) 749 AC_SUBST(TOPLEVEL_INCLUDES) 750]) 751 752 753dnl 754dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's. 755dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.) 756dnl 757dnl Substs: 758dnl OPTIMIZE_CXXFLAGS 759dnl WARN_FLAGS 760dnl 761AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [ 762 # Optimization flags that are probably a good idea for thrill-seekers. Just 763 # uncomment the lines below and make, everything else is ready to go... 764 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host. 765 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc 766 AC_SUBST(OPTIMIZE_CXXFLAGS) 767 768 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi' 769 AC_SUBST(WARN_FLAGS) 770]) 771 772 773dnl 774dnl All installation directory information is determined here. 775dnl 776dnl Substs: 777dnl gxx_install_dir 778dnl glibcxx_prefixdir 779dnl glibcxx_toolexecdir 780dnl glibcxx_toolexeclibdir 781dnl 782dnl Assumes cross_compiling bits already done, and with_cross_host in 783dnl particular. 784dnl 785dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir. 786dnl config/gxx-include-dir.m4 must be kept consistant with this as well. 787AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [ 788 glibcxx_toolexecdir=no 789 glibcxx_toolexeclibdir=no 790 glibcxx_prefixdir=$prefix 791 792 AC_MSG_CHECKING([for gxx-include-dir]) 793 AC_ARG_WITH([gxx-include-dir], 794 AC_HELP_STRING([--with-gxx-include-dir=DIR], 795 [installation directory for include files]), 796 [case "$withval" in 797 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;; 798 no) gxx_include_dir=no ;; 799 *) gxx_include_dir=$withval ;; 800 esac], 801 [gxx_include_dir=no]) 802 AC_MSG_RESULT($gxx_include_dir) 803 804 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs]) 805 AC_ARG_ENABLE([version-specific-runtime-libs], 806 AC_HELP_STRING([--enable-version-specific-runtime-libs], 807 [Specify that runtime libraries should be installed in a compiler-specific directory]), 808 [case "$enableval" in 809 yes) version_specific_libs=yes ;; 810 no) version_specific_libs=no ;; 811 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);; 812 esac], 813 [version_specific_libs=no]) 814 AC_MSG_RESULT($version_specific_libs) 815 816 # Default case for install directory for include files. 817 if test $version_specific_libs = no && test $gxx_include_dir = no; then 818 gxx_include_dir='include/c++/${gcc_version}' 819 if test -n "$with_cross_host" && 820 test x"$with_cross_host" != x"no"; then 821 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir" 822 else 823 gxx_include_dir='${prefix}/'"$gxx_include_dir" 824 fi 825 fi 826 827 # Version-specific runtime libs processing. 828 if test $version_specific_libs = yes; then 829 # Need the gcc compiler version to know where to install libraries 830 # and header files if --enable-version-specific-runtime-libs option 831 # is selected. FIXME: these variables are misnamed, there are 832 # no executables installed in _toolexecdir or _toolexeclibdir. 833 if test x"$gxx_include_dir" = x"no"; then 834 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++' 835 fi 836 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}' 837 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)' 838 fi 839 840 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir 841 # Install a library built with a cross compiler in tooldir, not libdir. 842 if test x"$glibcxx_toolexecdir" = x"no"; then 843 if test -n "$with_cross_host" && 844 test x"$with_cross_host" != x"no"; then 845 glibcxx_toolexecdir='${exec_prefix}/${host_alias}' 846 glibcxx_toolexeclibdir='${toolexecdir}/lib' 847 else 848 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}' 849 glibcxx_toolexeclibdir='${libdir}' 850 fi 851 multi_os_directory=`$CXX -print-multi-os-directory` 852 case $multi_os_directory in 853 .) ;; # Avoid trailing /. 854 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;; 855 esac 856 fi 857 858 AC_MSG_CHECKING([for install location]) 859 AC_MSG_RESULT($gxx_include_dir) 860 861 AC_SUBST(glibcxx_prefixdir) 862 AC_SUBST(gxx_include_dir) 863 AC_SUBST(glibcxx_toolexecdir) 864 AC_SUBST(glibcxx_toolexeclibdir) 865]) 866 867 868dnl 869dnl GLIBCXX_ENABLE 870dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING) 871dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c) 872dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER) 873dnl 874dnl See manual/appendix_porting.html#appendix.porting.build_hacking for 875dnl documentation. 876dnl 877m4_define([GLIBCXX_ENABLE],[dnl 878m4_define([_g_switch],[--enable-$1])dnl 879m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl 880 AC_ARG_ENABLE([$1],m4_dquote(_g_help), 881 m4_bmatch([$5], 882 [^permit ], 883 [[ 884 case "$enableval" in 885 m4_bpatsubst([$5],[permit ])) ;; 886 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;; 887 dnl Idea for future: generate a URL pointing to 888 dnl "onlinedocs/configopts.html#whatever" 889 esac 890 ]], 891 [^$], 892 [[ 893 case "$enableval" in 894 yes|no) ;; 895 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;; 896 esac 897 ]], 898 [[$5]]), 899 [enable_]m4_bpatsubst([$1],-,_)[=][$2]) 900m4_undefine([_g_switch])dnl 901m4_undefine([_g_help])dnl 902]) 903 904 905dnl 906dnl Check for ISO/IEC 9899:1999 "C99" support. 907dnl 908dnl --enable-c99 defines _GLIBCXX_USE_C99 909dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined 910dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)] 911dnl Where DEFAULT is either `yes' or `no'. 912dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'. 913dnl 914AC_DEFUN([GLIBCXX_ENABLE_C99], [ 915 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support]) 916 917 if test x"$enable_c99" = x"yes"; then 918 919 AC_LANG_SAVE 920 AC_LANG_CPLUSPLUS 921 922 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__ 923 # undefined and fake C99 facilities - like pre-standard snprintf - may be 924 # spuriously enabled. 925 # Long term, -std=c++0x could be even better, could manage to explicitly 926 # request C99 facilities to the underlying C headers. 927 ac_save_CXXFLAGS="$CXXFLAGS" 928 CXXFLAGS="$CXXFLAGS -std=c++98" 929 ac_save_LIBS="$LIBS" 930 ac_save_gcc_no_link="$gcc_no_link" 931 932 if test x$gcc_no_link != xyes; then 933 # Use -fno-exceptions to that the C driver can link these tests without 934 # hitting undefined references to personality routines. 935 CXXFLAGS="$CXXFLAGS -fno-exceptions" 936 AC_CHECK_LIB(m, sin, [ 937 LIBS="$LIBS -lm" 938 ], [ 939 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK 940 gcc_no_link=yes 941 ]) 942 fi 943 944 # Check for the existence of <math.h> functions used if C99 is enabled. 945 AC_MSG_CHECKING([for ISO C99 support in <math.h>]) 946 AC_CACHE_VAL(glibcxx_cv_c99_math, [ 947 GCC_TRY_COMPILE_OR_LINK( 948 [#include <math.h> 949 volatile double d1, d2; 950 volatile int i;], 951 [i = fpclassify(d1); 952 i = isfinite(d1); 953 i = isinf(d1); 954 i = isnan(d1); 955 i = isnormal(d1); 956 i = signbit(d1); 957 i = isgreater(d1, d2); 958 i = isgreaterequal(d1, d2); 959 i = isless(d1, d2); 960 i = islessequal(d1, d2); 961 i = islessgreater(d1, d2); 962 i = islessgreater(d1, d2); 963 i = isunordered(d1, d2); 964 ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no]) 965 ]) 966 AC_MSG_RESULT($glibcxx_cv_c99_math) 967 if test x"$glibcxx_cv_c99_math" = x"yes"; then 968 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1, 969 [Define if C99 functions or macros in <math.h> should be imported 970 in <cmath> in namespace std.]) 971 fi 972 973 # Check for the existence of <complex.h> complex math functions. 974 # This is necessary even though libstdc++ uses the builtin versions 975 # of these functions, because if the builtin cannot be used, a reference 976 # to the library function is emitted. 977 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no) 978 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no) 979 glibcxx_cv_c99_complex=no; 980 if test x"$ac_has_complex_h" = x"yes"; then 981 AC_MSG_CHECKING([for ISO C99 support in <complex.h>]) 982 GCC_TRY_COMPILE_OR_LINK( 983 [#include <complex.h> 984 typedef __complex__ float float_type; 985 typedef __complex__ double double_type; 986 typedef __complex__ long double ld_type; 987 volatile float_type tmpf; 988 volatile double_type tmpd; 989 volatile ld_type tmpld; 990 volatile float f; 991 volatile double d; 992 volatile long double ld;], 993 [f = cabsf(tmpf); 994 f = cargf(tmpf); 995 tmpf = ccosf(tmpf); 996 tmpf = ccoshf(tmpf); 997 tmpf = cexpf(tmpf); 998 tmpf = clogf(tmpf); 999 tmpf = csinf(tmpf); 1000 tmpf = csinhf(tmpf); 1001 tmpf = csqrtf(tmpf); 1002 tmpf = ctanf(tmpf); 1003 tmpf = ctanhf(tmpf); 1004 tmpf = cpowf(tmpf, tmpf); 1005 tmpf = cprojf(tmpf); 1006 d = cabs(tmpd); 1007 d = carg(tmpd); 1008 tmpd = ccos(tmpd); 1009 tmpd = ccosh(tmpd); 1010 tmpd = cexp(tmpd); 1011 tmpd = clog(tmpd); 1012 tmpd = csin(tmpd); 1013 tmpd = csinh(tmpd); 1014 tmpd = csqrt(tmpd); 1015 tmpd = ctan(tmpd); 1016 tmpd = ctanh(tmpd); 1017 tmpd = cpow(tmpd, tmpd); 1018 tmpd = cproj(tmpd); 1019 ld = cabsl(tmpld); 1020 ld = cargl(tmpld); 1021 tmpld = ccosl(tmpld); 1022 tmpld = ccoshl(tmpld); 1023 tmpld = cexpl(tmpld); 1024 tmpld = clogl(tmpld); 1025 tmpld = csinl(tmpld); 1026 tmpld = csinhl(tmpld); 1027 tmpld = csqrtl(tmpld); 1028 tmpld = ctanl(tmpld); 1029 tmpld = ctanhl(tmpld); 1030 tmpld = cpowl(tmpld, tmpld); 1031 tmpld = cprojl(tmpld); 1032 ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no]) 1033 fi 1034 AC_MSG_RESULT($glibcxx_cv_c99_complex) 1035 if test x"$glibcxx_cv_c99_complex" = x"yes"; then 1036 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1, 1037 [Define if C99 functions in <complex.h> should be used in 1038 <complex>. Using compiler builtins for these functions requires 1039 corresponding C99 library functions to be present.]) 1040 fi 1041 1042 # Check for the existence in <stdio.h> of vscanf, et. al. 1043 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>]) 1044 AC_CACHE_VAL(glibcxx_cv_c99_stdio, [ 1045 GCC_TRY_COMPILE_OR_LINK( 1046 [#include <stdio.h> 1047 #include <stdarg.h> 1048 void foo(char* fmt, ...) 1049 { 1050 va_list args; va_start(args, fmt); 1051 vfscanf(stderr, "%i", args); 1052 vscanf("%i", args); 1053 vsnprintf(fmt, 0, "%i", args); 1054 vsscanf(fmt, "%i", args); 1055 snprintf(fmt, 0, "%i"); 1056 }], [], 1057 [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no]) 1058 ]) 1059 AC_MSG_RESULT($glibcxx_cv_c99_stdio) 1060 1061 # Check for the existence in <stdlib.h> of lldiv_t, et. al. 1062 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>]) 1063 AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [ 1064 GCC_TRY_COMPILE_OR_LINK( 1065 [#include <stdlib.h> 1066 volatile float f; 1067 volatile long double ld; 1068 volatile unsigned long long ll; 1069 lldiv_t mydivt;], 1070 [char* tmp; 1071 f = strtof("gnu", &tmp); 1072 ld = strtold("gnu", &tmp); 1073 ll = strtoll("gnu", &tmp, 10); 1074 ll = strtoull("gnu", &tmp, 10); 1075 ll = llabs(10); 1076 mydivt = lldiv(10,1); 1077 ll = mydivt.quot; 1078 ll = mydivt.rem; 1079 ll = atoll("10"); 1080 _Exit(0); 1081 ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no]) 1082 ]) 1083 AC_MSG_RESULT($glibcxx_cv_c99_stdlib) 1084 1085 # Check for the existence in <wchar.h> of wcstold, etc. 1086 glibcxx_cv_c99_wchar=no; 1087 if test x"$ac_has_wchar_h" = xyes && 1088 test x"$ac_has_wctype_h" = xyes; then 1089 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>]) 1090 AC_TRY_COMPILE([#include <wchar.h> 1091 namespace test 1092 { 1093 using ::wcstold; 1094 using ::wcstoll; 1095 using ::wcstoull; 1096 } 1097 ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no]) 1098 1099 # Checks for wide character functions that may not be present. 1100 # Injection of these is wrapped with guard macros. 1101 # NB: only put functions here, instead of immediately above, if 1102 # absolutely necessary. 1103 AC_TRY_COMPILE([#include <wchar.h> 1104 namespace test { using ::vfwscanf; } ], [], 1105 [AC_DEFINE(HAVE_VFWSCANF,1, 1106 [Defined if vfwscanf exists.])],[]) 1107 1108 AC_TRY_COMPILE([#include <wchar.h> 1109 namespace test { using ::vswscanf; } ], [], 1110 [AC_DEFINE(HAVE_VSWSCANF,1, 1111 [Defined if vswscanf exists.])],[]) 1112 1113 AC_TRY_COMPILE([#include <wchar.h> 1114 namespace test { using ::vwscanf; } ], [], 1115 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[]) 1116 1117 AC_TRY_COMPILE([#include <wchar.h> 1118 namespace test { using ::wcstof; } ], [], 1119 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[]) 1120 1121 AC_TRY_COMPILE([#include <wctype.h>], 1122 [ wint_t t; int i = iswblank(t);], 1123 [AC_DEFINE(HAVE_ISWBLANK,1, 1124 [Defined if iswblank exists.])],[]) 1125 1126 AC_MSG_RESULT($glibcxx_cv_c99_wchar) 1127 fi 1128 1129 # Option parsed, now set things appropriately. 1130 if test x"$glibcxx_cv_c99_math" = x"no" || 1131 test x"$glibcxx_cv_c99_complex" = x"no" || 1132 test x"$glibcxx_cv_c99_stdio" = x"no" || 1133 test x"$glibcxx_cv_c99_stdlib" = x"no" || 1134 test x"$glibcxx_cv_c99_wchar" = x"no"; then 1135 enable_c99=no; 1136 else 1137 AC_DEFINE(_GLIBCXX_USE_C99, 1, 1138 [Define if C99 functions or macros from <wchar.h>, <math.h>, 1139 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.]) 1140 fi 1141 1142 gcc_no_link="$ac_save_gcc_no_link" 1143 LIBS="$ac_save_LIBS" 1144 CXXFLAGS="$ac_save_CXXFLAGS" 1145 AC_LANG_RESTORE 1146 fi 1147 1148 AC_MSG_CHECKING([for fully enabled ISO C99 support]) 1149 AC_MSG_RESULT($enable_c99) 1150]) 1151 1152 1153dnl 1154dnl Check for clock_gettime, nanosleep and sched_yield, used in the 1155dnl implementation of 20.11.7 [time.clock], and 30.3.2 [thread.thread.this] 1156dnl in the C++11 standard. 1157dnl 1158dnl --enable-libstdcxx-time 1159dnl --enable-libstdcxx-time=yes 1160dnl checks for the availability of monotonic and realtime clocks, 1161dnl nanosleep and sched_yield in libc and libposix4 and, if needed, 1162dnl links in the latter. 1163dnl --enable-libstdcxx-time=rt 1164dnl also searches (and, if needed, links) librt. Note that this is 1165dnl not always desirable because, in glibc 2.16 and earlier, for 1166dnl example, in turn it triggers the linking of libpthread too, 1167dnl which activates locking, 1168dnl a large overhead for single-thread programs. 1169dnl --enable-libstdcxx-time=no 1170dnl --disable-libstdcxx-time 1171dnl disables the checks completely 1172dnl 1173dnl N.B. Darwin provides nanosleep but doesn't support the whole POSIX 1174dnl Timers option, so doesn't define _POSIX_TIMERS. Because the test 1175dnl below fails Darwin unconditionally defines _GLIBCXX_USE_NANOSLEEP in 1176dnl os_defines.h and also defines _GLIBCXX_USE_SCHED_YIELD. 1177dnl 1178AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [ 1179 1180 GLIBCXX_ENABLE(libstdcxx-time,auto,[[[=KIND]]], 1181 [use KIND for check type], 1182 [permit yes|no|rt]) 1183 1184 AC_LANG_SAVE 1185 AC_LANG_CPLUSPLUS 1186 ac_save_CXXFLAGS="$CXXFLAGS" 1187 CXXFLAGS="$CXXFLAGS -fno-exceptions" 1188 ac_save_LIBS="$LIBS" 1189 1190 ac_has_clock_monotonic=no 1191 ac_has_clock_realtime=no 1192 ac_has_nanosleep=no 1193 ac_has_sched_yield=no 1194 1195 if test x"$enable_libstdcxx_time" = x"auto"; then 1196 1197 case "${target_os}" in 1198 cygwin*) 1199 ac_has_nanosleep=yes 1200 ;; 1201 darwin*) 1202 ac_has_nanosleep=yes 1203 ac_has_sched_yield=yes 1204 ;; 1205 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu) 1206 AC_MSG_CHECKING([for at least GNU libc 2.17]) 1207 AC_TRY_COMPILE( 1208 [#include <features.h>], 1209 [ 1210 #if ! __GLIBC_PREREQ(2, 17) 1211 #error 1212 #endif 1213 ], 1214 [glibcxx_glibc217=yes], [glibcxx_glibc217=no]) 1215 AC_MSG_RESULT($glibcxx_glibc217) 1216 1217 if test x"$glibcxx_glibc217" = x"yes"; then 1218 ac_has_clock_monotonic=yes 1219 ac_has_clock_realtime=yes 1220 fi 1221 ac_has_nanosleep=yes 1222 ac_has_sched_yield=yes 1223 ;; 1224 freebsd*|netbsd*|dragonfly*) 1225 ac_has_clock_monotonic=yes 1226 ac_has_clock_realtime=yes 1227 ac_has_nanosleep=yes 1228 ac_has_sched_yield=yes 1229 ;; 1230 openbsd*) 1231 ac_has_clock_monotonic=yes 1232 ac_has_clock_realtime=yes 1233 ac_has_nanosleep=yes 1234 ;; 1235 solaris*) 1236 GLIBCXX_LIBS="$GLIBCXX_LIBS -lrt" 1237 ac_has_clock_monotonic=yes 1238 ac_has_clock_realtime=yes 1239 ac_has_nanosleep=yes 1240 ac_has_sched_yield=yes 1241 ;; 1242 esac 1243 1244 elif test x"$enable_libstdcxx_time" != x"no"; then 1245 1246 if test x"$enable_libstdcxx_time" = x"rt"; then 1247 AC_SEARCH_LIBS(clock_gettime, [rt posix4]) 1248 AC_SEARCH_LIBS(nanosleep, [rt posix4]) 1249 else 1250 AC_SEARCH_LIBS(clock_gettime, [posix4]) 1251 AC_SEARCH_LIBS(nanosleep, [posix4]) 1252 fi 1253 1254 case "$ac_cv_search_clock_gettime" in 1255 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime 1256 ;; 1257 esac 1258 case "$ac_cv_search_nanosleep" in 1259 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep" 1260 ;; 1261 esac 1262 1263 AC_SEARCH_LIBS(sched_yield, [rt posix4]) 1264 1265 case "$ac_cv_search_sched_yield" in 1266 -lposix4*) 1267 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield" 1268 ac_has_sched_yield=yes 1269 ;; 1270 -lrt*) 1271 if test x"$enable_libstdcxx_time" = x"rt"; then 1272 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield" 1273 ac_has_sched_yield=yes 1274 fi 1275 ;; 1276 *) 1277 ac_has_sched_yield=yes 1278 ;; 1279 esac 1280 1281 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no) 1282 1283 if test x"$ac_has_unistd_h" = x"yes"; then 1284 AC_MSG_CHECKING([for monotonic clock]) 1285 AC_TRY_LINK( 1286 [#include <unistd.h> 1287 #include <time.h> 1288 ], 1289 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK) 1290 timespec tp; 1291 #endif 1292 clock_gettime(CLOCK_MONOTONIC, &tp); 1293 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no]) 1294 1295 AC_MSG_RESULT($ac_has_clock_monotonic) 1296 1297 AC_MSG_CHECKING([for realtime clock]) 1298 AC_TRY_LINK( 1299 [#include <unistd.h> 1300 #include <time.h> 1301 ], 1302 [#if _POSIX_TIMERS > 0 1303 timespec tp; 1304 #endif 1305 clock_gettime(CLOCK_REALTIME, &tp); 1306 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no]) 1307 1308 AC_MSG_RESULT($ac_has_clock_realtime) 1309 1310 AC_MSG_CHECKING([for nanosleep]) 1311 AC_TRY_LINK( 1312 [#include <unistd.h> 1313 #include <time.h> 1314 ], 1315 [#if _POSIX_TIMERS > 0 1316 timespec tp; 1317 #endif 1318 nanosleep(&tp, 0); 1319 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no]) 1320 1321 AC_MSG_RESULT($ac_has_nanosleep) 1322 fi 1323 fi 1324 1325 if test x"$ac_has_clock_monotonic" != x"yes"; then 1326 case ${target_os} in 1327 linux*) 1328 AC_MSG_CHECKING([for clock_gettime syscall]) 1329 AC_TRY_COMPILE( 1330 [#include <unistd.h> 1331 #include <time.h> 1332 #include <sys/syscall.h> 1333 ], 1334 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK) 1335 timespec tp; 1336 #endif 1337 syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &tp); 1338 syscall(SYS_clock_gettime, CLOCK_REALTIME, &tp); 1339 ], [ac_has_clock_monotonic_syscall=yes], [ac_has_clock_monotonic_syscall=no]) 1340 AC_MSG_RESULT($ac_has_clock_monotonic_syscall) 1341 if test x"$ac_has_clock_monotonic_syscall" = x"yes"; then 1342 AC_DEFINE(_GLIBCXX_USE_CLOCK_GETTIME_SYSCALL, 1, 1343 [ Defined if clock_gettime syscall has monotonic and realtime clock support. ]) 1344 ac_has_clock_monotonic=yes 1345 ac_has_clock_realtime=yes 1346 fi;; 1347 esac 1348 fi 1349 1350 if test x"$ac_has_clock_monotonic" = x"yes"; then 1351 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1, 1352 [ Defined if clock_gettime has monotonic clock support. ]) 1353 fi 1354 1355 if test x"$ac_has_clock_realtime" = x"yes"; then 1356 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1, 1357 [ Defined if clock_gettime has realtime clock support. ]) 1358 fi 1359 1360 if test x"$ac_has_sched_yield" = x"yes"; then 1361 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1, 1362 [ Defined if sched_yield is available. ]) 1363 fi 1364 1365 if test x"$ac_has_nanosleep" = x"yes"; then 1366 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1, 1367 [ Defined if nanosleep is available. ]) 1368 else 1369 AC_MSG_CHECKING([for sleep]) 1370 AC_TRY_COMPILE([#include <unistd.h>], 1371 [sleep(1)], 1372 [ac_has_sleep=yes],[ac_has_sleep=no]) 1373 if test x"$ac_has_sleep" = x"yes"; then 1374 AC_DEFINE(HAVE_SLEEP,1, [Defined if sleep exists.]) 1375 fi 1376 AC_MSG_RESULT($ac_has_sleep) 1377 AC_MSG_CHECKING([for usleep]) 1378 AC_TRY_COMPILE([#include <unistd.h>], 1379 [sleep(1); 1380 usleep(100);], 1381 [ac_has_usleep=yes],[ac_has_usleep=no]) 1382 if test x"$ac_has_usleep" = x"yes"; then 1383 AC_DEFINE(HAVE_USLEEP,1, [Defined if usleep exists.]) 1384 fi 1385 AC_MSG_RESULT($ac_has_usleep) 1386 fi 1387 1388 if test x"$ac_has_nanosleep$ac_has_sleep" = x"nono"; then 1389 AC_MSG_CHECKING([for Sleep]) 1390 AC_TRY_COMPILE([#include <windows.h>], 1391 [Sleep(1)], 1392 [ac_has_win32_sleep=yes],[ac_has_win32_sleep=no]) 1393 if test x"$ac_has_win32_sleep" = x"yes"; then 1394 AC_DEFINE(HAVE_WIN32_SLEEP,1, [Defined if Sleep exists.]) 1395 fi 1396 AC_MSG_RESULT($ac_has_win32_sleep) 1397 fi 1398 1399 AC_SUBST(GLIBCXX_LIBS) 1400 1401 CXXFLAGS="$ac_save_CXXFLAGS" 1402 LIBS="$ac_save_LIBS" 1403 AC_LANG_RESTORE 1404]) 1405 1406dnl 1407dnl Check for gettimeofday, used in the implementation of 20.11.7 1408dnl [time.clock] in the C++11 standard. 1409dnl 1410AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [ 1411 1412 AC_MSG_CHECKING([for gettimeofday]) 1413 1414 AC_LANG_SAVE 1415 AC_LANG_CPLUSPLUS 1416 ac_save_CXXFLAGS="$CXXFLAGS" 1417 CXXFLAGS="$CXXFLAGS -fno-exceptions" 1418 1419 ac_has_gettimeofday=no; 1420 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no) 1421 if test x"$ac_has_sys_time_h" = x"yes"; then 1422 AC_MSG_CHECKING([for gettimeofday]) 1423 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>], 1424 [timeval tv; gettimeofday(&tv, 0);], 1425 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no]) 1426 1427 AC_MSG_RESULT($ac_has_gettimeofday) 1428 fi 1429 1430 if test x"$ac_has_gettimeofday" = x"yes"; then 1431 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1, 1432 [ Defined if gettimeofday is available. ]) 1433 fi 1434 1435 CXXFLAGS="$ac_save_CXXFLAGS" 1436 AC_LANG_RESTORE 1437]) 1438 1439dnl 1440dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1" 1441dnl facilities in Chapter 8, "C compatibility". 1442dnl 1443AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [ 1444 1445 AC_LANG_SAVE 1446 AC_LANG_CPLUSPLUS 1447 1448 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__ 1449 # undefined and fake C99 facilities may be spuriously enabled. 1450 ac_save_CXXFLAGS="$CXXFLAGS" 1451 CXXFLAGS="$CXXFLAGS -std=c++98" 1452 1453 # Check for the existence of <complex.h> complex math functions used 1454 # by tr1/complex. 1455 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no) 1456 ac_c99_complex_tr1=no; 1457 if test x"$ac_has_complex_h" = x"yes"; then 1458 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>]) 1459 AC_TRY_COMPILE([#include <complex.h>], 1460 [typedef __complex__ float float_type; float_type tmpf; 1461 cacosf(tmpf); 1462 casinf(tmpf); 1463 catanf(tmpf); 1464 cacoshf(tmpf); 1465 casinhf(tmpf); 1466 catanhf(tmpf); 1467 typedef __complex__ double double_type; double_type tmpd; 1468 cacos(tmpd); 1469 casin(tmpd); 1470 catan(tmpd); 1471 cacosh(tmpd); 1472 casinh(tmpd); 1473 catanh(tmpd); 1474 typedef __complex__ long double ld_type; ld_type tmpld; 1475 cacosl(tmpld); 1476 casinl(tmpld); 1477 catanl(tmpld); 1478 cacoshl(tmpld); 1479 casinhl(tmpld); 1480 catanhl(tmpld); 1481 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no]) 1482 fi 1483 AC_MSG_RESULT($ac_c99_complex_tr1) 1484 if test x"$ac_c99_complex_tr1" = x"yes"; then 1485 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1, 1486 [Define if C99 functions in <complex.h> should be used in 1487 <tr1/complex>. Using compiler builtins for these functions 1488 requires corresponding C99 library functions to be present.]) 1489 fi 1490 1491 # Check for the existence of <ctype.h> functions. 1492 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>]) 1493 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [ 1494 AC_TRY_COMPILE([#include <ctype.h>], 1495 [int ch; 1496 int ret; 1497 ret = isblank(ch); 1498 ],[glibcxx_cv_c99_ctype_tr1=yes], 1499 [glibcxx_cv_c99_ctype_tr1=no]) 1500 ]) 1501 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1) 1502 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then 1503 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1, 1504 [Define if C99 functions in <ctype.h> should be imported in 1505 <tr1/cctype> in namespace std::tr1.]) 1506 fi 1507 1508 # Check for the existence of <fenv.h> functions. 1509 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no) 1510 ac_c99_fenv_tr1=no; 1511 if test x"$ac_has_fenv_h" = x"yes"; then 1512 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>]) 1513 AC_TRY_COMPILE([#include <fenv.h>], 1514 [int except, mode; 1515 fexcept_t* pflag; 1516 fenv_t* penv; 1517 int ret; 1518 ret = feclearexcept(except); 1519 ret = fegetexceptflag(pflag, except); 1520 ret = feraiseexcept(except); 1521 ret = fesetexceptflag(pflag, except); 1522 ret = fetestexcept(except); 1523 ret = fegetround(); 1524 ret = fesetround(mode); 1525 ret = fegetenv(penv); 1526 ret = feholdexcept(penv); 1527 ret = fesetenv(penv); 1528 ret = feupdateenv(penv); 1529 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no]) 1530 fi 1531 AC_MSG_RESULT($ac_c99_fenv_tr1) 1532 if test x"$ac_c99_fenv_tr1" = x"yes"; then 1533 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1, 1534 [Define if C99 functions in <fenv.h> should be imported in 1535 <tr1/cfenv> in namespace std::tr1.]) 1536 fi 1537 1538 # Check for the existence of <stdint.h> types. 1539 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>]) 1540 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [ 1541 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS 1542 #define __STDC_CONSTANT_MACROS 1543 #include <stdint.h>], 1544 [typedef int8_t my_int8_t; 1545 my_int8_t i8 = INT8_MIN; 1546 i8 = INT8_MAX; 1547 typedef int16_t my_int16_t; 1548 my_int16_t i16 = INT16_MIN; 1549 i16 = INT16_MAX; 1550 typedef int32_t my_int32_t; 1551 my_int32_t i32 = INT32_MIN; 1552 i32 = INT32_MAX; 1553 typedef int64_t my_int64_t; 1554 my_int64_t i64 = INT64_MIN; 1555 i64 = INT64_MAX; 1556 typedef int_fast8_t my_int_fast8_t; 1557 my_int_fast8_t if8 = INT_FAST8_MIN; 1558 if8 = INT_FAST8_MAX; 1559 typedef int_fast16_t my_int_fast16_t; 1560 my_int_fast16_t if16 = INT_FAST16_MIN; 1561 if16 = INT_FAST16_MAX; 1562 typedef int_fast32_t my_int_fast32_t; 1563 my_int_fast32_t if32 = INT_FAST32_MIN; 1564 if32 = INT_FAST32_MAX; 1565 typedef int_fast64_t my_int_fast64_t; 1566 my_int_fast64_t if64 = INT_FAST64_MIN; 1567 if64 = INT_FAST64_MAX; 1568 typedef int_least8_t my_int_least8_t; 1569 my_int_least8_t il8 = INT_LEAST8_MIN; 1570 il8 = INT_LEAST8_MAX; 1571 typedef int_least16_t my_int_least16_t; 1572 my_int_least16_t il16 = INT_LEAST16_MIN; 1573 il16 = INT_LEAST16_MAX; 1574 typedef int_least32_t my_int_least32_t; 1575 my_int_least32_t il32 = INT_LEAST32_MIN; 1576 il32 = INT_LEAST32_MAX; 1577 typedef int_least64_t my_int_least64_t; 1578 my_int_least64_t il64 = INT_LEAST64_MIN; 1579 il64 = INT_LEAST64_MAX; 1580 typedef intmax_t my_intmax_t; 1581 my_intmax_t im = INTMAX_MAX; 1582 im = INTMAX_MIN; 1583 typedef intptr_t my_intptr_t; 1584 my_intptr_t ip = INTPTR_MAX; 1585 ip = INTPTR_MIN; 1586 typedef uint8_t my_uint8_t; 1587 my_uint8_t ui8 = UINT8_MAX; 1588 ui8 = UINT8_MAX; 1589 typedef uint16_t my_uint16_t; 1590 my_uint16_t ui16 = UINT16_MAX; 1591 ui16 = UINT16_MAX; 1592 typedef uint32_t my_uint32_t; 1593 my_uint32_t ui32 = UINT32_MAX; 1594 ui32 = UINT32_MAX; 1595 typedef uint64_t my_uint64_t; 1596 my_uint64_t ui64 = UINT64_MAX; 1597 ui64 = UINT64_MAX; 1598 typedef uint_fast8_t my_uint_fast8_t; 1599 my_uint_fast8_t uif8 = UINT_FAST8_MAX; 1600 uif8 = UINT_FAST8_MAX; 1601 typedef uint_fast16_t my_uint_fast16_t; 1602 my_uint_fast16_t uif16 = UINT_FAST16_MAX; 1603 uif16 = UINT_FAST16_MAX; 1604 typedef uint_fast32_t my_uint_fast32_t; 1605 my_uint_fast32_t uif32 = UINT_FAST32_MAX; 1606 uif32 = UINT_FAST32_MAX; 1607 typedef uint_fast64_t my_uint_fast64_t; 1608 my_uint_fast64_t uif64 = UINT_FAST64_MAX; 1609 uif64 = UINT_FAST64_MAX; 1610 typedef uint_least8_t my_uint_least8_t; 1611 my_uint_least8_t uil8 = UINT_LEAST8_MAX; 1612 uil8 = UINT_LEAST8_MAX; 1613 typedef uint_least16_t my_uint_least16_t; 1614 my_uint_least16_t uil16 = UINT_LEAST16_MAX; 1615 uil16 = UINT_LEAST16_MAX; 1616 typedef uint_least32_t my_uint_least32_t; 1617 my_uint_least32_t uil32 = UINT_LEAST32_MAX; 1618 uil32 = UINT_LEAST32_MAX; 1619 typedef uint_least64_t my_uint_least64_t; 1620 my_uint_least64_t uil64 = UINT_LEAST64_MAX; 1621 uil64 = UINT_LEAST64_MAX; 1622 typedef uintmax_t my_uintmax_t; 1623 my_uintmax_t uim = UINTMAX_MAX; 1624 uim = UINTMAX_MAX; 1625 typedef uintptr_t my_uintptr_t; 1626 my_uintptr_t uip = UINTPTR_MAX; 1627 uip = UINTPTR_MAX; 1628 ],[glibcxx_cv_c99_stdint_tr1=yes], 1629 [glibcxx_cv_c99_stdint_tr1=no]) 1630 ]) 1631 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1) 1632 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then 1633 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1, 1634 [Define if C99 types in <stdint.h> should be imported in 1635 <tr1/cstdint> in namespace std::tr1.]) 1636 fi 1637 1638 # Check for the existence of <math.h> functions. 1639 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>]) 1640 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [ 1641 AC_TRY_COMPILE([#include <math.h>], 1642 [typedef double_t my_double_t; 1643 typedef float_t my_float_t; 1644 acosh(0.0); 1645 acoshf(0.0f); 1646 acoshl(0.0l); 1647 asinh(0.0); 1648 asinhf(0.0f); 1649 asinhl(0.0l); 1650 atanh(0.0); 1651 atanhf(0.0f); 1652 atanhl(0.0l); 1653 cbrt(0.0); 1654 cbrtf(0.0f); 1655 cbrtl(0.0l); 1656 copysign(0.0, 0.0); 1657 copysignf(0.0f, 0.0f); 1658 copysignl(0.0l, 0.0l); 1659 erf(0.0); 1660 erff(0.0f); 1661 erfl(0.0l); 1662 erfc(0.0); 1663 erfcf(0.0f); 1664 erfcl(0.0l); 1665 exp2(0.0); 1666 exp2f(0.0f); 1667 exp2l(0.0l); 1668 expm1(0.0); 1669 expm1f(0.0f); 1670 expm1l(0.0l); 1671 fdim(0.0, 0.0); 1672 fdimf(0.0f, 0.0f); 1673 fdiml(0.0l, 0.0l); 1674 fma(0.0, 0.0, 0.0); 1675 fmaf(0.0f, 0.0f, 0.0f); 1676 fmal(0.0l, 0.0l, 0.0l); 1677 fmax(0.0, 0.0); 1678 fmaxf(0.0f, 0.0f); 1679 fmaxl(0.0l, 0.0l); 1680 fmin(0.0, 0.0); 1681 fminf(0.0f, 0.0f); 1682 fminl(0.0l, 0.0l); 1683 hypot(0.0, 0.0); 1684 hypotf(0.0f, 0.0f); 1685 hypotl(0.0l, 0.0l); 1686 ilogb(0.0); 1687 ilogbf(0.0f); 1688 ilogbl(0.0l); 1689 lgamma(0.0); 1690 lgammaf(0.0f); 1691 lgammal(0.0l); 1692 llrint(0.0); 1693 llrintf(0.0f); 1694 llrintl(0.0l); 1695 llround(0.0); 1696 llroundf(0.0f); 1697 llroundl(0.0l); 1698 log1p(0.0); 1699 log1pf(0.0f); 1700 log1pl(0.0l); 1701 log2(0.0); 1702 log2f(0.0f); 1703 log2l(0.0l); 1704 logb(0.0); 1705 logbf(0.0f); 1706 logbl(0.0l); 1707 lrint(0.0); 1708 lrintf(0.0f); 1709 lrintl(0.0l); 1710 lround(0.0); 1711 lroundf(0.0f); 1712 lroundl(0.0l); 1713 nan(0); 1714 nanf(0); 1715 nanl(0); 1716 nearbyint(0.0); 1717 nearbyintf(0.0f); 1718 nearbyintl(0.0l); 1719 nextafter(0.0, 0.0); 1720 nextafterf(0.0f, 0.0f); 1721 nextafterl(0.0l, 0.0l); 1722 nexttoward(0.0, 0.0); 1723 nexttowardf(0.0f, 0.0f); 1724 nexttowardl(0.0l, 0.0l); 1725 remainder(0.0, 0.0); 1726 remainderf(0.0f, 0.0f); 1727 remainderl(0.0l, 0.0l); 1728 remquo(0.0, 0.0, 0); 1729 remquof(0.0f, 0.0f, 0); 1730 remquol(0.0l, 0.0l, 0); 1731 rint(0.0); 1732 rintf(0.0f); 1733 rintl(0.0l); 1734 round(0.0); 1735 roundf(0.0f); 1736 roundl(0.0l); 1737 scalbln(0.0, 0l); 1738 scalblnf(0.0f, 0l); 1739 scalblnl(0.0l, 0l); 1740 scalbn(0.0, 0); 1741 scalbnf(0.0f, 0); 1742 scalbnl(0.0l, 0); 1743 tgamma(0.0); 1744 tgammaf(0.0f); 1745 tgammal(0.0l); 1746 trunc(0.0); 1747 truncf(0.0f); 1748 truncl(0.0l); 1749 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no]) 1750 ]) 1751 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1) 1752 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then 1753 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1, 1754 [Define if C99 functions or macros in <math.h> should be imported 1755 in <tr1/cmath> in namespace std::tr1.]) 1756 fi 1757 1758 # Check for the existence of <inttypes.h> functions (NB: doesn't make 1759 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1). 1760 ac_c99_inttypes_tr1=no; 1761 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then 1762 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>]) 1763 AC_TRY_COMPILE([#include <inttypes.h>], 1764 [intmax_t i, numer, denom, base; 1765 const char* s; 1766 char** endptr; 1767 intmax_t ret = imaxabs(i); 1768 imaxdiv_t dret = imaxdiv(numer, denom); 1769 ret = strtoimax(s, endptr, base); 1770 uintmax_t uret = strtoumax(s, endptr, base); 1771 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no]) 1772 fi 1773 AC_MSG_RESULT($ac_c99_inttypes_tr1) 1774 if test x"$ac_c99_inttypes_tr1" = x"yes"; then 1775 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1, 1776 [Define if C99 functions in <inttypes.h> should be imported in 1777 <tr1/cinttypes> in namespace std::tr1.]) 1778 fi 1779 1780 # Check for the existence of wchar_t <inttypes.h> functions (NB: doesn't 1781 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1). 1782 ac_c99_inttypes_wchar_t_tr1=no; 1783 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then 1784 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>]) 1785 AC_TRY_COMPILE([#include <inttypes.h>], 1786 [intmax_t base; 1787 const wchar_t* s; 1788 wchar_t** endptr; 1789 intmax_t ret = wcstoimax(s, endptr, base); 1790 uintmax_t uret = wcstoumax(s, endptr, base); 1791 ],[ac_c99_inttypes_wchar_t_tr1=yes], 1792 [ac_c99_inttypes_wchar_t_tr1=no]) 1793 fi 1794 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1) 1795 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then 1796 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1, 1797 [Define if wchar_t C99 functions in <inttypes.h> should be 1798 imported in <tr1/cinttypes> in namespace std::tr1.]) 1799 fi 1800 1801 # Check for the existence of the <stdbool.h> header. 1802 AC_CHECK_HEADERS(stdbool.h) 1803 1804 # Check for the existence of the <stdalign.h> header. 1805 AC_CHECK_HEADERS(stdalign.h) 1806 1807 CXXFLAGS="$ac_save_CXXFLAGS" 1808 AC_LANG_RESTORE 1809]) 1810 1811dnl 1812dnl Check whether "/dev/random" and "/dev/urandom" are available for the 1813dnl random_device of "TR1" (Chapter 5.1, "Random number generation"). 1814dnl 1815AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [ 1816 1817 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device]) 1818 AC_CACHE_VAL(glibcxx_cv_random_tr1, [ 1819 if test -r /dev/random && test -r /dev/urandom; then 1820 ## For MSys environment the test above is detect as false-positive 1821 ## on mingw-targets. So disable it explicit for them. 1822 case ${target_os} in 1823 *mingw*) glibcxx_cv_random_tr1=no ;; 1824 *) glibcxx_cv_random_tr1=yes ;; 1825 esac 1826 else 1827 glibcxx_cv_random_tr1=no; 1828 fi 1829 ]) 1830 AC_MSG_RESULT($glibcxx_cv_random_tr1) 1831 1832 if test x"$glibcxx_cv_random_tr1" = x"yes"; then 1833 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1, 1834 [Define if /dev/random and /dev/urandom are available for 1835 the random_device of TR1 (Chapter 5.1).]) 1836 fi 1837 1838]) 1839 1840dnl 1841dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants. 1842dnl 1843AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [ 1844 1845 AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [ 1846 AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]], 1847 [#include <stdio.h>], 1848 [AC_MSG_ERROR([computing EOF failed])]) 1849 ]) 1850 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof, 1851 [Define to the value of the EOF integer constant.]) 1852 1853 AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [ 1854 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]], 1855 [#include <stdio.h>], 1856 [AC_MSG_ERROR([computing SEEK_CUR failed])]) 1857 ]) 1858 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur, 1859 [Define to the value of the SEEK_CUR integer constant.]) 1860 1861 AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [ 1862 AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]], 1863 [#include <stdio.h>], 1864 [AC_MSG_ERROR([computing SEEK_END failed])]) 1865 ]) 1866 AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end, 1867 [Define to the value of the SEEK_END integer constant.]) 1868]) 1869 1870dnl 1871dnl Check whether required C++ overloads are present in <stdio.h>. 1872dnl 1873AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [ 1874 1875 AC_LANG_SAVE 1876 AC_LANG_CPLUSPLUS 1877 1878 AC_MSG_CHECKING([for gets declaration]) 1879 AC_CACHE_VAL(glibcxx_cv_gets, [ 1880 AC_COMPILE_IFELSE([AC_LANG_SOURCE( 1881 [#include <stdio.h> 1882 namespace test 1883 { 1884 using ::gets; 1885 } 1886 ])], 1887 [glibcxx_cv_gets=yes], 1888 [glibcxx_cv_gets=no] 1889 )]) 1890 1891 if test $glibcxx_cv_gets = yes; then 1892 AC_DEFINE(HAVE_GETS, 1, [Define if gets is available in <stdio.h>.]) 1893 fi 1894 AC_MSG_RESULT($glibcxx_cv_gets) 1895 1896 AC_LANG_RESTORE 1897]) 1898 1899dnl 1900dnl Check whether required C++11 overloads for floating point and integral 1901dnl types are present in <math.h>. 1902dnl 1903AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [ 1904 1905 AC_LANG_SAVE 1906 AC_LANG_CPLUSPLUS 1907 ac_save_CXXFLAGS="$CXXFLAGS" 1908 CXXFLAGS="$CXXFLAGS -std=c++11" 1909 1910 case "$host" in 1911 *-*-solaris2.*) 1912 # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch 1913 # 11996[67]-02 introduced the C++11 <math.h> floating point overloads. 1914 AC_MSG_CHECKING([for C++11 <math.h> floating point overloads]) 1915 AC_CACHE_VAL(glibcxx_cv_math11_fp_overload, [ 1916 AC_COMPILE_IFELSE([AC_LANG_SOURCE( 1917 [#include <math.h> 1918 #undef isfinite 1919 namespace std { 1920 inline bool isfinite(float __x) 1921 { return __builtin_isfinite(__x); } 1922 } 1923 ])], 1924 [glibcxx_cv_math11_fp_overload=no], 1925 [glibcxx_cv_math11_fp_overload=yes] 1926 )]) 1927 1928 # autoheader cannot handle indented templates. 1929 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP], 1930 [/* Define if all C++11 floating point overloads are available in <math.h>. */ 1931#if __cplusplus >= 201103L 1932#undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1933#endif]) 1934 1935 if test $glibcxx_cv_math11_fp_overload = yes; then 1936 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP) 1937 fi 1938 AC_MSG_RESULT([$glibcxx_cv_math11_fp_overload]) 1939 1940 # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch 1941 # 11996[67]-02 introduced the C++11 <math.h> integral type overloads. 1942 AC_MSG_CHECKING([for C++11 <math.h> integral type overloads]) 1943 AC_CACHE_VAL(glibcxx_cv_math11_int_overload, [ 1944 AC_COMPILE_IFELSE([AC_LANG_SOURCE( 1945 [#include <math.h> 1946 namespace std { 1947 template<typename _Tp> 1948 struct __is_integer; 1949 template<> 1950 struct __is_integer<int> 1951 { 1952 enum { __value = 1 }; 1953 }; 1954 } 1955 namespace __gnu_cxx { 1956 template<bool, typename> 1957 struct __enable_if; 1958 template<typename _Tp> 1959 struct __enable_if<true, _Tp> 1960 { typedef _Tp __type; }; 1961 } 1962 namespace std { 1963 template<typename _Tp> 1964 constexpr typename __gnu_cxx::__enable_if 1965 <__is_integer<_Tp>::__value, double>::__type 1966 log2(_Tp __x) 1967 { return __builtin_log2(__x); } 1968 } 1969 int 1970 main (void) 1971 { 1972 int i = 1000; 1973 return std::log2(i); 1974 } 1975 ])], 1976 [glibcxx_cv_math11_int_overload=no], 1977 [glibcxx_cv_math11_int_overload=yes] 1978 )]) 1979 1980 # autoheader cannot handle indented templates. 1981 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT], 1982 [/* Define if all C++11 integral type overloads are available in <math.h>. */ 1983#if __cplusplus >= 201103L 1984#undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1985#endif]) 1986 1987 if test $glibcxx_cv_math11_int_overload = yes; then 1988 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT) 1989 fi 1990 AC_MSG_RESULT([$glibcxx_cv_math11_int_overload]) 1991 ;; 1992 esac 1993 1994 CXXFLAGS="$ac_save_CXXFLAGS" 1995 AC_LANG_RESTORE 1996]) 1997 1998dnl 1999dnl Check whether macros, etc are present for <system_error> 2000dnl 2001AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [ 2002 2003m4_pushdef([n_syserr], [1])dnl 2004m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA, 2005 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED, 2006 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY, 2007 ECHILD, ENOSPC, EPERM, 2008 ETIMEDOUT, EWOULDBLOCK], 2009[m4_pushdef([SYSERR], m4_toupper(syserr))dnl 2010AC_MSG_CHECKING([for syserr]) 2011AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [ 2012AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]], 2013 [int i = syserr;])], 2014 [glibcxx_cv_system_error[]n_syserr=yes], 2015 [glibcxx_cv_system_error[]n_syserr=no]) 2016]) 2017AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr]) 2018if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then 2019 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.]) 2020fi 2021m4_define([n_syserr], m4_incr(n_syserr))dnl 2022m4_popdef([SYSERR])dnl 2023]) 2024m4_popdef([n_syserr])dnl 2025]) 2026 2027dnl 2028dnl Check for what type of C headers to use. 2029dnl 2030dnl --enable-cheaders= [does stuff]. 2031dnl --disable-cheaders [does not do anything, really]. 2032dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)] 2033dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'. 2034dnl 2035AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [ 2036 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]], 2037 [construct "C" headers for g++], [permit c|c_std|c_global]) 2038 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders) 2039 2040 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders 2041 2042 # Allow overrides to configure.host here. 2043 if test $enable_cheaders = c_global; then 2044 c_compatibility=yes 2045 fi 2046 2047 AC_SUBST(C_INCLUDE_DIR) 2048 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c) 2049 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std) 2050 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global) 2051 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes) 2052]) 2053 2054 2055dnl 2056dnl Check for which locale library to use. The choice is mapped to 2057dnl a subdirectory of config/locale. 2058dnl 2059dnl Default is generic. 2060dnl 2061AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ 2062 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]], 2063 [use MODEL for target locale package], 2064 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto]) 2065 2066 # Deal with gettext issues. Default to not using it (=no) until we detect 2067 # support for it later. Let the user turn it off via --e/d, but let that 2068 # default to on for easier handling. 2069 USE_NLS=no 2070 AC_ARG_ENABLE(nls, 2071 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]), 2072 [], 2073 [enable_nls=yes]) 2074 2075 # Either a known package, or "auto" 2076 if test $enable_clocale = no || test $enable_clocale = yes; then 2077 enable_clocale=auto 2078 fi 2079 enable_clocale_flag=$enable_clocale 2080 2081 # Probe for locale model to use if none specified. 2082 # Default to "generic". 2083 if test $enable_clocale_flag = auto; then 2084 case ${target_os} in 2085 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) 2086 enable_clocale_flag=gnu 2087 ;; 2088 darwin* | freebsd*) 2089 enable_clocale_flag=darwin 2090 ;; 2091 dragonfly*) 2092 enable_clocale_flag=dragonfly 2093 ;; 2094 openbsd*) 2095 enable_clocale_flag=newlib 2096 ;; 2097 *) 2098 if test x"$with_newlib" = x"yes"; then 2099 enable_clocale_flag=newlib 2100 else 2101 enable_clocale_flag=generic 2102 fi 2103 ;; 2104 esac 2105 fi 2106 2107 # Sanity check model, and test for special functionality. 2108 if test $enable_clocale_flag = gnu; then 2109 AC_EGREP_CPP([_GLIBCXX_ok], [ 2110 #include <features.h> 2111 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__) 2112 _GLIBCXX_ok 2113 #endif 2114 ], enable_clocale_flag=gnu, enable_clocale_flag=generic) 2115 2116 # Set it to scream when it hurts. 2117 ac_save_CFLAGS="$CFLAGS" 2118 CFLAGS="-Wimplicit-function-declaration -Werror" 2119 2120 # Use strxfrm_l if available. 2121 AC_TRY_COMPILE([#define _GNU_SOURCE 1 2122 #include <string.h> 2123 #include <locale.h>], 2124 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);], 2125 AC_DEFINE(HAVE_STRXFRM_L, 1, 2126 [Define if strxfrm_l is available in <string.h>.]),) 2127 2128 # Use strerror_l if available. 2129 AC_TRY_COMPILE([#define _GNU_SOURCE 1 2130 #include <string.h> 2131 #include <locale.h>], 2132 [__locale_t loc; strerror_l(5, loc);], 2133 AC_DEFINE(HAVE_STRERROR_L, 1, 2134 [Define if strerror_l is available in <string.h>.]),) 2135 2136 CFLAGS="$ac_save_CFLAGS" 2137 fi 2138 2139 # Perhaps use strerror_r if available, and strerror_l isn't. 2140 ac_save_CFLAGS="$CFLAGS" 2141 CFLAGS="-Wimplicit-function-declaration -Werror" 2142 AC_TRY_COMPILE([#define _GNU_SOURCE 1 2143 #include <string.h> 2144 #include <locale.h>], 2145 [char s[128]; strerror_r(5, s, 128);], 2146 AC_DEFINE(HAVE_STRERROR_R, 1, 2147 [Define if strerror_r is available in <string.h>.]),) 2148 CFLAGS="$ac_save_CFLAGS" 2149 2150 # Set configure bits for specified locale package 2151 AC_MSG_CHECKING([for C locale to use]) 2152 case ${enable_clocale_flag} in 2153 generic) 2154 AC_MSG_RESULT(generic) 2155 2156 CLOCALE_H=config/locale/generic/c_locale.h 2157 CLOCALE_CC=config/locale/generic/c_locale.cc 2158 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2159 CCOLLATE_CC=config/locale/generic/collate_members.cc 2160 CCTYPE_CC=config/locale/generic/ctype_members.cc 2161 CMESSAGES_H=config/locale/generic/messages_members.h 2162 CMESSAGES_CC=config/locale/generic/messages_members.cc 2163 CMONEY_CC=config/locale/generic/monetary_members.cc 2164 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2165 CTIME_H=config/locale/generic/time_members.h 2166 CTIME_CC=config/locale/generic/time_members.cc 2167 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2168 ;; 2169 darwin) 2170 AC_MSG_RESULT(darwin or freebsd) 2171 2172 CLOCALE_H=config/locale/generic/c_locale.h 2173 CLOCALE_CC=config/locale/generic/c_locale.cc 2174 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2175 CCOLLATE_CC=config/locale/generic/collate_members.cc 2176 CCTYPE_CC=config/locale/darwin/ctype_members.cc 2177 CMESSAGES_H=config/locale/generic/messages_members.h 2178 CMESSAGES_CC=config/locale/generic/messages_members.cc 2179 CMONEY_CC=config/locale/generic/monetary_members.cc 2180 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2181 CTIME_H=config/locale/generic/time_members.h 2182 CTIME_CC=config/locale/generic/time_members.cc 2183 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2184 ;; 2185 2186 dragonfly) 2187 AC_MSG_RESULT(dragonfly) 2188 2189 CLOCALE_H=config/locale/generic/c_locale.h 2190 CLOCALE_CC=config/locale/dragonfly/c_locale.cc 2191 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2192 CCOLLATE_CC=config/locale/generic/collate_members.cc 2193 CCTYPE_CC=config/locale/dragonfly/ctype_members.cc 2194 CMESSAGES_H=config/locale/generic/messages_members.h 2195 CMESSAGES_CC=config/locale/generic/messages_members.cc 2196 CMONEY_CC=config/locale/generic/monetary_members.cc 2197 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2198 CTIME_H=config/locale/generic/time_members.h 2199 CTIME_CC=config/locale/generic/time_members.cc 2200 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2201 ;; 2202 2203 gnu) 2204 AC_MSG_RESULT(gnu) 2205 2206 # Declare intention to use gettext, and add support for specific 2207 # languages. 2208 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT 2209 ALL_LINGUAS="de fr" 2210 2211 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc. 2212 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no) 2213 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then 2214 USE_NLS=yes 2215 fi 2216 # Export the build objects. 2217 for ling in $ALL_LINGUAS; do \ 2218 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \ 2219 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \ 2220 done 2221 AC_SUBST(glibcxx_MOFILES) 2222 AC_SUBST(glibcxx_POFILES) 2223 2224 CLOCALE_H=config/locale/gnu/c_locale.h 2225 CLOCALE_CC=config/locale/gnu/c_locale.cc 2226 CCODECVT_CC=config/locale/gnu/codecvt_members.cc 2227 CCOLLATE_CC=config/locale/gnu/collate_members.cc 2228 CCTYPE_CC=config/locale/gnu/ctype_members.cc 2229 CMESSAGES_H=config/locale/gnu/messages_members.h 2230 CMESSAGES_CC=config/locale/gnu/messages_members.cc 2231 CMONEY_CC=config/locale/gnu/monetary_members.cc 2232 CNUMERIC_CC=config/locale/gnu/numeric_members.cc 2233 CTIME_H=config/locale/gnu/time_members.h 2234 CTIME_CC=config/locale/gnu/time_members.cc 2235 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h 2236 ;; 2237 ieee_1003.1-2001) 2238 AC_MSG_RESULT(IEEE 1003.1) 2239 2240 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h 2241 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc 2242 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2243 CCOLLATE_CC=config/locale/generic/collate_members.cc 2244 CCTYPE_CC=config/locale/generic/ctype_members.cc 2245 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h 2246 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc 2247 CMONEY_CC=config/locale/generic/monetary_members.cc 2248 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2249 CTIME_H=config/locale/generic/time_members.h 2250 CTIME_CC=config/locale/generic/time_members.cc 2251 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2252 ;; 2253 newlib) 2254 AC_MSG_RESULT(newlib) 2255 2256 CLOCALE_H=config/locale/generic/c_locale.h 2257 CLOCALE_CC=config/locale/generic/c_locale.cc 2258 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2259 CCOLLATE_CC=config/locale/generic/collate_members.cc 2260 CCTYPE_CC=config/locale/newlib/ctype_members.cc 2261 CMESSAGES_H=config/locale/generic/messages_members.h 2262 CMESSAGES_CC=config/locale/generic/messages_members.cc 2263 CMONEY_CC=config/locale/generic/monetary_members.cc 2264 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2265 CTIME_H=config/locale/generic/time_members.h 2266 CTIME_CC=config/locale/generic/time_members.cc 2267 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2268 ;; 2269 esac 2270 2271 # This is where the testsuite looks for locale catalogs, using the 2272 # -DLOCALEDIR define during testsuite compilation. 2273 glibcxx_localedir=${glibcxx_builddir}/po/share/locale 2274 AC_SUBST(glibcxx_localedir) 2275 2276 # A standalone libintl (e.g., GNU libintl) may be in use. 2277 if test $USE_NLS = yes; then 2278 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no) 2279 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no) 2280 fi 2281 if test $USE_NLS = yes; then 2282 AC_DEFINE(_GLIBCXX_USE_NLS, 1, 2283 [Define if NLS translations are to be used.]) 2284 fi 2285 2286 AC_SUBST(USE_NLS) 2287 AC_SUBST(CLOCALE_H) 2288 AC_SUBST(CMESSAGES_H) 2289 AC_SUBST(CCODECVT_CC) 2290 AC_SUBST(CCOLLATE_CC) 2291 AC_SUBST(CCTYPE_CC) 2292 AC_SUBST(CMESSAGES_CC) 2293 AC_SUBST(CMONEY_CC) 2294 AC_SUBST(CNUMERIC_CC) 2295 AC_SUBST(CTIME_H) 2296 AC_SUBST(CTIME_CC) 2297 AC_SUBST(CLOCALE_CC) 2298 AC_SUBST(CLOCALE_INTERNAL_H) 2299]) 2300 2301 2302dnl 2303dnl Check for which std::allocator base class to use. The choice is 2304dnl mapped from a subdirectory of include/ext. 2305dnl 2306dnl Default is new. 2307dnl 2308AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [ 2309 AC_MSG_CHECKING([for std::allocator base class]) 2310 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]], 2311 [use KIND for target std::allocator base], 2312 [permit new|malloc|mt|bitmap|pool|yes|no|auto]) 2313 2314 # If they didn't use this option switch, or if they specified --enable 2315 # with no specific model, we'll have to look for one. If they 2316 # specified --disable (???), do likewise. 2317 if test $enable_libstdcxx_allocator = no || 2318 test $enable_libstdcxx_allocator = yes; 2319 then 2320 enable_libstdcxx_allocator=auto 2321 fi 2322 2323 # Either a known package, or "auto". Auto implies the default choice 2324 # for a particular platform. 2325 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator 2326 2327 # Probe for host-specific support if no specific model is specified. 2328 # Default to "new". 2329 if test $enable_libstdcxx_allocator_flag = auto; then 2330 case ${target_os} in 2331 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) 2332 enable_libstdcxx_allocator_flag=new 2333 ;; 2334 *) 2335 enable_libstdcxx_allocator_flag=new 2336 ;; 2337 esac 2338 fi 2339 AC_MSG_RESULT($enable_libstdcxx_allocator_flag) 2340 2341 2342 # Set configure bits for specified locale package 2343 case ${enable_libstdcxx_allocator_flag} in 2344 bitmap) 2345 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h 2346 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator 2347 ;; 2348 malloc) 2349 ALLOCATOR_H=config/allocator/malloc_allocator_base.h 2350 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator 2351 ;; 2352 mt) 2353 ALLOCATOR_H=config/allocator/mt_allocator_base.h 2354 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc 2355 ;; 2356 new) 2357 ALLOCATOR_H=config/allocator/new_allocator_base.h 2358 ALLOCATOR_NAME=__gnu_cxx::new_allocator 2359 ;; 2360 pool) 2361 ALLOCATOR_H=config/allocator/pool_allocator_base.h 2362 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc 2363 ;; 2364 esac 2365 2366 AC_SUBST(ALLOCATOR_H) 2367 AC_SUBST(ALLOCATOR_NAME) 2368]) 2369 2370 2371dnl 2372dnl Check for whether the Boost-derived checks should be turned on. 2373dnl 2374dnl --enable-concept-checks turns them on. 2375dnl --disable-concept-checks leaves them off. 2376dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)] 2377dnl Where DEFAULT is either `yes' or `no'. 2378dnl 2379AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [ 2380 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks]) 2381 if test $enable_concept_checks = yes; then 2382 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1, 2383 [Define to use concept checking code from the boost libraries.]) 2384 fi 2385]) 2386 2387dnl 2388dnl Use extern templates. 2389dnl 2390dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1 2391dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0 2392 2393dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)] 2394dnl Where DEFAULT is `yes' or `no'. 2395dnl 2396AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [ 2397 2398 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template]) 2399 2400 AC_MSG_CHECKING([for extern template support]) 2401 AC_MSG_RESULT([$enable_extern_template]) 2402 2403 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes) 2404]) 2405 2406dnl 2407dnl Use vtable verification. 2408dnl 2409dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1 2410dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0 2411 2412dnl + Usage: GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)] 2413dnl Where DEFAULT is `yes' or `no'. 2414dnl 2415AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [ 2416 2417 GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify]) 2418 2419 AC_MSG_CHECKING([for vtable verify support]) 2420 AC_MSG_RESULT([$enable_vtable_verify]) 2421 2422 vtv_cygmin=no 2423 if test $enable_vtable_verify = yes; then 2424 case ${target_os} in 2425 cygwin*|mingw32*) 2426 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end" 2427 vtv_cygmin=yes 2428 ;; 2429 *) 2430 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end" 2431 ;; 2432 esac 2433 VTV_PCH_CXXFLAGS="-fvtable-verify=std" 2434 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs" 2435 else 2436 VTV_CXXFLAGS= 2437 VTV_PCH_CXXFLAGS= 2438 VTV_CXXLINKFLAGS= 2439 fi 2440 2441 AC_SUBST(VTV_CXXFLAGS) 2442 AC_SUBST(VTV_PCH_CXXFLAGS) 2443 AC_SUBST(VTV_CXXLINKFLAGS) 2444 AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes) 2445 GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes) 2446]) 2447 2448dnl 2449dnl Check for parallel mode pre-requisites, including OpenMP support. 2450dnl 2451dnl + Usage: GLIBCXX_ENABLE_PARALLEL 2452dnl 2453AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [ 2454 2455 enable_parallel=no; 2456 2457 # See if configured libgomp/omp.h exists. (libgomp may be in 2458 # noconfigdirs but not explicitly disabled.) 2459 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then 2460 enable_parallel=yes; 2461 else 2462 AC_MSG_NOTICE([target-libgomp not built]) 2463 fi 2464 2465 AC_MSG_CHECKING([for parallel mode support]) 2466 AC_MSG_RESULT([$enable_parallel]) 2467]) 2468 2469 2470dnl 2471dnl Check for which I/O library to use: stdio, or something specific. 2472dnl 2473dnl Default is stdio. 2474dnl 2475AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [ 2476 AC_MSG_CHECKING([for underlying I/O to use]) 2477 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]], 2478 [use target-specific I/O package], [permit stdio]) 2479 2480 # Now that libio has been removed, you can have any color you want as long 2481 # as it's black. This is one big no-op until other packages are added, but 2482 # showing the framework never hurts. 2483 case ${enable_cstdio} in 2484 stdio) 2485 CSTDIO_H=config/io/c_io_stdio.h 2486 BASIC_FILE_H=config/io/basic_file_stdio.h 2487 BASIC_FILE_CC=config/io/basic_file_stdio.cc 2488 AC_MSG_RESULT(stdio) 2489 ;; 2490 esac 2491 2492 AC_SUBST(CSTDIO_H) 2493 AC_SUBST(BASIC_FILE_H) 2494 AC_SUBST(BASIC_FILE_CC) 2495]) 2496 2497 2498dnl 2499dnl Check for "unusual" flags to pass to the compiler while building. 2500dnl 2501dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing 2502dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc. 2503dnl --disable-cxx-flags passes nothing. 2504dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html 2505dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html 2506dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html 2507dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags) 2508dnl If "default flags" is an empty string, the effect is the same 2509dnl as --disable or --enable=no. 2510dnl 2511AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl 2512 AC_MSG_CHECKING([for extra compiler flags for building]) 2513 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS], 2514 [pass compiler FLAGS when building library], 2515 [case "x$enable_cxx_flags" in 2516 xno | x) enable_cxx_flags= ;; 2517 x-*) ;; 2518 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;; 2519 esac]) 2520 2521 # Run through flags (either default or command-line) and set anything 2522 # extra (e.g., #defines) that must accompany particular g++ options. 2523 if test -n "$enable_cxx_flags"; then 2524 for f in $enable_cxx_flags; do 2525 case "$f" in 2526 -fhonor-std) ;; 2527 -*) ;; 2528 *) # and we're trying to pass /what/ exactly? 2529 AC_MSG_ERROR([compiler flags start with a -]) ;; 2530 esac 2531 done 2532 fi 2533 2534 EXTRA_CXX_FLAGS="$enable_cxx_flags" 2535 AC_MSG_RESULT($EXTRA_CXX_FLAGS) 2536 AC_SUBST(EXTRA_CXX_FLAGS) 2537]) 2538 2539 2540dnl 2541dnl Check to see if debugging libraries are to be built. 2542dnl 2543dnl --enable-libstdcxx-debug 2544dnl builds a separate set of debugging libraries in addition to the 2545dnl normal (shared, static) libstdc++ binaries. 2546dnl 2547dnl --disable-libstdcxx-debug 2548dnl builds only one (non-debug) version of libstdc++. 2549dnl 2550dnl --enable-libstdcxx-debug-flags=FLAGS 2551dnl iff --enable-debug == yes, then use FLAGS to build the debug library. 2552dnl 2553dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)] 2554dnl Where DEFAULT is either `yes' or `no'. 2555dnl 2556AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [ 2557 AC_MSG_CHECKING([for additional debug build]) 2558 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library]) 2559 AC_MSG_RESULT($enable_libstdcxx_debug) 2560 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes) 2561]) 2562 2563 2564dnl 2565dnl Check for explicit debug flags. 2566dnl 2567dnl --enable-libstdcxx-debug-flags='-O1' 2568dnl is a general method for passing flags to be used when 2569dnl building debug libraries with --enable-debug. 2570dnl 2571dnl --disable-libstdcxx-debug-flags does nothing. 2572dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags) 2573dnl If "default flags" is an empty string, the effect is the same 2574dnl as --disable or --enable=no. 2575dnl 2576AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [ 2577 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS], 2578 [pass compiler FLAGS when building debug library], 2579 [case "x$enable_libstdcxx_debug_flags" in 2580 xno | x) enable_libstdcxx_debug_flags= ;; 2581 x-*) ;; 2582 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;; 2583 esac]) 2584 2585 # Option parsed, now set things appropriately 2586 DEBUG_FLAGS="$enable_libstdcxx_debug_flags" 2587 AC_SUBST(DEBUG_FLAGS) 2588 2589 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS]) 2590]) 2591 2592 2593dnl 2594dnl Check if the user only wants a freestanding library implementation. 2595dnl 2596dnl --disable-hosted-libstdcxx will turn off most of the library build, 2597dnl installing only the headers required by [17.4.1.3] and the language 2598dnl support library. More than that will be built (to keep the Makefiles 2599dnl conveniently clean), but not installed. 2600dnl 2601dnl Sets: 2602dnl is_hosted (yes/no) 2603dnl 2604dnl Defines: 2605dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0) 2606dnl 2607AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [ 2608 AC_ARG_ENABLE([hosted-libstdcxx], 2609 AC_HELP_STRING([--disable-hosted-libstdcxx], 2610 [only build freestanding C++ runtime support]),, 2611 [case "$host" in 2612 arm*-*-symbianelf*) 2613 enable_hosted_libstdcxx=no 2614 ;; 2615 *) 2616 enable_hosted_libstdcxx=yes 2617 ;; 2618 esac]) 2619 if test "$enable_hosted_libstdcxx" = no; then 2620 AC_MSG_NOTICE([Only freestanding libraries will be built]) 2621 is_hosted=no 2622 hosted_define=0 2623 enable_abi_check=no 2624 enable_libstdcxx_pch=no 2625 else 2626 is_hosted=yes 2627 hosted_define=1 2628 fi 2629 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes) 2630 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define, 2631 [Define to 1 if a full hosted library is built, or 0 if freestanding.]) 2632]) 2633 2634 2635dnl 2636dnl Check if the user wants a non-verbose library implementation. 2637dnl 2638dnl --disable-libstdcxx-verbose will turn off descriptive messages to 2639dnl standard error on termination. 2640dnl 2641dnl Defines: 2642dnl _GLIBCXX_VERBOSE (always defined, either to 1 or 0) 2643dnl 2644AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [ 2645 AC_ARG_ENABLE([libstdcxx-verbose], 2646 AC_HELP_STRING([--disable-libstdcxx-verbose], 2647 [disable termination messages to standard error]),, 2648 [enable_libstdcxx_verbose=yes]) 2649 if test x"$enable_libstdcxx_verbose" = xyes; then 2650 verbose_define=1 2651 else 2652 AC_MSG_NOTICE([verbose termination messages are disabled]) 2653 verbose_define=0 2654 fi 2655 AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define, 2656 [Define to 1 if a verbose library is built, or 0 otherwise.]) 2657]) 2658 2659 2660dnl 2661dnl Check for template specializations for the 'long long' type. 2662dnl The result determines only whether 'long long' I/O is enabled; things 2663dnl like numeric_limits<> specializations are always available. 2664dnl 2665dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG 2666dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined 2667dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)] 2668dnl Where DEFAULT is either `yes' or `no'. 2669dnl 2670AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [ 2671 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long']) 2672 if test $enable_long_long = yes; then 2673 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1, 2674 [Define if code specialized for long long should be used.]) 2675 fi 2676 AC_MSG_CHECKING([for enabled long long specializations]) 2677 AC_MSG_RESULT([$enable_long_long]) 2678]) 2679 2680 2681dnl 2682dnl Check for decimal floating point. 2683dnl See: 2684dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float 2685dnl 2686dnl This checks to see if the host supports decimal floating point types. 2687dnl 2688dnl Defines: 2689dnl _GLIBCXX_USE_DECIMAL_FLOAT 2690dnl 2691AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [ 2692 2693 # Fake what AC_TRY_COMPILE does, without linking as this is 2694 # unnecessary for this test. 2695 2696 cat > conftest.$ac_ext << EOF 2697[#]line __oline__ "configure" 2698int main() 2699{ 2700 _Decimal32 d1; 2701 _Decimal64 d2; 2702 _Decimal128 d3; 2703 return 0; 2704} 2705EOF 2706 2707 AC_MSG_CHECKING([for ISO/IEC TR 24733 ]) 2708 if AC_TRY_EVAL(ac_compile); then 2709 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1, 2710 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.]) 2711 enable_dfp=yes 2712 else 2713 enable_dfp=no 2714 fi 2715 AC_MSG_RESULT($enable_dfp) 2716 rm -f conftest* 2717]) 2718 2719dnl 2720dnl Check for GNU 128-bit integer and floating point types. 2721dnl 2722dnl Note: also checks that the types aren't standard types. 2723dnl 2724dnl Defines: 2725dnl _GLIBCXX_USE_INT128 2726dnl _GLIBCXX_USE_FLOAT128 2727dnl 2728AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [ 2729 2730 AC_LANG_SAVE 2731 AC_LANG_CPLUSPLUS 2732 2733 # Fake what AC_TRY_COMPILE does, without linking as this is 2734 # unnecessary for this test. 2735 2736 cat > conftest.$ac_ext << EOF 2737[#]line __oline__ "configure" 2738template<typename T1, typename T2> 2739 struct same 2740 { typedef T2 type; }; 2741 2742template<typename T> 2743 struct same<T, T>; 2744 2745int main() 2746{ 2747 typename same<long, __int128>::type i1; 2748 typename same<long long, __int128>::type i2; 2749} 2750EOF 2751 2752 AC_MSG_CHECKING([for __int128]) 2753 if AC_TRY_EVAL(ac_compile); then 2754 AC_DEFINE(_GLIBCXX_USE_INT128, 1, 2755 [Define if __int128 is supported on this host.]) 2756 enable_int128=yes 2757 else 2758 enable_int128=no 2759 fi 2760 AC_MSG_RESULT($enable_int128) 2761 rm -f conftest* 2762 2763 cat > conftest.$ac_ext << EOF 2764[#]line __oline__ "configure" 2765template<typename T1, typename T2> 2766 struct same 2767 { typedef T2 type; }; 2768 2769template<typename T> 2770 struct same<T, T>; 2771 2772int main() 2773{ 2774 typename same<double, __float128>::type f1; 2775 typename same<long double, __float128>::type f2; 2776} 2777EOF 2778 2779 AC_MSG_CHECKING([for __float128]) 2780 if AC_TRY_EVAL(ac_compile); then 2781 AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1, 2782 [Define if __float128 is supported on this host.]) 2783 enable_float128=yes 2784 else 2785 enable_float128=no 2786 fi 2787 AC_MSG_RESULT($enable_float128) 2788 rm -f conftest* 2789 2790 AC_LANG_RESTORE 2791]) 2792 2793dnl 2794dnl Check for template specializations for the 'wchar_t' type. 2795dnl 2796dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T 2797dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined 2798dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)] 2799dnl Where DEFAULT is either `yes' or `no'. 2800dnl 2801dnl Necessary support must also be present. 2802dnl 2803AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [ 2804 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t']) 2805 2806 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos. 2807 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no) 2808 AC_MSG_CHECKING([for mbstate_t]) 2809 AC_TRY_COMPILE([#include <wchar.h>], 2810 [mbstate_t teststate;], 2811 have_mbstate_t=yes, have_mbstate_t=no) 2812 AC_MSG_RESULT($have_mbstate_t) 2813 if test x"$have_mbstate_t" = xyes; then 2814 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.]) 2815 fi 2816 2817 # Test it always, for use in GLIBCXX_ENABLE_C99, together with 2818 # ac_has_wchar_h. 2819 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no) 2820 2821 if test x"$enable_wchar_t" = x"yes"; then 2822 2823 AC_LANG_SAVE 2824 AC_LANG_CPLUSPLUS 2825 2826 if test x"$ac_has_wchar_h" = xyes && 2827 test x"$ac_has_wctype_h" = xyes; then 2828 AC_TRY_COMPILE([#include <wchar.h> 2829 #include <stddef.h> 2830 wint_t i; 2831 long l = WEOF; 2832 long j = WCHAR_MIN; 2833 long k = WCHAR_MAX; 2834 namespace test 2835 { 2836 using ::btowc; 2837 using ::fgetwc; 2838 using ::fgetws; 2839 using ::fputwc; 2840 using ::fputws; 2841 using ::fwide; 2842 using ::fwprintf; 2843 using ::fwscanf; 2844 using ::getwc; 2845 using ::getwchar; 2846 using ::mbrlen; 2847 using ::mbrtowc; 2848 using ::mbsinit; 2849 using ::mbsrtowcs; 2850 using ::putwc; 2851 using ::putwchar; 2852 using ::swprintf; 2853 using ::swscanf; 2854 using ::ungetwc; 2855 using ::vfwprintf; 2856 using ::vswprintf; 2857 using ::vwprintf; 2858 using ::wcrtomb; 2859 using ::wcscat; 2860 using ::wcschr; 2861 using ::wcscmp; 2862 using ::wcscoll; 2863 using ::wcscpy; 2864 using ::wcscspn; 2865 using ::wcsftime; 2866 using ::wcslen; 2867 using ::wcsncat; 2868 using ::wcsncmp; 2869 using ::wcsncpy; 2870 using ::wcspbrk; 2871 using ::wcsrchr; 2872 using ::wcsrtombs; 2873 using ::wcsspn; 2874 using ::wcsstr; 2875 using ::wcstod; 2876 using ::wcstok; 2877 using ::wcstol; 2878 using ::wcstoul; 2879 using ::wcsxfrm; 2880 using ::wctob; 2881 using ::wmemchr; 2882 using ::wmemcmp; 2883 using ::wmemcpy; 2884 using ::wmemmove; 2885 using ::wmemset; 2886 using ::wprintf; 2887 using ::wscanf; 2888 } 2889 ],[],[], [enable_wchar_t=no]) 2890 else 2891 enable_wchar_t=no 2892 fi 2893 2894 AC_LANG_RESTORE 2895 fi 2896 2897 if test x"$enable_wchar_t" = x"yes"; then 2898 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1, 2899 [Define if code specialized for wchar_t should be used.]) 2900 fi 2901 2902 AC_MSG_CHECKING([for enabled wchar_t specializations]) 2903 AC_MSG_RESULT([$enable_wchar_t]) 2904]) 2905 2906 2907dnl 2908dnl Check to see if building and using a C++ precompiled header can be done. 2909dnl 2910dnl --enable-libstdcxx-pch=yes 2911dnl default, this shows intent to use stdc++.h.gch If it looks like it 2912dnl may work, after some light-hearted attempts to puzzle out compiler 2913dnl support, flip bits on in include/Makefile.am 2914dnl 2915dnl --disable-libstdcxx-pch 2916dnl turns off attempts to use or build stdc++.h.gch. 2917dnl 2918dnl Substs: 2919dnl glibcxx_PCHFLAGS 2920dnl 2921AC_DEFUN([GLIBCXX_ENABLE_PCH], [ 2922 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers]) 2923 if test $enable_libstdcxx_pch = yes; then 2924 AC_CACHE_CHECK([for compiler with PCH support], 2925 [glibcxx_cv_prog_CXX_pch], 2926 [ac_save_CXXFLAGS="$CXXFLAGS" 2927 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated" 2928 AC_LANG_SAVE 2929 AC_LANG_CPLUSPLUS 2930 echo '#include <math.h>' > conftest.h 2931 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \ 2932 -o conftest.h.gch 1>&5 2>&1 && 2933 echo '#error "pch failed"' > conftest.h && 2934 echo '#include "conftest.h"' > conftest.cc && 2935 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ; 2936 then 2937 glibcxx_cv_prog_CXX_pch=yes 2938 else 2939 glibcxx_cv_prog_CXX_pch=no 2940 fi 2941 rm -f conftest* 2942 CXXFLAGS=$ac_save_CXXFLAGS 2943 AC_LANG_RESTORE 2944 ]) 2945 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch 2946 fi 2947 2948 AC_MSG_CHECKING([for enabled PCH]) 2949 AC_MSG_RESULT([$enable_libstdcxx_pch]) 2950 2951 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes) 2952 if test $enable_libstdcxx_pch = yes; then 2953 glibcxx_PCHFLAGS="-include bits/stdc++.h" 2954 else 2955 glibcxx_PCHFLAGS="" 2956 fi 2957 AC_SUBST(glibcxx_PCHFLAGS) 2958]) 2959 2960 2961dnl 2962dnl Check for atomic builtins. 2963dnl See: 2964dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html 2965dnl 2966dnl This checks to see if the host supports the compiler-generated 2967dnl builtins for atomic operations for various integral sizes. Note, this 2968dnl is intended to be an all-or-nothing switch, so all the atomic operations 2969dnl that are used should be checked. 2970dnl 2971dnl Note: 2972dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD. 2973dnl 2974AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [ 2975 AC_LANG_SAVE 2976 AC_LANG_CPLUSPLUS 2977 old_CXXFLAGS="$CXXFLAGS" 2978 2979 # Do link tests if possible, instead asm tests, limited to some platforms 2980 # see discussion in PR target/40134, PR libstdc++/40133 and the thread 2981 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html 2982 atomic_builtins_link_tests=no 2983 if test x$gcc_no_link != xyes; then 2984 # Can do link tests. Limit to some tested platforms 2985 case "$host" in 2986 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*) 2987 atomic_builtins_link_tests=yes 2988 ;; 2989 esac 2990 fi 2991 2992 if test x$atomic_builtins_link_tests = xyes; then 2993 2994 # Do link tests. 2995 2996 CXXFLAGS="$CXXFLAGS -fno-exceptions" 2997 2998 AC_MSG_CHECKING([for atomic builtins for bool]) 2999 AC_CACHE_VAL(glibcxx_cv_atomic_bool, [ 3000 AC_TRY_LINK( 3001 [ ], 3002 [typedef bool atomic_type; 3003 atomic_type c1; 3004 atomic_type c2; 3005 atomic_type c3(0); 3006 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3007 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3008 __ATOMIC_RELAXED); 3009 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3010 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3011 ], 3012 [glibcxx_cv_atomic_bool=yes], 3013 [glibcxx_cv_atomic_bool=no]) 3014 ]) 3015 AC_MSG_RESULT($glibcxx_cv_atomic_bool) 3016 3017 AC_MSG_CHECKING([for atomic builtins for short]) 3018 AC_CACHE_VAL(glibcxx_cv_atomic_short, [ 3019 AC_TRY_LINK( 3020 [ ], 3021 [typedef short atomic_type; 3022 atomic_type c1; 3023 atomic_type c2; 3024 atomic_type c3(0); 3025 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3026 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3027 __ATOMIC_RELAXED); 3028 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3029 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3030 ], 3031 [glibcxx_cv_atomic_short=yes], 3032 [glibcxx_cv_atomic_short=no]) 3033 ]) 3034 AC_MSG_RESULT($glibcxx_cv_atomic_short) 3035 3036 AC_MSG_CHECKING([for atomic builtins for int]) 3037 AC_CACHE_VAL(glibcxx_cv_atomic_int, [ 3038 AC_TRY_LINK( 3039 [ ], 3040 [typedef int atomic_type; 3041 atomic_type c1; 3042 atomic_type c2; 3043 atomic_type c3(0); 3044 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3045 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3046 __ATOMIC_RELAXED); 3047 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3048 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3049 ], 3050 [glibcxx_cv_atomic_int=yes], 3051 [glibcxx_cv_atomic_int=no]) 3052 ]) 3053 AC_MSG_RESULT($glibcxx_cv_atomic_int) 3054 3055 AC_MSG_CHECKING([for atomic builtins for long long]) 3056 AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [ 3057 AC_TRY_LINK( 3058 [ ], 3059 [typedef long long atomic_type; 3060 atomic_type c1; 3061 atomic_type c2; 3062 atomic_type c3(0); 3063 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3064 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3065 __ATOMIC_RELAXED); 3066 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3067 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3068 ], 3069 [glibcxx_cv_atomic_long_long=yes], 3070 [glibcxx_cv_atomic_long_long=no]) 3071 ]) 3072 AC_MSG_RESULT($glibcxx_cv_atomic_long_long) 3073 3074 else 3075 3076 # Do asm tests. 3077 3078 # Compile unoptimized. 3079 CXXFLAGS='-O0 -S' 3080 3081 # Fake what AC_TRY_COMPILE does. 3082 3083 cat > conftest.$ac_ext << EOF 3084[#]line __oline__ "configure" 3085int main() 3086{ 3087 typedef bool atomic_type; 3088 atomic_type c1; 3089 atomic_type c2; 3090 atomic_type c3(0); 3091 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3092 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3093 __ATOMIC_RELAXED); 3094 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3095 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3096 3097 return 0; 3098} 3099EOF 3100 3101 AC_MSG_CHECKING([for atomic builtins for bool]) 3102 if AC_TRY_EVAL(ac_compile); then 3103 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 3104 glibcxx_cv_atomic_bool=no 3105 else 3106 glibcxx_cv_atomic_bool=yes 3107 fi 3108 fi 3109 AC_MSG_RESULT($glibcxx_cv_atomic_bool) 3110 rm -f conftest* 3111 3112 cat > conftest.$ac_ext << EOF 3113[#]line __oline__ "configure" 3114int main() 3115{ 3116 typedef short atomic_type; 3117 atomic_type c1; 3118 atomic_type c2; 3119 atomic_type c3(0); 3120 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3121 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3122 __ATOMIC_RELAXED); 3123 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3124 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3125 3126 return 0; 3127} 3128EOF 3129 3130 AC_MSG_CHECKING([for atomic builtins for short]) 3131 if AC_TRY_EVAL(ac_compile); then 3132 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 3133 glibcxx_cv_atomic_short=no 3134 else 3135 glibcxx_cv_atomic_short=yes 3136 fi 3137 fi 3138 AC_MSG_RESULT($glibcxx_cv_atomic_short) 3139 rm -f conftest* 3140 3141 cat > conftest.$ac_ext << EOF 3142[#]line __oline__ "configure" 3143int main() 3144{ 3145 // NB: _Atomic_word not necessarily int. 3146 typedef int atomic_type; 3147 atomic_type c1; 3148 atomic_type c2; 3149 atomic_type c3(0); 3150 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3151 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3152 __ATOMIC_RELAXED); 3153 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3154 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3155 3156 return 0; 3157} 3158EOF 3159 3160 AC_MSG_CHECKING([for atomic builtins for int]) 3161 if AC_TRY_EVAL(ac_compile); then 3162 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 3163 glibcxx_cv_atomic_int=no 3164 else 3165 glibcxx_cv_atomic_int=yes 3166 fi 3167 fi 3168 AC_MSG_RESULT($glibcxx_cv_atomic_int) 3169 rm -f conftest* 3170 3171 cat > conftest.$ac_ext << EOF 3172[#]line __oline__ "configure" 3173int main() 3174{ 3175 typedef long long atomic_type; 3176 atomic_type c1; 3177 atomic_type c2; 3178 atomic_type c3(0); 3179 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3180 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3181 __ATOMIC_RELAXED); 3182 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3183 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3184 3185 return 0; 3186} 3187EOF 3188 3189 AC_MSG_CHECKING([for atomic builtins for long long]) 3190 if AC_TRY_EVAL(ac_compile); then 3191 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 3192 glibcxx_cv_atomic_long_long=no 3193 else 3194 glibcxx_cv_atomic_long_long=yes 3195 fi 3196 fi 3197 AC_MSG_RESULT($glibcxx_cv_atomic_long_long) 3198 rm -f conftest* 3199 3200 fi 3201 3202 CXXFLAGS="$old_CXXFLAGS" 3203 AC_LANG_RESTORE 3204 3205 # Set atomicity_dir to builtins if all but the long long test above passes. 3206 if test $glibcxx_cv_atomic_bool = yes \ 3207 && test $glibcxx_cv_atomic_short = yes \ 3208 && test $glibcxx_cv_atomic_int = yes; then 3209 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1, 3210 [Define if the compiler supports C++11 atomics.]) 3211 atomicity_dir=cpu/generic/atomicity_builtins 3212 fi 3213 3214 # If still generic, set to mutex. 3215 if test $atomicity_dir = "cpu/generic" ; then 3216 atomicity_dir=cpu/generic/atomicity_mutex 3217 AC_MSG_WARN([No native atomic operations are provided for this platform.]) 3218 if test "x$target_thread_file" = xsingle; then 3219 AC_MSG_WARN([They cannot be faked when thread support is disabled.]) 3220 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.]) 3221 else 3222 AC_MSG_WARN([They will be faked using a mutex.]) 3223 AC_MSG_WARN([Performance of certain classes will degrade as a result.]) 3224 fi 3225 fi 3226 3227]) 3228 3229 3230dnl 3231dnl Check for exception handling support. If an explicit enable/disable 3232dnl sjlj exceptions is given, we don't have to detect. Otherwise the 3233dnl target may or may not support call frame exceptions. 3234dnl 3235dnl --enable-sjlj-exceptions forces the use of builtin setjmp. 3236dnl --disable-sjlj-exceptions forces the use of call frame unwinding. 3237dnl Neither one forces an attempt at detection. 3238dnl 3239dnl Defines: 3240dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it 3241dnl 3242AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [ 3243 AC_MSG_CHECKING([for exception model to use]) 3244 AC_LANG_SAVE 3245 AC_LANG_CPLUSPLUS 3246 GLIBCXX_ENABLE(sjlj-exceptions,auto,, 3247 [force use of builtin_setjmp for exceptions], 3248 [permit yes|no|auto]) 3249 3250 if test $enable_sjlj_exceptions = auto; then 3251 # Botheration. Now we've got to detect the exception model. Link tests 3252 # against libgcc.a are problematic since we've not been given proper -L 3253 # bits for single-tree newlib and libgloss. 3254 # 3255 # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style. 3256 cat > conftest.$ac_ext << EOF 3257[#]line __oline__ "configure" 3258struct S { ~S(); }; 3259void bar(); 3260void foo() 3261{ 3262 S s; 3263 bar(); 3264} 3265EOF 3266 old_CXXFLAGS="$CXXFLAGS" 3267 CXXFLAGS=-S 3268 if AC_TRY_EVAL(ac_compile); then 3269 if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then 3270 enable_sjlj_exceptions=yes 3271 elif grep _Unwind_SjLj_Register conftest.s >/dev/null 2>&1 ; then 3272 enable_sjlj_exceptions=yes 3273 elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then 3274 enable_sjlj_exceptions=no 3275 elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then 3276 enable_sjlj_exceptions=no 3277 fi 3278 fi 3279 CXXFLAGS="$old_CXXFLAGS" 3280 rm -f conftest* 3281 fi 3282 3283 # This is a tad weird, for hysterical raisins. We have to map 3284 # enable/disable to two different models. 3285 case $enable_sjlj_exceptions in 3286 yes) 3287 AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1, 3288 [Define if the compiler is configured for setjmp/longjmp exceptions.]) 3289 ac_exception_model_name=sjlj 3290 ;; 3291 no) 3292 ac_exception_model_name="call frame" 3293 ;; 3294 *) 3295 AC_MSG_ERROR([unable to detect exception model]) 3296 ;; 3297 esac 3298 AC_LANG_RESTORE 3299 AC_MSG_RESULT($ac_exception_model_name) 3300]) 3301 3302 3303dnl 3304dnl Allow visibility attributes to be used on namespaces, objects, etc. 3305dnl 3306dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes. 3307dnl --disable-libstdcxx-visibility turns off all use of visibility attributes. 3308dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)] 3309dnl Where DEFAULT is 'yes'. 3310dnl 3311AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [ 3312GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage]) 3313 3314if test x$enable_libstdcxx_visibility = xyes ; then 3315 dnl all hail libgfortran 3316 dnl Check whether the target supports hidden visibility. 3317 AC_CACHE_CHECK([whether the target supports hidden visibility], 3318 glibcxx_cv_have_attribute_visibility, [ 3319 save_CFLAGS="$CFLAGS" 3320 CFLAGS="$CFLAGS -Werror" 3321 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }], 3322 [], glibcxx_cv_have_attribute_visibility=yes, 3323 glibcxx_cv_have_attribute_visibility=no) 3324 CFLAGS="$save_CFLAGS"]) 3325 if test $glibcxx_cv_have_attribute_visibility = no; then 3326 enable_libstdcxx_visibility=no 3327 fi 3328fi 3329 3330GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes) 3331AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility]) 3332]) 3333 3334 3335dnl 3336dnl Add version tags to symbols in shared library (or not), additionally 3337dnl marking other symbols as private/local (or not). 3338dnl 3339dnl Sets libtool_VERSION, and determines shared library SONAME. 3340dnl 3341dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no. 3342dnl 3343dnl --enable-symvers=style adds a version script to the linker call when 3344dnl creating the shared library. The choice of version script is 3345dnl controlled by 'style'. 3346dnl --disable-symvers does not. 3347dnl 3348dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)] 3349dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to 3350dnl choose a default style based on linker characteristics. Passing 3351dnl 'no' disables versioning. 3352dnl 3353AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [ 3354 3355GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]], 3356 [enables symbol versioning of the shared library], 3357 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun]) 3358 3359# If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we 3360# don't know enough about $LD to do tricks... 3361AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES]) 3362# Sun style symbol versions needs GNU c++filt for make_sunver.pl to work 3363# with extern "C++" in version scripts. 3364AC_REQUIRE([GCC_PROG_GNU_CXXFILT]) 3365 3366# Turn a 'yes' into a suitable default. 3367if test x$enable_symvers = xyes ; then 3368 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then 3369 enable_symvers=no 3370 else 3371 if test $with_gnu_ld = yes ; then 3372 case ${target_os} in 3373 hpux*) 3374 enable_symvers=no ;; 3375 *) 3376 enable_symvers=gnu ;; 3377 esac 3378 else 3379 case ${target_os} in 3380 darwin*) 3381 enable_symvers=darwin ;; 3382 # Sun symbol versioning exists since Solaris 2.5. 3383 solaris2.[[5-9]]* | solaris2.1[[0-9]]*) 3384 # make_sunver.pl needs GNU c++filt to support extern "C++" in 3385 # version scripts, so disable symbol versioning if none can be 3386 # found. 3387 if test -z "$ac_cv_path_CXXFILT"; then 3388 AC_MSG_WARN([=== You have requested Sun symbol versioning, but]) 3389 AC_MSG_WARN([=== no GNU c++filt could be found.]) 3390 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3391 enable_symvers=no 3392 else 3393 enable_symvers=sun 3394 fi 3395 ;; 3396 *) 3397 enable_symvers=no ;; 3398 esac 3399 fi 3400 fi 3401fi 3402 3403# Check to see if 'darwin' or 'darwin-export' can win. 3404if test x$enable_symvers = xdarwin-export ; then 3405 enable_symvers=darwin 3406fi 3407 3408# Check if 'sun' was requested on non-Solaris 2 platforms. 3409if test x$enable_symvers = xsun ; then 3410 case ${target_os} in 3411 solaris2*) 3412 # All fine. 3413 ;; 3414 *) 3415 # Unlikely to work. 3416 AC_MSG_WARN([=== You have requested Sun symbol versioning, but]) 3417 AC_MSG_WARN([=== you are not targetting Solaris 2.]) 3418 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3419 enable_symvers=no 3420 ;; 3421 esac 3422fi 3423 3424# Check to see if 'gnu' can win. 3425if test $enable_symvers = gnu || 3426 test $enable_symvers = gnu-versioned-namespace || 3427 test $enable_symvers = sun; then 3428 # Check to see if libgcc_s exists, indicating that shared libgcc is possible. 3429 AC_MSG_CHECKING([for shared libgcc]) 3430 ac_save_CFLAGS="$CFLAGS" 3431 CFLAGS=' -lgcc_s' 3432 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no) 3433 CFLAGS="$ac_save_CFLAGS" 3434 if test $glibcxx_shared_libgcc = no; then 3435 cat > conftest.c <<EOF 3436int main (void) { return 0; } 3437EOF 3438changequote(,)dnl 3439 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \ 3440 -shared -shared-libgcc -o conftest.so \ 3441 conftest.c -v 2>&1 >/dev/null \ 3442 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'` 3443changequote([,])dnl 3444 rm -f conftest.c conftest.so 3445 if test x${glibcxx_libgcc_s_suffix+set} = xset; then 3446 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix" 3447 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes) 3448 CFLAGS="$ac_save_CFLAGS" 3449 fi 3450 fi 3451 AC_MSG_RESULT($glibcxx_shared_libgcc) 3452 3453 # For GNU ld, we need at least this version. The format is described in 3454 # GLIBCXX_CHECK_LINKER_FEATURES above. 3455 glibcxx_min_gnu_ld_version=21400 3456 3457 # If no shared libgcc, can't win. 3458 if test $glibcxx_shared_libgcc != yes; then 3459 AC_MSG_WARN([=== You have requested GNU symbol versioning, but]) 3460 AC_MSG_WARN([=== you are not building a shared libgcc_s.]) 3461 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3462 enable_symvers=no 3463 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then 3464 : All interesting versions of Sun ld support sun style symbol versioning. 3465 elif test $with_gnu_ld != yes ; then 3466 # just fail for now 3467 AC_MSG_WARN([=== You have requested GNU symbol versioning, but]) 3468 AC_MSG_WARN([=== you are not using the GNU linker.]) 3469 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3470 enable_symvers=no 3471 elif test $glibcxx_ld_is_gold = yes ; then 3472 : All versions of gold support symbol versioning. 3473 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then 3474 # The right tools, the right setup, but too old. Fallbacks? 3475 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for) 3476 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.) 3477 AC_MSG_WARN(=== You would need to upgrade your binutils to version) 3478 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.) 3479 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3480 enable_symvers=no 3481 fi 3482fi 3483 3484# For libtool versioning info, format is CURRENT:REVISION:AGE 3485libtool_VERSION=6:21:0 3486 3487# Everything parsed; figure out what files and settings to use. 3488case $enable_symvers in 3489 no) 3490 SYMVER_FILE=config/abi/pre/none.ver 3491 ;; 3492 gnu) 3493 SYMVER_FILE=config/abi/pre/gnu.ver 3494 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1, 3495 [Define to use GNU versioning in the shared library.]) 3496 ;; 3497 gnu-versioned-namespace) 3498 libtool_VERSION=7:0:0 3499 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver 3500 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1, 3501 [Define to use GNU namespace versioning in the shared library.]) 3502 ;; 3503 darwin) 3504 SYMVER_FILE=config/abi/pre/gnu.ver 3505 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1, 3506 [Define to use darwin versioning in the shared library.]) 3507 ;; 3508 sun) 3509 SYMVER_FILE=config/abi/pre/gnu.ver 3510 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1, 3511 [Define to use Sun versioning in the shared library.]) 3512 ;; 3513esac 3514 3515if test x$enable_symvers != xno ; then 3516 AC_DEFINE(_GLIBCXX_SYMVER, 1, 3517 [Define to use symbol versioning in the shared library.]) 3518fi 3519 3520AC_CACHE_CHECK([whether the target supports .symver directive], 3521 glibcxx_cv_have_as_symver_directive, [ 3522 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");], 3523 [], glibcxx_cv_have_as_symver_directive=yes, 3524 glibcxx_cv_have_as_symver_directive=no)]) 3525if test $glibcxx_cv_have_as_symver_directive = yes; then 3526 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1, 3527 [Define to 1 if the target assembler supports .symver directive.]) 3528fi 3529 3530AC_SUBST(SYMVER_FILE) 3531AC_SUBST(port_specific_symbol_files) 3532GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no) 3533GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu) 3534GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace) 3535GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin) 3536GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun) 3537AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers) 3538 3539if test $enable_symvers != no ; then 3540 case ${target_os} in 3541 # The Solaris 2 runtime linker doesn't support the GNU extension of 3542 # binding the same symbol to different versions 3543 solaris2*) 3544 ;; 3545 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do. 3546 *) 3547 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1, 3548 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.]) 3549 ;; 3550 esac 3551fi 3552 3553# Now, set up compatibility support, if any. 3554# In addition, need this to deal with std::size_t mangling in 3555# src/compatibility.cc. In a perfect world, could use 3556# typeid(std::size_t).name()[0] to do direct substitution. 3557AC_MSG_CHECKING([for size_t as unsigned int]) 3558ac_save_CFLAGS="$CFLAGS" 3559CFLAGS="-Werror" 3560AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;], 3561 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no]) 3562CFLAGS=$ac_save_CFLAGS 3563if test "$glibcxx_size_t_is_i" = yes; then 3564 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.]) 3565fi 3566AC_MSG_RESULT([$glibcxx_size_t_is_i]) 3567 3568AC_MSG_CHECKING([for ptrdiff_t as int]) 3569ac_save_CFLAGS="$CFLAGS" 3570CFLAGS="-Werror" 3571AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;], 3572 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no]) 3573CFLAGS=$ac_save_CFLAGS 3574if test "$glibcxx_ptrdiff_t_is_i" = yes; then 3575 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.]) 3576fi 3577AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i]) 3578]) 3579 3580 3581dnl 3582dnl Setup to use the gcc gthr.h thread-specific memory and mutex model. 3583dnl We must stage the required headers so that they will be installed 3584dnl with the library (unlike libgcc, the STL implementation is provided 3585dnl solely within headers). Since we must not inject random user-space 3586dnl macro names into user-provided C++ code, we first stage into <file>-in 3587dnl and process to <file> with an output command. The reason for a two- 3588dnl stage process here is to correctly handle $srcdir!=$objdir without 3589dnl having to write complex code (the sed commands to clean the macro 3590dnl namespace are complex and fragile enough as it is). We must also 3591dnl add a relative path so that -I- is supported properly. 3592dnl 3593dnl Substs: 3594dnl thread_header 3595dnl 3596AC_DEFUN([GLIBCXX_ENABLE_THREADS], [ 3597 AC_MSG_CHECKING([for thread model used by GCC]) 3598 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'` 3599 AC_MSG_RESULT([$target_thread_file]) 3600 GCC_AC_THREAD_HEADER([$target_thread_file]) 3601]) 3602 3603 3604dnl 3605dnl Check if gthread implementation defines the types and functions 3606dnl required by the c++0x thread library. Conforming gthread 3607dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x. 3608dnl 3609dnl GLIBCXX_ENABLE_SYMVERS must be done before this. 3610dnl 3611AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [ 3612 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support]) 3613 3614 if test x$enable_libstdcxx_threads = xauto || 3615 test x$enable_libstdcxx_threads = xyes; then 3616 3617 AC_LANG_SAVE 3618 AC_LANG_CPLUSPLUS 3619 3620 ac_save_CXXFLAGS="$CXXFLAGS" 3621 CXXFLAGS="$CXXFLAGS -fno-exceptions \ 3622 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc" 3623 3624 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'` 3625 case $target_thread_file in 3626 posix) 3627 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS" 3628 esac 3629 3630 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available]) 3631 3632 AC_TRY_COMPILE([#include <unistd.h>], 3633 [ 3634 // In case of POSIX threads check _POSIX_TIMEOUTS. 3635 #if (defined(_PTHREADS) \ 3636 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0)) 3637 #error 3638 #endif 3639 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0]) 3640 3641 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock, 3642 [Define to 1 if mutex_timedlock is available.]) 3643 3644 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ; 3645 else res_mutex_timedlock=no ; fi 3646 AC_MSG_RESULT([$res_mutex_timedlock]) 3647 3648 AC_MSG_CHECKING([for gthreads library]) 3649 3650 AC_TRY_COMPILE([#include "gthr.h"], 3651 [ 3652 #ifndef __GTHREADS_CXX0X 3653 #error 3654 #endif 3655 ], [ac_has_gthreads=yes], [ac_has_gthreads=no]) 3656 else 3657 ac_has_gthreads=no 3658 fi 3659 3660 AC_MSG_RESULT([$ac_has_gthreads]) 3661 3662 if test x"$ac_has_gthreads" = x"yes"; then 3663 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1, 3664 [Define if gthreads library is available.]) 3665 3666 # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14 3667 AC_CHECK_TYPE([pthread_rwlock_t], 3668 [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1, 3669 [Define if POSIX read/write locks are available in <gthr.h>.])], 3670 [], 3671 [#include "gthr.h"]) 3672 fi 3673 3674 CXXFLAGS="$ac_save_CXXFLAGS" 3675 AC_LANG_RESTORE 3676]) 3677 3678 3679# Check whether LC_MESSAGES is available in <locale.h>. 3680# Ulrich Drepper <drepper@cygnus.com>, 1995. 3681# 3682# This file file be copied and used freely without restrictions. It can 3683# be used in projects which are not available under the GNU Public License 3684# but which still want to provide support for the GNU gettext functionality. 3685# Please note that the actual code is *not* freely available. 3686AC_DEFUN([AC_LC_MESSAGES], [ 3687 AC_CHECK_HEADER(locale.h, [ 3688 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES, 3689 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES], 3690 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)]) 3691 if test $ac_cv_val_LC_MESSAGES = yes; then 3692 AC_DEFINE(HAVE_LC_MESSAGES, 1, 3693 [Define if LC_MESSAGES is available in <locale.h>.]) 3694 fi 3695 ]) 3696]) 3697 3698dnl 3699dnl Check whether rdrand is supported in the assembler. 3700AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [ 3701 AC_MSG_CHECKING([for rdrand support in assembler]) 3702 AC_CACHE_VAL(ac_cv_x86_rdrand, [ 3703 ac_cv_x86_rdrand=no 3704 case "$target" in 3705 i?86-*-* | \ 3706 x86_64-*-*) 3707 AC_TRY_COMPILE(, [asm("rdrand %eax");], 3708 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no]) 3709 esac 3710 ]) 3711 if test $ac_cv_x86_rdrand = yes; then 3712 AC_DEFINE(_GLIBCXX_X86_RDRAND, 1, 3713 [ Defined if as can handle rdrand. ]) 3714 fi 3715 AC_MSG_RESULT($ac_cv_x86_rdrand) 3716]) 3717 3718dnl 3719dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS. 3720dnl 3721AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [ 3722 3723 AC_LANG_SAVE 3724 AC_LANG_CPLUSPLUS 3725 ac_save_CXXFLAGS="$CXXFLAGS" 3726 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3727 3728 AC_MSG_CHECKING([for get_nprocs]) 3729 AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [ 3730 GCC_TRY_COMPILE_OR_LINK( 3731 [#include <sys/sysinfo.h>], 3732 [int n = get_nprocs();], 3733 [glibcxx_cv_GET_NPROCS=yes], 3734 [glibcxx_cv_GET_NPROCS=no]) 3735 ]) 3736 if test $glibcxx_cv_GET_NPROCS = yes; then 3737 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.]) 3738 fi 3739 AC_MSG_RESULT($glibcxx_cv_GET_NPROCS) 3740 3741 CXXFLAGS="$ac_save_CXXFLAGS" 3742 AC_LANG_RESTORE 3743]) 3744 3745dnl 3746dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN. 3747dnl 3748AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [ 3749 3750 AC_LANG_SAVE 3751 AC_LANG_CPLUSPLUS 3752 ac_save_CXXFLAGS="$CXXFLAGS" 3753 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3754 3755 AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN]) 3756 AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [ 3757 GCC_TRY_COMPILE_OR_LINK( 3758 [#include <unistd.h>], 3759 [int n = sysconf(_SC_NPROCESSORS_ONLN);], 3760 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes], 3761 [glibcxx_cv_SC_NPROCESSORS_ONLN=no]) 3762 ]) 3763 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then 3764 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.]) 3765 fi 3766 AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN) 3767 3768 CXXFLAGS="$ac_save_CXXFLAGS" 3769 AC_LANG_RESTORE 3770]) 3771 3772dnl 3773dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN. 3774dnl 3775AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [ 3776 3777 AC_LANG_SAVE 3778 AC_LANG_CPLUSPLUS 3779 ac_save_CXXFLAGS="$CXXFLAGS" 3780 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3781 3782 AC_MSG_CHECKING([for _SC_NPROC_ONLN]) 3783 AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [ 3784 GCC_TRY_COMPILE_OR_LINK( 3785 [#include <unistd.h>], 3786 [int n = sysconf(_SC_NPROC_ONLN);], 3787 [glibcxx_cv_SC_NPROC_ONLN=yes], 3788 [glibcxx_cv_SC_NPROC_ONLN=no]) 3789 ]) 3790 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then 3791 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.]) 3792 fi 3793 AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN) 3794 3795 CXXFLAGS="$ac_save_CXXFLAGS" 3796 AC_LANG_RESTORE 3797]) 3798 3799dnl 3800dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP. 3801dnl 3802AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [ 3803 3804 AC_LANG_SAVE 3805 AC_LANG_CPLUSPLUS 3806 ac_save_CXXFLAGS="$CXXFLAGS" 3807 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3808 3809 AC_MSG_CHECKING([for pthreads_num_processors_np]) 3810 AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [ 3811 GCC_TRY_COMPILE_OR_LINK( 3812 [#include <pthread.h>], 3813 [int n = pthread_num_processors_np();], 3814 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes], 3815 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no]) 3816 ]) 3817 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then 3818 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.]) 3819 fi 3820 AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP) 3821 3822 CXXFLAGS="$ac_save_CXXFLAGS" 3823 AC_LANG_RESTORE 3824]) 3825 3826dnl 3827dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU. 3828dnl 3829AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [ 3830 3831 AC_LANG_SAVE 3832 AC_LANG_CPLUSPLUS 3833 ac_save_CXXFLAGS="$CXXFLAGS" 3834 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3835 3836 AC_MSG_CHECKING([for hw.ncpu sysctl]) 3837 AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [ 3838 GCC_TRY_COMPILE_OR_LINK( 3839 [ 3840 #include <stddef.h> 3841 #include <sys/sysctl.h> 3842 ], 3843 [ 3844 int count; 3845 size_t size = sizeof(count); 3846 int mib[] = { CTL_HW, HW_NCPU }; 3847 sysctl(mib, 2, &count, &size, NULL, 0); 3848 ], 3849 [glibcxx_cv_SYSCTL_HW_NCPU=yes], 3850 [glibcxx_cv_SYSCTL_HW_NCPU=no]) 3851 ]) 3852 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then 3853 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.]) 3854 fi 3855 AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU) 3856 3857 CXXFLAGS="$ac_save_CXXFLAGS" 3858 AC_LANG_RESTORE 3859]) 3860 3861dnl 3862dnl Check to see if python pretty printing can be activated. 3863dnl 3864dnl --with-python-dir=dir 3865dnl installs directory into $prefix/dir 3866AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [ 3867 3868AC_MSG_CHECKING([for custom python install directory]) 3869AC_ARG_WITH([python-dir], 3870 AS_HELP_STRING([--with-python-dir], 3871 [the location to install Python modules. This path is relative starting from the prefix.]), 3872 [with_python_dir=$withval], [with_python_dir="no"]) 3873AC_MSG_RESULT(${with_python_dir}) 3874 3875# Needed for installing Python modules during make install. 3876python_mod_dir="${with_python_dir}" 3877AC_SUBST(python_mod_dir) 3878GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no) 3879]) 3880 3881dnl 3882dnl Check to see if -Werror is disabled. 3883dnl 3884dnl --enable-werror/--disable-werror 3885AC_DEFUN([GLIBCXX_ENABLE_WERROR], [ 3886 AC_MSG_CHECKING([for -Werror]) 3887 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror]) 3888 AC_MSG_RESULT($enable_werror) 3889 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes) 3890]) 3891 3892dnl 3893dnl Check whether obsolescent tmpnam is available in <stdio.h>, 3894dnl and define _GLIBCXX_USE_TMPNAM. 3895dnl 3896AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl 3897dnl 3898 AC_LANG_SAVE 3899 AC_LANG_CPLUSPLUS 3900 ac_save_CXXFLAGS="$CXXFLAGS" 3901 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3902dnl 3903 AC_MSG_CHECKING([for tmpnam]) 3904 AC_CACHE_VAL(glibcxx_cv_TMPNAM, [dnl 3905 GCC_TRY_COMPILE_OR_LINK( 3906 [#include <stdio.h>], 3907 [char *tmp = tmpnam(NULL);], 3908 [glibcxx_cv_TMPNAM=yes], 3909 [glibcxx_cv_TMPNAM=no]) 3910 ]) 3911 if test $glibcxx_cv_TMPNAM = yes; then 3912 AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.]) 3913 fi 3914 AC_MSG_RESULT($glibcxx_cv_TMPNAM) 3915dnl 3916 CXXFLAGS="$ac_save_CXXFLAGS" 3917 AC_LANG_RESTORE 3918]) 3919 3920dnl 3921dnl Check to see if sys/sdt.h exists and that it is suitable for use. 3922dnl Some versions of sdt.h were not compatible with C++11. 3923dnl 3924AC_DEFUN([GLIBCXX_CHECK_SDT_H], [ 3925 AC_MSG_CHECKING([for suitable sys/sdt.h]) 3926 # Note that this test has to be run with the C language. 3927 # Otherwise, sdt.h will try to include some headers from 3928 # libstdc++ itself. 3929 AC_LANG_SAVE 3930 AC_LANG_C 3931 AC_CACHE_VAL(glibcxx_cv_sys_sdt_h, [ 3932 # Because we have to run the test in C, we use grep rather 3933 # than the compiler to check for the bug. The bug is that 3934 # were strings without trailing whitespace, causing g++ 3935 # to look for operator"". The pattern searches for the fixed 3936 # output. 3937 AC_EGREP_CPP([ \",\" ], [ 3938 #include <sys/sdt.h> 3939 int f() { STAP_PROBE(hi, bob); } 3940 ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no]) 3941 ]) 3942 AC_LANG_RESTORE 3943 if test $glibcxx_cv_sys_sdt_h = yes; then 3944 AC_DEFINE(HAVE_SYS_SDT_H, 1, 3945 [Define to 1 if you have a suitable <sys/sdt.h> header file]) 3946 fi 3947 AC_MSG_RESULT($glibcxx_cv_sys_sdt_h) 3948]) 3949 3950dnl 3951dnl Control whether the library should define symbols for old and new ABIs. 3952dnl This affects definitions of strings, stringstreams and locale facets. 3953dnl 3954dnl --disable-libstdcxx-dual-abi will use old ABI for all types. 3955dnl 3956dnl Defines: 3957dnl _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0) 3958dnl 3959AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [ 3960 GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string]) 3961 if test x$enable_symvers = xgnu-versioned-namespace; then 3962 # gnu-versioned-namespace is incompatible with the dual ABI. 3963 enable_libstdcxx_dual_abi="no" 3964 fi 3965 if test x"$enable_libstdcxx_dual_abi" != xyes; then 3966 AC_MSG_NOTICE([dual ABI is disabled]) 3967 default_libstdcxx_abi="gcc4-compatible" 3968 fi 3969 GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes) 3970]) 3971 3972dnl 3973dnl Check to see which ABI should be enabled by default. 3974dnl 3975dnl --with-default-libstdcxx-abi={gcc4-compatible,new} 3976dnl 3977dnl Defines: 3978dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0) 3979dnl 3980AC_DEFUN([GLIBCXX_DEFAULT_ABI], [ 3981 if test x$enable_libstdcxx_dual_abi = xyes; then 3982 AC_MSG_CHECKING([for default std::string ABI to use]) 3983 AC_ARG_WITH([default-libstdcxx-abi], 3984 AS_HELP_STRING([--with-default-libstdcxx-abi], 3985 [set the std::string ABI to use by default]), 3986 [case "$withval" in 3987 gcc4-compatible) default_libstdcxx_abi="gcc4-compatible" ;; 3988 new|cxx11) default_libstdcxx_abi="new" ;; 3989 c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;; 3990 *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;; 3991 esac 3992 ], 3993 [default_libstdcxx_abi="new"]) 3994 AC_MSG_RESULT(${default_libstdcxx_abi}) 3995 fi 3996 if test $default_libstdcxx_abi = "new"; then 3997 glibcxx_cxx11_abi=1 3998 glibcxx_cxx98_abi=0 3999 else 4000 glibcxx_cxx11_abi=0 4001 glibcxx_cxx98_abi=1 4002 fi 4003 AC_SUBST(glibcxx_cxx98_abi) 4004 GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1) 4005]) 4006 4007dnl 4008dnl Check to see whether to build libstdc++fs.a 4009dnl 4010dnl --enable-libstdcxx-filesystem-ts 4011dnl 4012AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [ 4013 GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,, 4014 [turns on ISO/IEC TS 18822 support], 4015 [permit yes|no|auto]) 4016 4017 AC_MSG_CHECKING([whether to build Filesystem TS support]) 4018 if test x"$ac_cv_header_dirent_h" != x"yes"; then 4019 enable_libstdcxx_filesystem_ts=no 4020 fi 4021 if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then 4022 case "${target_os}" in 4023 freebsd*|netbsd*|openbsd*|dragonfly*|darwin*) 4024 enable_libstdcxx_filesystem_ts=yes 4025 ;; 4026 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu) 4027 enable_libstdcxx_filesystem_ts=yes 4028 ;; 4029 solaris*) 4030 enable_libstdcxx_filesystem_ts=yes 4031 ;; 4032 *) 4033 enable_libstdcxx_filesystem_ts=no 4034 ;; 4035 esac 4036 fi 4037 AC_MSG_RESULT($enable_libstdcxx_filesystem_ts) 4038 GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes) 4039]) 4040 4041dnl 4042dnl Check whether the library calls required by the Filesystem TS are present 4043dnl and define _GLIBCXX_USE_REALPATH and _GLIBCXX_USE_UTIMENSAT. 4044dnl 4045AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl 4046dnl 4047 AC_LANG_SAVE 4048 AC_LANG_CPLUSPLUS 4049 ac_save_CXXFLAGS="$CXXFLAGS" 4050 CXXFLAGS="$CXXFLAGS -fno-exceptions" 4051dnl 4052 AC_MSG_CHECKING([for struct dirent.d_type]) 4053 AC_CACHE_VAL(glibcxx_cv_dirent_d_type, [dnl 4054 GCC_TRY_COMPILE_OR_LINK( 4055 [#include <dirent.h>], 4056 [ 4057 struct dirent d; 4058 if (sizeof d.d_type) return 0; 4059 ], 4060 [glibcxx_cv_dirent_d_type=yes], 4061 [glibcxx_cv_dirent_d_type=no]) 4062 ]) 4063 if test $glibcxx_cv_dirent_d_type = yes; then 4064 AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.]) 4065 fi 4066 AC_MSG_RESULT($glibcxx_cv_dirent_d_type) 4067dnl 4068 AC_MSG_CHECKING([for realpath]) 4069 AC_CACHE_VAL(glibcxx_cv_realpath, [dnl 4070 GCC_TRY_COMPILE_OR_LINK( 4071 [ 4072 #include <limits.h> 4073 #include <stdlib.h> 4074 #include <unistd.h> 4075 ], 4076 [ 4077 #if _XOPEN_VERSION < 500 4078 #error 4079 #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX) 4080 char *tmp = realpath((const char*)NULL, (char*)NULL); 4081 #else 4082 #error 4083 #endif 4084 ], 4085 [glibcxx_cv_realpath=yes], 4086 [glibcxx_cv_realpath=no]) 4087 ]) 4088 if test $glibcxx_cv_realpath = yes; then 4089 AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.]) 4090 fi 4091 AC_MSG_RESULT($glibcxx_cv_realpath) 4092dnl 4093 AC_MSG_CHECKING([for utimensat]) 4094 AC_CACHE_VAL(glibcxx_cv_utimensat, [dnl 4095 GCC_TRY_COMPILE_OR_LINK( 4096 [ 4097 #include <fcntl.h> 4098 #include <sys/stat.h> 4099 ], 4100 [ 4101 struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } }; 4102 int i = utimensat(AT_FDCWD, "path", ts, 0); 4103 ], 4104 [glibcxx_cv_utimensat=yes], 4105 [glibcxx_cv_utimensat=no]) 4106 ]) 4107 if test $glibcxx_cv_utimensat = yes; then 4108 AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.]) 4109 fi 4110 AC_MSG_RESULT($glibcxx_cv_utimensat) 4111dnl 4112 AC_MSG_CHECKING([for struct stat.st_mtim.tv_nsec]) 4113 AC_CACHE_VAL(glibcxx_cv_st_mtim, [dnl 4114 GCC_TRY_COMPILE_OR_LINK( 4115 [ #include <sys/stat.h> ], 4116 [ 4117 struct stat st; 4118 return st.st_mtim.tv_nsec; 4119 ], 4120 [glibcxx_cv_st_mtim=yes], 4121 [glibcxx_cv_st_mtim=no]) 4122 ]) 4123 if test $glibcxx_cv_st_mtim = yes; then 4124 AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.]) 4125 fi 4126 AC_MSG_RESULT($glibcxx_cv_st_mtim) 4127dnl 4128 AC_MSG_CHECKING([for fchmod]) 4129 AC_CACHE_VAL(glibcxx_cv_fchmod, [dnl 4130 GCC_TRY_COMPILE_OR_LINK( 4131 [#include <sys/stat.h>], 4132 [fchmod(1, S_IWUSR);], 4133 [glibcxx_cv_fchmod=yes], 4134 [glibcxx_cv_fchmod=no]) 4135 ]) 4136 if test $glibcxx_cv_fchmod = yes; then 4137 AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.]) 4138 fi 4139 AC_MSG_RESULT($glibcxx_cv_fchmod) 4140dnl 4141 AC_MSG_CHECKING([for fchmodat]) 4142 AC_CACHE_VAL(glibcxx_cv_fchmodat, [dnl 4143 GCC_TRY_COMPILE_OR_LINK( 4144 [ 4145 #include <fcntl.h> 4146 #include <sys/stat.h> 4147 ], 4148 [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);], 4149 [glibcxx_cv_fchmodat=yes], 4150 [glibcxx_cv_fchmodat=no]) 4151 ]) 4152 if test $glibcxx_cv_fchmodat = yes; then 4153 AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.]) 4154 fi 4155 AC_MSG_RESULT($glibcxx_cv_fchmodat) 4156dnl 4157 AC_MSG_CHECKING([for sendfile that can copy files]) 4158 AC_CACHE_VAL(glibcxx_cv_sendfile, [dnl 4159 case "${target_os}" in 4160 gnu* | linux* | solaris*) 4161 GCC_TRY_COMPILE_OR_LINK( 4162 [#include <sys/sendfile.h>], 4163 [sendfile(1, 2, (off_t*)0, sizeof 1);], 4164 [glibcxx_cv_sendfile=yes], 4165 [glibcxx_cv_sendfile=no]) 4166 ;; 4167 *) 4168 glibcxx_cv_sendfile=no 4169 ;; 4170 esac 4171 ]) 4172 if test $glibcxx_cv_sendfile = yes; then 4173 AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.]) 4174 fi 4175 AC_MSG_RESULT($glibcxx_cv_sendfile) 4176dnl 4177 CXXFLAGS="$ac_save_CXXFLAGS" 4178 AC_LANG_RESTORE 4179]) 4180 4181# Macros from the top-level gcc directory. 4182m4_include([../config/gc++filt.m4]) 4183m4_include([../config/tls.m4]) 4184m4_include([../config/gthr.m4]) 4185