libatomic/acinclude.m4

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