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 po testsuite 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 are present in <math.h>. 1901dnl 1902AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [ 1903 1904 AC_LANG_SAVE 1905 AC_LANG_CPLUSPLUS 1906 ac_save_CXXFLAGS="$CXXFLAGS" 1907 CXXFLAGS="$CXXFLAGS -std=c++11" 1908 1909 case "$host" in 1910 *-*-solaris2.*) 1911 # Solaris 12 introduced the C++11 <math.h> overloads. A backport to 1912 # a Solaris 11.3 SRU is likely, maybe even a Solaris 10 patch. 1913 AC_MSG_CHECKING([for C++11 <math.h> overloads]) 1914 AC_CACHE_VAL(glibcxx_cv_math11_overload, [ 1915 AC_COMPILE_IFELSE([AC_LANG_SOURCE( 1916 [#include <math.h> 1917 #undef isfinite 1918 namespace std { 1919 inline bool isfinite(float __x) 1920 { return __builtin_isfinite(__x); } 1921 } 1922 ])], 1923 [glibcxx_cv_math11_overload=no], 1924 [glibcxx_cv_math11_overload=yes] 1925 )]) 1926 1927 # autoheader cannot handle indented templates. 1928 AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO], 1929 [/* Define if all C++11 overloads are available in <math.h>. */ 1930#if __cplusplus >= 201103L 1931#undef __CORRECT_ISO_CPP11_MATH_H_PROTO 1932#endif]) 1933 1934 if test $glibcxx_cv_math11_overload = yes; then 1935 AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO) 1936 fi 1937 AC_MSG_RESULT([$glibcxx_cv_math11_overload]) 1938 ;; 1939 esac 1940 1941 CXXFLAGS="$ac_save_CXXFLAGS" 1942 AC_LANG_RESTORE 1943]) 1944 1945dnl 1946dnl Check whether macros, etc are present for <system_error> 1947dnl 1948AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [ 1949 1950m4_pushdef([n_syserr], [1])dnl 1951m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA, 1952 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED, 1953 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY, 1954 ECHILD, ENOSPC, EPERM, 1955 ETIMEDOUT, EWOULDBLOCK], 1956[m4_pushdef([SYSERR], m4_toupper(syserr))dnl 1957AC_MSG_CHECKING([for syserr]) 1958AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [ 1959AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]], 1960 [int i = syserr;])], 1961 [glibcxx_cv_system_error[]n_syserr=yes], 1962 [glibcxx_cv_system_error[]n_syserr=no]) 1963]) 1964AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr]) 1965if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then 1966 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.]) 1967fi 1968m4_define([n_syserr], m4_incr(n_syserr))dnl 1969m4_popdef([SYSERR])dnl 1970]) 1971m4_popdef([n_syserr])dnl 1972]) 1973 1974dnl 1975dnl Check for what type of C headers to use. 1976dnl 1977dnl --enable-cheaders= [does stuff]. 1978dnl --disable-cheaders [does not do anything, really]. 1979dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)] 1980dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'. 1981dnl 1982AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [ 1983 GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]], 1984 [construct "C" headers for g++], [permit c|c_std|c_global]) 1985 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders) 1986 1987 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders 1988 1989 # Allow overrides to configure.host here. 1990 if test $enable_cheaders = c_global; then 1991 c_compatibility=yes 1992 fi 1993 1994 AC_SUBST(C_INCLUDE_DIR) 1995 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c) 1996 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std) 1997 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global) 1998 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes) 1999]) 2000 2001 2002dnl 2003dnl Check for which locale library to use. The choice is mapped to 2004dnl a subdirectory of config/locale. 2005dnl 2006dnl Default is generic. 2007dnl 2008AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ 2009 GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]], 2010 [use MODEL for target locale package], 2011 [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto]) 2012 2013 # Deal with gettext issues. Default to not using it (=no) until we detect 2014 # support for it later. Let the user turn it off via --e/d, but let that 2015 # default to on for easier handling. 2016 USE_NLS=no 2017 AC_ARG_ENABLE(nls, 2018 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]), 2019 [], 2020 [enable_nls=yes]) 2021 2022 # Either a known package, or "auto" 2023 if test $enable_clocale = no || test $enable_clocale = yes; then 2024 enable_clocale=auto 2025 fi 2026 enable_clocale_flag=$enable_clocale 2027 2028 # Probe for locale model to use if none specified. 2029 # Default to "generic". 2030 if test $enable_clocale_flag = auto; then 2031 case ${target_os} in 2032 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) 2033 enable_clocale_flag=gnu 2034 ;; 2035 darwin* | freebsd*) 2036 enable_clocale_flag=darwin 2037 ;; 2038 dragonfly*) 2039 enable_clocale_flag=dragonfly 2040 ;; 2041 openbsd*) 2042 enable_clocale_flag=newlib 2043 ;; 2044 *) 2045 if test x"$with_newlib" = x"yes"; then 2046 enable_clocale_flag=newlib 2047 else 2048 enable_clocale_flag=generic 2049 fi 2050 ;; 2051 esac 2052 fi 2053 2054 # Sanity check model, and test for special functionality. 2055 if test $enable_clocale_flag = gnu; then 2056 AC_EGREP_CPP([_GLIBCXX_ok], [ 2057 #include <features.h> 2058 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__) 2059 _GLIBCXX_ok 2060 #endif 2061 ], enable_clocale_flag=gnu, enable_clocale_flag=generic) 2062 2063 # Set it to scream when it hurts. 2064 ac_save_CFLAGS="$CFLAGS" 2065 CFLAGS="-Wimplicit-function-declaration -Werror" 2066 2067 # Use strxfrm_l if available. 2068 AC_TRY_COMPILE([#define _GNU_SOURCE 1 2069 #include <string.h> 2070 #include <locale.h>], 2071 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);], 2072 AC_DEFINE(HAVE_STRXFRM_L, 1, 2073 [Define if strxfrm_l is available in <string.h>.]),) 2074 2075 # Use strerror_l if available. 2076 AC_TRY_COMPILE([#define _GNU_SOURCE 1 2077 #include <string.h> 2078 #include <locale.h>], 2079 [__locale_t loc; strerror_l(5, loc);], 2080 AC_DEFINE(HAVE_STRERROR_L, 1, 2081 [Define if strerror_l is available in <string.h>.]),) 2082 2083 CFLAGS="$ac_save_CFLAGS" 2084 fi 2085 2086 # Perhaps use strerror_r if available, and strerror_l isn't. 2087 ac_save_CFLAGS="$CFLAGS" 2088 CFLAGS="-Wimplicit-function-declaration -Werror" 2089 AC_TRY_COMPILE([#define _GNU_SOURCE 1 2090 #include <string.h> 2091 #include <locale.h>], 2092 [char s[128]; strerror_r(5, s, 128);], 2093 AC_DEFINE(HAVE_STRERROR_R, 1, 2094 [Define if strerror_r is available in <string.h>.]),) 2095 CFLAGS="$ac_save_CFLAGS" 2096 2097 # Set configure bits for specified locale package 2098 AC_MSG_CHECKING([for C locale to use]) 2099 case ${enable_clocale_flag} in 2100 generic) 2101 AC_MSG_RESULT(generic) 2102 2103 CLOCALE_H=config/locale/generic/c_locale.h 2104 CLOCALE_CC=config/locale/generic/c_locale.cc 2105 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2106 CCOLLATE_CC=config/locale/generic/collate_members.cc 2107 CCTYPE_CC=config/locale/generic/ctype_members.cc 2108 CMESSAGES_H=config/locale/generic/messages_members.h 2109 CMESSAGES_CC=config/locale/generic/messages_members.cc 2110 CMONEY_CC=config/locale/generic/monetary_members.cc 2111 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2112 CTIME_H=config/locale/generic/time_members.h 2113 CTIME_CC=config/locale/generic/time_members.cc 2114 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2115 ;; 2116 darwin) 2117 AC_MSG_RESULT(darwin or freebsd) 2118 2119 CLOCALE_H=config/locale/generic/c_locale.h 2120 CLOCALE_CC=config/locale/generic/c_locale.cc 2121 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2122 CCOLLATE_CC=config/locale/generic/collate_members.cc 2123 CCTYPE_CC=config/locale/darwin/ctype_members.cc 2124 CMESSAGES_H=config/locale/generic/messages_members.h 2125 CMESSAGES_CC=config/locale/generic/messages_members.cc 2126 CMONEY_CC=config/locale/generic/monetary_members.cc 2127 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2128 CTIME_H=config/locale/generic/time_members.h 2129 CTIME_CC=config/locale/generic/time_members.cc 2130 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2131 ;; 2132 2133 dragonfly) 2134 AC_MSG_RESULT(dragonfly) 2135 2136 CLOCALE_H=config/locale/generic/c_locale.h 2137 CLOCALE_CC=config/locale/dragonfly/c_locale.cc 2138 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2139 CCOLLATE_CC=config/locale/generic/collate_members.cc 2140 CCTYPE_CC=config/locale/dragonfly/ctype_members.cc 2141 CMESSAGES_H=config/locale/generic/messages_members.h 2142 CMESSAGES_CC=config/locale/generic/messages_members.cc 2143 CMONEY_CC=config/locale/generic/monetary_members.cc 2144 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2145 CTIME_H=config/locale/generic/time_members.h 2146 CTIME_CC=config/locale/generic/time_members.cc 2147 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2148 ;; 2149 2150 gnu) 2151 AC_MSG_RESULT(gnu) 2152 2153 # Declare intention to use gettext, and add support for specific 2154 # languages. 2155 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT 2156 ALL_LINGUAS="de fr" 2157 2158 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc. 2159 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no) 2160 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then 2161 USE_NLS=yes 2162 fi 2163 # Export the build objects. 2164 for ling in $ALL_LINGUAS; do \ 2165 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \ 2166 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \ 2167 done 2168 AC_SUBST(glibcxx_MOFILES) 2169 AC_SUBST(glibcxx_POFILES) 2170 2171 CLOCALE_H=config/locale/gnu/c_locale.h 2172 CLOCALE_CC=config/locale/gnu/c_locale.cc 2173 CCODECVT_CC=config/locale/gnu/codecvt_members.cc 2174 CCOLLATE_CC=config/locale/gnu/collate_members.cc 2175 CCTYPE_CC=config/locale/gnu/ctype_members.cc 2176 CMESSAGES_H=config/locale/gnu/messages_members.h 2177 CMESSAGES_CC=config/locale/gnu/messages_members.cc 2178 CMONEY_CC=config/locale/gnu/monetary_members.cc 2179 CNUMERIC_CC=config/locale/gnu/numeric_members.cc 2180 CTIME_H=config/locale/gnu/time_members.h 2181 CTIME_CC=config/locale/gnu/time_members.cc 2182 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h 2183 ;; 2184 ieee_1003.1-2001) 2185 AC_MSG_RESULT(IEEE 1003.1) 2186 2187 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h 2188 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc 2189 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2190 CCOLLATE_CC=config/locale/generic/collate_members.cc 2191 CCTYPE_CC=config/locale/generic/ctype_members.cc 2192 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h 2193 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc 2194 CMONEY_CC=config/locale/generic/monetary_members.cc 2195 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2196 CTIME_H=config/locale/generic/time_members.h 2197 CTIME_CC=config/locale/generic/time_members.cc 2198 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2199 ;; 2200 newlib) 2201 AC_MSG_RESULT(newlib) 2202 2203 CLOCALE_H=config/locale/generic/c_locale.h 2204 CLOCALE_CC=config/locale/generic/c_locale.cc 2205 CCODECVT_CC=config/locale/generic/codecvt_members.cc 2206 CCOLLATE_CC=config/locale/generic/collate_members.cc 2207 CCTYPE_CC=config/locale/newlib/ctype_members.cc 2208 CMESSAGES_H=config/locale/generic/messages_members.h 2209 CMESSAGES_CC=config/locale/generic/messages_members.cc 2210 CMONEY_CC=config/locale/generic/monetary_members.cc 2211 CNUMERIC_CC=config/locale/generic/numeric_members.cc 2212 CTIME_H=config/locale/generic/time_members.h 2213 CTIME_CC=config/locale/generic/time_members.cc 2214 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 2215 ;; 2216 esac 2217 2218 # This is where the testsuite looks for locale catalogs, using the 2219 # -DLOCALEDIR define during testsuite compilation. 2220 glibcxx_localedir=${glibcxx_builddir}/po/share/locale 2221 AC_SUBST(glibcxx_localedir) 2222 2223 # A standalone libintl (e.g., GNU libintl) may be in use. 2224 if test $USE_NLS = yes; then 2225 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no) 2226 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no) 2227 fi 2228 if test $USE_NLS = yes; then 2229 AC_DEFINE(_GLIBCXX_USE_NLS, 1, 2230 [Define if NLS translations are to be used.]) 2231 fi 2232 2233 AC_SUBST(USE_NLS) 2234 AC_SUBST(CLOCALE_H) 2235 AC_SUBST(CMESSAGES_H) 2236 AC_SUBST(CCODECVT_CC) 2237 AC_SUBST(CCOLLATE_CC) 2238 AC_SUBST(CCTYPE_CC) 2239 AC_SUBST(CMESSAGES_CC) 2240 AC_SUBST(CMONEY_CC) 2241 AC_SUBST(CNUMERIC_CC) 2242 AC_SUBST(CTIME_H) 2243 AC_SUBST(CTIME_CC) 2244 AC_SUBST(CLOCALE_CC) 2245 AC_SUBST(CLOCALE_INTERNAL_H) 2246]) 2247 2248 2249dnl 2250dnl Check for which std::allocator base class to use. The choice is 2251dnl mapped from a subdirectory of include/ext. 2252dnl 2253dnl Default is new. 2254dnl 2255AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [ 2256 AC_MSG_CHECKING([for std::allocator base class]) 2257 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]], 2258 [use KIND for target std::allocator base], 2259 [permit new|malloc|mt|bitmap|pool|yes|no|auto]) 2260 2261 # If they didn't use this option switch, or if they specified --enable 2262 # with no specific model, we'll have to look for one. If they 2263 # specified --disable (???), do likewise. 2264 if test $enable_libstdcxx_allocator = no || 2265 test $enable_libstdcxx_allocator = yes; 2266 then 2267 enable_libstdcxx_allocator=auto 2268 fi 2269 2270 # Either a known package, or "auto". Auto implies the default choice 2271 # for a particular platform. 2272 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator 2273 2274 # Probe for host-specific support if no specific model is specified. 2275 # Default to "new". 2276 if test $enable_libstdcxx_allocator_flag = auto; then 2277 case ${target_os} in 2278 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) 2279 enable_libstdcxx_allocator_flag=new 2280 ;; 2281 *) 2282 enable_libstdcxx_allocator_flag=new 2283 ;; 2284 esac 2285 fi 2286 AC_MSG_RESULT($enable_libstdcxx_allocator_flag) 2287 2288 2289 # Set configure bits for specified locale package 2290 case ${enable_libstdcxx_allocator_flag} in 2291 bitmap) 2292 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h 2293 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator 2294 ;; 2295 malloc) 2296 ALLOCATOR_H=config/allocator/malloc_allocator_base.h 2297 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator 2298 ;; 2299 mt) 2300 ALLOCATOR_H=config/allocator/mt_allocator_base.h 2301 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc 2302 ;; 2303 new) 2304 ALLOCATOR_H=config/allocator/new_allocator_base.h 2305 ALLOCATOR_NAME=__gnu_cxx::new_allocator 2306 ;; 2307 pool) 2308 ALLOCATOR_H=config/allocator/pool_allocator_base.h 2309 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc 2310 ;; 2311 esac 2312 2313 AC_SUBST(ALLOCATOR_H) 2314 AC_SUBST(ALLOCATOR_NAME) 2315]) 2316 2317 2318dnl 2319dnl Check for whether the Boost-derived checks should be turned on. 2320dnl 2321dnl --enable-concept-checks turns them on. 2322dnl --disable-concept-checks leaves them off. 2323dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)] 2324dnl Where DEFAULT is either `yes' or `no'. 2325dnl 2326AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [ 2327 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks]) 2328 if test $enable_concept_checks = yes; then 2329 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1, 2330 [Define to use concept checking code from the boost libraries.]) 2331 fi 2332]) 2333 2334dnl 2335dnl Use extern templates. 2336dnl 2337dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1 2338dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0 2339 2340dnl + Usage: GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)] 2341dnl Where DEFAULT is `yes' or `no'. 2342dnl 2343AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [ 2344 2345 GLIBCXX_ENABLE(extern-template,$1,,[enable extern template]) 2346 2347 AC_MSG_CHECKING([for extern template support]) 2348 AC_MSG_RESULT([$enable_extern_template]) 2349 2350 GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes) 2351]) 2352 2353dnl 2354dnl Use vtable verification. 2355dnl 2356dnl --enable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 1 2357dnl --disable-vtable-verify defines _GLIBCXX_VTABLE_VERIFY to 0 2358 2359dnl + Usage: GLIBCXX_ENABLE_VTABLE_VERIFY[(DEFAULT)] 2360dnl Where DEFAULT is `yes' or `no'. 2361dnl 2362AC_DEFUN([GLIBCXX_ENABLE_VTABLE_VERIFY], [ 2363 2364 GLIBCXX_ENABLE(vtable-verify,$1,,[enable vtable verify]) 2365 2366 AC_MSG_CHECKING([for vtable verify support]) 2367 AC_MSG_RESULT([$enable_vtable_verify]) 2368 2369 vtv_cygmin=no 2370 if test $enable_vtable_verify = yes; then 2371 case ${target_os} in 2372 cygwin*|mingw32*) 2373 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-lvtv,-u_vtable_map_vars_start,-u_vtable_map_vars_end" 2374 vtv_cygmin=yes 2375 ;; 2376 *) 2377 VTV_CXXFLAGS="-fvtable-verify=std -Wl,-u_vtable_map_vars_start,-u_vtable_map_vars_end" 2378 ;; 2379 esac 2380 VTV_PCH_CXXFLAGS="-fvtable-verify=std" 2381 VTV_CXXLINKFLAGS="-L${toplevel_builddir}/libvtv/.libs -Wl,--rpath -Wl,${toplevel_builddir}/libvtv/.libs" 2382 else 2383 VTV_CXXFLAGS= 2384 VTV_PCH_CXXFLAGS= 2385 VTV_CXXLINKFLAGS= 2386 fi 2387 2388 AC_SUBST(VTV_CXXFLAGS) 2389 AC_SUBST(VTV_PCH_CXXFLAGS) 2390 AC_SUBST(VTV_CXXLINKFLAGS) 2391 AM_CONDITIONAL(VTV_CYGMIN, test x$vtv_cygmin = xyes) 2392 GLIBCXX_CONDITIONAL(ENABLE_VTABLE_VERIFY, test $enable_vtable_verify = yes) 2393]) 2394 2395dnl 2396dnl Check for parallel mode pre-requisites, including OpenMP support. 2397dnl 2398dnl + Usage: GLIBCXX_ENABLE_PARALLEL 2399dnl 2400AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [ 2401 2402 enable_parallel=no; 2403 2404 # See if configured libgomp/omp.h exists. (libgomp may be in 2405 # noconfigdirs but not explicitly disabled.) 2406 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then 2407 enable_parallel=yes; 2408 else 2409 AC_MSG_NOTICE([target-libgomp not built]) 2410 fi 2411 2412 AC_MSG_CHECKING([for parallel mode support]) 2413 AC_MSG_RESULT([$enable_parallel]) 2414]) 2415 2416 2417dnl 2418dnl Check for which I/O library to use: stdio, or something specific. 2419dnl 2420dnl Default is stdio. 2421dnl 2422AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [ 2423 AC_MSG_CHECKING([for underlying I/O to use]) 2424 GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]], 2425 [use target-specific I/O package], [permit stdio]) 2426 2427 # Now that libio has been removed, you can have any color you want as long 2428 # as it's black. This is one big no-op until other packages are added, but 2429 # showing the framework never hurts. 2430 case ${enable_cstdio} in 2431 stdio) 2432 CSTDIO_H=config/io/c_io_stdio.h 2433 BASIC_FILE_H=config/io/basic_file_stdio.h 2434 BASIC_FILE_CC=config/io/basic_file_stdio.cc 2435 AC_MSG_RESULT(stdio) 2436 ;; 2437 esac 2438 2439 AC_SUBST(CSTDIO_H) 2440 AC_SUBST(BASIC_FILE_H) 2441 AC_SUBST(BASIC_FILE_CC) 2442]) 2443 2444 2445dnl 2446dnl Check for "unusual" flags to pass to the compiler while building. 2447dnl 2448dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing 2449dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc. 2450dnl --disable-cxx-flags passes nothing. 2451dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html 2452dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html 2453dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html 2454dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags) 2455dnl If "default flags" is an empty string, the effect is the same 2456dnl as --disable or --enable=no. 2457dnl 2458AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl 2459 AC_MSG_CHECKING([for extra compiler flags for building]) 2460 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS], 2461 [pass compiler FLAGS when building library], 2462 [case "x$enable_cxx_flags" in 2463 xno | x) enable_cxx_flags= ;; 2464 x-*) ;; 2465 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;; 2466 esac]) 2467 2468 # Run through flags (either default or command-line) and set anything 2469 # extra (e.g., #defines) that must accompany particular g++ options. 2470 if test -n "$enable_cxx_flags"; then 2471 for f in $enable_cxx_flags; do 2472 case "$f" in 2473 -fhonor-std) ;; 2474 -*) ;; 2475 *) # and we're trying to pass /what/ exactly? 2476 AC_MSG_ERROR([compiler flags start with a -]) ;; 2477 esac 2478 done 2479 fi 2480 2481 EXTRA_CXX_FLAGS="$enable_cxx_flags" 2482 AC_MSG_RESULT($EXTRA_CXX_FLAGS) 2483 AC_SUBST(EXTRA_CXX_FLAGS) 2484]) 2485 2486 2487dnl 2488dnl Check to see if debugging libraries are to be built. 2489dnl 2490dnl --enable-libstdcxx-debug 2491dnl builds a separate set of debugging libraries in addition to the 2492dnl normal (shared, static) libstdc++ binaries. 2493dnl 2494dnl --disable-libstdcxx-debug 2495dnl builds only one (non-debug) version of libstdc++. 2496dnl 2497dnl --enable-libstdcxx-debug-flags=FLAGS 2498dnl iff --enable-debug == yes, then use FLAGS to build the debug library. 2499dnl 2500dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)] 2501dnl Where DEFAULT is either `yes' or `no'. 2502dnl 2503AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [ 2504 AC_MSG_CHECKING([for additional debug build]) 2505 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library]) 2506 AC_MSG_RESULT($enable_libstdcxx_debug) 2507 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes) 2508]) 2509 2510 2511dnl 2512dnl Check for explicit debug flags. 2513dnl 2514dnl --enable-libstdcxx-debug-flags='-O1' 2515dnl is a general method for passing flags to be used when 2516dnl building debug libraries with --enable-debug. 2517dnl 2518dnl --disable-libstdcxx-debug-flags does nothing. 2519dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags) 2520dnl If "default flags" is an empty string, the effect is the same 2521dnl as --disable or --enable=no. 2522dnl 2523AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [ 2524 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS], 2525 [pass compiler FLAGS when building debug library], 2526 [case "x$enable_libstdcxx_debug_flags" in 2527 xno | x) enable_libstdcxx_debug_flags= ;; 2528 x-*) ;; 2529 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;; 2530 esac]) 2531 2532 # Option parsed, now set things appropriately 2533 DEBUG_FLAGS="$enable_libstdcxx_debug_flags" 2534 AC_SUBST(DEBUG_FLAGS) 2535 2536 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS]) 2537]) 2538 2539 2540dnl 2541dnl Check if the user only wants a freestanding library implementation. 2542dnl 2543dnl --disable-hosted-libstdcxx will turn off most of the library build, 2544dnl installing only the headers required by [17.4.1.3] and the language 2545dnl support library. More than that will be built (to keep the Makefiles 2546dnl conveniently clean), but not installed. 2547dnl 2548dnl Sets: 2549dnl is_hosted (yes/no) 2550dnl 2551dnl Defines: 2552dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0) 2553dnl 2554AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [ 2555 AC_ARG_ENABLE([hosted-libstdcxx], 2556 AC_HELP_STRING([--disable-hosted-libstdcxx], 2557 [only build freestanding C++ runtime support]),, 2558 [case "$host" in 2559 arm*-*-symbianelf*) 2560 enable_hosted_libstdcxx=no 2561 ;; 2562 *) 2563 enable_hosted_libstdcxx=yes 2564 ;; 2565 esac]) 2566 if test "$enable_hosted_libstdcxx" = no; then 2567 AC_MSG_NOTICE([Only freestanding libraries will be built]) 2568 is_hosted=no 2569 hosted_define=0 2570 enable_abi_check=no 2571 enable_libstdcxx_pch=no 2572 else 2573 is_hosted=yes 2574 hosted_define=1 2575 fi 2576 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes) 2577 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define, 2578 [Define to 1 if a full hosted library is built, or 0 if freestanding.]) 2579]) 2580 2581 2582dnl 2583dnl Check if the user wants a non-verbose library implementation. 2584dnl 2585dnl --disable-libstdcxx-verbose will turn off descriptive messages to 2586dnl standard error on termination. 2587dnl 2588dnl Defines: 2589dnl _GLIBCXX_VERBOSE (always defined, either to 1 or 0) 2590dnl 2591AC_DEFUN([GLIBCXX_ENABLE_VERBOSE], [ 2592 AC_ARG_ENABLE([libstdcxx-verbose], 2593 AC_HELP_STRING([--disable-libstdcxx-verbose], 2594 [disable termination messages to standard error]),, 2595 [enable_libstdcxx_verbose=yes]) 2596 if test x"$enable_libstdcxx_verbose" = xyes; then 2597 verbose_define=1 2598 else 2599 AC_MSG_NOTICE([verbose termination messages are disabled]) 2600 verbose_define=0 2601 fi 2602 AC_DEFINE_UNQUOTED(_GLIBCXX_VERBOSE, $verbose_define, 2603 [Define to 1 if a verbose library is built, or 0 otherwise.]) 2604]) 2605 2606 2607dnl 2608dnl Check for template specializations for the 'long long' type. 2609dnl The result determines only whether 'long long' I/O is enabled; things 2610dnl like numeric_limits<> specializations are always available. 2611dnl 2612dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG 2613dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined 2614dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)] 2615dnl Where DEFAULT is either `yes' or `no'. 2616dnl 2617AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [ 2618 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long']) 2619 if test $enable_long_long = yes; then 2620 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1, 2621 [Define if code specialized for long long should be used.]) 2622 fi 2623 AC_MSG_CHECKING([for enabled long long specializations]) 2624 AC_MSG_RESULT([$enable_long_long]) 2625]) 2626 2627 2628dnl 2629dnl Check for decimal floating point. 2630dnl See: 2631dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float 2632dnl 2633dnl This checks to see if the host supports decimal floating point types. 2634dnl 2635dnl Defines: 2636dnl _GLIBCXX_USE_DECIMAL_FLOAT 2637dnl 2638AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [ 2639 2640 # Fake what AC_TRY_COMPILE does, without linking as this is 2641 # unnecessary for this test. 2642 2643 cat > conftest.$ac_ext << EOF 2644[#]line __oline__ "configure" 2645int main() 2646{ 2647 _Decimal32 d1; 2648 _Decimal64 d2; 2649 _Decimal128 d3; 2650 return 0; 2651} 2652EOF 2653 2654 AC_MSG_CHECKING([for ISO/IEC TR 24733 ]) 2655 if AC_TRY_EVAL(ac_compile); then 2656 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1, 2657 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.]) 2658 enable_dfp=yes 2659 else 2660 enable_dfp=no 2661 fi 2662 AC_MSG_RESULT($enable_dfp) 2663 rm -f conftest* 2664]) 2665 2666dnl 2667dnl Check for GNU 128-bit integer and floating point types. 2668dnl 2669dnl Note: also checks that the types aren't standard types. 2670dnl 2671dnl Defines: 2672dnl _GLIBCXX_USE_INT128 2673dnl _GLIBCXX_USE_FLOAT128 2674dnl 2675AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [ 2676 2677 AC_LANG_SAVE 2678 AC_LANG_CPLUSPLUS 2679 2680 # Fake what AC_TRY_COMPILE does, without linking as this is 2681 # unnecessary for this test. 2682 2683 cat > conftest.$ac_ext << EOF 2684[#]line __oline__ "configure" 2685template<typename T1, typename T2> 2686 struct same 2687 { typedef T2 type; }; 2688 2689template<typename T> 2690 struct same<T, T>; 2691 2692int main() 2693{ 2694 typename same<long, __int128>::type i1; 2695 typename same<long long, __int128>::type i2; 2696} 2697EOF 2698 2699 AC_MSG_CHECKING([for __int128]) 2700 if AC_TRY_EVAL(ac_compile); then 2701 AC_DEFINE(_GLIBCXX_USE_INT128, 1, 2702 [Define if __int128 is supported on this host.]) 2703 enable_int128=yes 2704 else 2705 enable_int128=no 2706 fi 2707 AC_MSG_RESULT($enable_int128) 2708 rm -f conftest* 2709 2710 cat > conftest.$ac_ext << EOF 2711[#]line __oline__ "configure" 2712template<typename T1, typename T2> 2713 struct same 2714 { typedef T2 type; }; 2715 2716template<typename T> 2717 struct same<T, T>; 2718 2719int main() 2720{ 2721 typename same<double, __float128>::type f1; 2722 typename same<long double, __float128>::type f2; 2723} 2724EOF 2725 2726 AC_MSG_CHECKING([for __float128]) 2727 if AC_TRY_EVAL(ac_compile); then 2728 AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1, 2729 [Define if __float128 is supported on this host.]) 2730 enable_float128=yes 2731 else 2732 enable_float128=no 2733 fi 2734 AC_MSG_RESULT($enable_float128) 2735 rm -f conftest* 2736 2737 AC_LANG_RESTORE 2738]) 2739 2740dnl 2741dnl Check for template specializations for the 'wchar_t' type. 2742dnl 2743dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T 2744dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined 2745dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)] 2746dnl Where DEFAULT is either `yes' or `no'. 2747dnl 2748dnl Necessary support must also be present. 2749dnl 2750AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [ 2751 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t']) 2752 2753 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos. 2754 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no) 2755 AC_MSG_CHECKING([for mbstate_t]) 2756 AC_TRY_COMPILE([#include <wchar.h>], 2757 [mbstate_t teststate;], 2758 have_mbstate_t=yes, have_mbstate_t=no) 2759 AC_MSG_RESULT($have_mbstate_t) 2760 if test x"$have_mbstate_t" = xyes; then 2761 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.]) 2762 fi 2763 2764 # Test it always, for use in GLIBCXX_ENABLE_C99, together with 2765 # ac_has_wchar_h. 2766 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no) 2767 2768 if test x"$enable_wchar_t" = x"yes"; then 2769 2770 AC_LANG_SAVE 2771 AC_LANG_CPLUSPLUS 2772 2773 if test x"$ac_has_wchar_h" = xyes && 2774 test x"$ac_has_wctype_h" = xyes; then 2775 AC_TRY_COMPILE([#include <wchar.h> 2776 #include <stddef.h> 2777 wint_t i; 2778 long l = WEOF; 2779 long j = WCHAR_MIN; 2780 long k = WCHAR_MAX; 2781 namespace test 2782 { 2783 using ::btowc; 2784 using ::fgetwc; 2785 using ::fgetws; 2786 using ::fputwc; 2787 using ::fputws; 2788 using ::fwide; 2789 using ::fwprintf; 2790 using ::fwscanf; 2791 using ::getwc; 2792 using ::getwchar; 2793 using ::mbrlen; 2794 using ::mbrtowc; 2795 using ::mbsinit; 2796 using ::mbsrtowcs; 2797 using ::putwc; 2798 using ::putwchar; 2799 using ::swprintf; 2800 using ::swscanf; 2801 using ::ungetwc; 2802 using ::vfwprintf; 2803 using ::vswprintf; 2804 using ::vwprintf; 2805 using ::wcrtomb; 2806 using ::wcscat; 2807 using ::wcschr; 2808 using ::wcscmp; 2809 using ::wcscoll; 2810 using ::wcscpy; 2811 using ::wcscspn; 2812 using ::wcsftime; 2813 using ::wcslen; 2814 using ::wcsncat; 2815 using ::wcsncmp; 2816 using ::wcsncpy; 2817 using ::wcspbrk; 2818 using ::wcsrchr; 2819 using ::wcsrtombs; 2820 using ::wcsspn; 2821 using ::wcsstr; 2822 using ::wcstod; 2823 using ::wcstok; 2824 using ::wcstol; 2825 using ::wcstoul; 2826 using ::wcsxfrm; 2827 using ::wctob; 2828 using ::wmemchr; 2829 using ::wmemcmp; 2830 using ::wmemcpy; 2831 using ::wmemmove; 2832 using ::wmemset; 2833 using ::wprintf; 2834 using ::wscanf; 2835 } 2836 ],[],[], [enable_wchar_t=no]) 2837 else 2838 enable_wchar_t=no 2839 fi 2840 2841 AC_LANG_RESTORE 2842 fi 2843 2844 if test x"$enable_wchar_t" = x"yes"; then 2845 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1, 2846 [Define if code specialized for wchar_t should be used.]) 2847 fi 2848 2849 AC_MSG_CHECKING([for enabled wchar_t specializations]) 2850 AC_MSG_RESULT([$enable_wchar_t]) 2851]) 2852 2853 2854dnl 2855dnl Check to see if building and using a C++ precompiled header can be done. 2856dnl 2857dnl --enable-libstdcxx-pch=yes 2858dnl default, this shows intent to use stdc++.h.gch If it looks like it 2859dnl may work, after some light-hearted attempts to puzzle out compiler 2860dnl support, flip bits on in include/Makefile.am 2861dnl 2862dnl --disable-libstdcxx-pch 2863dnl turns off attempts to use or build stdc++.h.gch. 2864dnl 2865dnl Substs: 2866dnl glibcxx_PCHFLAGS 2867dnl 2868AC_DEFUN([GLIBCXX_ENABLE_PCH], [ 2869 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers]) 2870 if test $enable_libstdcxx_pch = yes; then 2871 AC_CACHE_CHECK([for compiler with PCH support], 2872 [glibcxx_cv_prog_CXX_pch], 2873 [ac_save_CXXFLAGS="$CXXFLAGS" 2874 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated" 2875 AC_LANG_SAVE 2876 AC_LANG_CPLUSPLUS 2877 echo '#include <math.h>' > conftest.h 2878 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \ 2879 -o conftest.h.gch 1>&5 2>&1 && 2880 echo '#error "pch failed"' > conftest.h && 2881 echo '#include "conftest.h"' > conftest.cc && 2882 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ; 2883 then 2884 glibcxx_cv_prog_CXX_pch=yes 2885 else 2886 glibcxx_cv_prog_CXX_pch=no 2887 fi 2888 rm -f conftest* 2889 CXXFLAGS=$ac_save_CXXFLAGS 2890 AC_LANG_RESTORE 2891 ]) 2892 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch 2893 fi 2894 2895 AC_MSG_CHECKING([for enabled PCH]) 2896 AC_MSG_RESULT([$enable_libstdcxx_pch]) 2897 2898 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes) 2899 if test $enable_libstdcxx_pch = yes; then 2900 glibcxx_PCHFLAGS="-include bits/stdc++.h" 2901 else 2902 glibcxx_PCHFLAGS="" 2903 fi 2904 AC_SUBST(glibcxx_PCHFLAGS) 2905]) 2906 2907 2908dnl 2909dnl Check for atomic builtins. 2910dnl See: 2911dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html 2912dnl 2913dnl This checks to see if the host supports the compiler-generated 2914dnl builtins for atomic operations for various integral sizes. Note, this 2915dnl is intended to be an all-or-nothing switch, so all the atomic operations 2916dnl that are used should be checked. 2917dnl 2918dnl Note: 2919dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD. 2920dnl 2921AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [ 2922 AC_LANG_SAVE 2923 AC_LANG_CPLUSPLUS 2924 old_CXXFLAGS="$CXXFLAGS" 2925 2926 # Do link tests if possible, instead asm tests, limited to some platforms 2927 # see discussion in PR target/40134, PR libstdc++/40133 and the thread 2928 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html 2929 atomic_builtins_link_tests=no 2930 if test x$gcc_no_link != xyes; then 2931 # Can do link tests. Limit to some tested platforms 2932 case "$host" in 2933 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*) 2934 atomic_builtins_link_tests=yes 2935 ;; 2936 esac 2937 fi 2938 2939 if test x$atomic_builtins_link_tests = xyes; then 2940 2941 # Do link tests. 2942 2943 CXXFLAGS="$CXXFLAGS -fno-exceptions" 2944 2945 AC_MSG_CHECKING([for atomic builtins for bool]) 2946 AC_CACHE_VAL(glibcxx_cv_atomic_bool, [ 2947 AC_TRY_LINK( 2948 [ ], 2949 [typedef bool atomic_type; 2950 atomic_type c1; 2951 atomic_type c2; 2952 atomic_type c3(0); 2953 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 2954 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 2955 __ATOMIC_RELAXED); 2956 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 2957 __atomic_load_n(&c1, __ATOMIC_RELAXED); 2958 ], 2959 [glibcxx_cv_atomic_bool=yes], 2960 [glibcxx_cv_atomic_bool=no]) 2961 ]) 2962 AC_MSG_RESULT($glibcxx_cv_atomic_bool) 2963 2964 AC_MSG_CHECKING([for atomic builtins for short]) 2965 AC_CACHE_VAL(glibcxx_cv_atomic_short, [ 2966 AC_TRY_LINK( 2967 [ ], 2968 [typedef short atomic_type; 2969 atomic_type c1; 2970 atomic_type c2; 2971 atomic_type c3(0); 2972 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 2973 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 2974 __ATOMIC_RELAXED); 2975 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 2976 __atomic_load_n(&c1, __ATOMIC_RELAXED); 2977 ], 2978 [glibcxx_cv_atomic_short=yes], 2979 [glibcxx_cv_atomic_short=no]) 2980 ]) 2981 AC_MSG_RESULT($glibcxx_cv_atomic_short) 2982 2983 AC_MSG_CHECKING([for atomic builtins for int]) 2984 AC_CACHE_VAL(glibcxx_cv_atomic_int, [ 2985 AC_TRY_LINK( 2986 [ ], 2987 [typedef int atomic_type; 2988 atomic_type c1; 2989 atomic_type c2; 2990 atomic_type c3(0); 2991 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 2992 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 2993 __ATOMIC_RELAXED); 2994 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 2995 __atomic_load_n(&c1, __ATOMIC_RELAXED); 2996 ], 2997 [glibcxx_cv_atomic_int=yes], 2998 [glibcxx_cv_atomic_int=no]) 2999 ]) 3000 AC_MSG_RESULT($glibcxx_cv_atomic_int) 3001 3002 AC_MSG_CHECKING([for atomic builtins for long long]) 3003 AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [ 3004 AC_TRY_LINK( 3005 [ ], 3006 [typedef long long atomic_type; 3007 atomic_type c1; 3008 atomic_type c2; 3009 atomic_type c3(0); 3010 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3011 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3012 __ATOMIC_RELAXED); 3013 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3014 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3015 ], 3016 [glibcxx_cv_atomic_long_long=yes], 3017 [glibcxx_cv_atomic_long_long=no]) 3018 ]) 3019 AC_MSG_RESULT($glibcxx_cv_atomic_long_long) 3020 3021 else 3022 3023 # Do asm tests. 3024 3025 # Compile unoptimized. 3026 CXXFLAGS='-O0 -S' 3027 3028 # Fake what AC_TRY_COMPILE does. 3029 3030 cat > conftest.$ac_ext << EOF 3031[#]line __oline__ "configure" 3032int main() 3033{ 3034 typedef bool atomic_type; 3035 atomic_type c1; 3036 atomic_type c2; 3037 atomic_type c3(0); 3038 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3039 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3040 __ATOMIC_RELAXED); 3041 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3042 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3043 3044 return 0; 3045} 3046EOF 3047 3048 AC_MSG_CHECKING([for atomic builtins for bool]) 3049 if AC_TRY_EVAL(ac_compile); then 3050 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 3051 glibcxx_cv_atomic_bool=no 3052 else 3053 glibcxx_cv_atomic_bool=yes 3054 fi 3055 fi 3056 AC_MSG_RESULT($glibcxx_cv_atomic_bool) 3057 rm -f conftest* 3058 3059 cat > conftest.$ac_ext << EOF 3060[#]line __oline__ "configure" 3061int main() 3062{ 3063 typedef short atomic_type; 3064 atomic_type c1; 3065 atomic_type c2; 3066 atomic_type c3(0); 3067 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3068 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3069 __ATOMIC_RELAXED); 3070 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3071 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3072 3073 return 0; 3074} 3075EOF 3076 3077 AC_MSG_CHECKING([for atomic builtins for short]) 3078 if AC_TRY_EVAL(ac_compile); then 3079 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 3080 glibcxx_cv_atomic_short=no 3081 else 3082 glibcxx_cv_atomic_short=yes 3083 fi 3084 fi 3085 AC_MSG_RESULT($glibcxx_cv_atomic_short) 3086 rm -f conftest* 3087 3088 cat > conftest.$ac_ext << EOF 3089[#]line __oline__ "configure" 3090int main() 3091{ 3092 // NB: _Atomic_word not necessarily int. 3093 typedef int atomic_type; 3094 atomic_type c1; 3095 atomic_type c2; 3096 atomic_type c3(0); 3097 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3098 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3099 __ATOMIC_RELAXED); 3100 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3101 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3102 3103 return 0; 3104} 3105EOF 3106 3107 AC_MSG_CHECKING([for atomic builtins for int]) 3108 if AC_TRY_EVAL(ac_compile); then 3109 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 3110 glibcxx_cv_atomic_int=no 3111 else 3112 glibcxx_cv_atomic_int=yes 3113 fi 3114 fi 3115 AC_MSG_RESULT($glibcxx_cv_atomic_int) 3116 rm -f conftest* 3117 3118 cat > conftest.$ac_ext << EOF 3119[#]line __oline__ "configure" 3120int main() 3121{ 3122 typedef long long atomic_type; 3123 atomic_type c1; 3124 atomic_type c2; 3125 atomic_type c3(0); 3126 __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED); 3127 __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL, 3128 __ATOMIC_RELAXED); 3129 __atomic_test_and_set(&c1, __ATOMIC_RELAXED); 3130 __atomic_load_n(&c1, __ATOMIC_RELAXED); 3131 3132 return 0; 3133} 3134EOF 3135 3136 AC_MSG_CHECKING([for atomic builtins for long long]) 3137 if AC_TRY_EVAL(ac_compile); then 3138 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 3139 glibcxx_cv_atomic_long_long=no 3140 else 3141 glibcxx_cv_atomic_long_long=yes 3142 fi 3143 fi 3144 AC_MSG_RESULT($glibcxx_cv_atomic_long_long) 3145 rm -f conftest* 3146 3147 fi 3148 3149 CXXFLAGS="$old_CXXFLAGS" 3150 AC_LANG_RESTORE 3151 3152 # Set atomicity_dir to builtins if all but the long long test above passes. 3153 if test $glibcxx_cv_atomic_bool = yes \ 3154 && test $glibcxx_cv_atomic_short = yes \ 3155 && test $glibcxx_cv_atomic_int = yes; then 3156 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1, 3157 [Define if the compiler supports C++11 atomics.]) 3158 atomicity_dir=cpu/generic/atomicity_builtins 3159 fi 3160 3161 # If still generic, set to mutex. 3162 if test $atomicity_dir = "cpu/generic" ; then 3163 atomicity_dir=cpu/generic/atomicity_mutex 3164 AC_MSG_WARN([No native atomic operations are provided for this platform.]) 3165 if test "x$target_thread_file" = xsingle; then 3166 AC_MSG_WARN([They cannot be faked when thread support is disabled.]) 3167 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.]) 3168 else 3169 AC_MSG_WARN([They will be faked using a mutex.]) 3170 AC_MSG_WARN([Performance of certain classes will degrade as a result.]) 3171 fi 3172 fi 3173 3174]) 3175 3176 3177dnl 3178dnl Check for exception handling support. If an explicit enable/disable 3179dnl sjlj exceptions is given, we don't have to detect. Otherwise the 3180dnl target may or may not support call frame exceptions. 3181dnl 3182dnl --enable-sjlj-exceptions forces the use of builtin setjmp. 3183dnl --disable-sjlj-exceptions forces the use of call frame unwinding. 3184dnl Neither one forces an attempt at detection. 3185dnl 3186dnl Defines: 3187dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it 3188dnl 3189AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [ 3190 AC_MSG_CHECKING([for exception model to use]) 3191 AC_LANG_SAVE 3192 AC_LANG_CPLUSPLUS 3193 GLIBCXX_ENABLE(sjlj-exceptions,auto,, 3194 [force use of builtin_setjmp for exceptions], 3195 [permit yes|no|auto]) 3196 3197 if test $enable_sjlj_exceptions = auto; then 3198 # Botheration. Now we've got to detect the exception model. Link tests 3199 # against libgcc.a are problematic since we've not been given proper -L 3200 # bits for single-tree newlib and libgloss. 3201 # 3202 # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style. 3203 cat > conftest.$ac_ext << EOF 3204[#]line __oline__ "configure" 3205struct S { ~S(); }; 3206void bar(); 3207void foo() 3208{ 3209 S s; 3210 bar(); 3211} 3212EOF 3213 old_CXXFLAGS="$CXXFLAGS" 3214 CXXFLAGS=-S 3215 if AC_TRY_EVAL(ac_compile); then 3216 if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then 3217 enable_sjlj_exceptions=yes 3218 elif grep _Unwind_SjLj_Register conftest.s >/dev/null 2>&1 ; then 3219 enable_sjlj_exceptions=yes 3220 elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then 3221 enable_sjlj_exceptions=no 3222 elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then 3223 enable_sjlj_exceptions=no 3224 fi 3225 fi 3226 CXXFLAGS="$old_CXXFLAGS" 3227 rm -f conftest* 3228 fi 3229 3230 # This is a tad weird, for hysterical raisins. We have to map 3231 # enable/disable to two different models. 3232 case $enable_sjlj_exceptions in 3233 yes) 3234 AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1, 3235 [Define if the compiler is configured for setjmp/longjmp exceptions.]) 3236 ac_exception_model_name=sjlj 3237 ;; 3238 no) 3239 ac_exception_model_name="call frame" 3240 ;; 3241 *) 3242 AC_MSG_ERROR([unable to detect exception model]) 3243 ;; 3244 esac 3245 AC_LANG_RESTORE 3246 AC_MSG_RESULT($ac_exception_model_name) 3247]) 3248 3249 3250dnl 3251dnl Allow visibility attributes to be used on namespaces, objects, etc. 3252dnl 3253dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes. 3254dnl --disable-libstdcxx-visibility turns off all use of visibility attributes. 3255dnl + Usage: GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)] 3256dnl Where DEFAULT is 'yes'. 3257dnl 3258AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [ 3259GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage]) 3260 3261if test x$enable_libstdcxx_visibility = xyes ; then 3262 dnl all hail libgfortran 3263 dnl Check whether the target supports hidden visibility. 3264 AC_CACHE_CHECK([whether the target supports hidden visibility], 3265 glibcxx_cv_have_attribute_visibility, [ 3266 save_CFLAGS="$CFLAGS" 3267 CFLAGS="$CFLAGS -Werror" 3268 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }], 3269 [], glibcxx_cv_have_attribute_visibility=yes, 3270 glibcxx_cv_have_attribute_visibility=no) 3271 CFLAGS="$save_CFLAGS"]) 3272 if test $glibcxx_cv_have_attribute_visibility = no; then 3273 enable_libstdcxx_visibility=no 3274 fi 3275fi 3276 3277GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes) 3278AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility]) 3279]) 3280 3281 3282dnl 3283dnl Add version tags to symbols in shared library (or not), additionally 3284dnl marking other symbols as private/local (or not). 3285dnl 3286dnl Sets libtool_VERSION, and determines shared library SONAME. 3287dnl 3288dnl This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no. 3289dnl 3290dnl --enable-symvers=style adds a version script to the linker call when 3291dnl creating the shared library. The choice of version script is 3292dnl controlled by 'style'. 3293dnl --disable-symvers does not. 3294dnl 3295dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)] 3296dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to 3297dnl choose a default style based on linker characteristics. Passing 3298dnl 'no' disables versioning. 3299dnl 3300AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [ 3301 3302GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]], 3303 [enables symbol versioning of the shared library], 3304 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun]) 3305 3306# If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we 3307# don't know enough about $LD to do tricks... 3308AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES]) 3309# Sun style symbol versions needs GNU c++filt for make_sunver.pl to work 3310# with extern "C++" in version scripts. 3311AC_REQUIRE([GCC_PROG_GNU_CXXFILT]) 3312 3313# Turn a 'yes' into a suitable default. 3314if test x$enable_symvers = xyes ; then 3315 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then 3316 enable_symvers=no 3317 else 3318 if test $with_gnu_ld = yes ; then 3319 case ${target_os} in 3320 hpux*) 3321 enable_symvers=no ;; 3322 *) 3323 enable_symvers=gnu ;; 3324 esac 3325 else 3326 case ${target_os} in 3327 darwin*) 3328 enable_symvers=darwin ;; 3329 # Sun symbol versioning exists since Solaris 2.5. 3330 solaris2.[[5-9]]* | solaris2.1[[0-9]]*) 3331 # make_sunver.pl needs GNU c++filt to support extern "C++" in 3332 # version scripts, so disable symbol versioning if none can be 3333 # found. 3334 if test -z "$ac_cv_path_CXXFILT"; then 3335 AC_MSG_WARN([=== You have requested Sun symbol versioning, but]) 3336 AC_MSG_WARN([=== no GNU c++filt could be found.]) 3337 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3338 enable_symvers=no 3339 else 3340 enable_symvers=sun 3341 fi 3342 ;; 3343 *) 3344 enable_symvers=no ;; 3345 esac 3346 fi 3347 fi 3348fi 3349 3350# Check to see if 'darwin' or 'darwin-export' can win. 3351if test x$enable_symvers = xdarwin-export ; then 3352 enable_symvers=darwin 3353fi 3354 3355# Check if 'sun' was requested on non-Solaris 2 platforms. 3356if test x$enable_symvers = xsun ; then 3357 case ${target_os} in 3358 solaris2*) 3359 # All fine. 3360 ;; 3361 *) 3362 # Unlikely to work. 3363 AC_MSG_WARN([=== You have requested Sun symbol versioning, but]) 3364 AC_MSG_WARN([=== you are not targetting Solaris 2.]) 3365 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3366 enable_symvers=no 3367 ;; 3368 esac 3369fi 3370 3371# Check to see if 'gnu' can win. 3372if test $enable_symvers = gnu || 3373 test $enable_symvers = gnu-versioned-namespace || 3374 test $enable_symvers = sun; then 3375 # Check to see if libgcc_s exists, indicating that shared libgcc is possible. 3376 AC_MSG_CHECKING([for shared libgcc]) 3377 ac_save_CFLAGS="$CFLAGS" 3378 CFLAGS=' -lgcc_s' 3379 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no) 3380 CFLAGS="$ac_save_CFLAGS" 3381 if test $glibcxx_shared_libgcc = no; then 3382 cat > conftest.c <<EOF 3383int main (void) { return 0; } 3384EOF 3385changequote(,)dnl 3386 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \ 3387 -shared -shared-libgcc -o conftest.so \ 3388 conftest.c -v 2>&1 >/dev/null \ 3389 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'` 3390changequote([,])dnl 3391 rm -f conftest.c conftest.so 3392 if test x${glibcxx_libgcc_s_suffix+set} = xset; then 3393 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix" 3394 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes) 3395 CFLAGS="$ac_save_CFLAGS" 3396 fi 3397 fi 3398 AC_MSG_RESULT($glibcxx_shared_libgcc) 3399 3400 # For GNU ld, we need at least this version. The format is described in 3401 # GLIBCXX_CHECK_LINKER_FEATURES above. 3402 glibcxx_min_gnu_ld_version=21400 3403 3404 # If no shared libgcc, can't win. 3405 if test $glibcxx_shared_libgcc != yes; then 3406 AC_MSG_WARN([=== You have requested GNU symbol versioning, but]) 3407 AC_MSG_WARN([=== you are not building a shared libgcc_s.]) 3408 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3409 enable_symvers=no 3410 elif test $with_gnu_ld != yes && test $enable_symvers = sun; then 3411 : All interesting versions of Sun ld support sun style symbol versioning. 3412 elif test $with_gnu_ld != yes ; then 3413 # just fail for now 3414 AC_MSG_WARN([=== You have requested GNU symbol versioning, but]) 3415 AC_MSG_WARN([=== you are not using the GNU linker.]) 3416 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3417 enable_symvers=no 3418 elif test $glibcxx_ld_is_gold = yes ; then 3419 : All versions of gold support symbol versioning. 3420 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then 3421 # The right tools, the right setup, but too old. Fallbacks? 3422 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for) 3423 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.) 3424 AC_MSG_WARN(=== You would need to upgrade your binutils to version) 3425 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.) 3426 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 3427 enable_symvers=no 3428 fi 3429fi 3430 3431# For libtool versioning info, format is CURRENT:REVISION:AGE 3432libtool_VERSION=6:21:0 3433 3434# Everything parsed; figure out what files and settings to use. 3435case $enable_symvers in 3436 no) 3437 SYMVER_FILE=config/abi/pre/none.ver 3438 ;; 3439 gnu) 3440 SYMVER_FILE=config/abi/pre/gnu.ver 3441 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1, 3442 [Define to use GNU versioning in the shared library.]) 3443 ;; 3444 gnu-versioned-namespace) 3445 libtool_VERSION=7:0:0 3446 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver 3447 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1, 3448 [Define to use GNU namespace versioning in the shared library.]) 3449 ;; 3450 darwin) 3451 SYMVER_FILE=config/abi/pre/gnu.ver 3452 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1, 3453 [Define to use darwin versioning in the shared library.]) 3454 ;; 3455 sun) 3456 SYMVER_FILE=config/abi/pre/gnu.ver 3457 AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1, 3458 [Define to use Sun versioning in the shared library.]) 3459 ;; 3460esac 3461 3462if test x$enable_symvers != xno ; then 3463 AC_DEFINE(_GLIBCXX_SYMVER, 1, 3464 [Define to use symbol versioning in the shared library.]) 3465fi 3466 3467AC_CACHE_CHECK([whether the target supports .symver directive], 3468 glibcxx_cv_have_as_symver_directive, [ 3469 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");], 3470 [], glibcxx_cv_have_as_symver_directive=yes, 3471 glibcxx_cv_have_as_symver_directive=no)]) 3472if test $glibcxx_cv_have_as_symver_directive = yes; then 3473 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1, 3474 [Define to 1 if the target assembler supports .symver directive.]) 3475fi 3476 3477AC_SUBST(SYMVER_FILE) 3478AC_SUBST(port_specific_symbol_files) 3479GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no) 3480GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu) 3481GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace) 3482GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin) 3483GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun) 3484AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers) 3485 3486if test $enable_symvers != no ; then 3487 case ${target_os} in 3488 # The Solaris 2 runtime linker doesn't support the GNU extension of 3489 # binding the same symbol to different versions 3490 solaris2*) 3491 ;; 3492 # Other platforms with GNU symbol versioning (GNU/Linux, more?) do. 3493 *) 3494 AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1, 3495 [Define to 1 if the target runtime linker supports binding the same symbol to different versions.]) 3496 ;; 3497 esac 3498fi 3499 3500# Now, set up compatibility support, if any. 3501# In addition, need this to deal with std::size_t mangling in 3502# src/compatibility.cc. In a perfect world, could use 3503# typeid(std::size_t).name()[0] to do direct substitution. 3504AC_MSG_CHECKING([for size_t as unsigned int]) 3505ac_save_CFLAGS="$CFLAGS" 3506CFLAGS="-Werror" 3507AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;], 3508 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no]) 3509CFLAGS=$ac_save_CFLAGS 3510if test "$glibcxx_size_t_is_i" = yes; then 3511 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.]) 3512fi 3513AC_MSG_RESULT([$glibcxx_size_t_is_i]) 3514 3515AC_MSG_CHECKING([for ptrdiff_t as int]) 3516ac_save_CFLAGS="$CFLAGS" 3517CFLAGS="-Werror" 3518AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;], 3519 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no]) 3520CFLAGS=$ac_save_CFLAGS 3521if test "$glibcxx_ptrdiff_t_is_i" = yes; then 3522 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.]) 3523fi 3524AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i]) 3525]) 3526 3527 3528dnl 3529dnl Setup to use the gcc gthr.h thread-specific memory and mutex model. 3530dnl We must stage the required headers so that they will be installed 3531dnl with the library (unlike libgcc, the STL implementation is provided 3532dnl solely within headers). Since we must not inject random user-space 3533dnl macro names into user-provided C++ code, we first stage into <file>-in 3534dnl and process to <file> with an output command. The reason for a two- 3535dnl stage process here is to correctly handle $srcdir!=$objdir without 3536dnl having to write complex code (the sed commands to clean the macro 3537dnl namespace are complex and fragile enough as it is). We must also 3538dnl add a relative path so that -I- is supported properly. 3539dnl 3540dnl Substs: 3541dnl thread_header 3542dnl 3543AC_DEFUN([GLIBCXX_ENABLE_THREADS], [ 3544 AC_MSG_CHECKING([for thread model used by GCC]) 3545 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'` 3546 AC_MSG_RESULT([$target_thread_file]) 3547 GCC_AC_THREAD_HEADER([$target_thread_file]) 3548]) 3549 3550 3551dnl 3552dnl Check if gthread implementation defines the types and functions 3553dnl required by the c++0x thread library. Conforming gthread 3554dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x. 3555dnl 3556dnl GLIBCXX_ENABLE_SYMVERS must be done before this. 3557dnl 3558AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [ 3559 GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support]) 3560 3561 if test x$enable_libstdcxx_threads = xauto || 3562 test x$enable_libstdcxx_threads = xyes; then 3563 3564 AC_LANG_SAVE 3565 AC_LANG_CPLUSPLUS 3566 3567 ac_save_CXXFLAGS="$CXXFLAGS" 3568 CXXFLAGS="$CXXFLAGS -fno-exceptions \ 3569 -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc" 3570 3571 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'` 3572 case $target_thread_file in 3573 posix) 3574 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS" 3575 esac 3576 3577 AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available]) 3578 3579 AC_TRY_COMPILE([#include <unistd.h>], 3580 [ 3581 // In case of POSIX threads check _POSIX_TIMEOUTS. 3582 #if (defined(_PTHREADS) \ 3583 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0)) 3584 #error 3585 #endif 3586 ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0]) 3587 3588 AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock, 3589 [Define to 1 if mutex_timedlock is available.]) 3590 3591 if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ; 3592 else res_mutex_timedlock=no ; fi 3593 AC_MSG_RESULT([$res_mutex_timedlock]) 3594 3595 AC_MSG_CHECKING([for gthreads library]) 3596 3597 AC_TRY_COMPILE([#include "gthr.h"], 3598 [ 3599 #ifndef __GTHREADS_CXX0X 3600 #error 3601 #endif 3602 ], [ac_has_gthreads=yes], [ac_has_gthreads=no]) 3603 else 3604 ac_has_gthreads=no 3605 fi 3606 3607 AC_MSG_RESULT([$ac_has_gthreads]) 3608 3609 if test x"$ac_has_gthreads" = x"yes"; then 3610 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1, 3611 [Define if gthreads library is available.]) 3612 3613 # Also check for pthread_rwlock_t for std::shared_timed_mutex in C++14 3614 AC_CHECK_TYPE([pthread_rwlock_t], 3615 [AC_DEFINE([_GLIBCXX_USE_PTHREAD_RWLOCK_T], 1, 3616 [Define if POSIX read/write locks are available in <gthr.h>.])], 3617 [], 3618 [#include "gthr.h"]) 3619 fi 3620 3621 CXXFLAGS="$ac_save_CXXFLAGS" 3622 AC_LANG_RESTORE 3623]) 3624 3625 3626# Check whether LC_MESSAGES is available in <locale.h>. 3627# Ulrich Drepper <drepper@cygnus.com>, 1995. 3628# 3629# This file file be copied and used freely without restrictions. It can 3630# be used in projects which are not available under the GNU Public License 3631# but which still want to provide support for the GNU gettext functionality. 3632# Please note that the actual code is *not* freely available. 3633AC_DEFUN([AC_LC_MESSAGES], [ 3634 AC_CHECK_HEADER(locale.h, [ 3635 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES, 3636 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES], 3637 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)]) 3638 if test $ac_cv_val_LC_MESSAGES = yes; then 3639 AC_DEFINE(HAVE_LC_MESSAGES, 1, 3640 [Define if LC_MESSAGES is available in <locale.h>.]) 3641 fi 3642 ]) 3643]) 3644 3645dnl 3646dnl Check whether rdrand is supported in the assembler. 3647AC_DEFUN([GLIBCXX_CHECK_X86_RDRAND], [ 3648 AC_MSG_CHECKING([for rdrand support in assembler]) 3649 AC_CACHE_VAL(ac_cv_x86_rdrand, [ 3650 ac_cv_x86_rdrand=no 3651 case "$target" in 3652 i?86-*-* | \ 3653 x86_64-*-*) 3654 AC_TRY_COMPILE(, [asm("rdrand %eax");], 3655 [ac_cv_x86_rdrand=yes], [ac_cv_x86_rdrand=no]) 3656 esac 3657 ]) 3658 if test $ac_cv_x86_rdrand = yes; then 3659 AC_DEFINE(_GLIBCXX_X86_RDRAND, 1, 3660 [ Defined if as can handle rdrand. ]) 3661 fi 3662 AC_MSG_RESULT($ac_cv_x86_rdrand) 3663]) 3664 3665dnl 3666dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS. 3667dnl 3668AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [ 3669 3670 AC_LANG_SAVE 3671 AC_LANG_CPLUSPLUS 3672 ac_save_CXXFLAGS="$CXXFLAGS" 3673 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3674 3675 AC_MSG_CHECKING([for get_nprocs]) 3676 AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [ 3677 GCC_TRY_COMPILE_OR_LINK( 3678 [#include <sys/sysinfo.h>], 3679 [int n = get_nprocs();], 3680 [glibcxx_cv_GET_NPROCS=yes], 3681 [glibcxx_cv_GET_NPROCS=no]) 3682 ]) 3683 if test $glibcxx_cv_GET_NPROCS = yes; then 3684 AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.]) 3685 fi 3686 AC_MSG_RESULT($glibcxx_cv_GET_NPROCS) 3687 3688 CXXFLAGS="$ac_save_CXXFLAGS" 3689 AC_LANG_RESTORE 3690]) 3691 3692dnl 3693dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN. 3694dnl 3695AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [ 3696 3697 AC_LANG_SAVE 3698 AC_LANG_CPLUSPLUS 3699 ac_save_CXXFLAGS="$CXXFLAGS" 3700 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3701 3702 AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN]) 3703 AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [ 3704 GCC_TRY_COMPILE_OR_LINK( 3705 [#include <unistd.h>], 3706 [int n = sysconf(_SC_NPROCESSORS_ONLN);], 3707 [glibcxx_cv_SC_NPROCESSORS_ONLN=yes], 3708 [glibcxx_cv_SC_NPROCESSORS_ONLN=no]) 3709 ]) 3710 if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then 3711 AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>.]) 3712 fi 3713 AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN) 3714 3715 CXXFLAGS="$ac_save_CXXFLAGS" 3716 AC_LANG_RESTORE 3717]) 3718 3719dnl 3720dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN. 3721dnl 3722AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [ 3723 3724 AC_LANG_SAVE 3725 AC_LANG_CPLUSPLUS 3726 ac_save_CXXFLAGS="$CXXFLAGS" 3727 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3728 3729 AC_MSG_CHECKING([for _SC_NPROC_ONLN]) 3730 AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [ 3731 GCC_TRY_COMPILE_OR_LINK( 3732 [#include <unistd.h>], 3733 [int n = sysconf(_SC_NPROC_ONLN);], 3734 [glibcxx_cv_SC_NPROC_ONLN=yes], 3735 [glibcxx_cv_SC_NPROC_ONLN=no]) 3736 ]) 3737 if test $glibcxx_cv_SC_NPROC_ONLN = yes; then 3738 AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN is available in <unistd.h>.]) 3739 fi 3740 AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN) 3741 3742 CXXFLAGS="$ac_save_CXXFLAGS" 3743 AC_LANG_RESTORE 3744]) 3745 3746dnl 3747dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP. 3748dnl 3749AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [ 3750 3751 AC_LANG_SAVE 3752 AC_LANG_CPLUSPLUS 3753 ac_save_CXXFLAGS="$CXXFLAGS" 3754 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3755 3756 AC_MSG_CHECKING([for pthreads_num_processors_np]) 3757 AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [ 3758 GCC_TRY_COMPILE_OR_LINK( 3759 [#include <pthread.h>], 3760 [int n = pthread_num_processors_np();], 3761 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes], 3762 [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no]) 3763 ]) 3764 if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then 3765 AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.]) 3766 fi 3767 AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP) 3768 3769 CXXFLAGS="$ac_save_CXXFLAGS" 3770 AC_LANG_RESTORE 3771]) 3772 3773dnl 3774dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU. 3775dnl 3776AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [ 3777 3778 AC_LANG_SAVE 3779 AC_LANG_CPLUSPLUS 3780 ac_save_CXXFLAGS="$CXXFLAGS" 3781 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3782 3783 AC_MSG_CHECKING([for hw.ncpu sysctl]) 3784 AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [ 3785 GCC_TRY_COMPILE_OR_LINK( 3786 [ 3787 #include <stddef.h> 3788 #include <sys/sysctl.h> 3789 ], 3790 [ 3791 int count; 3792 size_t size = sizeof(count); 3793 int mib[] = { CTL_HW, HW_NCPU }; 3794 sysctl(mib, 2, &count, &size, NULL, 0); 3795 ], 3796 [glibcxx_cv_SYSCTL_HW_NCPU=yes], 3797 [glibcxx_cv_SYSCTL_HW_NCPU=no]) 3798 ]) 3799 if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then 3800 AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.]) 3801 fi 3802 AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU) 3803 3804 CXXFLAGS="$ac_save_CXXFLAGS" 3805 AC_LANG_RESTORE 3806]) 3807 3808dnl 3809dnl Check to see if python pretty printing can be activated. 3810dnl 3811dnl --with-python-dir=dir 3812dnl installs directory into $prefix/dir 3813AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [ 3814 3815AC_MSG_CHECKING([for custom python install directory]) 3816AC_ARG_WITH([python-dir], 3817 AS_HELP_STRING([--with-python-dir], 3818 [the location to install Python modules. This path is relative starting from the prefix.]), 3819 [with_python_dir=$withval], [with_python_dir="no"]) 3820AC_MSG_RESULT(${with_python_dir}) 3821 3822# Needed for installing Python modules during make install. 3823python_mod_dir="${with_python_dir}" 3824AC_SUBST(python_mod_dir) 3825GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no) 3826]) 3827 3828dnl 3829dnl Check to see if -Werror is disabled. 3830dnl 3831dnl --enable-werror/--disable-werror 3832AC_DEFUN([GLIBCXX_ENABLE_WERROR], [ 3833 AC_MSG_CHECKING([for -Werror]) 3834 GLIBCXX_ENABLE(werror,$1,,[turns on -Werror]) 3835 AC_MSG_RESULT($enable_werror) 3836 GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes) 3837]) 3838 3839dnl 3840dnl Check whether obsolescent tmpnam is available in <stdio.h>, 3841dnl and define _GLIBCXX_USE_TMPNAM. 3842dnl 3843AC_DEFUN([GLIBCXX_CHECK_TMPNAM], [dnl 3844dnl 3845 AC_LANG_SAVE 3846 AC_LANG_CPLUSPLUS 3847 ac_save_CXXFLAGS="$CXXFLAGS" 3848 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3849dnl 3850 AC_MSG_CHECKING([for tmpnam]) 3851 AC_CACHE_VAL(glibcxx_cv_TMPNAM, [dnl 3852 GCC_TRY_COMPILE_OR_LINK( 3853 [#include <stdio.h>], 3854 [char *tmp = tmpnam(NULL);], 3855 [glibcxx_cv_TMPNAM=yes], 3856 [glibcxx_cv_TMPNAM=no]) 3857 ]) 3858 if test $glibcxx_cv_TMPNAM = yes; then 3859 AC_DEFINE(_GLIBCXX_USE_TMPNAM, 1, [Define if obsolescent tmpnam is available in <stdio.h>.]) 3860 fi 3861 AC_MSG_RESULT($glibcxx_cv_TMPNAM) 3862dnl 3863 CXXFLAGS="$ac_save_CXXFLAGS" 3864 AC_LANG_RESTORE 3865]) 3866 3867dnl 3868dnl Check to see if sys/sdt.h exists and that it is suitable for use. 3869dnl Some versions of sdt.h were not compatible with C++11. 3870dnl 3871AC_DEFUN([GLIBCXX_CHECK_SDT_H], [ 3872 AC_MSG_CHECKING([for suitable sys/sdt.h]) 3873 # Note that this test has to be run with the C language. 3874 # Otherwise, sdt.h will try to include some headers from 3875 # libstdc++ itself. 3876 AC_LANG_SAVE 3877 AC_LANG_C 3878 AC_CACHE_VAL(glibcxx_cv_sys_sdt_h, [ 3879 # Because we have to run the test in C, we use grep rather 3880 # than the compiler to check for the bug. The bug is that 3881 # were strings without trailing whitespace, causing g++ 3882 # to look for operator"". The pattern searches for the fixed 3883 # output. 3884 AC_EGREP_CPP([ \",\" ], [ 3885 #include <sys/sdt.h> 3886 int f() { STAP_PROBE(hi, bob); } 3887 ], [glibcxx_cv_sys_sdt_h=yes], [glibcxx_cv_sys_sdt_h=no]) 3888 ]) 3889 AC_LANG_RESTORE 3890 if test $glibcxx_cv_sys_sdt_h = yes; then 3891 AC_DEFINE(HAVE_SYS_SDT_H, 1, 3892 [Define to 1 if you have a suitable <sys/sdt.h> header file]) 3893 fi 3894 AC_MSG_RESULT($glibcxx_cv_sys_sdt_h) 3895]) 3896 3897dnl 3898dnl Control whether the library should define symbols for old and new ABIs. 3899dnl This affects definitions of strings, stringstreams and locale facets. 3900dnl 3901dnl --disable-libstdcxx-dual-abi will use old ABI for all types. 3902dnl 3903dnl Defines: 3904dnl _GLIBCXX_USE_DUAL_ABI (always defined, either to 1 or 0) 3905dnl 3906AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_DUAL_ABI], [ 3907 GLIBCXX_ENABLE(libstdcxx-dual-abi,$1,,[support two versions of std::string]) 3908 if test x$enable_symvers = xgnu-versioned-namespace; then 3909 # gnu-versioned-namespace is incompatible with the dual ABI. 3910 enable_libstdcxx_dual_abi="no" 3911 fi 3912 if test x"$enable_libstdcxx_dual_abi" != xyes; then 3913 AC_MSG_NOTICE([dual ABI is disabled]) 3914 default_libstdcxx_abi="gcc4-compatible" 3915 fi 3916 GLIBCXX_CONDITIONAL(ENABLE_DUAL_ABI, test $enable_libstdcxx_dual_abi = yes) 3917]) 3918 3919dnl 3920dnl Check to see which ABI should be enabled by default. 3921dnl 3922dnl --with-default-libstdcxx-abi={gcc4-compatible,new} 3923dnl 3924dnl Defines: 3925dnl _GLIBCXX_USE_CXX11_ABI (always defined, either to 1 or 0) 3926dnl 3927AC_DEFUN([GLIBCXX_DEFAULT_ABI], [ 3928 if test x$enable_libstdcxx_dual_abi = xyes; then 3929 AC_MSG_CHECKING([for default std::string ABI to use]) 3930 AC_ARG_WITH([default-libstdcxx-abi], 3931 AS_HELP_STRING([--with-default-libstdcxx-abi], 3932 [set the std::string ABI to use by default]), 3933 [case "$withval" in 3934 gcc4-compatible) default_libstdcxx_abi="gcc4-compatible" ;; 3935 new|cxx11) default_libstdcxx_abi="new" ;; 3936 c++*|gnu++*) AC_MSG_ERROR([Supported arguments for --with-default-libstdcxx-abi have changed, use "new" or "gcc4-compatible"]) ;; 3937 *) AC_MSG_ERROR([Invalid argument for --with-default-libstdcxx-abi]) ;; 3938 esac 3939 ], 3940 [default_libstdcxx_abi="new"]) 3941 AC_MSG_RESULT(${default_libstdcxx_abi}) 3942 fi 3943 if test $default_libstdcxx_abi = "new"; then 3944 glibcxx_cxx11_abi=1 3945 glibcxx_cxx98_abi=0 3946 else 3947 glibcxx_cxx11_abi=0 3948 glibcxx_cxx98_abi=1 3949 fi 3950 AC_SUBST(glibcxx_cxx98_abi) 3951 GLIBCXX_CONDITIONAL(ENABLE_CXX11_ABI, test $glibcxx_cxx11_abi = 1) 3952]) 3953 3954dnl 3955dnl Check to see whether to build libstdc++fs.a 3956dnl 3957dnl --enable-libstdcxx-filesystem-ts 3958dnl 3959AC_DEFUN([GLIBCXX_ENABLE_FILESYSTEM_TS], [ 3960 GLIBCXX_ENABLE(libstdcxx-filesystem-ts,auto,, 3961 [turns on ISO/IEC TS 18822 support], 3962 [permit yes|no|auto]) 3963 3964 AC_MSG_CHECKING([whether to build Filesystem TS support]) 3965 if test x"$ac_cv_header_dirent_h" != x"yes"; then 3966 enable_libstdcxx_filesystem_ts=no 3967 fi 3968 if test x"$enable_libstdcxx_filesystem_ts" = x"auto"; then 3969 case "${target_os}" in 3970 freebsd*|netbsd*|openbsd*|dragonfly*|darwin*) 3971 enable_libstdcxx_filesystem_ts=yes 3972 ;; 3973 gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu) 3974 enable_libstdcxx_filesystem_ts=yes 3975 ;; 3976 solaris*) 3977 enable_libstdcxx_filesystem_ts=yes 3978 ;; 3979 *) 3980 enable_libstdcxx_filesystem_ts=no 3981 ;; 3982 esac 3983 fi 3984 AC_MSG_RESULT($enable_libstdcxx_filesystem_ts) 3985 GLIBCXX_CONDITIONAL(ENABLE_FILESYSTEM_TS, test $enable_libstdcxx_filesystem_ts = yes) 3986]) 3987 3988dnl 3989dnl Check whether the library calls required by the Filesystem TS are present 3990dnl and define _GLIBCXX_USE_REALPATH and _GLIBCXX_USE_UTIMENSAT. 3991dnl 3992AC_DEFUN([GLIBCXX_CHECK_FILESYSTEM_DEPS], [dnl 3993dnl 3994 AC_LANG_SAVE 3995 AC_LANG_CPLUSPLUS 3996 ac_save_CXXFLAGS="$CXXFLAGS" 3997 CXXFLAGS="$CXXFLAGS -fno-exceptions" 3998dnl 3999 AC_MSG_CHECKING([for struct dirent.d_type]) 4000 AC_CACHE_VAL(glibcxx_cv_dirent_d_type, [dnl 4001 GCC_TRY_COMPILE_OR_LINK( 4002 [#include <dirent.h>], 4003 [ 4004 struct dirent d; 4005 if (sizeof d.d_type) return 0; 4006 ], 4007 [glibcxx_cv_dirent_d_type=yes], 4008 [glibcxx_cv_dirent_d_type=no]) 4009 ]) 4010 if test $glibcxx_cv_dirent_d_type = yes; then 4011 AC_DEFINE(HAVE_STRUCT_DIRENT_D_TYPE, 1, [Define to 1 if `d_type' is a member of `struct dirent'.]) 4012 fi 4013 AC_MSG_RESULT($glibcxx_cv_dirent_d_type) 4014dnl 4015 AC_MSG_CHECKING([for realpath]) 4016 AC_CACHE_VAL(glibcxx_cv_realpath, [dnl 4017 GCC_TRY_COMPILE_OR_LINK( 4018 [ 4019 #include <stdlib.h> 4020 #include <unistd.h> 4021 ], 4022 [ 4023 #if _XOPEN_VERSION < 500 4024 #error 4025 #elif _XOPEN_VERSION >= 700 || defined(PATH_MAX) 4026 char *tmp = realpath((const char*)NULL, (char*)NULL); 4027 #else 4028 #error 4029 #endif 4030 ], 4031 [glibcxx_cv_realpath=yes], 4032 [glibcxx_cv_realpath=no]) 4033 ]) 4034 if test $glibcxx_cv_realpath = yes; then 4035 AC_DEFINE(_GLIBCXX_USE_REALPATH, 1, [Define if usable realpath is available in <stdlib.h>.]) 4036 fi 4037 AC_MSG_RESULT($glibcxx_cv_realpath) 4038dnl 4039 AC_MSG_CHECKING([for utimensat]) 4040 AC_CACHE_VAL(glibcxx_cv_utimensat, [dnl 4041 GCC_TRY_COMPILE_OR_LINK( 4042 [ 4043 #include <fcntl.h> 4044 #include <sys/stat.h> 4045 ], 4046 [ 4047 struct timespec ts[2] = { { 0, UTIME_OMIT }, { 1, 1 } }; 4048 int i = utimensat(AT_FDCWD, "path", ts, 0); 4049 ], 4050 [glibcxx_cv_utimensat=yes], 4051 [glibcxx_cv_utimensat=no]) 4052 ]) 4053 if test $glibcxx_cv_utimensat = yes; then 4054 AC_DEFINE(_GLIBCXX_USE_UTIMENSAT, 1, [Define if utimensat and UTIME_OMIT are available in <sys/stat.h> and AT_FDCWD in <fcntl.h>.]) 4055 fi 4056 AC_MSG_RESULT($glibcxx_cv_utimensat) 4057dnl 4058 AC_MSG_CHECKING([for struct stat.st_mtim.tv_nsec]) 4059 AC_CACHE_VAL(glibcxx_cv_st_mtim, [dnl 4060 GCC_TRY_COMPILE_OR_LINK( 4061 [ #include <sys/stat.h> ], 4062 [ 4063 struct stat st; 4064 return st.st_mtim.tv_nsec; 4065 ], 4066 [glibcxx_cv_st_mtim=yes], 4067 [glibcxx_cv_st_mtim=no]) 4068 ]) 4069 if test $glibcxx_cv_st_mtim = yes; then 4070 AC_DEFINE(_GLIBCXX_USE_ST_MTIM, 1, [Define if struct stat has timespec members.]) 4071 fi 4072 AC_MSG_RESULT($glibcxx_cv_st_mtim) 4073dnl 4074 AC_MSG_CHECKING([for fchmod]) 4075 AC_CACHE_VAL(glibcxx_cv_fchmod, [dnl 4076 GCC_TRY_COMPILE_OR_LINK( 4077 [#include <sys/stat.h>], 4078 [fchmod(1, S_IWUSR);], 4079 [glibcxx_cv_fchmod=yes], 4080 [glibcxx_cv_fchmod=no]) 4081 ]) 4082 if test $glibcxx_cv_fchmod = yes; then 4083 AC_DEFINE(_GLIBCXX_USE_FCHMOD, 1, [Define if fchmod is available in <sys/stat.h>.]) 4084 fi 4085 AC_MSG_RESULT($glibcxx_cv_fchmod) 4086dnl 4087 AC_MSG_CHECKING([for fchmodat]) 4088 AC_CACHE_VAL(glibcxx_cv_fchmodat, [dnl 4089 GCC_TRY_COMPILE_OR_LINK( 4090 [ 4091 #include <fcntl.h> 4092 #include <sys/stat.h> 4093 ], 4094 [fchmodat(AT_FDCWD, "", 0, AT_SYMLINK_NOFOLLOW);], 4095 [glibcxx_cv_fchmodat=yes], 4096 [glibcxx_cv_fchmodat=no]) 4097 ]) 4098 if test $glibcxx_cv_fchmodat = yes; then 4099 AC_DEFINE(_GLIBCXX_USE_FCHMODAT, 1, [Define if fchmodat is available in <sys/stat.h>.]) 4100 fi 4101 AC_MSG_RESULT($glibcxx_cv_fchmodat) 4102dnl 4103 AC_MSG_CHECKING([for sendfile that can copy files]) 4104 AC_CACHE_VAL(glibcxx_cv_sendfile, [dnl 4105 case "${target_os}" in 4106 gnu* | linux* | solaris*) 4107 GCC_TRY_COMPILE_OR_LINK( 4108 [#include <sys/sendfile.h>], 4109 [sendfile(1, 2, (off_t*)NULL, sizeof 1);], 4110 [glibcxx_cv_sendfile=yes], 4111 [glibcxx_cv_sendfile=no]) 4112 ;; 4113 *) 4114 glibcxx_cv_sendfile=no 4115 ;; 4116 esac 4117 ]) 4118 if test $glibcxx_cv_sendfile = yes; then 4119 AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/stat.h>.]) 4120 fi 4121 AC_MSG_RESULT($glibcxx_cv_sendfile) 4122dnl 4123 CXXFLAGS="$ac_save_CXXFLAGS" 4124 AC_LANG_RESTORE 4125]) 4126 4127# Macros from the top-level gcc directory. 4128m4_include([../config/gc++filt.m4]) 4129m4_include([../config/tls.m4]) 4130m4_include([../config/gthr.m4]) 4131