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