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