1dnl 2dnl Unconditionally define a preprocessor macro, translating the shell 3dnl macro from yes/no to 1/0. 4dnl 5AC_DEFUN([LIBAT_DEFINE_YESNO], [ 6 yesno=`echo $2 | tr 'yesno' '1 0 '` 7 AC_DEFINE_UNQUOTED([$1], $yesno, [$3]) 8]) 9dnl 10dnl Iterate over all of the modes we're prepared to check. 11dnl 12AC_DEFUN([LIBAT_FORALL_MODES], 13 [$1(QI,1) 14 $1(HI,2) 15 $1(SI,4) 16 $1(DI,8) 17 $1(TI,16)] 18) 19dnl 20dnl Check for builtin types by mode. 21dnl 22dnl A less interesting of size checking than autoconf normally provides. 23dnl We know that gcc always provides <stdint.h>, but we don't often 24dnl provide a builtin type for TImode. 25dnl 26AC_DEFUN([LIBAT_HAVE_INT_MODE],[ 27 AC_CACHE_CHECK([for $2 byte integer],[libat_cv_have_mode_$1], 28 [AC_COMPILE_IFELSE([int x __attribute__((mode($1)));], 29 [libat_cv_have_mode_$1=yes],[libat_cv_have_mode_$1=no])]) 30 LIBAT_DEFINE_YESNO([HAVE_INT$2], [$libat_cv_have_mode_$1], 31 [Have support for $2 byte integers.]) 32 if test x$libat_cv_have_mode_$1 = xyes; then 33 SIZES="$SIZES $2" 34 fi 35]) 36dnl 37dnl Check for atomic builtins. 38dnl See: 39dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html 40dnl 41dnl This checks to see if the host supports the compiler-generated 42dnl builtins for atomic operations for various integral sizes. 43dnl 44AC_DEFUN([LIBAT_TEST_ATOMIC_INIT],[ 45 # Do link tests if possible, instead asm tests, limited to some platforms 46 # see discussion in PR target/40134, PR libstdc++/40133 and the thread 47 # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html 48 atomic_builtins_link_tests=no 49 if test x$gcc_no_link != xyes; then 50 # Can do link tests. Limit to some tested platforms 51 case "$host" in 52 *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*) 53 atomic_builtins_link_tests=yes 54 ;; 55 esac 56 fi 57]) 58AC_DEFUN([LIBAT_TEST_ATOMIC_BUILTIN],[ 59 AC_CACHE_CHECK([$1],[$2],[ 60 AC_LANG_CONFTEST([AC_LANG_PROGRAM([],[$3])]) 61 if test x$atomic_builtins_link_tests = xyes; then 62 if AC_TRY_EVAL(ac_link); then 63 eval $2=yes 64 else 65 eval $2=no 66 fi 67 else 68 old_CFLAGS="$CFLAGS" 69 # Compile unoptimized. 70 CFLAGS="$CFLAGS -O0 -S" 71 if AC_TRY_EVAL(ac_compile); then 72 if grep __atomic_ conftest.s >/dev/null 2>&1 ; then 73 eval $2=no 74 else 75 eval $2=yes 76 fi 77 else 78 eval $2=no 79 fi 80 CFLAGS="$old_CFLAGS" 81 fi 82 rm -f conftest* 83 ]) 84]) 85 86dnl 87dnl Test if we have __atomic_load and __atomic_store for mode $1, size $2 88dnl 89AC_DEFUN([LIBAT_HAVE_ATOMIC_LOADSTORE],[ 90 LIBAT_TEST_ATOMIC_BUILTIN([for __atomic_load/store for size $2], 91 [libat_cv_have_at_ldst_$2], 92 [typedef int T __attribute__((mode($1))); 93 T *x; volatile T sink; asm("" : "=g"(x)); 94 sink = __atomic_load_n(x, 0); 95 __atomic_store_n(x, sink, 0);]) 96 LIBAT_DEFINE_YESNO([HAVE_ATOMIC_LDST_$2], [$libat_cv_have_at_ldst_$2], 97 [Have __atomic_load/store for $2 byte integers.]) 98 AH_BOTTOM([#define MAYBE_HAVE_ATOMIC_LDST_$2 HAVE_ATOMIC_LDST_$2]) 99]) 100 101dnl 102dnl Test if we have __atomic_test_and_set for mode $1, size $2 103dnl 104AC_DEFUN([LIBAT_HAVE_ATOMIC_TAS],[ 105 LIBAT_TEST_ATOMIC_BUILTIN([for __atomic_test_and_set for size $2], 106 [libat_cv_have_at_tas_$2], 107 [typedef int T __attribute__((mode($1))); T *x; asm("" : "=g"(x)); 108 __atomic_test_and_set(x, 0);]) 109 LIBAT_DEFINE_YESNO([HAVE_ATOMIC_TAS_$2], [$libat_cv_have_at_tas_$2], 110 [Have __atomic_test_and_set for $2 byte integers.]) 111 AH_BOTTOM([#define MAYBE_HAVE_ATOMIC_TAS_$2 HAVE_ATOMIC_TAS_$2]) 112]) 113 114dnl 115dnl Test if we have __atomic_exchange for mode $1, size $2 116dnl 117AC_DEFUN([LIBAT_HAVE_ATOMIC_EXCHANGE],[ 118 LIBAT_TEST_ATOMIC_BUILTIN([for __atomic_exchange for size $2], 119 [libat_cv_have_at_exch_$2], 120 [typedef int T __attribute__((mode($1))); T *x; asm("" : "=g"(x)); 121 __atomic_exchange_n(x, 0, 0);]) 122 LIBAT_DEFINE_YESNO([HAVE_ATOMIC_EXCHANGE_$2], [$libat_cv_have_at_exch_$2], 123 [Have __atomic_exchange for $2 byte integers.]) 124 AH_BOTTOM([#define MAYBE_HAVE_ATOMIC_EXCHANGE_$2 HAVE_ATOMIC_EXCHANGE_$2]) 125]) 126 127dnl 128dnl Test if we have __atomic_compare_exchange for mode $1, size $2 129dnl 130AC_DEFUN([LIBAT_HAVE_ATOMIC_CAS],[ 131 LIBAT_TEST_ATOMIC_BUILTIN([for __atomic_compare_exchange for size $2], 132 [libat_cv_have_at_cas_$2], 133 [typedef int T __attribute__((mode($1))); T *x, *y; 134 asm("" : "=g"(x), "=g"(y)); 135 __atomic_compare_exchange_n(x, y, 0, 0, 0, 0);]) 136 LIBAT_DEFINE_YESNO([HAVE_ATOMIC_CAS_$2], [$libat_cv_have_at_cas_$2], 137 [Have __atomic_compare_exchange for $2 byte integers.]) 138 AH_BOTTOM([#define MAYBE_HAVE_ATOMIC_CAS_$2 HAVE_ATOMIC_CAS_$2]) 139]) 140 141dnl 142dnl Test if we have __atomic_fetch_add for mode $1, size $2 143dnl 144AC_DEFUN([LIBAT_HAVE_ATOMIC_FETCH_ADD],[ 145 LIBAT_TEST_ATOMIC_BUILTIN([for __atomic_fetch_add for size $2], 146 [libat_cv_have_at_fadd_$2], 147 [typedef int T __attribute__((mode($1))); T *x, y; 148 asm("" : "=g"(x), "=g"(y)); 149 __atomic_fetch_add (x, y, 0); 150 __atomic_add_fetch (x, y, 0);]) 151 LIBAT_DEFINE_YESNO([HAVE_ATOMIC_FETCH_ADD_$2], [$libat_cv_have_at_fadd_$2], 152 [Have __atomic_fetch_add for $2 byte integers.]) 153 AH_BOTTOM([#define MAYBE_HAVE_ATOMIC_FETCH_ADD_$2 HAVE_ATOMIC_FETCH_ADD_$2]) 154]) 155 156dnl 157dnl Test if we have __atomic_fetch_op for all op for mode $1, size $2 158dnl 159AC_DEFUN([LIBAT_HAVE_ATOMIC_FETCH_OP],[ 160 LIBAT_TEST_ATOMIC_BUILTIN([for __atomic_fetch_op for size $2], 161 [libat_cv_have_at_fop_$2], 162 [typedef int T __attribute__((mode($1))); T *x, y; 163 asm("" : "=g"(x), "=g"(y)); 164 __atomic_fetch_add (x, y, 0); __atomic_add_fetch (x, y, 0); 165 __atomic_fetch_sub (x, y, 0); __atomic_sub_fetch (x, y, 0); 166 __atomic_fetch_and (x, y, 0); __atomic_and_fetch (x, y, 0); 167 __atomic_fetch_nand (x, y, 0); __atomic_nand_fetch (x, y, 0); 168 __atomic_fetch_xor (x, y, 0); __atomic_xor_fetch (x, y, 0); 169 __atomic_fetch_or (x, y, 0); __atomic_or_fetch (x, y, 0); ]) 170 LIBAT_DEFINE_YESNO([HAVE_ATOMIC_FETCH_OP_$2], [$libat_cv_have_at_fop_$2], 171 [Have __atomic_fetch_op for all op for $2 byte integers.]) 172 AH_BOTTOM([#define MAYBE_HAVE_ATOMIC_FETCH_OP_$2 HAVE_ATOMIC_FETCH_OP_$2]) 173]) 174 175dnl 176dnl Test for the size of the target word. 177dnl 178AC_DEFUN([LIBAT_WORDSIZE],[ 179 AC_CACHE_CHECK([for the word size],[libat_cv_wordsize], 180 [AC_COMPUTE_INT(libat_cv_wordsize, 181 [sizeof(word)], [typedef int word __attribute__((mode(word)));], 182 AC_ERROR([Could not determine word size.]))]) 183 AC_DEFINE_UNQUOTED(WORDSIZE, $libat_cv_wordsize, 184 [The word size in bytes of the machine.]) 185]) 186 187dnl 188dnl Check whether the target supports the ifunc attribute. 189dnl 190AC_DEFUN([LIBAT_CHECK_IFUNC], [ 191 AC_CACHE_CHECK([whether the target supports the ifunc attribute], 192 libat_cv_have_ifunc, [ 193 save_CFLAGS="$CFLAGS" 194 CFLAGS="$CFLAGS -Werror" 195 AC_TRY_LINK([ 196 int foo_alt(void) { return 0; } 197 void *foo_sel(void) { return foo_alt; } 198 int foo(void) __attribute__((ifunc("foo_sel")));], 199 [return foo();], libat_cv_have_ifunc=yes, libat_cv_have_ifunc=no)]) 200 LIBAT_DEFINE_YESNO([HAVE_IFUNC], [$libat_cv_have_ifunc], 201 [Define to 1 if the target supports __attribute__((ifunc(...))).]) 202]) 203 204dnl ---------------------------------------------------------------------- 205dnl This whole bit snagged from libitm. 206 207dnl Check whether the target supports hidden visibility. 208AC_DEFUN([LIBAT_CHECK_ATTRIBUTE_VISIBILITY], [ 209 AC_CACHE_CHECK([whether the target supports hidden visibility], 210 libat_cv_have_attribute_visibility, [ 211 save_CFLAGS="$CFLAGS" 212 CFLAGS="$CFLAGS -Werror" 213 AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }], 214 [], libat_cv_have_attribute_visibility=yes, 215 libat_cv_have_attribute_visibility=no) 216 CFLAGS="$save_CFLAGS"]) 217 if test $libat_cv_have_attribute_visibility = yes; then 218 AC_DEFINE(HAVE_ATTRIBUTE_VISIBILITY, 1, 219 [Define to 1 if the target supports __attribute__((visibility(...))).]) 220 fi]) 221 222dnl Check whether the target supports dllexport 223AC_DEFUN([LIBAT_CHECK_ATTRIBUTE_DLLEXPORT], [ 224 AC_CACHE_CHECK([whether the target supports dllexport], 225 libat_cv_have_attribute_dllexport, [ 226 save_CFLAGS="$CFLAGS" 227 CFLAGS="$CFLAGS -Werror" 228 AC_TRY_COMPILE([void __attribute__((dllexport)) foo(void) { }], 229 [], libat_cv_have_attribute_dllexport=yes, 230 libat_cv_have_attribute_dllexport=no) 231 CFLAGS="$save_CFLAGS"]) 232 if test $libat_cv_have_attribute_dllexport = yes; then 233 AC_DEFINE(HAVE_ATTRIBUTE_DLLEXPORT, 1, 234 [Define to 1 if the target supports __attribute__((dllexport)).]) 235 fi]) 236 237dnl Check whether the target supports symbol aliases. 238AC_DEFUN([LIBAT_CHECK_ATTRIBUTE_ALIAS], [ 239 AC_CACHE_CHECK([whether the target supports symbol aliases], 240 libat_cv_have_attribute_alias, [ 241 AC_TRY_LINK([ 242void foo(void) { } 243extern void bar(void) __attribute__((alias("foo")));], 244 [bar();], libat_cv_have_attribute_alias=yes, libat_cv_have_attribute_alias=no)]) 245 if test $libat_cv_have_attribute_alias = yes; then 246 AC_DEFINE(HAVE_ATTRIBUTE_ALIAS, 1, 247 [Define to 1 if the target supports __attribute__((alias(...))).]) 248 fi]) 249 250dnl ---------------------------------------------------------------------- 251dnl This whole bit snagged from libstdc++-v3. 252 253dnl 254dnl LIBAT_ENABLE 255dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING) 256dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c) 257dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER) 258dnl 259dnl See docs/html/17_intro/configury.html#enable for documentation. 260dnl 261m4_define([LIBAT_ENABLE],[dnl 262m4_define([_g_switch],[--enable-$1])dnl 263m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl 264 AC_ARG_ENABLE($1,_g_help, 265 m4_bmatch([$5], 266 [^permit ], 267 [[ 268 case "$enableval" in 269 m4_bpatsubst([$5],[permit ])) ;; 270 *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;; 271 dnl Idea for future: generate a URL pointing to 272 dnl "onlinedocs/configopts.html#whatever" 273 esac 274 ]], 275 [^$], 276 [[ 277 case "$enableval" in 278 yes|no) ;; 279 *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;; 280 esac 281 ]], 282 [[$5]]), 283 [enable_]m4_bpatsubst([$1],-,_)[=][$2]) 284m4_undefine([_g_switch])dnl 285m4_undefine([_g_help])dnl 286]) 287 288dnl 289dnl If GNU ld is in use, check to see if tricky linker opts can be used. If 290dnl the native linker is in use, all variables will be defined to something 291dnl safe (like an empty string). 292dnl 293dnl Defines: 294dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible 295dnl OPT_LDFLAGS='-Wl,-O1' if possible 296dnl LD (as a side effect of testing) 297dnl Sets: 298dnl with_gnu_ld 299dnl libat_ld_is_gold (possibly) 300dnl libat_gnu_ld_version (possibly) 301dnl 302dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will 303dnl set libat_gnu_ld_version to 12345. Zeros cause problems. 304dnl 305AC_DEFUN([LIBAT_CHECK_LINKER_FEATURES], [ 306 # If we're not using GNU ld, then there's no point in even trying these 307 # tests. Check for that first. We should have already tested for gld 308 # by now (in libtool), but require it now just to be safe... 309 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS='' 310 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS='' 311 AC_REQUIRE([AC_PROG_LD]) 312 AC_REQUIRE([AC_PROG_AWK]) 313 314 # The name set by libtool depends on the version of libtool. Shame on us 315 # for depending on an impl detail, but c'est la vie. Older versions used 316 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on 317 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually 318 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't 319 # set (hence we're using an older libtool), then set it. 320 if test x${with_gnu_ld+set} != xset; then 321 if test x${ac_cv_prog_gnu_ld+set} != xset; then 322 # We got through "ac_require(ac_prog_ld)" and still not set? Huh? 323 with_gnu_ld=no 324 else 325 with_gnu_ld=$ac_cv_prog_gnu_ld 326 fi 327 fi 328 329 # Start by getting the version number. I think the libtool test already 330 # does some of this, but throws away the result. 331 libat_ld_is_gold=no 332 if $LD --version 2>/dev/null | grep 'GNU gold'> /dev/null 2>&1; then 333 libat_ld_is_gold=yes 334 fi 335 changequote(,) 336 ldver=`$LD --version 2>/dev/null | 337 sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'` 338 changequote([,]) 339 libat_gnu_ld_version=`echo $ldver | \ 340 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'` 341 342 # Set --gc-sections. 343 if test "$with_gnu_ld" = "notbroken"; then 344 # GNU ld it is! Joy and bunny rabbits! 345 346 # All these tests are for C++; save the language and the compiler flags. 347 # Need to do this so that g++ won't try to link in libstdc++ 348 ac_test_CFLAGS="${CFLAGS+set}" 349 ac_save_CFLAGS="$CFLAGS" 350 CFLAGS='-x c++ -Wl,--gc-sections' 351 352 # Check for -Wl,--gc-sections 353 # XXX This test is broken at the moment, as symbols required for linking 354 # are now in libsupc++ (not built yet). In addition, this test has 355 # cored on solaris in the past. In addition, --gc-sections doesn't 356 # really work at the moment (keeps on discarding used sections, first 357 # .eh_frame and now some of the glibc sections for iconv). 358 # Bzzzzt. Thanks for playing, maybe next time. 359 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections]) 360 AC_TRY_RUN([ 361 int main(void) 362 { 363 try { throw 1; } 364 catch (...) { }; 365 return 0; 366 } 367 ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes]) 368 if test "$ac_test_CFLAGS" = set; then 369 CFLAGS="$ac_save_CFLAGS" 370 else 371 # this is the suspicious part 372 CFLAGS='' 373 fi 374 if test "$ac_sectionLDflags" = "yes"; then 375 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS" 376 fi 377 AC_MSG_RESULT($ac_sectionLDflags) 378 fi 379 380 # Set linker optimization flags. 381 if test x"$with_gnu_ld" = x"yes"; then 382 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS" 383 fi 384 385 AC_SUBST(SECTION_LDFLAGS) 386 AC_SUBST(OPT_LDFLAGS) 387]) 388 389 390dnl 391dnl If GNU ld is in use, check to see if tricky linker opts can be used. If 392dnl the native linker is in use, all variables will be defined to something 393dnl safe (like an empty string). 394dnl 395dnl Defines: 396dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible 397dnl OPT_LDFLAGS='-Wl,-O1' if possible 398dnl LD (as a side effect of testing) 399dnl Sets: 400dnl with_gnu_ld 401dnl libat_ld_is_gold (possibly) 402dnl libat_gnu_ld_version (possibly) 403dnl 404dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will 405dnl set libat_gnu_ld_version to 12345. Zeros cause problems. 406dnl 407AC_DEFUN([LIBAT_CHECK_LINKER_FEATURES], [ 408 # If we're not using GNU ld, then there's no point in even trying these 409 # tests. Check for that first. We should have already tested for gld 410 # by now (in libtool), but require it now just to be safe... 411 test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS='' 412 test -z "$OPT_LDFLAGS" && OPT_LDFLAGS='' 413 AC_REQUIRE([AC_PROG_LD]) 414 AC_REQUIRE([AC_PROG_AWK]) 415 416 # The name set by libtool depends on the version of libtool. Shame on us 417 # for depending on an impl detail, but c'est la vie. Older versions used 418 # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on 419 # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually 420 # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't 421 # set (hence we're using an older libtool), then set it. 422 if test x${with_gnu_ld+set} != xset; then 423 if test x${ac_cv_prog_gnu_ld+set} != xset; then 424 # We got through "ac_require(ac_prog_ld)" and still not set? Huh? 425 with_gnu_ld=no 426 else 427 with_gnu_ld=$ac_cv_prog_gnu_ld 428 fi 429 fi 430 431 # Start by getting the version number. I think the libtool test already 432 # does some of this, but throws away the result. 433 libat_ld_is_gold=no 434 if $LD --version 2>/dev/null | grep 'GNU gold'> /dev/null 2>&1; then 435 libat_ld_is_gold=yes 436 fi 437 changequote(,) 438 ldver=`$LD --version 2>/dev/null | 439 sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'` 440 changequote([,]) 441 libat_gnu_ld_version=`echo $ldver | \ 442 $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'` 443 444 # Set --gc-sections. 445 if test "$with_gnu_ld" = "notbroken"; then 446 # GNU ld it is! Joy and bunny rabbits! 447 448 # All these tests are for C++; save the language and the compiler flags. 449 # Need to do this so that g++ won't try to link in libstdc++ 450 ac_test_CFLAGS="${CFLAGS+set}" 451 ac_save_CFLAGS="$CFLAGS" 452 CFLAGS='-x c++ -Wl,--gc-sections' 453 454 # Check for -Wl,--gc-sections 455 # XXX This test is broken at the moment, as symbols required for linking 456 # are now in libsupc++ (not built yet). In addition, this test has 457 # cored on solaris in the past. In addition, --gc-sections doesn't 458 # really work at the moment (keeps on discarding used sections, first 459 # .eh_frame and now some of the glibc sections for iconv). 460 # Bzzzzt. Thanks for playing, maybe next time. 461 AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections]) 462 AC_TRY_RUN([ 463 int main(void) 464 { 465 try { throw 1; } 466 catch (...) { }; 467 return 0; 468 } 469 ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes]) 470 if test "$ac_test_CFLAGS" = set; then 471 CFLAGS="$ac_save_CFLAGS" 472 else 473 # this is the suspicious part 474 CFLAGS='' 475 fi 476 if test "$ac_sectionLDflags" = "yes"; then 477 SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS" 478 fi 479 AC_MSG_RESULT($ac_sectionLDflags) 480 fi 481 482 # Set linker optimization flags. 483 if test x"$with_gnu_ld" = x"yes"; then 484 OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS" 485 fi 486 487 AC_SUBST(SECTION_LDFLAGS) 488 AC_SUBST(OPT_LDFLAGS) 489]) 490 491 492dnl 493dnl Add version tags to symbols in shared library (or not), additionally 494dnl marking other symbols as private/local (or not). 495dnl 496dnl --enable-symvers=style adds a version script to the linker call when 497dnl creating the shared library. The choice of version script is 498dnl controlled by 'style'. 499dnl --disable-symvers does not. 500dnl + Usage: LIBAT_ENABLE_SYMVERS[(DEFAULT)] 501dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to 502dnl choose a default style based on linker characteristics. Passing 503dnl 'no' disables versioning. 504dnl 505AC_DEFUN([LIBAT_ENABLE_SYMVERS], [ 506 507LIBAT_ENABLE(symvers,yes,[=STYLE], 508 [enables symbol versioning of the shared library], 509 [permit yes|no|gnu*|sun]) 510 511# If we never went through the LIBAT_CHECK_LINKER_FEATURES macro, then we 512# don't know enough about $LD to do tricks... 513AC_REQUIRE([LIBAT_CHECK_LINKER_FEATURES]) 514 515# Turn a 'yes' into a suitable default. 516if test x$enable_symvers = xyes ; then 517 # FIXME The following test is too strict, in theory. 518 if test $enable_shared = no || test "x$LD" = x; then 519 enable_symvers=no 520 else 521 if test $with_gnu_ld = yes ; then 522 enable_symvers=gnu 523 else 524 case ${target_os} in 525 # Sun symbol versioning exists since Solaris 2.5. 526 solaris2.[[5-9]]* | solaris2.1[[0-9]]*) 527 enable_symvers=sun ;; 528 *) 529 enable_symvers=no ;; 530 esac 531 fi 532 fi 533fi 534 535# Check if 'sun' was requested on non-Solaris 2 platforms. 536if test x$enable_symvers = xsun ; then 537 case ${target_os} in 538 solaris2*) 539 # All fine. 540 ;; 541 *) 542 # Unlikely to work. 543 AC_MSG_WARN([=== You have requested Sun symbol versioning, but]) 544 AC_MSG_WARN([=== you are not targetting Solaris 2.]) 545 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 546 enable_symvers=no 547 ;; 548 esac 549fi 550 551# Check to see if libgcc_s exists, indicating that shared libgcc is possible. 552if test $enable_symvers != no; then 553 AC_MSG_CHECKING([for shared libgcc]) 554 ac_save_CFLAGS="$CFLAGS" 555 CFLAGS=' -lgcc_s' 556 AC_TRY_LINK(, [return 0;], libat_shared_libgcc=yes, libat_shared_libgcc=no) 557 CFLAGS="$ac_save_CFLAGS" 558 if test $libat_shared_libgcc = no; then 559 cat > conftest.c <<EOF 560int main (void) { return 0; } 561EOF 562changequote(,)dnl 563 libat_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \ 564 -shared -shared-libgcc -o conftest.so \ 565 conftest.c -v 2>&1 >/dev/null \ 566 | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'` 567changequote([,])dnl 568 rm -f conftest.c conftest.so 569 if test x${libat_libgcc_s_suffix+set} = xset; then 570 CFLAGS=" -lgcc_s$libat_libgcc_s_suffix" 571 AC_TRY_LINK(, [return 0;], libat_shared_libgcc=yes) 572 CFLAGS="$ac_save_CFLAGS" 573 fi 574 fi 575 AC_MSG_RESULT($libat_shared_libgcc) 576fi 577 578# For GNU ld, we need at least this version. The format is described in 579# LIBAT_CHECK_LINKER_FEATURES above. 580libat_min_gnu_ld_version=21400 581# XXXXXXXXXXX libat_gnu_ld_version=21390 582 583# Check to see if unspecified "yes" value can win, given results above. 584# Change "yes" into either "no" or a style name. 585if test $enable_symvers != no && test $libat_shared_libgcc = yes; then 586 if test $with_gnu_ld = yes; then 587 if test $libat_gnu_ld_version -ge $libat_min_gnu_ld_version ; then 588 enable_symvers=gnu 589 elif test $libat_ld_is_gold = yes ; then 590 enable_symvers=gnu 591 else 592 # The right tools, the right setup, but too old. Fallbacks? 593 AC_MSG_WARN(=== Linker version $libat_gnu_ld_version is too old for) 594 AC_MSG_WARN(=== full symbol versioning support in this release of GCC.) 595 AC_MSG_WARN(=== You would need to upgrade your binutils to version) 596 AC_MSG_WARN(=== $libat_min_gnu_ld_version or later and rebuild GCC.) 597 if test $libat_gnu_ld_version -ge 21200 ; then 598 # Globbing fix is present, proper block support is not. 599 dnl AC_MSG_WARN([=== Dude, you are soooo close. Maybe we can fake it.]) 600 dnl enable_symvers=??? 601 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 602 enable_symvers=no 603 else 604 # 2.11 or older. 605 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 606 enable_symvers=no 607 fi 608 fi 609 elif test $enable_symvers = sun; then 610 : All interesting versions of Sun ld support sun style symbol versioning. 611 else 612 # just fail for now 613 AC_MSG_WARN([=== You have requested some kind of symbol versioning, but]) 614 AC_MSG_WARN([=== either you are not using a supported linker, or you are]) 615 AC_MSG_WARN([=== not building a shared libgcc_s (which is required).]) 616 AC_MSG_WARN([=== Symbol versioning will be disabled.]) 617 enable_symvers=no 618 fi 619fi 620if test $enable_symvers = gnu; then 621 AC_DEFINE(LIBAT_GNU_SYMBOL_VERSIONING, 1, 622 [Define to 1 if GNU symbol versioning is used for libatomic.]) 623fi 624 625AM_CONDITIONAL(LIBAT_BUILD_VERSIONED_SHLIB, test $enable_symvers != no) 626AM_CONDITIONAL(LIBAT_BUILD_VERSIONED_SHLIB_GNU, test $enable_symvers = gnu) 627AM_CONDITIONAL(LIBAT_BUILD_VERSIONED_SHLIB_SUN, test $enable_symvers = sun) 628AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers) 629]) 630 631dnl ---------------------------------------------------------------------- 632sinclude(../libtool.m4) 633dnl The lines below arrange for aclocal not to bring an installed 634dnl libtool.m4 into aclocal.m4, while still arranging for automake to 635dnl add a definition of LIBTOOL to Makefile.in. 636ifelse(,,,[AC_SUBST(LIBTOOL) 637AC_DEFUN([AM_PROG_LIBTOOL]) 638AC_DEFUN([AC_LIBTOOL_DLOPEN]) 639AC_DEFUN([AC_PROG_LD]) 640]) 641