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