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