1 2dnl 3dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST) 4dnl 5dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the 6dnl end of configure. This lets tested variables be reassigned, and the 7dnl conditional will depend on the final state of the variable. For a simple 8dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED. 9dnl 10m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl 11AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl 12 m4_divert_text([glibcxx_diversion],dnl 13 AM_CONDITIONAL([$1],[$2]) 14 )dnl 15])dnl 16AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl 17 18 19dnl 20dnl Check to see what architecture and operating system we are compiling 21dnl for. Also, if architecture- or OS-specific flags are required for 22dnl compilation, pick them up here. 23dnl 24AC_DEFUN([GLIBCXX_CHECK_HOST], [ 25 . $glibcxx_srcdir/configure.host 26 AC_MSG_NOTICE([CPU config directory is $cpu_include_dir]) 27 AC_MSG_NOTICE([OS config directory is $os_include_dir]) 28]) 29 30dnl 31dnl Initialize the rest of the library configury. At this point we have 32dnl variables like $host. 33dnl 34dnl Sets: 35dnl SUBDIRS 36dnl Substs: 37dnl glibcxx_builddir (absolute path) 38dnl glibcxx_srcdir (absolute path) 39dnl toplevel_srcdir (absolute path) 40dnl with_cross_host 41dnl with_newlib 42dnl with_target_subdir 43dnl plus 44dnl - the variables in GLIBCXX_CHECK_HOST / configure.host 45dnl - default settings for all AM_CONFITIONAL test variables 46dnl - lots of tools, like CC and CXX 47dnl 48AC_DEFUN([GLIBCXX_CONFIGURE], [ 49 # Keep these sync'd with the list in Makefile.am. The first provides an 50 # expandable list at autoconf time; the second provides an expandable list 51 # (i.e., shell variable) at configure time. 52 m4_define([glibcxx_SUBDIRS],[include libsupc++ python src doc po testsuite]) 53 SUBDIRS='glibcxx_SUBDIRS' 54 55 # These need to be absolute paths, yet at the same time need to 56 # canonicalize only relative paths, because then amd will not unmount 57 # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd. 58 glibcxx_builddir=`${PWDCMD-pwd}` 59 case $srcdir in 60 [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;; 61 *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;; 62 esac 63 toplevel_srcdir=${glibcxx_srcdir}/.. 64 AC_SUBST(glibcxx_builddir) 65 AC_SUBST(glibcxx_srcdir) 66 AC_SUBST(toplevel_srcdir) 67 68 # We use these options to decide which functions to include. They are 69 # set from the top level. 70 AC_ARG_WITH([target-subdir], 71 AC_HELP_STRING([--with-target-subdir=SUBDIR], 72 [configuring in a subdirectory])) 73 74 AC_ARG_WITH([cross-host], 75 AC_HELP_STRING([--with-cross-host=HOST], 76 [configuring with a cross compiler])) 77 78 AC_ARG_WITH([newlib], 79 AC_HELP_STRING([--with-newlib], 80 [assume newlib as a system C library])) 81 82 # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't 83 # available). Uncomment the next line to force a particular method. 84 AC_PROG_LN_S 85 #LN_S='cp -p' 86 87 AC_CHECK_TOOL(AS, as) 88 AC_CHECK_TOOL(AR, ar) 89 AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error) 90 91 AM_MAINTAINER_MODE 92 93 # Set up safe default values for all subsequent AM_CONDITIONAL tests 94 # which are themselves conditionally expanded. 95 ## (Right now, this only matters for enable_wchar_t, but nothing prevents 96 ## other macros from doing the same. This should be automated.) -pme 97 98 # Check for uClibc since Linux platforms use different configuration 99 # directories depending on the C library in use. 100 AC_EGREP_CPP([_using_uclibc], [ 101 #include <stdio.h> 102 #if __UCLIBC__ 103 _using_uclibc 104 #endif 105 ], uclibc=yes, uclibc=no) 106 107 # Find platform-specific directories containing configuration info. 108 # Also possibly modify flags used elsewhere, as needed by the platform. 109 GLIBCXX_CHECK_HOST 110]) 111 112 113dnl 114dnl Tests for newer compiler features, or features that are present in newer 115dnl compiler versions but not older compiler versions still in use, should 116dnl be placed here. 117dnl 118dnl Defines: 119dnl WERROR='-Werror' if requested and possible; g++'s that lack the 120dnl new inlining code or the new system_header pragma will die on -Werror. 121dnl Leave it out by default and use maint-mode to use it. 122dnl SECTION_FLAGS='-ffunction-sections -fdata-sections' if 123dnl compiler supports it and the user has not requested debug mode. 124dnl 125AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [ 126 # All these tests are for C++; save the language and the compiler flags. 127 # The CXXFLAGS thing is suspicious, but based on similar bits previously 128 # found in GLIBCXX_CONFIGURE. 129 AC_LANG_SAVE 130 AC_LANG_CPLUSPLUS 131 ac_test_CXXFLAGS="${CXXFLAGS+set}" 132 ac_save_CXXFLAGS="$CXXFLAGS" 133 134 # Check for maintainer-mode bits. 135 if test x"$USE_MAINTAINER_MODE" = xno; then 136 WERROR='' 137 else 138 WERROR='-Werror' 139 fi 140 141 # Check for -ffunction-sections -fdata-sections 142 AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections]) 143 CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections' 144 AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no]) 145 if test "$ac_test_CXXFLAGS" = set; then 146 CXXFLAGS="$ac_save_CXXFLAGS" 147 else 148 # this is the suspicious part 149 CXXFLAGS='' 150 fi 151 if test x"$ac_fdsections" = x"yes"; then 152 SECTION_FLAGS='-ffunction-sections -fdata-sections' 153 fi 154 AC_MSG_RESULT($ac_fdsections) 155 156 AC_LANG_RESTORE 157 AC_SUBST(WERROR) 158 AC_SUBST(SECTION_FLAGS) 159]) 160 161 162dnl 163dnl If GNU ld is in use, check to see if tricky linker opts can be used. If 164dnl the native linker is in use, all variables will be defined to something 165dnl safe (like an empty string). 166dnl 167dnl Defines: 168dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible 169dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible 170dnl LD (as a side effect of testing) 171dnl Sets: 172dnl with_gnu_ld 173dnl glibcxx_ld_is_gold (set to "no" or "yes") 174dnl glibcxx_gnu_ld_version (possibly) 175dnl 176dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will 177dnl set glibcxx_gnu_ld_version to 12345. Zeros cause problems. 178dnl 179AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [ 180 # If we're not using GNU ld, then there's no point in even trying these 181 # tests. Check for that first. We should have already tested for gld 182 # by now (in libtool), but require it now just to be safe... 183 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS='' 184 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS='' 185 AC_REQUIRE([AC_PROG_LD]) 186 AC_REQUIRE([AC_PROG_AWK]) 187 188 # The name set by libtool depends on the version of libtool. Shame on us 189 # for depending on an impl detail, but c'est la vie. Older versions used 190 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on 191 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually 192 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't 193 # set (hence we're using an older libtool), then set it. 194 if test x${with_gnu_ld+set} != xset; then 195 if test x${ac_cv_prog_gnu_ld+set} != xset; then 196 # We got through "ac_require(ac_prog_ld)" and still not set? Huh? 197 with_gnu_ld=no 198 else 199 with_gnu_ld=$ac_cv_prog_gnu_ld 200 fi 201 fi 202 203 # Start by getting the version number. I think the libtool test already 204 # does some of this, but throws away the result. 205 glibcxx_ld_is_gold=no 206 if test x"$with_gnu_ld" = x"yes"; then 207 AC_MSG_CHECKING([for ld version]) 208 changequote(,) 209 if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then 210 glibcxx_ld_is_gold=yes 211 fi 212 ldver=`$LD --version 2>/dev/null | 213 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'` 214 changequote([,]) 215 glibcxx_gnu_ld_version=`echo $ldver | \ 216 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'` 217 AC_MSG_RESULT($glibcxx_gnu_ld_version) 218 fi 219 220 # Set --gc-sections. 221 glibcxx_have_gc_sections=no 222 if test "$glibcxx_ld_is_gold" = "yes"; then 223 if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then 224 glibcxx_have_gc_sections=yes 225 fi 226 else 227 glibcxx_gcsections_min_ld=21602 228 if test x"$with_gnu_ld" = x"yes" && 229 test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then 230 glibcxx_have_gc_sections=yes 231 fi 232 fi 233 if test "$glibcxx_have_gc_sections" = "yes"; then 234 # Sufficiently young GNU ld it is! Joy and bunny rabbits! 235 # NB: This flag only works reliably after 2.16.1. Configure tests 236 # for this are difficult, so hard wire a value that should work. 237 238 ac_test_CFLAGS="${CFLAGS+set}" 239 ac_save_CFLAGS="$CFLAGS" 240 CFLAGS='-Wl,--gc-sections' 241 242 # Check for -Wl,--gc-sections 243 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections]) 244 AC_TRY_LINK([ int one(void) { return 1; } 245 int two(void) { return 2; } 246 ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no]) 247 if test "$ac_gcsections" = "yes"; then 248 rm -f conftest.c 249 touch conftest.c 250 if $CC -c conftest.c; then 251 if $LD --gc-sections -o conftest conftest.o 2>&1 | \ 252 grep "Warning: gc-sections option ignored" > /dev/null; then 253 ac_gcsections=no 254 fi 255 fi 256 rm -f conftest.c conftest.o conftest 257 fi 258 if test "$ac_gcsections" = "yes"; then 259 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS" 260 fi 261 AC_MSG_RESULT($ac_gcsections) 262 263 if test "$ac_test_CFLAGS" = set; then 264 CFLAGS="$ac_save_CFLAGS" 265 else 266 # this is the suspicious part 267 CFLAGS='' 268 fi 269 fi 270 271 # Set -z,relro. 272 # Note this is only for shared objects. 273 ac_ld_relro=no 274 if test x"$with_gnu_ld" = x"yes"; then 275 AC_MSG_CHECKING([for ld that supports -Wl,-z,relro]) 276 cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"` 277 if test -n "$cxx_z_relo"; then 278 OPT_LDFLAGS="-Wl,-z,relro" 279 ac_ld_relro=yes 280 fi 281 AC_MSG_RESULT($ac_ld_relro) 282 fi 283 284 # Set linker optimization flags. 285 if test x"$with_gnu_ld" = x"yes"; then 286 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS" 287 fi 288 289 AC_SUBST(SECTION_LDFLAGS) 290 AC_SUBST(OPT_LDFLAGS) 291]) 292 293 294dnl 295dnl Check for headers for, and arguments to, the setrlimit() function. 296dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE. 297dnl 298dnl Defines: 299dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits 300dnl various HAVE_LIMIT_* for individual limit names 301dnl 302AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [ 303 AC_MSG_CHECKING([for RLIMIT_$1]) 304 AC_TRY_COMPILE( 305 [#include <unistd.h> 306 #include <sys/time.h> 307 #include <sys/resource.h> 308 ], 309 [ int f = RLIMIT_$1 ; ], 310 [glibcxx_mresult=1], [glibcxx_mresult=0]) 311 AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult, 312 [Only used in build directory testsuite_hooks.h.]) 313 if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi 314 AC_MSG_RESULT($res) 315]) 316 317AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [ 318 setrlimit_have_headers=yes 319 AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h, 320 [], 321 [setrlimit_have_headers=no]) 322 # If don't have the headers, then we can't run the tests now, and we 323 # won't be seeing any of these during testsuite compilation. 324 if test $setrlimit_have_headers = yes; then 325 # Can't do these in a loop, else the resulting syntax is wrong. 326 GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA) 327 GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS) 328 GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM) 329 GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS) 330 GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE) 331 332 # Check for rlimit, setrlimit. 333 AC_CACHE_VAL(glibcxx_cv_setrlimit, [ 334 AC_TRY_COMPILE( 335 [#include <unistd.h> 336 #include <sys/time.h> 337 #include <sys/resource.h> 338 ], 339 [struct rlimit r; 340 setrlimit(0, &r);], 341 [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no]) 342 ]) 343 fi 344 345 AC_MSG_CHECKING([for testsuite resource limits support]) 346 if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then 347 ac_res_limits=yes 348 AC_DEFINE(_GLIBCXX_RES_LIMITS, 1, 349 [Define if using setrlimit to set resource limits during 350 "make check"]) 351 else 352 ac_res_limits=no 353 fi 354 AC_MSG_RESULT($ac_res_limits) 355]) 356 357 358dnl 359dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>. 360dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately. 361dnl 362AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [ 363 364 AC_LANG_SAVE 365 AC_LANG_CPLUSPLUS 366 ac_save_CXXFLAGS="$CXXFLAGS" 367 CXXFLAGS="$CXXFLAGS -fno-exceptions" 368 369 AC_MSG_CHECKING([for S_ISREG or S_IFREG]) 370 AC_CACHE_VAL(glibcxx_cv_S_ISREG, [ 371 GCC_TRY_COMPILE_OR_LINK( 372 [#include <sys/stat.h>], 373 [struct stat buffer; 374 fstat(0, &buffer); 375 S_ISREG(buffer.st_mode);], 376 [glibcxx_cv_S_ISREG=yes], 377 [glibcxx_cv_S_ISREG=no]) 378 ]) 379 AC_CACHE_VAL(glibcxx_cv_S_IFREG, [ 380 GCC_TRY_COMPILE_OR_LINK( 381 [#include <sys/stat.h>], 382 [struct stat buffer; 383 fstat(0, &buffer); 384 S_IFREG & buffer.st_mode;], 385 [glibcxx_cv_S_IFREG=yes], 386 [glibcxx_cv_S_IFREG=no]) 387 ]) 388 res=no 389 if test $glibcxx_cv_S_ISREG = yes; then 390 AC_DEFINE(HAVE_S_ISREG, 1, 391 [Define if S_IFREG is available in <sys/stat.h>.]) 392 res=S_ISREG 393 elif test $glibcxx_cv_S_IFREG = yes; then 394 AC_DEFINE(HAVE_S_IFREG, 1, 395 [Define if S_IFREG is available in <sys/stat.h>.]) 396 res=S_IFREG 397 fi 398 AC_MSG_RESULT($res) 399 400 CXXFLAGS="$ac_save_CXXFLAGS" 401 AC_LANG_RESTORE 402]) 403 404 405dnl 406dnl Check whether poll is available in <poll.h>, and define HAVE_POLL. 407dnl 408AC_DEFUN([GLIBCXX_CHECK_POLL], [ 409 410 AC_LANG_SAVE 411 AC_LANG_CPLUSPLUS 412 ac_save_CXXFLAGS="$CXXFLAGS" 413 CXXFLAGS="$CXXFLAGS -fno-exceptions" 414 415 AC_MSG_CHECKING([for poll]) 416 AC_CACHE_VAL(glibcxx_cv_POLL, [ 417 GCC_TRY_COMPILE_OR_LINK( 418 [#include <poll.h>], 419 [struct pollfd pfd[1]; 420 pfd[0].events = POLLIN; 421 poll(pfd, 1, 0);], 422 [glibcxx_cv_POLL=yes], 423 [glibcxx_cv_POLL=no]) 424 ]) 425 if test $glibcxx_cv_POLL = yes; then 426 AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.]) 427 fi 428 AC_MSG_RESULT($glibcxx_cv_POLL) 429 430 CXXFLAGS="$ac_save_CXXFLAGS" 431 AC_LANG_RESTORE 432]) 433 434 435dnl 436dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV. 437dnl 438AC_DEFUN([GLIBCXX_CHECK_WRITEV], [ 439 440 AC_LANG_SAVE 441 AC_LANG_CPLUSPLUS 442 ac_save_CXXFLAGS="$CXXFLAGS" 443 CXXFLAGS="$CXXFLAGS -fno-exceptions" 444 445 AC_MSG_CHECKING([for writev]) 446 AC_CACHE_VAL(glibcxx_cv_WRITEV, [ 447 GCC_TRY_COMPILE_OR_LINK( 448 [#include <sys/uio.h>], 449 [struct iovec iov[2]; 450 writev(0, iov, 0);], 451 [glibcxx_cv_WRITEV=yes], 452 [glibcxx_cv_WRITEV=no]) 453 ]) 454 if test $glibcxx_cv_WRITEV = yes; then 455 AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.]) 456 fi 457 AC_MSG_RESULT($glibcxx_cv_WRITEV) 458 459 CXXFLAGS="$ac_save_CXXFLAGS" 460 AC_LANG_RESTORE 461]) 462 463 464dnl 465dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T. 466dnl Also check whether int64_t is actually a typedef to long or long long. 467dnl 468AC_DEFUN([GLIBCXX_CHECK_INT64_T], [ 469 470 AC_LANG_SAVE 471 AC_LANG_CPLUSPLUS 472 473 AC_MSG_CHECKING([for int64_t]) 474 AC_CACHE_VAL(glibcxx_cv_INT64_T, [ 475 AC_TRY_COMPILE( 476 [#include <stdint.h>], 477 [int64_t var;], 478 [glibcxx_cv_INT64_T=yes], 479 [glibcxx_cv_INT64_T=no]) 480 ]) 481 482 if test $glibcxx_cv_INT64_T = yes; then 483 AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.]) 484 AC_MSG_RESULT($glibcxx_cv_INT64_T) 485 486 AC_MSG_CHECKING([for int64_t as long]) 487 AC_CACHE_VAL(glibcxx_cv_int64_t_long, [ 488 AC_TRY_COMPILE( 489 [#include <stdint.h> 490 template<typename, typename> struct same { enum { value = -1 }; }; 491 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; }; 492 int array[same<int64_t, long>::value];], [], 493 [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no]) 494 ]) 495 496 if test $glibcxx_cv_int64_t_long = yes; then 497 AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.]) 498 AC_MSG_RESULT($glibcxx_cv_int64_t_long) 499 fi 500 501 AC_MSG_CHECKING([for int64_t as long long]) 502 AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [ 503 AC_TRY_COMPILE( 504 [#include <stdint.h> 505 template<typename, typename> struct same { enum { value = -1 }; }; 506 template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; }; 507 int array[same<int64_t, long long>::value];], [], 508 [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no]) 509 ]) 510 511 if test $glibcxx_cv_int64_t_long_long = yes; then 512 AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.]) 513 AC_MSG_RESULT($glibcxx_cv_int64_t_long_long) 514 fi 515 fi 516 517 AC_LANG_RESTORE 518]) 519 520 521dnl 522dnl Check whether LFS support is available. 523dnl 524AC_DEFUN([GLIBCXX_CHECK_LFS], [ 525 AC_LANG_SAVE 526 AC_LANG_CPLUSPLUS 527 ac_save_CXXFLAGS="$CXXFLAGS" 528 CXXFLAGS="$CXXFLAGS -fno-exceptions" 529 AC_MSG_CHECKING([for LFS support]) 530 AC_CACHE_VAL(glibcxx_cv_LFS, [ 531 GCC_TRY_COMPILE_OR_LINK( 532 [#include <unistd.h> 533 #include <stdio.h> 534 #include <sys/stat.h> 535 ], 536 [FILE* fp; 537 fopen64("t", "w"); 538 fseeko64(fp, 0, SEEK_CUR); 539 ftello64(fp); 540 lseek64(1, 0, SEEK_CUR); 541 struct stat64 buf; 542 fstat64(1, &buf);], 543 [glibcxx_cv_LFS=yes], 544 [glibcxx_cv_LFS=no]) 545 ]) 546 if test $glibcxx_cv_LFS = yes; then 547 AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.]) 548 fi 549 AC_MSG_RESULT($glibcxx_cv_LFS) 550 CXXFLAGS="$ac_save_CXXFLAGS" 551 AC_LANG_RESTORE 552]) 553 554 555dnl 556dnl Check for whether a fully dynamic basic_string implementation should 557dnl be turned on, that does not put empty objects in per-process static 558dnl memory (mostly useful together with shared memory allocators, see PR 559dnl libstdc++/16612 for details). 560dnl 561dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING 562dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined 563dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)] 564dnl Where DEFAULT is either `yes' or `no'. 565dnl 566AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [ 567 GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory]) 568 if test $enable_fully_dynamic_string = yes; then 569 AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1, 570 [Define if a fully dynamic basic_string is wanted.]) 571 fi 572]) 573 574 575dnl 576dnl Does any necessary configuration of the testsuite directory. Generates 577dnl the testsuite_hooks.h header. 578dnl 579dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this. 580dnl 581dnl Sets: 582dnl enable_abi_check 583dnl GLIBCXX_TEST_WCHAR_T 584dnl GLIBCXX_TEST_THREAD 585dnl Substs: 586dnl baseline_dir 587dnl 588AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [ 589 if $GLIBCXX_IS_NATIVE ; then 590 # Do checks for resource limit functions. 591 GLIBCXX_CHECK_SETRLIMIT 592 593 # Look for setenv, so that extended locale tests can be performed. 594 GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv) 595 fi 596 597 if $GLIBCXX_IS_NATIVE && test $is_hosted = yes && 598 test $enable_symvers != no; then 599 case "$host" in 600 *-*-cygwin*) 601 enable_abi_check=no ;; 602 *) 603 enable_abi_check=yes ;; 604 esac 605 else 606 # Only build this as native, since automake does not understand 607 # CXX_FOR_BUILD. 608 enable_abi_check=no 609 fi 610 611 # Export file names for ABI checking. 612 baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}" 613 AC_SUBST(baseline_dir) 614]) 615 616 617dnl 618dnl Set up *_INCLUDES variables for all sundry Makefile.am's. 619dnl 620dnl Substs: 621dnl GLIBCXX_INCLUDES 622dnl TOPLEVEL_INCLUDES 623dnl 624AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [ 625 # Used for every C++ compile we perform. 626 GLIBCXX_INCLUDES="\ 627-I$glibcxx_builddir/include/$host_alias \ 628-I$glibcxx_builddir/include \ 629-I$glibcxx_srcdir/libsupc++" 630 631 # For Canadian crosses, pick this up too. 632 if test $CANADIAN = yes; then 633 GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}" 634 fi 635 636 # Stuff in the actual top level. Currently only used by libsupc++ to 637 # get unwind* headers from the gcc dir. 638 #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc -I$(toplevel_srcdir)/include' 639 TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/gcc' 640 641 # Now, export this to all the little Makefiles.... 642 AC_SUBST(GLIBCXX_INCLUDES) 643 AC_SUBST(TOPLEVEL_INCLUDES) 644]) 645 646 647dnl 648dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's. 649dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.) 650dnl 651dnl Substs: 652dnl OPTIMIZE_CXXFLAGS 653dnl WARN_FLAGS 654dnl 655AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [ 656 # Optimization flags that are probably a good idea for thrill-seekers. Just 657 # uncomment the lines below and make, everything else is ready to go... 658 # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host. 659 # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc 660 AC_SUBST(OPTIMIZE_CXXFLAGS) 661 662 WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual' 663 AC_SUBST(WARN_FLAGS) 664]) 665 666 667dnl 668dnl All installation directory information is determined here. 669dnl 670dnl Substs: 671dnl gxx_install_dir 672dnl glibcxx_prefixdir 673dnl glibcxx_toolexecdir 674dnl glibcxx_toolexeclibdir 675dnl 676dnl Assumes cross_compiling bits already done, and with_cross_host in 677dnl particular. 678dnl 679dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir. 680dnl config/gxx-include-dir.m4 must be kept consistant with this as well. 681AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [ 682 glibcxx_toolexecdir=no 683 glibcxx_toolexeclibdir=no 684 glibcxx_prefixdir=$prefix 685 686 AC_MSG_CHECKING([for gxx-include-dir]) 687 AC_ARG_WITH([gxx-include-dir], 688 AC_HELP_STRING([--with-gxx-include-dir=DIR], 689 [installation directory for include files]), 690 [case "$withval" in 691 yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;; 692 no) gxx_include_dir=no ;; 693 *) gxx_include_dir=$withval ;; 694 esac], 695 [gxx_include_dir=no]) 696 AC_MSG_RESULT($gxx_include_dir) 697 698 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs]) 699 AC_ARG_ENABLE([version-specific-runtime-libs], 700 AC_HELP_STRING([--enable-version-specific-runtime-libs], 701 [Specify that runtime libraries should be installed in a compiler-specific directory]), 702 [case "$enableval" in 703 yes) version_specific_libs=yes ;; 704 no) version_specific_libs=no ;; 705 *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);; 706 esac], 707 [version_specific_libs=no]) 708 AC_MSG_RESULT($version_specific_libs) 709 710 # Default case for install directory for include files. 711 if test $version_specific_libs = no && test $gxx_include_dir = no; then 712 gxx_include_dir='include/c++/${gcc_version}' 713 if test -n "$with_cross_host" && 714 test x"$with_cross_host" != x"no"; then 715 gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir" 716 else 717 gxx_include_dir='${prefix}/'"$gxx_include_dir" 718 fi 719 fi 720 721 # Version-specific runtime libs processing. 722 if test $version_specific_libs = yes; then 723 # Need the gcc compiler version to know where to install libraries 724 # and header files if --enable-version-specific-runtime-libs option 725 # is selected. FIXME: these variables are misnamed, there are 726 # no executables installed in _toolexecdir or _toolexeclibdir. 727 if test x"$gxx_include_dir" = x"no"; then 728 gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++' 729 fi 730 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}' 731 glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)' 732 fi 733 734 # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir 735 # Install a library built with a cross compiler in tooldir, not libdir. 736 if test x"$glibcxx_toolexecdir" = x"no"; then 737 if test -n "$with_cross_host" && 738 test x"$with_cross_host" != x"no"; then 739 glibcxx_toolexecdir='${exec_prefix}/${host_alias}' 740 glibcxx_toolexeclibdir='${toolexecdir}/lib' 741 else 742 glibcxx_toolexecdir='${libdir}/gcc/${host_alias}' 743 glibcxx_toolexeclibdir='${libdir}' 744 fi 745 multi_os_directory=`$CXX -print-multi-os-directory` 746 case $multi_os_directory in 747 .) ;; # Avoid trailing /. 748 *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;; 749 esac 750 fi 751 752 AC_MSG_CHECKING([for install location]) 753 AC_MSG_RESULT($gxx_include_dir) 754 755 AC_SUBST(glibcxx_prefixdir) 756 AC_SUBST(gxx_include_dir) 757 AC_SUBST(glibcxx_toolexecdir) 758 AC_SUBST(glibcxx_toolexeclibdir) 759]) 760 761 762dnl 763dnl GLIBCXX_ENABLE 764dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING) 765dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c) 766dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER) 767dnl 768dnl See docs/html/17_intro/configury.html#enable for documentation. 769dnl 770m4_define([GLIBCXX_ENABLE],[dnl 771m4_define([_g_switch],[--enable-$1])dnl 772m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl 773 AC_ARG_ENABLE($1,_g_help, 774 m4_bmatch([$5], 775 [^permit ], 776 [[ 777 case "$enableval" in 778 m4_bpatsubst([$5],[permit ])) ;; 779 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;; 780 dnl Idea for future: generate a URL pointing to 781 dnl "onlinedocs/configopts.html#whatever" 782 esac 783 ]], 784 [^$], 785 [[ 786 case "$enableval" in 787 yes|no) ;; 788 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;; 789 esac 790 ]], 791 [[$5]]), 792 [enable_]m4_bpatsubst([$1],-,_)[=][$2]) 793m4_undefine([_g_switch])dnl 794m4_undefine([_g_help])dnl 795]) 796 797 798dnl 799dnl Check for ISO/IEC 9899:1999 "C99" support. 800dnl 801dnl --enable-c99 defines _GLIBCXX_USE_C99 802dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined 803dnl + Usage: GLIBCXX_ENABLE_C99[(DEFAULT)] 804dnl Where DEFAULT is either `yes' or `no'. 805dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'. 806dnl 807AC_DEFUN([GLIBCXX_ENABLE_C99], [ 808 GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support]) 809 810 if test x"$enable_c99" = x"yes"; then 811 812 AC_LANG_SAVE 813 AC_LANG_CPLUSPLUS 814 815 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__ 816 # undefined and fake C99 facilities - like pre-standard snprintf - may be 817 # spuriously enabled. 818 # Long term, -std=c++0x could be even better, could manage to explicitely 819 # request C99 facilities to the underlying C headers. 820 ac_save_CXXFLAGS="$CXXFLAGS" 821 CXXFLAGS="$CXXFLAGS -std=c++98" 822 ac_save_LIBS="$LIBS" 823 ac_save_gcc_no_link="$gcc_no_link" 824 825 if test x$gcc_no_link != xyes; then 826 # Use -fno-exceptions to that the C driver can link these tests without 827 # hitting undefined references to personality routines. 828 CXXFLAGS="$CXXFLAGS -fno-exceptions" 829 AC_CHECK_LIB(m, sin, [ 830 LIBS="$LIBS -lm" 831 ], [ 832 # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK 833 gcc_no_link=yes 834 ]) 835 fi 836 837 # Check for the existence of <math.h> functions used if C99 is enabled. 838 AC_MSG_CHECKING([for ISO C99 support in <math.h>]) 839 AC_CACHE_VAL(glibcxx_cv_c99_math, [ 840 GCC_TRY_COMPILE_OR_LINK( 841 [#include <math.h> 842 volatile double d1, d2; 843 volatile int i;], 844 [i = fpclassify(d1); 845 i = isfinite(d1); 846 i = isinf(d1); 847 i = isnan(d1); 848 i = isnormal(d1); 849 i = signbit(d1); 850 i = isgreater(d1, d2); 851 i = isgreaterequal(d1, d2); 852 i = isless(d1, d2); 853 i = islessequal(d1, d2); 854 i = islessgreater(d1, d2); 855 i = islessgreater(d1, d2); 856 i = isunordered(d1, d2); 857 ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no]) 858 ]) 859 AC_MSG_RESULT($glibcxx_cv_c99_math) 860 if test x"$glibcxx_cv_c99_math" = x"yes"; then 861 AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1, 862 [Define if C99 functions or macros in <math.h> should be imported 863 in <cmath> in namespace std.]) 864 fi 865 866 # Check for the existence of <complex.h> complex math functions. 867 # This is necessary even though libstdc++ uses the builtin versions 868 # of these functions, because if the builtin cannot be used, a reference 869 # to the library function is emitted. 870 AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no) 871 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no) 872 glibcxx_cv_c99_complex=no; 873 if test x"$ac_has_complex_h" = x"yes"; then 874 AC_MSG_CHECKING([for ISO C99 support in <complex.h>]) 875 GCC_TRY_COMPILE_OR_LINK( 876 [#include <complex.h> 877 typedef __complex__ float float_type; 878 typedef __complex__ double double_type; 879 typedef __complex__ long double ld_type; 880 volatile float_type tmpf; 881 volatile double_type tmpd; 882 volatile ld_type tmpld; 883 volatile float f; 884 volatile double d; 885 volatile long double ld;], 886 [f = cabsf(tmpf); 887 f = cargf(tmpf); 888 tmpf = ccosf(tmpf); 889 tmpf = ccoshf(tmpf); 890 tmpf = cexpf(tmpf); 891 tmpf = clogf(tmpf); 892 tmpf = csinf(tmpf); 893 tmpf = csinhf(tmpf); 894 tmpf = csqrtf(tmpf); 895 tmpf = ctanf(tmpf); 896 tmpf = ctanhf(tmpf); 897 tmpf = cpowf(tmpf, tmpf); 898 tmpf = cprojf(tmpf); 899 d = cabs(tmpd); 900 d = carg(tmpd); 901 tmpd = ccos(tmpd); 902 tmpd = ccosh(tmpd); 903 tmpd = cexp(tmpd); 904 tmpd = clog(tmpd); 905 tmpd = csin(tmpd); 906 tmpd = csinh(tmpd); 907 tmpd = csqrt(tmpd); 908 tmpd = ctan(tmpd); 909 tmpd = ctanh(tmpd); 910 tmpd = cpow(tmpd, tmpd); 911 tmpd = cproj(tmpd); 912 ld = cabsl(tmpld); 913 ld = cargl(tmpld); 914 tmpld = ccosl(tmpld); 915 tmpld = ccoshl(tmpld); 916 tmpld = cexpl(tmpld); 917 tmpld = clogl(tmpld); 918 tmpld = csinl(tmpld); 919 tmpld = csinhl(tmpld); 920 tmpld = csqrtl(tmpld); 921 tmpld = ctanl(tmpld); 922 tmpld = ctanhl(tmpld); 923 tmpld = cpowl(tmpld, tmpld); 924 tmpld = cprojl(tmpld); 925 ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no]) 926 fi 927 AC_MSG_RESULT($glibcxx_cv_c99_complex) 928 if test x"$glibcxx_cv_c99_complex" = x"yes"; then 929 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1, 930 [Define if C99 functions in <complex.h> should be used in 931 <complex>. Using compiler builtins for these functions requires 932 corresponding C99 library functions to be present.]) 933 fi 934 935 # Check for the existence in <stdio.h> of vscanf, et. al. 936 AC_MSG_CHECKING([for ISO C99 support in <stdio.h>]) 937 AC_CACHE_VAL(glibcxx_cv_c99_stdio, [ 938 GCC_TRY_COMPILE_OR_LINK( 939 [#include <stdio.h> 940 #include <stdarg.h> 941 void foo(char* fmt, ...) 942 { 943 va_list args; va_start(args, fmt); 944 vfscanf(stderr, "%i", args); 945 vscanf("%i", args); 946 vsnprintf(fmt, 0, "%i", args); 947 vsscanf(fmt, "%i", args); 948 }], 949 [snprintf("12", 0, "%i");], 950 [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no]) 951 ]) 952 AC_MSG_RESULT($glibcxx_cv_c99_stdio) 953 954 # Check for the existence in <stdlib.h> of lldiv_t, et. al. 955 AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>]) 956 AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [ 957 GCC_TRY_COMPILE_OR_LINK( 958 [#include <stdlib.h> 959 volatile float f; 960 volatile long double ld; 961 volatile unsigned long long ll; 962 lldiv_t mydivt;], 963 [char* tmp; 964 f = strtof("gnu", &tmp); 965 ld = strtold("gnu", &tmp); 966 ll = strtoll("gnu", &tmp, 10); 967 ll = strtoull("gnu", &tmp, 10); 968 ll = llabs(10); 969 mydivt = lldiv(10,1); 970 ll = mydivt.quot; 971 ll = mydivt.rem; 972 ll = atoll("10"); 973 _Exit(0); 974 ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no]) 975 ]) 976 AC_MSG_RESULT($glibcxx_cv_c99_stdlib) 977 978 # Check for the existence in <wchar.h> of wcstold, etc. 979 glibcxx_cv_c99_wchar=no; 980 if test x"$ac_has_wchar_h" = xyes && 981 test x"$ac_has_wctype_h" = xyes; then 982 AC_MSG_CHECKING([for ISO C99 support in <wchar.h>]) 983 AC_TRY_COMPILE([#include <wchar.h> 984 namespace test 985 { 986 using ::wcstold; 987 using ::wcstoll; 988 using ::wcstoull; 989 } 990 ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no]) 991 992 # Checks for wide character functions that may not be present. 993 # Injection of these is wrapped with guard macros. 994 # NB: only put functions here, instead of immediately above, if 995 # absolutely necessary. 996 AC_TRY_COMPILE([#include <wchar.h> 997 namespace test { using ::vfwscanf; } ], [], 998 [AC_DEFINE(HAVE_VFWSCANF,1, 999 [Defined if vfwscanf exists.])],[]) 1000 1001 AC_TRY_COMPILE([#include <wchar.h> 1002 namespace test { using ::vswscanf; } ], [], 1003 [AC_DEFINE(HAVE_VSWSCANF,1, 1004 [Defined if vswscanf exists.])],[]) 1005 1006 AC_TRY_COMPILE([#include <wchar.h> 1007 namespace test { using ::vwscanf; } ], [], 1008 [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[]) 1009 1010 AC_TRY_COMPILE([#include <wchar.h> 1011 namespace test { using ::wcstof; } ], [], 1012 [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[]) 1013 1014 AC_TRY_COMPILE([#include <wctype.h>], 1015 [ wint_t t; int i = iswblank(t);], 1016 [AC_DEFINE(HAVE_ISWBLANK,1, 1017 [Defined if iswblank exists.])],[]) 1018 1019 AC_MSG_RESULT($glibcxx_cv_c99_wchar) 1020 fi 1021 1022 # Option parsed, now set things appropriately. 1023 if test x"$glibcxx_cv_c99_math" = x"no" || 1024 test x"$glibcxx_cv_c99_complex" = x"no" || 1025 test x"$glibcxx_cv_c99_stdio" = x"no" || 1026 test x"$glibcxx_cv_c99_stdlib" = x"no" || 1027 test x"$glibcxx_cv_c99_wchar" = x"no"; then 1028 enable_c99=no; 1029 else 1030 AC_DEFINE(_GLIBCXX_USE_C99, 1, 1031 [Define if C99 functions or macros from <wchar.h>, <math.h>, 1032 <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.]) 1033 fi 1034 1035 gcc_no_link="$ac_save_gcc_no_link" 1036 LIBS="$ac_save_LIBS" 1037 CXXFLAGS="$ac_save_CXXFLAGS" 1038 AC_LANG_RESTORE 1039 fi 1040 1041 AC_MSG_CHECKING([for fully enabled ISO C99 support]) 1042 AC_MSG_RESULT($enable_c99) 1043]) 1044 1045 1046dnl 1047dnl Check for clock_gettime, nanosleep and sched_yield, used in the 1048dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this] 1049dnl in the current C++0x working draft. 1050dnl 1051dnl --enable-libstdcxx-time 1052dnl --enable-libstdcxx-time=yes 1053dnl checks for the availability of monotonic and realtime clocks, 1054dnl nanosleep and sched_yield in libc and libposix4 and, in case, links 1055dnl the latter 1056dnl --enable-libstdcxx-time=rt 1057dnl also searches (and, in case, links) librt. Note that this is 1058dnl not always desirable because, in glibc, for example, in turn it 1059dnl triggers the linking of libpthread too, which activates locking, 1060dnl a large overhead for single-thread programs. 1061dnl --enable-libstdcxx-time=no 1062dnl --disable-libstdcxx-time 1063dnl disables the checks completely 1064dnl 1065AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [ 1066 1067 AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield]) 1068 GLIBCXX_ENABLE(libstdcxx-time,$1,[=KIND], 1069 [use KIND for check type], 1070 [permit yes|no|rt]) 1071 1072 AC_LANG_SAVE 1073 AC_LANG_CPLUSPLUS 1074 ac_save_CXXFLAGS="$CXXFLAGS" 1075 CXXFLAGS="$CXXFLAGS -fno-exceptions" 1076 ac_save_LIBS="$LIBS" 1077 1078 ac_has_clock_monotonic=no 1079 ac_has_clock_realtime=no 1080 AC_MSG_RESULT($enable_libstdcxx_time) 1081 1082 if test x"$enable_libstdcxx_time" != x"no"; then 1083 1084 if test x"$enable_libstdcxx_time" = x"rt"; then 1085 AC_SEARCH_LIBS(clock_gettime, [rt posix4]) 1086 AC_SEARCH_LIBS(nanosleep, [rt posix4]) 1087 else 1088 AC_SEARCH_LIBS(clock_gettime, [posix4]) 1089 AC_SEARCH_LIBS(nanosleep, [posix4]) 1090 fi 1091 1092 case "$ac_cv_search_clock_gettime" in 1093 -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime 1094 ;; 1095 esac 1096 case "$ac_cv_search_nanosleep" in 1097 -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep" 1098 ;; 1099 esac 1100 1101 AC_SEARCH_LIBS(sched_yield, [rt posix4]) 1102 1103 case "$ac_cv_search_sched_yield" in 1104 -lposix4*) 1105 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield" 1106 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1, 1107 [ Defined if sched_yield is available. ]) 1108 ;; 1109 -lrt*) 1110 if test x"$enable_libstdcxx_time" = x"rt"; then 1111 GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield" 1112 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1, 1113 [ Defined if sched_yield is available. ]) 1114 fi 1115 ;; 1116 *) 1117 AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1, 1118 [ Defined if sched_yield is available. ]) 1119 ;; 1120 esac 1121 1122 AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no) 1123 1124 if test x"$ac_has_unistd_h" = x"yes"; then 1125 AC_MSG_CHECKING([for monotonic clock]) 1126 AC_TRY_LINK( 1127 [#include <unistd.h> 1128 #include <time.h> 1129 ], 1130 [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK) 1131 timespec tp; 1132 #endif 1133 clock_gettime(CLOCK_MONOTONIC, &tp); 1134 ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no]) 1135 1136 AC_MSG_RESULT($ac_has_clock_monotonic) 1137 1138 AC_MSG_CHECKING([for realtime clock]) 1139 AC_TRY_LINK( 1140 [#include <unistd.h> 1141 #include <time.h> 1142 ], 1143 [#if _POSIX_TIMERS > 0 1144 timespec tp; 1145 #endif 1146 clock_gettime(CLOCK_REALTIME, &tp); 1147 ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no]) 1148 1149 AC_MSG_RESULT($ac_has_clock_realtime) 1150 1151 AC_MSG_CHECKING([for nanosleep]) 1152 AC_TRY_LINK( 1153 [#include <unistd.h> 1154 #include <time.h> 1155 ], 1156 [#if _POSIX_TIMERS > 0 1157 timespec tp; 1158 #endif 1159 nanosleep(&tp, 0); 1160 ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no]) 1161 1162 AC_MSG_RESULT($ac_has_nanosleep) 1163 fi 1164 fi 1165 1166 if test x"$ac_has_clock_monotonic" = x"yes"; then 1167 AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1, 1168 [ Defined if clock_gettime has monotonic clock support. ]) 1169 fi 1170 1171 if test x"$ac_has_clock_realtime" = x"yes"; then 1172 AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1, 1173 [ Defined if clock_gettime has realtime clock support. ]) 1174 fi 1175 1176 if test x"$ac_has_nanosleep" = x"yes"; then 1177 AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1, 1178 [ Defined if nanosleep is available. ]) 1179 fi 1180 1181 AC_SUBST(GLIBCXX_LIBS) 1182 1183 CXXFLAGS="$ac_save_CXXFLAGS" 1184 LIBS="$ac_save_LIBS" 1185 AC_LANG_RESTORE 1186]) 1187 1188dnl 1189dnl Check for gettimeofday, used in the implementation of 20.8.5 1190dnl [time.clock] in the current C++0x working draft. 1191dnl 1192AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [ 1193 1194 AC_MSG_CHECKING([for gettimeofday]) 1195 1196 AC_LANG_SAVE 1197 AC_LANG_CPLUSPLUS 1198 ac_save_CXXFLAGS="$CXXFLAGS" 1199 CXXFLAGS="$CXXFLAGS -fno-exceptions" 1200 1201 ac_has_gettimeofday=no; 1202 AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no) 1203 if test x"$ac_has_sys_time_h" = x"yes"; then 1204 AC_MSG_CHECKING([for gettimeofday]) 1205 GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>], 1206 [timeval tv; gettimeofday(&tv, 0);], 1207 [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no]) 1208 1209 AC_MSG_RESULT($ac_has_gettimeofday) 1210 fi 1211 1212 if test x"$ac_has_gettimeofday" = x"yes"; then 1213 AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1, 1214 [ Defined if gettimeofday is available. ]) 1215 fi 1216 1217 CXXFLAGS="$ac_save_CXXFLAGS" 1218 AC_LANG_RESTORE 1219]) 1220 1221dnl 1222dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1" 1223dnl facilities in Chapter 8, "C compatibility". 1224dnl 1225AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [ 1226 1227 AC_LANG_SAVE 1228 AC_LANG_CPLUSPLUS 1229 1230 # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__ 1231 # undefined and fake C99 facilities may be spuriously enabled. 1232 ac_save_CXXFLAGS="$CXXFLAGS" 1233 CXXFLAGS="$CXXFLAGS -std=c++98" 1234 1235 # Check for the existence of <complex.h> complex math functions used 1236 # by tr1/complex. 1237 AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no) 1238 ac_c99_complex_tr1=no; 1239 if test x"$ac_has_complex_h" = x"yes"; then 1240 AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>]) 1241 AC_TRY_COMPILE([#include <complex.h>], 1242 [typedef __complex__ float float_type; float_type tmpf; 1243 cacosf(tmpf); 1244 casinf(tmpf); 1245 catanf(tmpf); 1246 cacoshf(tmpf); 1247 casinhf(tmpf); 1248 catanhf(tmpf); 1249 typedef __complex__ double double_type; double_type tmpd; 1250 cacos(tmpd); 1251 casin(tmpd); 1252 catan(tmpd); 1253 cacosh(tmpd); 1254 casinh(tmpd); 1255 catanh(tmpd); 1256 typedef __complex__ long double ld_type; ld_type tmpld; 1257 cacosl(tmpld); 1258 casinl(tmpld); 1259 catanl(tmpld); 1260 cacoshl(tmpld); 1261 casinhl(tmpld); 1262 catanhl(tmpld); 1263 ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no]) 1264 fi 1265 AC_MSG_RESULT($ac_c99_complex_tr1) 1266 if test x"$ac_c99_complex_tr1" = x"yes"; then 1267 AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1, 1268 [Define if C99 functions in <complex.h> should be used in 1269 <tr1/complex>. Using compiler builtins for these functions 1270 requires corresponding C99 library functions to be present.]) 1271 fi 1272 1273 # Check for the existence of <ctype.h> functions. 1274 AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>]) 1275 AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [ 1276 AC_TRY_COMPILE([#include <ctype.h>], 1277 [int ch; 1278 int ret; 1279 ret = isblank(ch); 1280 ],[glibcxx_cv_c99_ctype_tr1=yes], 1281 [glibcxx_cv_c99_ctype_tr1=no]) 1282 ]) 1283 AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1) 1284 if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then 1285 AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1, 1286 [Define if C99 functions in <ctype.h> should be imported in 1287 <tr1/cctype> in namespace std::tr1.]) 1288 fi 1289 1290 # Check for the existence of <fenv.h> functions. 1291 AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no) 1292 ac_c99_fenv_tr1=no; 1293 if test x"$ac_has_fenv_h" = x"yes"; then 1294 AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>]) 1295 AC_TRY_COMPILE([#include <fenv.h>], 1296 [int except, mode; 1297 fexcept_t* pflag; 1298 fenv_t* penv; 1299 int ret; 1300 ret = feclearexcept(except); 1301 ret = fegetexceptflag(pflag, except); 1302 ret = feraiseexcept(except); 1303 ret = fesetexceptflag(pflag, except); 1304 ret = fetestexcept(except); 1305 ret = fegetround(); 1306 ret = fesetround(mode); 1307 ret = fegetenv(penv); 1308 ret = feholdexcept(penv); 1309 ret = fesetenv(penv); 1310 ret = feupdateenv(penv); 1311 ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no]) 1312 fi 1313 AC_MSG_RESULT($ac_c99_fenv_tr1) 1314 if test x"$ac_c99_fenv_tr1" = x"yes"; then 1315 AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1, 1316 [Define if C99 functions in <fenv.h> should be imported in 1317 <tr1/cfenv> in namespace std::tr1.]) 1318 fi 1319 1320 # Check for the existence of <stdint.h> types. 1321 AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>]) 1322 AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [ 1323 AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS 1324 #define __STDC_CONSTANT_MACROS 1325 #include <stdint.h>], 1326 [typedef int8_t my_int8_t; 1327 my_int8_t i8 = INT8_MIN; 1328 i8 = INT8_MAX; 1329 typedef int16_t my_int16_t; 1330 my_int16_t i16 = INT16_MIN; 1331 i16 = INT16_MAX; 1332 typedef int32_t my_int32_t; 1333 my_int32_t i32 = INT32_MIN; 1334 i32 = INT32_MAX; 1335 typedef int64_t my_int64_t; 1336 my_int64_t i64 = INT64_MIN; 1337 i64 = INT64_MAX; 1338 typedef int_fast8_t my_int_fast8_t; 1339 my_int_fast8_t if8 = INT_FAST8_MIN; 1340 if8 = INT_FAST8_MAX; 1341 typedef int_fast16_t my_int_fast16_t; 1342 my_int_fast16_t if16 = INT_FAST16_MIN; 1343 if16 = INT_FAST16_MAX; 1344 typedef int_fast32_t my_int_fast32_t; 1345 my_int_fast32_t if32 = INT_FAST32_MIN; 1346 if32 = INT_FAST32_MAX; 1347 typedef int_fast64_t my_int_fast64_t; 1348 my_int_fast64_t if64 = INT_FAST64_MIN; 1349 if64 = INT_FAST64_MAX; 1350 typedef int_least8_t my_int_least8_t; 1351 my_int_least8_t il8 = INT_LEAST8_MIN; 1352 il8 = INT_LEAST8_MAX; 1353 typedef int_least16_t my_int_least16_t; 1354 my_int_least16_t il16 = INT_LEAST16_MIN; 1355 il16 = INT_LEAST16_MAX; 1356 typedef int_least32_t my_int_least32_t; 1357 my_int_least32_t il32 = INT_LEAST32_MIN; 1358 il32 = INT_LEAST32_MAX; 1359 typedef int_least64_t my_int_least64_t; 1360 my_int_least64_t il64 = INT_LEAST64_MIN; 1361 il64 = INT_LEAST64_MAX; 1362 typedef intmax_t my_intmax_t; 1363 my_intmax_t im = INTMAX_MAX; 1364 im = INTMAX_MIN; 1365 typedef intptr_t my_intptr_t; 1366 my_intptr_t ip = INTPTR_MAX; 1367 ip = INTPTR_MIN; 1368 typedef uint8_t my_uint8_t; 1369 my_uint8_t ui8 = UINT8_MAX; 1370 ui8 = UINT8_MAX; 1371 typedef uint16_t my_uint16_t; 1372 my_uint16_t ui16 = UINT16_MAX; 1373 ui16 = UINT16_MAX; 1374 typedef uint32_t my_uint32_t; 1375 my_uint32_t ui32 = UINT32_MAX; 1376 ui32 = UINT32_MAX; 1377 typedef uint64_t my_uint64_t; 1378 my_uint64_t ui64 = UINT64_MAX; 1379 ui64 = UINT64_MAX; 1380 typedef uint_fast8_t my_uint_fast8_t; 1381 my_uint_fast8_t uif8 = UINT_FAST8_MAX; 1382 uif8 = UINT_FAST8_MAX; 1383 typedef uint_fast16_t my_uint_fast16_t; 1384 my_uint_fast16_t uif16 = UINT_FAST16_MAX; 1385 uif16 = UINT_FAST16_MAX; 1386 typedef uint_fast32_t my_uint_fast32_t; 1387 my_uint_fast32_t uif32 = UINT_FAST32_MAX; 1388 uif32 = UINT_FAST32_MAX; 1389 typedef uint_fast64_t my_uint_fast64_t; 1390 my_uint_fast64_t uif64 = UINT_FAST64_MAX; 1391 uif64 = UINT_FAST64_MAX; 1392 typedef uint_least8_t my_uint_least8_t; 1393 my_uint_least8_t uil8 = UINT_LEAST8_MAX; 1394 uil8 = UINT_LEAST8_MAX; 1395 typedef uint_least16_t my_uint_least16_t; 1396 my_uint_least16_t uil16 = UINT_LEAST16_MAX; 1397 uil16 = UINT_LEAST16_MAX; 1398 typedef uint_least32_t my_uint_least32_t; 1399 my_uint_least32_t uil32 = UINT_LEAST32_MAX; 1400 uil32 = UINT_LEAST32_MAX; 1401 typedef uint_least64_t my_uint_least64_t; 1402 my_uint_least64_t uil64 = UINT_LEAST64_MAX; 1403 uil64 = UINT_LEAST64_MAX; 1404 typedef uintmax_t my_uintmax_t; 1405 my_uintmax_t uim = UINTMAX_MAX; 1406 uim = UINTMAX_MAX; 1407 typedef uintptr_t my_uintptr_t; 1408 my_uintptr_t uip = UINTPTR_MAX; 1409 uip = UINTPTR_MAX; 1410 ],[glibcxx_cv_c99_stdint_tr1=yes], 1411 [glibcxx_cv_c99_stdint_tr1=no]) 1412 ]) 1413 AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1) 1414 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then 1415 AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1, 1416 [Define if C99 types in <stdint.h> should be imported in 1417 <tr1/cstdint> in namespace std::tr1.]) 1418 fi 1419 1420 # Check for the existence of <math.h> functions. 1421 AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>]) 1422 AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [ 1423 AC_TRY_COMPILE([#include <math.h>], 1424 [typedef double_t my_double_t; 1425 typedef float_t my_float_t; 1426 acosh(0.0); 1427 acoshf(0.0f); 1428 acoshl(0.0l); 1429 asinh(0.0); 1430 asinhf(0.0f); 1431 asinhl(0.0l); 1432 atanh(0.0); 1433 atanhf(0.0f); 1434 atanhl(0.0l); 1435 cbrt(0.0); 1436 cbrtf(0.0f); 1437 cbrtl(0.0l); 1438 copysign(0.0, 0.0); 1439 copysignf(0.0f, 0.0f); 1440 copysignl(0.0l, 0.0l); 1441 erf(0.0); 1442 erff(0.0f); 1443 erfl(0.0l); 1444 erfc(0.0); 1445 erfcf(0.0f); 1446 erfcl(0.0l); 1447 exp2(0.0); 1448 exp2f(0.0f); 1449 exp2l(0.0l); 1450 expm1(0.0); 1451 expm1f(0.0f); 1452 expm1l(0.0l); 1453 fdim(0.0, 0.0); 1454 fdimf(0.0f, 0.0f); 1455 fdiml(0.0l, 0.0l); 1456 fma(0.0, 0.0, 0.0); 1457 fmaf(0.0f, 0.0f, 0.0f); 1458 fmal(0.0l, 0.0l, 0.0l); 1459 fmax(0.0, 0.0); 1460 fmaxf(0.0f, 0.0f); 1461 fmaxl(0.0l, 0.0l); 1462 fmin(0.0, 0.0); 1463 fminf(0.0f, 0.0f); 1464 fminl(0.0l, 0.0l); 1465 hypot(0.0, 0.0); 1466 hypotf(0.0f, 0.0f); 1467 hypotl(0.0l, 0.0l); 1468 ilogb(0.0); 1469 ilogbf(0.0f); 1470 ilogbl(0.0l); 1471 lgamma(0.0); 1472 lgammaf(0.0f); 1473 lgammal(0.0l); 1474 llrint(0.0); 1475 llrintf(0.0f); 1476 llrintl(0.0l); 1477 llround(0.0); 1478 llroundf(0.0f); 1479 llroundl(0.0l); 1480 log1p(0.0); 1481 log1pf(0.0f); 1482 log1pl(0.0l); 1483 log2(0.0); 1484 log2f(0.0f); 1485 log2l(0.0l); 1486 logb(0.0); 1487 logbf(0.0f); 1488 logbl(0.0l); 1489 lrint(0.0); 1490 lrintf(0.0f); 1491 lrintl(0.0l); 1492 lround(0.0); 1493 lroundf(0.0f); 1494 lroundl(0.0l); 1495 nan(0); 1496 nanf(0); 1497 nanl(0); 1498 nearbyint(0.0); 1499 nearbyintf(0.0f); 1500 nearbyintl(0.0l); 1501 nextafter(0.0, 0.0); 1502 nextafterf(0.0f, 0.0f); 1503 nextafterl(0.0l, 0.0l); 1504 nexttoward(0.0, 0.0); 1505 nexttowardf(0.0f, 0.0f); 1506 nexttowardl(0.0l, 0.0l); 1507 remainder(0.0, 0.0); 1508 remainderf(0.0f, 0.0f); 1509 remainderl(0.0l, 0.0l); 1510 remquo(0.0, 0.0, 0); 1511 remquof(0.0f, 0.0f, 0); 1512 remquol(0.0l, 0.0l, 0); 1513 rint(0.0); 1514 rintf(0.0f); 1515 rintl(0.0l); 1516 round(0.0); 1517 roundf(0.0f); 1518 roundl(0.0l); 1519 scalbln(0.0, 0l); 1520 scalblnf(0.0f, 0l); 1521 scalblnl(0.0l, 0l); 1522 scalbn(0.0, 0); 1523 scalbnf(0.0f, 0); 1524 scalbnl(0.0l, 0); 1525 tgamma(0.0); 1526 tgammaf(0.0f); 1527 tgammal(0.0l); 1528 trunc(0.0); 1529 truncf(0.0f); 1530 truncl(0.0l); 1531 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no]) 1532 ]) 1533 AC_MSG_RESULT($glibcxx_cv_c99_math_tr1) 1534 if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then 1535 AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1, 1536 [Define if C99 functions or macros in <math.h> should be imported 1537 in <tr1/cmath> in namespace std::tr1.]) 1538 fi 1539 1540 # Check for the existence of <inttypes.h> functions (NB: doesn't make 1541 # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1). 1542 ac_c99_inttypes_tr1=no; 1543 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then 1544 AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>]) 1545 AC_TRY_COMPILE([#include <inttypes.h>], 1546 [intmax_t i, numer, denom, base; 1547 const char* s; 1548 char** endptr; 1549 intmax_t ret = imaxabs(i); 1550 imaxdiv_t dret = imaxdiv(numer, denom); 1551 ret = strtoimax(s, endptr, base); 1552 uintmax_t uret = strtoumax(s, endptr, base); 1553 ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no]) 1554 fi 1555 AC_MSG_RESULT($ac_c99_inttypes_tr1) 1556 if test x"$ac_c99_inttypes_tr1" = x"yes"; then 1557 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1, 1558 [Define if C99 functions in <inttypes.h> should be imported in 1559 <tr1/cinttypes> in namespace std::tr1.]) 1560 fi 1561 1562 # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't 1563 # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1). 1564 ac_c99_inttypes_wchar_t_tr1=no; 1565 if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then 1566 AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>]) 1567 AC_TRY_COMPILE([#include <inttypes.h>], 1568 [intmax_t base; 1569 const wchar_t* s; 1570 wchar_t** endptr; 1571 intmax_t ret = wcstoimax(s, endptr, base); 1572 uintmax_t uret = wcstoumax(s, endptr, base); 1573 ],[ac_c99_inttypes_wchar_t_tr1=yes], 1574 [ac_c99_inttypes_wchar_t_tr1=no]) 1575 fi 1576 AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1) 1577 if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then 1578 AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1, 1579 [Define if wchar_t C99 functions in <inttypes.h> should be 1580 imported in <tr1/cinttypes> in namespace std::tr1.]) 1581 fi 1582 1583 # Check for the existence of the <stdbool.h> header. 1584 AC_CHECK_HEADERS(stdbool.h) 1585 1586 CXXFLAGS="$ac_save_CXXFLAGS" 1587 AC_LANG_RESTORE 1588]) 1589 1590dnl 1591dnl Check whether "/dev/random" and "/dev/urandom" are available for the 1592dnl random_device of "TR1" (Chapter 5.1, "Random number generation"). 1593dnl 1594AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [ 1595 1596 AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device]) 1597 AC_CACHE_VAL(glibcxx_cv_random_tr1, [ 1598 if test -r /dev/random && test -r /dev/urandom; then 1599 glibcxx_cv_random_tr1=yes; 1600 else 1601 glibcxx_cv_random_tr1=no; 1602 fi 1603 ]) 1604 AC_MSG_RESULT($glibcxx_cv_random_tr1) 1605 1606 if test x"$glibcxx_cv_random_tr1" = x"yes"; then 1607 AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1, 1608 [Define if /dev/random and /dev/urandom are available for 1609 the random_device of TR1 (Chapter 5.1).]) 1610 fi 1611 1612]) 1613 1614dnl 1615dnl Check whether EOF, SEEK_CUR, and SEEK_END have the most common values: 1616dnl in that case including <cstdio> in some C++ headers can be avoided. 1617dnl 1618AC_DEFUN([GLIBCXX_CHECK_STDIO_MACROS], [ 1619 1620 AC_MSG_CHECKING([for EOF == -1, SEEK_CUR == 1, SEEK_END == 2]) 1621 AC_CACHE_VAL(glibcxx_cv_stdio_macros, [ 1622 AC_TRY_COMPILE([#include <stdio.h>], 1623 [#if ((EOF != -1) || (SEEK_CUR != 1) || (SEEK_END != 2)) 1624 unusual values... 1625 #endif 1626 ], [glibcxx_cv_stdio_macros=yes], 1627 [glibcxx_cv_stdio_macros=no]) 1628 ]) 1629 AC_MSG_RESULT($glibcxx_cv_stdio_macros) 1630 if test x"$glibcxx_cv_stdio_macros" = x"yes"; then 1631 AC_DEFINE(_GLIBCXX_STDIO_MACROS, 1, 1632 [Define if EOF == -1, SEEK_CUR == 1, SEEK_END == 2.]) 1633 fi 1634 1635]) 1636 1637dnl 1638dnl Check whether macros, etc are present for <system_error> 1639dnl 1640AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [ 1641 1642m4_pushdef([n_syserr], [1])dnl 1643m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA, 1644 ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED, 1645 EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY], 1646[m4_pushdef([SYSERR], m4_toupper(syserr))dnl 1647AC_MSG_CHECKING([for syserr]) 1648AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [ 1649AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]], 1650 [int i = syserr;])], 1651 [glibcxx_cv_system_error[]n_syserr=yes], 1652 [glibcxx_cv_system_error[]n_syserr=no]) 1653]) 1654AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr]) 1655if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then 1656 AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.]) 1657fi 1658m4_define([n_syserr], m4_incr(n_syserr))dnl 1659m4_popdef([SYSERR])dnl 1660]) 1661m4_popdef([n_syserr])dnl 1662]) 1663 1664dnl 1665dnl Check for what type of C headers to use. 1666dnl 1667dnl --enable-cheaders= [does stuff]. 1668dnl --disable-cheaders [does not do anything, really]. 1669dnl + Usage: GLIBCXX_ENABLE_CHEADERS[(DEFAULT)] 1670dnl Where DEFAULT is either 'c' or 'c_std' or 'c_global'. 1671dnl 1672AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [ 1673 GLIBCXX_ENABLE(cheaders,$1,[=KIND], 1674 [construct "C" headers for g++], [permit c|c_std|c_global]) 1675 AC_MSG_NOTICE("C" header strategy set to $enable_cheaders) 1676 1677 C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders 1678 1679 # Allow overrides to configure.host here. 1680 if test $enable_cheaders = c_global; then 1681 c_compatibility=yes 1682 fi 1683 1684 if test $enable_cheaders = c_global || test $enable_cheaders = c_std; then 1685 c_extra=yes 1686 fi 1687 1688 AC_SUBST(C_INCLUDE_DIR) 1689 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c) 1690 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std) 1691 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global) 1692 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes) 1693 GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_EXTRA, test $c_extra = yes) 1694]) 1695 1696 1697dnl 1698dnl Check for which locale library to use. The choice is mapped to 1699dnl a subdirectory of config/locale. 1700dnl 1701dnl Default is generic. 1702dnl 1703AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [ 1704 GLIBCXX_ENABLE(clocale,auto,[@<:@=MODEL@:>@], 1705 [use MODEL for target locale package], 1706 [permit generic|gnu|ieee_1003.1-2001|yes|no|auto]) 1707 1708 # Deal with gettext issues. Default to not using it (=no) until we detect 1709 # support for it later. Let the user turn it off via --e/d, but let that 1710 # default to on for easier handling. 1711 USE_NLS=no 1712 AC_ARG_ENABLE(nls, 1713 AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]), 1714 [], 1715 [enable_nls=yes]) 1716 1717 # Either a known packaage, or "auto" 1718 if test $enable_clocale = no || test $enable_clocale = yes; then 1719 enable_clocale=auto 1720 fi 1721 enable_clocale_flag=$enable_clocale 1722 1723 # Probe for locale model to use if none specified. 1724 # Default to "generic". 1725 if test $enable_clocale_flag = auto; then 1726 case ${target_os} in 1727 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) 1728 enable_clocale_flag=gnu 1729 ;; 1730 darwin* | freebsd*) 1731 enable_clocale_flag=darwin 1732 ;; 1733 *) 1734 enable_clocale_flag=generic 1735 ;; 1736 esac 1737 fi 1738 1739 # Sanity check model, and test for special functionality. 1740 if test $enable_clocale_flag = gnu; then 1741 AC_EGREP_CPP([_GLIBCXX_ok], [ 1742 #include <features.h> 1743 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) 1744 _GLIBCXX_ok 1745 #endif 1746 ], enable_clocale_flag=gnu, enable_clocale_flag=generic) 1747 1748 if test $enable_clocale = auto; then 1749 # Test for bugs early in glibc-2.2.x series 1750 AC_TRY_RUN([ 1751 #define _GNU_SOURCE 1 1752 #include <locale.h> 1753 #include <string.h> 1754 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) 1755 extern __typeof(newlocale) __newlocale; 1756 extern __typeof(duplocale) __duplocale; 1757 extern __typeof(strcoll_l) __strcoll_l; 1758 #endif 1759 int main() 1760 { 1761 const char __one[] = "�uglein Augmen"; 1762 const char __two[] = "�uglein"; 1763 int i; 1764 int j; 1765 __locale_t loc; 1766 __locale_t loc_dup; 1767 loc = __newlocale(1 << LC_ALL, "de_DE", 0); 1768 loc_dup = __duplocale(loc); 1769 i = __strcoll_l(__one, __two, loc); 1770 j = __strcoll_l(__one, __two, loc_dup); 1771 return 0; 1772 } 1773 ], 1774 [enable_clocale_flag=gnu],[enable_clocale_flag=generic], 1775 [enable_clocale_flag=generic]) 1776 fi 1777 1778 # Set it to scream when it hurts. 1779 ac_save_CFLAGS="$CFLAGS" 1780 CFLAGS="-Wimplicit-function-declaration -Werror" 1781 1782 # Use strxfrm_l if available. 1783 AC_TRY_COMPILE([#define _GNU_SOURCE 1 1784 #include <string.h> 1785 #include <locale.h>], 1786 [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);], 1787 AC_DEFINE(HAVE_STRXFRM_L, 1, 1788 [Define if strxfrm_l is available in <string.h>.]),) 1789 1790 # Use strerror_l if available. 1791 AC_TRY_COMPILE([#define _GNU_SOURCE 1 1792 #include <string.h> 1793 #include <locale.h>], 1794 [__locale_t loc; strerror_l(5, loc);], 1795 AC_DEFINE(HAVE_STRERROR_L, 1, 1796 [Define if strerror_l is available in <string.h>.]),) 1797 1798 CFLAGS="$ac_save_CFLAGS" 1799 fi 1800 1801 # Perhaps use strerror_r if available, and strerror_l isn't. 1802 ac_save_CFLAGS="$CFLAGS" 1803 CFLAGS="-Wimplicit-function-declaration -Werror" 1804 AC_TRY_COMPILE([#define _GNU_SOURCE 1 1805 #include <string.h> 1806 #include <locale.h>], 1807 [char s[128]; strerror_r(5, s, 128);], 1808 AC_DEFINE(HAVE_STRERROR_R, 1, 1809 [Define if strerror_r is available in <string.h>.]),) 1810 CFLAGS="$ac_save_CFLAGS" 1811 1812 # Set configure bits for specified locale package 1813 AC_MSG_CHECKING([for C locale to use]) 1814 case ${enable_clocale_flag} in 1815 generic) 1816 AC_MSG_RESULT(generic) 1817 1818 CLOCALE_H=config/locale/generic/c_locale.h 1819 CLOCALE_CC=config/locale/generic/c_locale.cc 1820 CCODECVT_CC=config/locale/generic/codecvt_members.cc 1821 CCOLLATE_CC=config/locale/generic/collate_members.cc 1822 CCTYPE_CC=config/locale/generic/ctype_members.cc 1823 CMESSAGES_H=config/locale/generic/messages_members.h 1824 CMESSAGES_CC=config/locale/generic/messages_members.cc 1825 CMONEY_CC=config/locale/generic/monetary_members.cc 1826 CNUMERIC_CC=config/locale/generic/numeric_members.cc 1827 CTIME_H=config/locale/generic/time_members.h 1828 CTIME_CC=config/locale/generic/time_members.cc 1829 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 1830 ;; 1831 darwin) 1832 AC_MSG_RESULT(darwin or freebsd) 1833 1834 CLOCALE_H=config/locale/generic/c_locale.h 1835 CLOCALE_CC=config/locale/generic/c_locale.cc 1836 CCODECVT_CC=config/locale/generic/codecvt_members.cc 1837 CCOLLATE_CC=config/locale/generic/collate_members.cc 1838 CCTYPE_CC=config/locale/darwin/ctype_members.cc 1839 CMESSAGES_H=config/locale/generic/messages_members.h 1840 CMESSAGES_CC=config/locale/generic/messages_members.cc 1841 CMONEY_CC=config/locale/generic/monetary_members.cc 1842 CNUMERIC_CC=config/locale/generic/numeric_members.cc 1843 CTIME_H=config/locale/generic/time_members.h 1844 CTIME_CC=config/locale/generic/time_members.cc 1845 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 1846 ;; 1847 1848 gnu) 1849 AC_MSG_RESULT(gnu) 1850 1851 # Declare intention to use gettext, and add support for specific 1852 # languages. 1853 # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT 1854 ALL_LINGUAS="de fr" 1855 1856 # Don't call AM-GNU-GETTEXT here. Instead, assume glibc. 1857 AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no) 1858 if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then 1859 USE_NLS=yes 1860 fi 1861 # Export the build objects. 1862 for ling in $ALL_LINGUAS; do \ 1863 glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \ 1864 glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \ 1865 done 1866 AC_SUBST(glibcxx_MOFILES) 1867 AC_SUBST(glibcxx_POFILES) 1868 1869 CLOCALE_H=config/locale/gnu/c_locale.h 1870 CLOCALE_CC=config/locale/gnu/c_locale.cc 1871 CCODECVT_CC=config/locale/gnu/codecvt_members.cc 1872 CCOLLATE_CC=config/locale/gnu/collate_members.cc 1873 CCTYPE_CC=config/locale/gnu/ctype_members.cc 1874 CMESSAGES_H=config/locale/gnu/messages_members.h 1875 CMESSAGES_CC=config/locale/gnu/messages_members.cc 1876 CMONEY_CC=config/locale/gnu/monetary_members.cc 1877 CNUMERIC_CC=config/locale/gnu/numeric_members.cc 1878 CTIME_H=config/locale/gnu/time_members.h 1879 CTIME_CC=config/locale/gnu/time_members.cc 1880 CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h 1881 ;; 1882 ieee_1003.1-2001) 1883 AC_MSG_RESULT(IEEE 1003.1) 1884 1885 CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h 1886 CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc 1887 CCODECVT_CC=config/locale/generic/codecvt_members.cc 1888 CCOLLATE_CC=config/locale/generic/collate_members.cc 1889 CCTYPE_CC=config/locale/generic/ctype_members.cc 1890 CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h 1891 CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc 1892 CMONEY_CC=config/locale/generic/monetary_members.cc 1893 CNUMERIC_CC=config/locale/generic/numeric_members.cc 1894 CTIME_H=config/locale/generic/time_members.h 1895 CTIME_CC=config/locale/generic/time_members.cc 1896 CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h 1897 ;; 1898 esac 1899 1900 # This is where the testsuite looks for locale catalogs, using the 1901 # -DLOCALEDIR define during testsuite compilation. 1902 glibcxx_localedir=${glibcxx_builddir}/po/share/locale 1903 AC_SUBST(glibcxx_localedir) 1904 1905 # A standalone libintl (e.g., GNU libintl) may be in use. 1906 if test $USE_NLS = yes; then 1907 AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no) 1908 AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no) 1909 fi 1910 if test $USE_NLS = yes; then 1911 AC_DEFINE(_GLIBCXX_USE_NLS, 1, 1912 [Define if NLS translations are to be used.]) 1913 fi 1914 1915 AC_SUBST(USE_NLS) 1916 AC_SUBST(CLOCALE_H) 1917 AC_SUBST(CMESSAGES_H) 1918 AC_SUBST(CCODECVT_CC) 1919 AC_SUBST(CCOLLATE_CC) 1920 AC_SUBST(CCTYPE_CC) 1921 AC_SUBST(CMESSAGES_CC) 1922 AC_SUBST(CMONEY_CC) 1923 AC_SUBST(CNUMERIC_CC) 1924 AC_SUBST(CTIME_H) 1925 AC_SUBST(CTIME_CC) 1926 AC_SUBST(CLOCALE_CC) 1927 AC_SUBST(CLOCALE_INTERNAL_H) 1928]) 1929 1930 1931dnl 1932dnl Check for which std::allocator base class to use. The choice is 1933dnl mapped from a subdirectory of include/ext. 1934dnl 1935dnl Default is new. 1936dnl 1937AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [ 1938 AC_MSG_CHECKING([for std::allocator base class]) 1939 GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND], 1940 [use KIND for target std::allocator base], 1941 [permit new|malloc|mt|bitmap|pool|yes|no|auto]) 1942 1943 # If they didn't use this option switch, or if they specified --enable 1944 # with no specific model, we'll have to look for one. If they 1945 # specified --disable (???), do likewise. 1946 if test $enable_libstdcxx_allocator = no || 1947 test $enable_libstdcxx_allocator = yes; 1948 then 1949 enable_libstdcxx_allocator=auto 1950 fi 1951 1952 # Either a known package, or "auto". Auto implies the default choice 1953 # for a particular platform. 1954 enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator 1955 1956 # Probe for host-specific support if no specific model is specified. 1957 # Default to "new". 1958 if test $enable_libstdcxx_allocator_flag = auto; then 1959 case ${target_os} in 1960 linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu) 1961 enable_libstdcxx_allocator_flag=new 1962 ;; 1963 *) 1964 enable_libstdcxx_allocator_flag=new 1965 ;; 1966 esac 1967 fi 1968 AC_MSG_RESULT($enable_libstdcxx_allocator_flag) 1969 1970 1971 # Set configure bits for specified locale package 1972 case ${enable_libstdcxx_allocator_flag} in 1973 bitmap) 1974 ALLOCATOR_H=config/allocator/bitmap_allocator_base.h 1975 ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator 1976 ;; 1977 malloc) 1978 ALLOCATOR_H=config/allocator/malloc_allocator_base.h 1979 ALLOCATOR_NAME=__gnu_cxx::malloc_allocator 1980 ;; 1981 mt) 1982 ALLOCATOR_H=config/allocator/mt_allocator_base.h 1983 ALLOCATOR_NAME=__gnu_cxx::__mt_alloc 1984 ;; 1985 new) 1986 ALLOCATOR_H=config/allocator/new_allocator_base.h 1987 ALLOCATOR_NAME=__gnu_cxx::new_allocator 1988 ;; 1989 pool) 1990 ALLOCATOR_H=config/allocator/pool_allocator_base.h 1991 ALLOCATOR_NAME=__gnu_cxx::__pool_alloc 1992 ;; 1993 esac 1994 1995 AC_SUBST(ALLOCATOR_H) 1996 AC_SUBST(ALLOCATOR_NAME) 1997]) 1998 1999 2000dnl 2001dnl Check for whether the Boost-derived checks should be turned on. 2002dnl 2003dnl --enable-concept-checks turns them on. 2004dnl --disable-concept-checks leaves them off. 2005dnl + Usage: GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)] 2006dnl Where DEFAULT is either `yes' or `no'. 2007dnl 2008AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [ 2009 GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks]) 2010 if test $enable_concept_checks = yes; then 2011 AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1, 2012 [Define to use concept checking code from the boost libraries.]) 2013 fi 2014]) 2015 2016dnl 2017dnl Check for parallel mode pre-requisites, including OpenMP support. 2018dnl 2019dnl + Usage: GLIBCXX_ENABLE_PARALLEL 2020dnl 2021AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [ 2022 2023 enable_parallel=no; 2024 2025 # See if configured libgomp/omp.h exists. (libgomp may be in 2026 # noconfigdirs but not explicitly disabled.) 2027 if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then 2028 enable_parallel=yes; 2029 else 2030 AC_MSG_NOTICE([target-libgomp not built]) 2031 fi 2032 2033 AC_MSG_CHECKING([for parallel mode support]) 2034 AC_MSG_RESULT([$enable_parallel]) 2035 GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes) 2036]) 2037 2038 2039dnl 2040dnl Check for which I/O library to use: stdio, or something specific. 2041dnl 2042dnl Default is stdio. 2043dnl 2044AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [ 2045 AC_MSG_CHECKING([for underlying I/O to use]) 2046 GLIBCXX_ENABLE(cstdio,stdio,[=PACKAGE], 2047 [use target-specific I/O package], [permit stdio]) 2048 2049 # Now that libio has been removed, you can have any color you want as long 2050 # as it's black. This is one big no-op until other packages are added, but 2051 # showing the framework never hurts. 2052 case ${enable_cstdio} in 2053 stdio) 2054 CSTDIO_H=config/io/c_io_stdio.h 2055 BASIC_FILE_H=config/io/basic_file_stdio.h 2056 BASIC_FILE_CC=config/io/basic_file_stdio.cc 2057 AC_MSG_RESULT(stdio) 2058 ;; 2059 esac 2060 2061 AC_SUBST(CSTDIO_H) 2062 AC_SUBST(BASIC_FILE_H) 2063 AC_SUBST(BASIC_FILE_CC) 2064]) 2065 2066 2067dnl 2068dnl Check for "unusual" flags to pass to the compiler while building. 2069dnl 2070dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing 2071dnl experimental flags such as -fpch, -fIMI, -Dfloat=char, etc. 2072dnl --disable-cxx-flags passes nothing. 2073dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html 2074dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html 2075dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html 2076dnl + Usage: GLIBCXX_ENABLE_CXX_FLAGS(default flags) 2077dnl If "default flags" is an empty string, the effect is the same 2078dnl as --disable or --enable=no. 2079dnl 2080AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl 2081 AC_MSG_CHECKING([for extra compiler flags for building]) 2082 GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS], 2083 [pass compiler FLAGS when building library], 2084 [case "x$enable_cxx_flags" in 2085 xno | x) enable_cxx_flags= ;; 2086 x-*) ;; 2087 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;; 2088 esac]) 2089 2090 # Run through flags (either default or command-line) and set anything 2091 # extra (e.g., #defines) that must accompany particular g++ options. 2092 if test -n "$enable_cxx_flags"; then 2093 for f in $enable_cxx_flags; do 2094 case "$f" in 2095 -fhonor-std) ;; 2096 -*) ;; 2097 *) # and we're trying to pass /what/ exactly? 2098 AC_MSG_ERROR([compiler flags start with a -]) ;; 2099 esac 2100 done 2101 fi 2102 2103 EXTRA_CXX_FLAGS="$enable_cxx_flags" 2104 AC_MSG_RESULT($EXTRA_CXX_FLAGS) 2105 AC_SUBST(EXTRA_CXX_FLAGS) 2106]) 2107 2108 2109dnl 2110dnl Check to see if debugging libraries are to be built. 2111dnl 2112dnl --enable-libstdcxx-debug 2113dnl builds a separate set of debugging libraries in addition to the 2114dnl normal (shared, static) libstdc++ binaries. 2115dnl 2116dnl --disable-libstdcxx-debug 2117dnl builds only one (non-debug) version of libstdc++. 2118dnl 2119dnl --enable-libstdcxx-debug-flags=FLAGS 2120dnl iff --enable-debug == yes, then use FLAGS to build the debug library. 2121dnl 2122dnl + Usage: GLIBCXX_ENABLE_DEBUG[(DEFAULT)] 2123dnl Where DEFAULT is either `yes' or `no'. 2124dnl 2125AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [ 2126 AC_MSG_CHECKING([for additional debug build]) 2127 GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library]) 2128 AC_MSG_RESULT($enable_libstdcxx_debug) 2129 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes) 2130]) 2131 2132 2133dnl 2134dnl Check for explicit debug flags. 2135dnl 2136dnl --enable-libstdcxx-debug-flags='-O1' 2137dnl is a general method for passing flags to be used when 2138dnl building debug libraries with --enable-debug. 2139dnl 2140dnl --disable-libstdcxx-debug-flags does nothing. 2141dnl + Usage: GLIBCXX_ENABLE_DEBUG_FLAGS(default flags) 2142dnl If "default flags" is an empty string, the effect is the same 2143dnl as --disable or --enable=no. 2144dnl 2145AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [ 2146 GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS], 2147 [pass compiler FLAGS when building debug library], 2148 [case "x$enable_libstdcxx_debug_flags" in 2149 xno | x) enable_libstdcxx_debug_flags= ;; 2150 x-*) ;; 2151 *) AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;; 2152 esac]) 2153 2154 # Option parsed, now set things appropriately 2155 DEBUG_FLAGS="$enable_libstdcxx_debug_flags" 2156 AC_SUBST(DEBUG_FLAGS) 2157 2158 AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS]) 2159]) 2160 2161 2162dnl 2163dnl Check if the user only wants a freestanding library implementation. 2164dnl 2165dnl --disable-hosted-libstdcxx will turn off most of the library build, 2166dnl installing only the headers required by [17.4.1.3] and the language 2167dnl support library. More than that will be built (to keep the Makefiles 2168dnl conveniently clean), but not installed. 2169dnl 2170dnl Sets: 2171dnl is_hosted (yes/no) 2172dnl 2173dnl Defines: 2174dnl _GLIBCXX_HOSTED (always defined, either to 1 or 0) 2175dnl 2176AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [ 2177 AC_ARG_ENABLE([hosted-libstdcxx], 2178 AC_HELP_STRING([--disable-hosted-libstdcxx], 2179 [only build freestanding C++ runtime support]),, 2180 [case "$host" in 2181 arm*-*-symbianelf*) 2182 enable_hosted_libstdcxx=no 2183 ;; 2184 *) 2185 enable_hosted_libstdcxx=yes 2186 ;; 2187 esac]) 2188 if test "$enable_hosted_libstdcxx" = no; then 2189 AC_MSG_NOTICE([Only freestanding libraries will be built]) 2190 is_hosted=no 2191 hosted_define=0 2192 enable_abi_check=no 2193 enable_libstdcxx_pch=no 2194 else 2195 is_hosted=yes 2196 hosted_define=1 2197 fi 2198 GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes) 2199 AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define, 2200 [Define to 1 if a full hosted library is built, or 0 if freestanding.]) 2201]) 2202 2203 2204dnl 2205dnl Check for template specializations for the 'long long' type. 2206dnl The result determines only whether 'long long' I/O is enabled; things 2207dnl like numeric_limits<> specializations are always available. 2208dnl 2209dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG 2210dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined 2211dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)] 2212dnl Where DEFAULT is either `yes' or `no'. 2213dnl 2214AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [ 2215 GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long']) 2216 if test $enable_long_long = yes; then 2217 AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1, 2218 [Define if code specialized for long long should be used.]) 2219 fi 2220 AC_MSG_CHECKING([for enabled long long specializations]) 2221 AC_MSG_RESULT([$enable_long_long]) 2222]) 2223 2224 2225dnl 2226dnl Check for decimal floating point. 2227dnl See: 2228dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float 2229dnl 2230dnl This checks to see if the host supports decimal floating point types. 2231dnl 2232dnl Defines: 2233dnl _GLIBCXX_USE_DECIMAL_FLOAT 2234dnl 2235AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [ 2236 2237 # Fake what AC_TRY_COMPILE does, without linking as this is 2238 # unnecessary for this test. 2239 2240 cat > conftest.$ac_ext << EOF 2241[#]line __oline__ "configure" 2242int main() 2243{ 2244 _Decimal32 d1; 2245 _Decimal64 d2; 2246 _Decimal128 d3; 2247 return 0; 2248} 2249EOF 2250 2251 AC_MSG_CHECKING([for ISO/IEC TR 24733 ]) 2252 if AC_TRY_EVAL(ac_compile); then 2253 AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1, 2254 [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.]) 2255 enable_dfp=yes 2256 else 2257 enable_dfp=no 2258 fi 2259 AC_MSG_RESULT($enable_dfp) 2260 rm -f conftest* 2261]) 2262 2263dnl 2264dnl Check for template specializations for the 'wchar_t' type. 2265dnl 2266dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T 2267dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined 2268dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)] 2269dnl Where DEFAULT is either `yes' or `no'. 2270dnl 2271dnl Necessary support must also be present. 2272dnl 2273AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [ 2274 GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t']) 2275 2276 # Test wchar.h for mbstate_t, which is needed for char_traits and fpos. 2277 AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no) 2278 AC_MSG_CHECKING([for mbstate_t]) 2279 AC_TRY_COMPILE([#include <wchar.h>], 2280 [mbstate_t teststate;], 2281 have_mbstate_t=yes, have_mbstate_t=no) 2282 AC_MSG_RESULT($have_mbstate_t) 2283 if test x"$have_mbstate_t" = xyes; then 2284 AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.]) 2285 fi 2286 2287 # Test it always, for use in GLIBCXX_ENABLE_C99, together with 2288 # ac_has_wchar_h. 2289 AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no) 2290 2291 if test x"$enable_wchar_t" = x"yes"; then 2292 2293 AC_LANG_SAVE 2294 AC_LANG_CPLUSPLUS 2295 2296 if test x"$ac_has_wchar_h" = xyes && 2297 test x"$ac_has_wctype_h" = xyes; then 2298 AC_TRY_COMPILE([#include <wchar.h> 2299 #include <stddef.h> 2300 wint_t i; 2301 long l = WEOF; 2302 long j = WCHAR_MIN; 2303 long k = WCHAR_MAX; 2304 namespace test 2305 { 2306 using ::btowc; 2307 using ::fgetwc; 2308 using ::fgetws; 2309 using ::fputwc; 2310 using ::fputws; 2311 using ::fwide; 2312 using ::fwprintf; 2313 using ::fwscanf; 2314 using ::getwc; 2315 using ::getwchar; 2316 using ::mbrlen; 2317 using ::mbrtowc; 2318 using ::mbsinit; 2319 using ::mbsrtowcs; 2320 using ::putwc; 2321 using ::putwchar; 2322 using ::swprintf; 2323 using ::swscanf; 2324 using ::ungetwc; 2325 using ::vfwprintf; 2326 using ::vswprintf; 2327 using ::vwprintf; 2328 using ::wcrtomb; 2329 using ::wcscat; 2330 using ::wcschr; 2331 using ::wcscmp; 2332 using ::wcscoll; 2333 using ::wcscpy; 2334 using ::wcscspn; 2335 using ::wcsftime; 2336 using ::wcslen; 2337 using ::wcsncat; 2338 using ::wcsncmp; 2339 using ::wcsncpy; 2340 using ::wcspbrk; 2341 using ::wcsrchr; 2342 using ::wcsrtombs; 2343 using ::wcsspn; 2344 using ::wcsstr; 2345 using ::wcstod; 2346 using ::wcstok; 2347 using ::wcstol; 2348 using ::wcstoul; 2349 using ::wcsxfrm; 2350 using ::wctob; 2351 using ::wmemchr; 2352 using ::wmemcmp; 2353 using ::wmemcpy; 2354 using ::wmemmove; 2355 using ::wmemset; 2356 using ::wprintf; 2357 using ::wscanf; 2358 } 2359 ],[],[], [enable_wchar_t=no]) 2360 else 2361 enable_wchar_t=no 2362 fi 2363 2364 AC_LANG_RESTORE 2365 fi 2366 2367 if test x"$enable_wchar_t" = x"yes"; then 2368 AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1, 2369 [Define if code specialized for wchar_t should be used.]) 2370 fi 2371 2372 AC_MSG_CHECKING([for enabled wchar_t specializations]) 2373 AC_MSG_RESULT([$enable_wchar_t]) 2374]) 2375 2376 2377dnl 2378dnl Check to see if building and using a C++ precompiled header can be done. 2379dnl 2380dnl --enable-libstdcxx-pch=yes 2381dnl default, this shows intent to use stdc++.h.gch If it looks like it 2382dnl may work, after some light-hearted attempts to puzzle out compiler 2383dnl support, flip bits on in include/Makefile.am 2384dnl 2385dnl --disable-libstdcxx-pch 2386dnl turns off attempts to use or build stdc++.h.gch. 2387dnl 2388dnl Substs: 2389dnl glibcxx_PCHFLAGS 2390dnl 2391AC_DEFUN([GLIBCXX_ENABLE_PCH], [ 2392 GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers]) 2393 if test $enable_libstdcxx_pch = yes; then 2394 AC_CACHE_CHECK([for compiler with PCH support], 2395 [glibcxx_cv_prog_CXX_pch], 2396 [ac_save_CXXFLAGS="$CXXFLAGS" 2397 CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated" 2398 AC_LANG_SAVE 2399 AC_LANG_CPLUSPLUS 2400 echo '#include <math.h>' > conftest.h 2401 if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \ 2402 -o conftest.h.gch 1>&5 2>&1 && 2403 echo '#error "pch failed"' > conftest.h && 2404 echo '#include "conftest.h"' > conftest.cc && 2405 $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ; 2406 then 2407 glibcxx_cv_prog_CXX_pch=yes 2408 else 2409 glibcxx_cv_prog_CXX_pch=no 2410 fi 2411 rm -f conftest* 2412 CXXFLAGS=$ac_save_CXXFLAGS 2413 AC_LANG_RESTORE 2414 ]) 2415 enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch 2416 fi 2417 2418 AC_MSG_CHECKING([for enabled PCH]) 2419 AC_MSG_RESULT([$enable_libstdcxx_pch]) 2420 2421 GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes) 2422 if test $enable_libstdcxx_pch = yes; then 2423 glibcxx_PCHFLAGS="-include bits/stdc++.h" 2424 else 2425 glibcxx_PCHFLAGS="" 2426 fi 2427 AC_SUBST(glibcxx_PCHFLAGS) 2428]) 2429 2430 2431dnl 2432dnl Check for atomic builtins. 2433dnl See: 2434dnl http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html#Atomic-Builtins 2435dnl 2436dnl This checks to see if the host supports the compiler-generated 2437dnl builtins for atomic operations for various integral sizes. Note, this 2438dnl is intended to be an all-or-nothing switch, so all the atomic operations 2439dnl that are used should be checked. 2440dnl 2441dnl Note: 2442dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD. 2443dnl 2444dnl Defines: 2445dnl _GLIBCXX_ATOMIC_BUILTINS_1 2446dnl _GLIBCXX_ATOMIC_BUILTINS_2 2447dnl _GLIBCXX_ATOMIC_BUILTINS_4 2448dnl _GLIBCXX_ATOMIC_BUILTINS_8 2449dnl 2450AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [ 2451 AC_LANG_SAVE 2452 AC_LANG_CPLUSPLUS 2453 old_CXXFLAGS="$CXXFLAGS" 2454 2455 # Do link tests if possible, instead asm tests, limited to some platforms 2456 # see discussion in PR target/40134, PR libstdc++/40133 and the thread 2457 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html 2458 atomic_builtins_link_tests=no 2459 if test x$gcc_no_link != xyes; then 2460 # Can do link tests. Limit to some tested platforms 2461 case "$host" in 2462 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*) 2463 atomic_builtins_link_tests=yes 2464 ;; 2465 esac 2466 fi 2467 2468 if test x$atomic_builtins_link_tests = xyes; then 2469 2470 # Do link tests. 2471 2472 CXXFLAGS="$CXXFLAGS -fno-exceptions" 2473 2474 AC_MSG_CHECKING([for atomic builtins for bool]) 2475 AC_CACHE_VAL(glibcxx_cv_atomic_bool, [ 2476 AC_TRY_LINK( 2477 [ ], 2478 [typedef bool atomic_type; 2479 atomic_type c1; 2480 atomic_type c2; 2481 const atomic_type c3(0); 2482 __sync_fetch_and_add(&c1, c2); 2483 __sync_val_compare_and_swap(&c1, c3, c2); 2484 __sync_lock_test_and_set(&c1, c3); 2485 __sync_lock_release(&c1); 2486 __sync_synchronize();], 2487 [glibcxx_cv_atomic_bool=yes], 2488 [glibcxx_cv_atomic_bool=no]) 2489 ]) 2490 if test $glibcxx_cv_atomic_bool = yes; then 2491 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1, 2492 [Define if builtin atomic operations for bool are supported on this host.]) 2493 fi 2494 AC_MSG_RESULT($glibcxx_cv_atomic_bool) 2495 2496 AC_MSG_CHECKING([for atomic builtins for short]) 2497 AC_CACHE_VAL(glibcxx_cv_atomic_short, [ 2498 AC_TRY_LINK( 2499 [ ], 2500 [typedef short atomic_type; 2501 atomic_type c1; 2502 atomic_type c2; 2503 const atomic_type c3(0); 2504 __sync_fetch_and_add(&c1, c2); 2505 __sync_val_compare_and_swap(&c1, c3, c2); 2506 __sync_lock_test_and_set(&c1, c3); 2507 __sync_lock_release(&c1); 2508 __sync_synchronize();], 2509 [glibcxx_cv_atomic_short=yes], 2510 [glibcxx_cv_atomic_short=no]) 2511 ]) 2512 if test $glibcxx_cv_atomic_short = yes; then 2513 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1, 2514 [Define if builtin atomic operations for short are supported on this host.]) 2515 fi 2516 AC_MSG_RESULT($glibcxx_cv_atomic_short) 2517 2518 AC_MSG_CHECKING([for atomic builtins for int]) 2519 AC_CACHE_VAL(glibcxx_cv_atomic_int, [ 2520 AC_TRY_LINK( 2521 [ ], 2522 [typedef int atomic_type; 2523 atomic_type c1; 2524 atomic_type c2; 2525 const atomic_type c3(0); 2526 __sync_fetch_and_add(&c1, c2); 2527 __sync_val_compare_and_swap(&c1, c3, c2); 2528 __sync_lock_test_and_set(&c1, c3); 2529 __sync_lock_release(&c1); 2530 __sync_synchronize();], 2531 [glibcxx_cv_atomic_int=yes], 2532 [glibcxx_cv_atomic_int=no]) 2533 ]) 2534 if test $glibcxx_cv_atomic_int = yes; then 2535 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1, 2536 [Define if builtin atomic operations for int are supported on this host.]) 2537 fi 2538 AC_MSG_RESULT($glibcxx_cv_atomic_int) 2539 2540 AC_MSG_CHECKING([for atomic builtins for long long]) 2541 AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [ 2542 AC_TRY_LINK( 2543 [ ], 2544 [typedef long long atomic_type; 2545 atomic_type c1; 2546 atomic_type c2; 2547 const atomic_type c3(0); 2548 __sync_fetch_and_add(&c1, c2); 2549 __sync_val_compare_and_swap(&c1, c3, c2); 2550 __sync_lock_test_and_set(&c1, c3); 2551 __sync_lock_release(&c1); 2552 __sync_synchronize();], 2553 [glibcxx_cv_atomic_long_long=yes], 2554 [glibcxx_cv_atomic_long_long=no]) 2555 ]) 2556 if test $glibcxx_cv_atomic_long_long = yes; then 2557 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1, 2558 [Define if builtin atomic operations for long long are supported on this host.]) 2559 fi 2560 AC_MSG_RESULT($glibcxx_cv_atomic_long_long) 2561 2562 else 2563 2564 # Do asm tests. 2565 2566 # Compile unoptimized. 2567 CXXFLAGS='-O0 -S' 2568 2569 # Fake what AC_TRY_COMPILE does. 2570 2571 cat > conftest.$ac_ext << EOF 2572[#]line __oline__ "configure" 2573int main() 2574{ 2575 typedef bool atomic_type; 2576 atomic_type c1; 2577 atomic_type c2; 2578 const atomic_type c3(0); 2579 __sync_fetch_and_add(&c1, c2); 2580 __sync_val_compare_and_swap(&c1, c3, c2); 2581 __sync_lock_test_and_set(&c1, c3); 2582 __sync_lock_release(&c1); 2583 __sync_synchronize(); 2584 return 0; 2585} 2586EOF 2587 2588 AC_MSG_CHECKING([for atomic builtins for bool]) 2589 if AC_TRY_EVAL(ac_compile); then 2590 if grep __sync_ conftest.s >/dev/null 2>&1 ; then 2591 glibcxx_cv_atomic_bool=no 2592 else 2593 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_1, 1, 2594 [Define if builtin atomic operations for bool are supported on this host.]) 2595 glibcxx_cv_atomic_bool=yes 2596 fi 2597 fi 2598 AC_MSG_RESULT($glibcxx_cv_atomic_bool) 2599 rm -f conftest* 2600 2601 cat > conftest.$ac_ext << EOF 2602[#]line __oline__ "configure" 2603int main() 2604{ 2605 typedef short atomic_type; 2606 atomic_type c1; 2607 atomic_type c2; 2608 const atomic_type c3(0); 2609 __sync_fetch_and_add(&c1, c2); 2610 __sync_val_compare_and_swap(&c1, c3, c2); 2611 __sync_lock_test_and_set(&c1, c3); 2612 __sync_lock_release(&c1); 2613 __sync_synchronize(); 2614 return 0; 2615} 2616EOF 2617 2618 AC_MSG_CHECKING([for atomic builtins for short]) 2619 if AC_TRY_EVAL(ac_compile); then 2620 if grep __sync_ conftest.s >/dev/null 2>&1 ; then 2621 glibcxx_cv_atomic_short=no 2622 else 2623 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_2, 1, 2624 [Define if builtin atomic operations for short are supported on this host.]) 2625 glibcxx_cv_atomic_short=yes 2626 fi 2627 fi 2628 AC_MSG_RESULT($glibcxx_cv_atomic_short) 2629 rm -f conftest* 2630 2631 cat > conftest.$ac_ext << EOF 2632[#]line __oline__ "configure" 2633int main() 2634{ 2635 // NB: _Atomic_word not necessarily int. 2636 typedef int atomic_type; 2637 atomic_type c1; 2638 atomic_type c2; 2639 const atomic_type c3(0); 2640 __sync_fetch_and_add(&c1, c2); 2641 __sync_val_compare_and_swap(&c1, c3, c2); 2642 __sync_lock_test_and_set(&c1, c3); 2643 __sync_lock_release(&c1); 2644 __sync_synchronize(); 2645 return 0; 2646} 2647EOF 2648 2649 AC_MSG_CHECKING([for atomic builtins for int]) 2650 if AC_TRY_EVAL(ac_compile); then 2651 if grep __sync_ conftest.s >/dev/null 2>&1 ; then 2652 glibcxx_cv_atomic_int=no 2653 else 2654 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_4, 1, 2655 [Define if builtin atomic operations for int are supported on this host.]) 2656 glibcxx_cv_atomic_int=yes 2657 fi 2658 fi 2659 AC_MSG_RESULT($glibcxx_cv_atomic_int) 2660 rm -f conftest* 2661 2662 cat > conftest.$ac_ext << EOF 2663[#]line __oline__ "configure" 2664int main() 2665{ 2666 typedef long long atomic_type; 2667 atomic_type c1; 2668 atomic_type c2; 2669 const atomic_type c3(0); 2670 __sync_fetch_and_add(&c1, c2); 2671 __sync_val_compare_and_swap(&c1, c3, c2); 2672 __sync_lock_test_and_set(&c1, c3); 2673 __sync_lock_release(&c1); 2674 __sync_synchronize(); 2675 return 0; 2676} 2677EOF 2678 2679 AC_MSG_CHECKING([for atomic builtins for long long]) 2680 if AC_TRY_EVAL(ac_compile); then 2681 if grep __sync_ conftest.s >/dev/null 2>&1 ; then 2682 glibcxx_cv_atomic_long_long=no 2683 else 2684 AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS_8, 1, 2685 [Define if builtin atomic operations for long long are supported on this host.]) 2686 glibcxx_cv_atomic_long_long=yes 2687 fi 2688 fi 2689 AC_MSG_RESULT($glibcxx_cv_atomic_long_long) 2690 rm -f conftest* 2691 2692 fi 2693 2694 CXXFLAGS="$old_CXXFLAGS" 2695 AC_LANG_RESTORE 2696 2697 # Set atomicity_dir to builtins if either of above tests pass. 2698 if test $glibcxx_cv_atomic_int = yes || test $glibcxx_cv_atomic_bool = yes ; then 2699 atomicity_dir=cpu/generic/atomicity_builtins 2700 fi 2701 2702 # If still generic, set to mutex. 2703 if test $atomicity_dir = "cpu/generic" ; then 2704 atomicity_dir=cpu/generic/atomicity_mutex 2705 AC_MSG_WARN([No native atomic operations are provided for this platform.]) 2706 if test "x$target_thread_file" = xsingle; then 2707 AC_MSG_WARN([They cannot be faked when thread support is disabled.]) 2708 AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.]) 2709 else 2710 AC_MSG_WARN([They will be faked using a mutex.]) 2711 AC_MSG_WARN([Performance of certain classes will degrade as a result.]) 2712 fi 2713 fi 2714 2715]) 2716 2717 2718dnl 2719dnl Check for exception handling support. If an explicit enable/disable 2720dnl sjlj exceptions is given, we don't have to detect. Otherwise the 2721dnl target may or may not support call frame exceptions. 2722dnl 2723dnl --enable-sjlj-exceptions forces the use of builtin setjmp. 2724dnl --disable-sjlj-exceptions forces the use of call frame unwinding. 2725dnl Neither one forces an attempt at detection. 2726dnl 2727dnl Defines: 2728dnl _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it 2729dnl 2730AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [ 2731 AC_MSG_CHECKING([for exception model to use]) 2732 AC_LANG_SAVE 2733 AC_LANG_CPLUSPLUS 2734 GLIBCXX_ENABLE(sjlj-exceptions,auto,, 2735 [force use of builtin_setjmp for exceptions], 2736 [permit yes|no|auto]) 2737 2738 if test $enable_sjlj_exceptions = auto; then 2739 # Botheration. Now we've got to detect the exception model. Link tests 2740 # against libgcc.a are problematic since we've not been given proper -L 2741 # bits for single-tree newlib and libgloss. 2742 # 2743 # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style. 2744 cat > conftest.$ac_ext << EOF 2745[#]line __oline__ "configure" 2746struct S { ~S(); }; 2747void bar(); 2748void foo() 2749{ 2750 S s; 2751 bar(); 2752} 2753EOF 2754 old_CXXFLAGS="$CXXFLAGS" 2755 CXXFLAGS=-S 2756 if AC_TRY_EVAL(ac_compile); then 2757 if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then 2758 enable_sjlj_exceptions=yes 2759 elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then 2760 enable_sjlj_exceptions=no 2761 elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then 2762 enable_sjlj_exceptions=no 2763 fi 2764 fi 2765 CXXFLAGS="$old_CXXFLAGS" 2766 rm -f conftest* 2767 fi 2768 2769 # This is a tad weird, for hysterical raisins. We have to map 2770 # enable/disable to two different models. 2771 case $enable_sjlj_exceptions in 2772 yes) 2773 AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1, 2774 [Define if the compiler is configured for setjmp/longjmp exceptions.]) 2775 ac_exception_model_name=sjlj 2776 ;; 2777 no) 2778 ac_exception_model_name="call frame" 2779 ;; 2780 *) 2781 AC_MSG_ERROR([unable to detect exception model]) 2782 ;; 2783 esac 2784 AC_LANG_RESTORE 2785 AC_MSG_RESULT($ac_exception_model_name) 2786]) 2787 2788 2789dnl 2790dnl Allow visibility attributes to be used on namespaces, objects, etc. 2791dnl 2792dnl --enable-visibility enables attempt to use visibility attributes. 2793dnl --disable-visibility turns off all use of visibility attributes. 2794dnl + Usage: GLIBCXX_ENABLE_VISIBILITY[(DEFAULT)] 2795dnl Where DEFAULT is 'yes'. 2796dnl 2797AC_DEFUN([GLIBCXX_ENABLE_VISIBILITY], [ 2798GLIBCXX_ENABLE(visibility,$1,,[enables visibility safe usage]) 2799 2800if test x$enable_visibility = xyes ; then 2801 dnl all hail libgfortran 2802 dnl Check whether the target supports hidden visibility. 2803 AC_CACHE_CHECK([whether the target supports hidden visibility], 2804 glibcxx_cv_have_attribute_visibility, [ 2805 save_CFLAGS="$CFLAGS" 2806 CFLAGS="$CFLAGS -Werror" 2807 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }], 2808 [], glibcxx_cv_have_attribute_visibility=yes, 2809 glibcxx_cv_have_attribute_visibility=no) 2810 CFLAGS="$save_CFLAGS"]) 2811 if test $glibcxx_cv_have_attribute_visibility = no; then 2812 enable_visibility=no 2813 fi 2814fi 2815 2816GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_visibility = yes) 2817AC_MSG_NOTICE([visibility supported: $enable_visibility]) 2818]) 2819 2820 2821dnl 2822dnl Add version tags to symbols in shared library (or not), additionally 2823dnl marking other symbols as private/local (or not). 2824dnl 2825dnl --enable-symvers=style adds a version script to the linker call when 2826dnl creating the shared library. The choice of version script is 2827dnl controlled by 'style'. 2828dnl --disable-symvers does not. 2829dnl + Usage: GLIBCXX_ENABLE_SYMVERS[(DEFAULT)] 2830dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to 2831dnl choose a default style based on linker characteristics. Passing 2832dnl 'no' disables versioning. 2833dnl 2834AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [ 2835 2836GLIBCXX_ENABLE(symvers,$1,[=STYLE], 2837 [enables symbol versioning of the shared library], 2838 [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export]) 2839 2840# If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we 2841# don't know enough about $LD to do tricks... 2842AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES]) 2843 2844# Turn a 'yes' into a suitable default. 2845if test x$enable_symvers = xyes ; then 2846 if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then 2847 enable_symvers=no 2848 else 2849 if test $with_gnu_ld = yes ; then 2850 case ${target_os} in 2851 hpux*) 2852 enable_symvers=no ;; 2853 *) 2854 enable_symvers=gnu ;; 2855 esac 2856 else 2857 case ${target_os} in 2858 darwin*) 2859 enable_symvers=darwin ;; 2860 *) 2861 enable_symvers=no ;; 2862 esac 2863 fi 2864 fi 2865fi 2866 2867# Check to see if 'darwin' or 'darwin-export' can win. 2868if test x$enable_symvers = xdarwin-export ; then 2869 enable_symvers=darwin 2870fi 2871 2872# Check to see if 'gnu' can win. 2873if test $enable_symvers = gnu || test $enable_symvers = gnu-versioned-namespace; then 2874 # Check to see if libgcc_s exists, indicating that shared libgcc is possible. 2875 AC_MSG_CHECKING([for shared libgcc]) 2876 ac_save_CFLAGS="$CFLAGS" 2877 CFLAGS=' -lgcc_s' 2878 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no) 2879 CFLAGS="$ac_save_CFLAGS" 2880 if test $glibcxx_shared_libgcc = no; then 2881 cat > conftest.c <<EOF 2882int main (void) { return 0; } 2883EOF 2884changequote(,)dnl 2885 glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \ 2886 -shared -shared-libgcc -o conftest.so \ 2887 conftest.c -v 2>&1 >/dev/null \ 2888 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'` 2889changequote([,])dnl 2890 rm -f conftest.c conftest.so 2891 if test x${glibcxx_libgcc_s_suffix+set} = xset; then 2892 CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix" 2893 AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes) 2894 CFLAGS="$ac_save_CFLAGS" 2895 fi 2896 fi 2897 AC_MSG_RESULT($glibcxx_shared_libgcc) 2898 2899 # For GNU ld, we need at least this version. The format is described in 2900 # GLIBCXX_CHECK_LINKER_FEATURES above. 2901 glibcxx_min_gnu_ld_version=21400 2902 2903 # If no shared libgcc, can't win. 2904 if test $glibcxx_shared_libgcc != yes; then 2905 AC_MSG_WARN([=== You have requested GNU symbol versioning, but]) 2906 AC_MSG_WARN([=== you are not building a shared libgcc_s.]) 2907 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 2908 enable_symvers=no 2909 elif test $with_gnu_ld != yes ; then 2910 # just fail for now 2911 AC_MSG_WARN([=== You have requested GNU symbol versioning, but]) 2912 AC_MSG_WARN([=== you are not using the GNU linker.]) 2913 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 2914 enable_symvers=no 2915 elif test $glibcxx_ld_is_gold = yes ; then 2916 : All versions of gold support symbol versioning. 2917 elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then 2918 # The right tools, the right setup, but too old. Fallbacks? 2919 AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for) 2920 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.) 2921 AC_MSG_WARN(=== You would need to upgrade your binutils to version) 2922 AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.) 2923 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 2924 enable_symvers=no 2925 fi 2926fi 2927 2928# Everything parsed; figure out what file to use. 2929case $enable_symvers in 2930 no) 2931 SYMVER_FILE=config/abi/pre/none.ver 2932 ;; 2933 gnu) 2934 SYMVER_FILE=config/abi/pre/gnu.ver 2935 AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1, 2936 [Define to use GNU versioning in the shared library.]) 2937 ;; 2938 gnu-versioned-namespace) 2939 SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver 2940 AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1, 2941 [Define to use GNU namespace versioning in the shared library.]) 2942 ;; 2943 darwin) 2944 SYMVER_FILE=config/abi/pre/gnu.ver 2945 AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1, 2946 [Define to use darwin versioning in the shared library.]) 2947 ;; 2948esac 2949 2950if test x$enable_symvers != xno ; then 2951 AC_DEFINE(_GLIBCXX_SYMVER, 1, 2952 [Define to use symbol versioning in the shared library.]) 2953fi 2954 2955AC_CACHE_CHECK([whether the target supports .symver directive], 2956 glibcxx_cv_have_as_symver_directive, [ 2957 AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");], 2958 [], glibcxx_cv_have_as_symver_directive=yes, 2959 glibcxx_cv_have_as_symver_directive=no)]) 2960if test $glibcxx_cv_have_as_symver_directive = yes; then 2961 AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1, 2962 [Define to 1 if the target assembler supports .symver directive.]) 2963fi 2964 2965AC_SUBST(SYMVER_FILE) 2966AC_SUBST(port_specific_symbol_files) 2967GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no) 2968GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu) 2969GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace) 2970GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin) 2971AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers) 2972 2973# Now, set up compatibility support, if any. 2974# In addition, need this to deal with std::size_t mangling in 2975# src/compatibility.cc. In a perfect world, could use 2976# typeid(std::size_t).name()[0] to do direct substitution. 2977AC_MSG_CHECKING([for size_t as unsigned int]) 2978ac_save_CFLAGS="$CFLAGS" 2979CFLAGS="-Werror" 2980AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;], 2981 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no]) 2982CFLAGS=$ac_save_CFLAGS 2983if test "$glibcxx_size_t_is_i" = yes; then 2984 AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.]) 2985fi 2986AC_MSG_RESULT([$glibcxx_size_t_is_i]) 2987 2988AC_MSG_CHECKING([for ptrdiff_t as int]) 2989ac_save_CFLAGS="$CFLAGS" 2990CFLAGS="-Werror" 2991AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;], 2992 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no]) 2993CFLAGS=$ac_save_CFLAGS 2994if test "$glibcxx_ptrdiff_t_is_i" = yes; then 2995 AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.]) 2996fi 2997AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i]) 2998]) 2999 3000 3001dnl 3002dnl Setup to use the gcc gthr.h thread-specific memory and mutex model. 3003dnl We must stage the required headers so that they will be installed 3004dnl with the library (unlike libgcc, the STL implementation is provided 3005dnl solely within headers). Since we must not inject random user-space 3006dnl macro names into user-provided C++ code, we first stage into <file>-in 3007dnl and process to <file> with an output command. The reason for a two- 3008dnl stage process here is to correctly handle $srcdir!=$objdir without 3009dnl having to write complex code (the sed commands to clean the macro 3010dnl namespace are complex and fragile enough as it is). We must also 3011dnl add a relative path so that -I- is supported properly. 3012dnl 3013dnl Substs: 3014dnl glibcxx_thread_h 3015dnl 3016dnl Defines: 3017dnl HAVE_GTHR_DEFAULT 3018dnl 3019AC_DEFUN([GLIBCXX_ENABLE_THREADS], [ 3020 AC_MSG_CHECKING([for thread model used by GCC]) 3021 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'` 3022 AC_MSG_RESULT([$target_thread_file]) 3023 3024 if test $target_thread_file != single; then 3025 AC_DEFINE(HAVE_GTHR_DEFAULT, 1, 3026 [Define if gthr-default.h exists 3027 (meaning that threading support is enabled).]) 3028 fi 3029 3030 glibcxx_thread_h=gthr-$target_thread_file.h 3031 3032 dnl Check for __GTHREADS define. 3033 gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h} 3034 if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then 3035 enable_thread=yes 3036 else 3037 enable_thread=no 3038 fi 3039 3040 AC_SUBST(glibcxx_thread_h) 3041]) 3042 3043 3044dnl 3045dnl Check if gthread implementation defines the types and functions 3046dnl required by the c++0x thread library. Conforming gthread 3047dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x. 3048dnl 3049AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [ 3050 AC_LANG_SAVE 3051 AC_LANG_CPLUSPLUS 3052 3053 ac_save_CXXFLAGS="$CXXFLAGS" 3054 CXXFLAGS="$CXXFLAGS -fno-exceptions -I${toplevel_srcdir}/gcc" 3055 3056 target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'` 3057 case $target_thread_file in 3058 posix) 3059 CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS" 3060 esac 3061 3062 AC_MSG_CHECKING([for gthreads library]) 3063 3064 AC_TRY_COMPILE([#include "gthr.h"], 3065 [ 3066 #ifndef __GTHREADS_CXX0X 3067 #error 3068 #endif 3069 3070 // In case of POSIX threads check _POSIX_TIMEOUTS too. 3071 #if (defined(_PTHREADS) \ 3072 && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0)) 3073 #error 3074 #endif 3075 ], [ac_has_gthreads=yes], [ac_has_gthreads=no]) 3076 3077 AC_MSG_RESULT([$ac_has_gthreads]) 3078 3079 if test x"$ac_has_gthreads" = x"yes"; then 3080 AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1, 3081 [Define if gthreads library is available.]) 3082 fi 3083 3084 CXXFLAGS="$ac_save_CXXFLAGS" 3085 AC_LANG_RESTORE 3086]) 3087 3088 3089# Check whether LC_MESSAGES is available in <locale.h>. 3090# Ulrich Drepper <drepper@cygnus.com>, 1995. 3091# 3092# This file file be copied and used freely without restrictions. It can 3093# be used in projects which are not available under the GNU Public License 3094# but which still want to provide support for the GNU gettext functionality. 3095# Please note that the actual code is *not* freely available. 3096AC_DEFUN([AC_LC_MESSAGES], [ 3097 AC_CHECK_HEADER(locale.h, [ 3098 AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES, 3099 [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES], 3100 ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)]) 3101 if test $ac_cv_val_LC_MESSAGES = yes; then 3102 AC_DEFINE(HAVE_LC_MESSAGES, 1, 3103 [Define if LC_MESSAGES is available in <locale.h>.]) 3104 fi 3105 ]) 3106]) 3107 3108# Macros from the top-level gcc directory. 3109m4_include([../config/tls.m4]) 3110 3111