[thirdparty/gcc.git] / libitm / acinclude.m4

dnl ----------------------------------------------------------------------
dnl This whole bit snagged from libgfortran.

dnl Check whether the target supports __sync_*_compare_and_swap.
AC_DEFUN([LIBITM_CHECK_SYNC_BUILTINS], [
  AC_CACHE_CHECK([whether the target supports __sync_*_compare_and_swap],
		 libitm_cv_have_sync_builtins, [
  AC_TRY_LINK([], [int foo, bar; bar = __sync_val_compare_and_swap(&foo, 0, 1);],
	      libitm_cv_have_sync_builtins=yes, libitm_cv_have_sync_builtins=no)])
  if test $libitm_cv_have_sync_builtins = yes; then
    AC_DEFINE(HAVE_SYNC_BUILTINS, 1,
	      [Define to 1 if the target supports __sync_*_compare_and_swap])
  fi])

dnl Check whether the target supports 64-bit __sync_*_compare_and_swap.
AC_DEFUN([LIBITM_CHECK_64BIT_SYNC_BUILTINS], [
  AC_CACHE_CHECK([whether the target supports 64-bit __sync_*_compare_and_swap],
		 libitm_cv_have_64bit_sync_builtins, [
  AC_TRY_LINK([#include <stdint.h>],
    [uint64_t foo, bar;
     bar = __sync_val_compare_and_swap(&foo, 0, 1);],
    libitm_cv_have_64bit_sync_builtins=yes,
    libitm_cv_have_64bit_sync_builtins=no)])
    if test $libitm_cv_have_64bit_sync_builtins = yes; then
      AC_DEFINE(HAVE_64BIT_SYNC_BUILTINS, 1,
	        [Define to 1 if the target supports 64-bit __sync_*_compare_and_swap])
  fi])

dnl Check whether the target supports hidden visibility.
AC_DEFUN([LIBITM_CHECK_ATTRIBUTE_VISIBILITY], [
  AC_CACHE_CHECK([whether the target supports hidden visibility],
		 libitm_cv_have_attribute_visibility, [
  save_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -Werror"
  AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
		 [], libitm_cv_have_attribute_visibility=yes,
		 libitm_cv_have_attribute_visibility=no)
  CFLAGS="$save_CFLAGS"])
  if test $libitm_cv_have_attribute_visibility = yes; then
    AC_DEFINE(HAVE_ATTRIBUTE_VISIBILITY, 1,
      [Define to 1 if the target supports __attribute__((visibility(...))).])
  fi])

dnl Check whether the target supports dllexport
AC_DEFUN([LIBITM_CHECK_ATTRIBUTE_DLLEXPORT], [
  AC_CACHE_CHECK([whether the target supports dllexport],
		 libitm_cv_have_attribute_dllexport, [
  save_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -Werror"
  AC_TRY_COMPILE([void __attribute__((dllexport)) foo(void) { }],
		 [], libitm_cv_have_attribute_dllexport=yes,
		 libitm_cv_have_attribute_dllexport=no)
  CFLAGS="$save_CFLAGS"])
  if test $libitm_cv_have_attribute_dllexport = yes; then
    AC_DEFINE(HAVE_ATTRIBUTE_DLLEXPORT, 1,
      [Define to 1 if the target supports __attribute__((dllexport)).])
  fi])

dnl Check whether the target supports symbol aliases.
AC_DEFUN([LIBITM_CHECK_ATTRIBUTE_ALIAS], [
  AC_CACHE_CHECK([whether the target supports symbol aliases],
		 libitm_cv_have_attribute_alias, [
  AC_TRY_LINK([
void foo(void) { }
extern void bar(void) __attribute__((alias("foo")));],
    [bar();], libitm_cv_have_attribute_alias=yes, libitm_cv_have_attribute_alias=no)])
  if test $libitm_cv_have_attribute_alias = yes; then
    AC_DEFINE(HAVE_ATTRIBUTE_ALIAS, 1,
      [Define to 1 if the target supports __attribute__((alias(...))).])
  fi])

dnl Check how size_t is mangled.
AC_DEFUN([LIBITM_CHECK_SIZE_T_MANGLING], [
  AC_CACHE_CHECK([how size_t is mangled],
                 libitm_cv_size_t_mangling, [
    AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
	           [libitm_cv_size_t_mangling=m], [
      AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
	             [libitm_cv_size_t_mangling=j], [
        AC_TRY_COMPILE([],
		       [extern __SIZE_TYPE__ x; extern unsigned long long x;],
	               [libitm_cv_size_t_mangling=y], [
          AC_TRY_COMPILE([],
			 [extern __SIZE_TYPE__ x; extern unsigned short x;],
			 [libitm_cv_size_t_mangling=t],
		         [libitm_cv_size_t_mangling=x])
	])
      ])
    ])
  ])
  if test $libitm_cv_size_t_mangling = x; then
    AC_MSG_ERROR([Unknown underlying type for size_t])
  fi
  AC_DEFINE_UNQUOTED(MANGLE_SIZE_T, [$libitm_cv_size_t_mangling],
    [Define to the letter to which size_t is mangled.])
])

dnl Check if as supports AVX instructions.
AC_DEFUN([LIBITM_CHECK_AS_AVX], [
case "${target_cpu}" in
i[[34567]]86 | x86_64)
  AC_CACHE_CHECK([if the assembler supports AVX], libitm_cv_as_avx, [
    AC_TRY_COMPILE([], [asm("vzeroupper");],
		   [libitm_cv_as_avx=yes], [libitm_cv_as_avx=no])
  ])
  if test x$libitm_cv_as_avx = xyes; then
    AC_DEFINE(HAVE_AS_AVX, 1, [Define to 1 if the assembler supports AVX.])
  fi
  ;;
esac])

sinclude(../libtool.m4)
dnl The lines below arrange for aclocal not to bring an installed
dnl libtool.m4 into aclocal.m4, while still arranging for automake to
dnl add a definition of LIBTOOL to Makefile.in.
ifelse(,,,[AC_SUBST(LIBTOOL)
AC_DEFUN([AM_PROG_LIBTOOL])
AC_DEFUN([AC_LIBTOOL_DLOPEN])
AC_DEFUN([AC_PROG_LD])
])

dnl ----------------------------------------------------------------------
dnl This whole bit snagged from libstdc++-v3.

dnl
dnl LIBITM_ENABLE
dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
dnl
dnl See docs/html/17_intro/configury.html#enable for documentation.
dnl
m4_define([LIBITM_ENABLE],[dnl
m4_define([_g_switch],[--enable-$1])dnl
m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
 AC_ARG_ENABLE($1,_g_help,
  m4_bmatch([$5],
   [^permit ],
     [[
      case "$enableval" in
       m4_bpatsubst([$5],[permit ])) ;;
       *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
          dnl Idea for future:  generate a URL pointing to
          dnl "onlinedocs/configopts.html#whatever"
      esac
     ]],
   [^$],
     [[
      case "$enableval" in
       yes|no) ;;
       *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
      esac
     ]],
   [[$5]]),
  [enable_]m4_bpatsubst([$1],-,_)[=][$2])
m4_undefine([_g_switch])dnl
m4_undefine([_g_help])dnl
])


dnl
dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
dnl the native linker is in use, all variables will be defined to something
dnl safe (like an empty string).
dnl
dnl Defines:
dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
dnl  OPT_LDFLAGS='-Wl,-O1' if possible
dnl  LD (as a side effect of testing)
dnl Sets:
dnl  with_gnu_ld
dnl  libitm_gnu_ld_version (possibly)
dnl
dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
dnl set libitm_gnu_ld_version to 12345.  Zeros cause problems.
dnl
AC_DEFUN([LIBITM_CHECK_LINKER_FEATURES], [
  # If we're not using GNU ld, then there's no point in even trying these
  # tests.  Check for that first.  We should have already tested for gld
  # by now (in libtool), but require it now just to be safe...
  test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
  test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
  AC_REQUIRE([AC_PROG_LD])
  AC_REQUIRE([AC_PROG_AWK])

  # The name set by libtool depends on the version of libtool.  Shame on us
  # for depending on an impl detail, but c'est la vie.  Older versions used
  # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
  # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
  # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
  # set (hence we're using an older libtool), then set it.
  if test x${with_gnu_ld+set} != xset; then
    if test x${ac_cv_prog_gnu_ld+set} != xset; then
      # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
      with_gnu_ld=no
    else
      with_gnu_ld=$ac_cv_prog_gnu_ld
    fi
  fi

  # Start by getting the version number.  I think the libtool test already
  # does some of this, but throws away the result.
  changequote(,)
  ldver=`$LD --version 2>/dev/null | head -1 | \
         sed -e 's/GNU ld \(version \)\{0,1\}\(([^)]*) \)\{0,1\}\([0-9.][0-9.]*\).*/\3/'`
  changequote([,])
  libitm_gnu_ld_version=`echo $ldver | \
         $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`

  # Set --gc-sections.
  if test "$with_gnu_ld" = "notbroken"; then
    # GNU ld it is!  Joy and bunny rabbits!

    # All these tests are for C++; save the language and the compiler flags.
    # Need to do this so that g++ won't try to link in libstdc++
    ac_test_CFLAGS="${CFLAGS+set}"
    ac_save_CFLAGS="$CFLAGS"
    CFLAGS='-x c++  -Wl,--gc-sections'

    # Check for -Wl,--gc-sections
    # XXX This test is broken at the moment, as symbols required for linking
    # are now in libsupc++ (not built yet).  In addition, this test has
    # cored on solaris in the past.  In addition, --gc-sections doesn't
    # really work at the moment (keeps on discarding used sections, first
    # .eh_frame and now some of the glibc sections for iconv).
    # Bzzzzt.  Thanks for playing, maybe next time.
    AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
    AC_TRY_RUN([
     int main(void)
     {
       try { throw 1; }
       catch (...) { };
       return 0;
     }
    ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
    if test "$ac_test_CFLAGS" = set; then
      CFLAGS="$ac_save_CFLAGS"
    else
      # this is the suspicious part
      CFLAGS=''
    fi
    if test "$ac_sectionLDflags" = "yes"; then
      SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
    fi
    AC_MSG_RESULT($ac_sectionLDflags)
  fi

  # Set linker optimization flags.
  if test x"$with_gnu_ld" = x"yes"; then
    OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
  fi

  AC_SUBST(SECTION_LDFLAGS)
  AC_SUBST(OPT_LDFLAGS)
])


dnl
dnl Add version tags to symbols in shared library (or not), additionally
dnl marking other symbols as private/local (or not).
dnl
dnl --enable-symvers=style adds a version script to the linker call when
dnl       creating the shared library.  The choice of version script is
dnl       controlled by 'style'.
dnl --disable-symvers does not.
dnl  +  Usage:  LIBITM_ENABLE_SYMVERS[(DEFAULT)]
dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
dnl       choose a default style based on linker characteristics.  Passing
dnl       'no' disables versioning.
dnl
AC_DEFUN([LIBITM_ENABLE_SYMVERS], [

LIBITM_ENABLE(symvers,yes,[=STYLE],
  [enables symbol versioning of the shared library],
  [permit yes|no|gnu])

# If we never went through the LIBITM_CHECK_LINKER_FEATURES macro, then we
# don't know enough about $LD to do tricks...
AC_REQUIRE([LIBITM_CHECK_LINKER_FEATURES])
# FIXME  The following test is too strict, in theory.
if test $enable_shared = no ||
        test "x$LD" = x ||
        test x$libitm_gnu_ld_version = x; then
  enable_symvers=no
fi

# Check to see if libgcc_s exists, indicating that shared libgcc is possible.
if test $enable_symvers != no; then
  AC_MSG_CHECKING([for shared libgcc])
  ac_save_CFLAGS="$CFLAGS"
  CFLAGS=' -lgcc_s'
  AC_TRY_LINK(, [return 0;], libitm_shared_libgcc=yes, libitm_shared_libgcc=no)
  CFLAGS="$ac_save_CFLAGS"
  if test $libitm_shared_libgcc = no; then
    cat > conftest.c <<EOF
int main (void) { return 0; }
EOF
changequote(,)dnl
    libitm_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
			     -shared -shared-libgcc -o conftest.so \
			     conftest.c -v 2>&1 >/dev/null \
			     | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
changequote([,])dnl
    rm -f conftest.c conftest.so
    if test x${libitm_libgcc_s_suffix+set} = xset; then
      CFLAGS=" -lgcc_s$libitm_libgcc_s_suffix"
      AC_TRY_LINK(, [return 0;], libitm_shared_libgcc=yes)
      CFLAGS="$ac_save_CFLAGS"
    fi
  fi
  AC_MSG_RESULT($libitm_shared_libgcc)
fi

# For GNU ld, we need at least this version.  The format is described in
# LIBITM_CHECK_LINKER_FEATURES above.
libitm_min_gnu_ld_version=21400
# XXXXXXXXXXX libitm_gnu_ld_version=21390

# Check to see if unspecified "yes" value can win, given results above.
# Change "yes" into either "no" or a style name.
if test $enable_symvers = yes; then
  if test $with_gnu_ld = yes &&
     test $libitm_shared_libgcc = yes;
  then
    if test $libitm_gnu_ld_version -ge $libitm_min_gnu_ld_version ; then
      enable_symvers=gnu
    else
      # The right tools, the right setup, but too old.  Fallbacks?
      AC_MSG_WARN(=== Linker version $libitm_gnu_ld_version is too old for)
      AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
      AC_MSG_WARN(=== You would need to upgrade your binutils to version)
      AC_MSG_WARN(=== $libitm_min_gnu_ld_version or later and rebuild GCC.)
      if test $libitm_gnu_ld_version -ge 21200 ; then
        # Globbing fix is present, proper block support is not.
        dnl AC_MSG_WARN([=== Dude, you are soooo close.  Maybe we can fake it.])
        dnl enable_symvers=???
        AC_MSG_WARN([=== Symbol versioning will be disabled.])
        enable_symvers=no
      else
        # 2.11 or older.
        AC_MSG_WARN([=== Symbol versioning will be disabled.])
        enable_symvers=no
      fi
    fi
  else
    # just fail for now
    AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
    AC_MSG_WARN([=== either you are not using a supported linker, or you are])
    AC_MSG_WARN([=== not building a shared libgcc_s (which is required).])
    AC_MSG_WARN([=== Symbol versioning will be disabled.])
    enable_symvers=no
  fi
fi

AM_CONDITIONAL(LIBITM_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
])
Commit	Line	Data
0a35513e AH	1	dnl ----------------------------------------------------------------------
	2	dnl This whole bit snagged from libgfortran.
	3
	4	dnl Check whether the target supports __sync_*_compare_and_swap.
	5	AC_DEFUN([LIBITM_CHECK_SYNC_BUILTINS], [
	6	AC_CACHE_CHECK([whether the target supports __sync_*_compare_and_swap],
	7	libitm_cv_have_sync_builtins, [
	8	AC_TRY_LINK([], [int foo, bar; bar = __sync_val_compare_and_swap(&foo, 0, 1);],
	9	libitm_cv_have_sync_builtins=yes, libitm_cv_have_sync_builtins=no)])
	10	if test $libitm_cv_have_sync_builtins = yes; then
	11	AC_DEFINE(HAVE_SYNC_BUILTINS, 1,
	12	[Define to 1 if the target supports __sync_*_compare_and_swap])
	13	fi])
	14
	15	dnl Check whether the target supports 64-bit __sync_*_compare_and_swap.
	16	AC_DEFUN([LIBITM_CHECK_64BIT_SYNC_BUILTINS], [
	17	AC_CACHE_CHECK([whether the target supports 64-bit __sync_*_compare_and_swap],
	18	libitm_cv_have_64bit_sync_builtins, [
	19	AC_TRY_LINK([#include <stdint.h>],
	20	[uint64_t foo, bar;
	21	bar = __sync_val_compare_and_swap(&foo, 0, 1);],
	22	libitm_cv_have_64bit_sync_builtins=yes,
	23	libitm_cv_have_64bit_sync_builtins=no)])
	24	if test $libitm_cv_have_64bit_sync_builtins = yes; then
	25	AC_DEFINE(HAVE_64BIT_SYNC_BUILTINS, 1,
	26	[Define to 1 if the target supports 64-bit __sync_*_compare_and_swap])
	27	fi])
	28
	29	dnl Check whether the target supports hidden visibility.
	30	AC_DEFUN([LIBITM_CHECK_ATTRIBUTE_VISIBILITY], [
	31	AC_CACHE_CHECK([whether the target supports hidden visibility],
	32	libitm_cv_have_attribute_visibility, [
	33	save_CFLAGS="$CFLAGS"
	34	CFLAGS="$CFLAGS -Werror"
	35	AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
	36	[], libitm_cv_have_attribute_visibility=yes,
	37	libitm_cv_have_attribute_visibility=no)
	38	CFLAGS="$save_CFLAGS"])
	39	if test $libitm_cv_have_attribute_visibility = yes; then
	40	AC_DEFINE(HAVE_ATTRIBUTE_VISIBILITY, 1,
	41	[Define to 1 if the target supports __attribute__((visibility(...))).])
	42	fi])
	43
	44	dnl Check whether the target supports dllexport
	45	AC_DEFUN([LIBITM_CHECK_ATTRIBUTE_DLLEXPORT], [
	46	AC_CACHE_CHECK([whether the target supports dllexport],
	47	libitm_cv_have_attribute_dllexport, [
	48	save_CFLAGS="$CFLAGS"
	49	CFLAGS="$CFLAGS -Werror"
	50	AC_TRY_COMPILE([void __attribute__((dllexport)) foo(void) { }],
	51	[], libitm_cv_have_attribute_dllexport=yes,
	52	libitm_cv_have_attribute_dllexport=no)
	53	CFLAGS="$save_CFLAGS"])
	54	if test $libitm_cv_have_attribute_dllexport = yes; then
	55	AC_DEFINE(HAVE_ATTRIBUTE_DLLEXPORT, 1,
	56	[Define to 1 if the target supports __attribute__((dllexport)).])
	57	fi])
	58
	59	dnl Check whether the target supports symbol aliases.
	60	AC_DEFUN([LIBITM_CHECK_ATTRIBUTE_ALIAS], [
	61	AC_CACHE_CHECK([whether the target supports symbol aliases],
	62	libitm_cv_have_attribute_alias, [
	63	AC_TRY_LINK([
	64	void foo(void) { }
65	extern void bar(void) __attribute__((alias("foo")));],
66	[bar();], libitm_cv_have_attribute_alias=yes, libitm_cv_have_attribute_alias=no)])
67	if test $libitm_cv_have_attribute_alias = yes; then
68	AC_DEFINE(HAVE_ATTRIBUTE_ALIAS, 1,
69	[Define to 1 if the target supports __attribute__((alias(...))).])
70	fi])
71
72	dnl Check how size_t is mangled.
73	AC_DEFUN([LIBITM_CHECK_SIZE_T_MANGLING], [
74	AC_CACHE_CHECK([how size_t is mangled],
75	libitm_cv_size_t_mangling, [
76	AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned long x;],
77	[libitm_cv_size_t_mangling=m], [
78	AC_TRY_COMPILE([], [extern __SIZE_TYPE__ x; extern unsigned int x;],
79	[libitm_cv_size_t_mangling=j], [
80	AC_TRY_COMPILE([],
81	[extern __SIZE_TYPE__ x; extern unsigned long long x;],
82	[libitm_cv_size_t_mangling=y], [
83	AC_TRY_COMPILE([],
84	[extern __SIZE_TYPE__ x; extern unsigned short x;],
85	[libitm_cv_size_t_mangling=t],
86	[libitm_cv_size_t_mangling=x])
87	])
88	])
89	])
90	])
91	if test $libitm_cv_size_t_mangling = x; then
92	AC_MSG_ERROR([Unknown underlying type for size_t])
93	fi
94	AC_DEFINE_UNQUOTED(MANGLE_SIZE_T, [$libitm_cv_size_t_mangling],
95	[Define to the letter to which size_t is mangled.])
96	])
97
430616e7 RH	98	dnl Check if as supports AVX instructions.
	99	AC_DEFUN([LIBITM_CHECK_AS_AVX], [
	100	case "${target_cpu}" in
80713347	101	i[[34567]]86 \| x86_64)
430616e7 RH	102	AC_CACHE_CHECK([if the assembler supports AVX], libitm_cv_as_avx, [
	103	AC_TRY_COMPILE([], [asm("vzeroupper");],
	104	[libitm_cv_as_avx=yes], [libitm_cv_as_avx=no])
	105	])
	106	if test x$libitm_cv_as_avx = xyes; then
	107	AC_DEFINE(HAVE_AS_AVX, 1, [Define to 1 if the assembler supports AVX.])
	108	fi
	109	;;
	110	esac])
	111
0a35513e AH	112	sinclude(../libtool.m4)
	113	dnl The lines below arrange for aclocal not to bring an installed
	114	dnl libtool.m4 into aclocal.m4, while still arranging for automake to
	115	dnl add a definition of LIBTOOL to Makefile.in.
	116	ifelse(,,,[AC_SUBST(LIBTOOL)
	117	AC_DEFUN([AM_PROG_LIBTOOL])
	118	AC_DEFUN([AC_LIBTOOL_DLOPEN])
	119	AC_DEFUN([AC_PROG_LD])
	120	])
	121
	122	dnl ----------------------------------------------------------------------
	123	dnl This whole bit snagged from libstdc++-v3.
	124
	125	dnl
	126	dnl LIBITM_ENABLE
	127	dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
	128	dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a\|b\|c)
	129	dnl (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
	130	dnl
	131	dnl See docs/html/17_intro/configury.html#enable for documentation.
	132	dnl
	133	m4_define([LIBITM_ENABLE],[dnl
	134	m4_define([_g_switch],[--enable-$1])dnl
	135	m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
	136	AC_ARG_ENABLE($1,_g_help,
	137	m4_bmatch([$5],
	138	[^permit ],
	139	[[
	140	case "$enableval" in
	141	m4_bpatsubst([$5],[permit ])) ;;
	142	*) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
	143	dnl Idea for future: generate a URL pointing to
	144	dnl "onlinedocs/configopts.html#whatever"
	145	esac
	146	]],
	147	[^$],
	148	[[
	149	case "$enableval" in
	150	yes\|no) ;;
	151	*) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
	152	esac
	153	]],
	154	[[$5]]),
	155	[enable_]m4_bpatsubst([$1],-,_)[=][$2])
	156	m4_undefine([_g_switch])dnl
	157	m4_undefine([_g_help])dnl
	158	])
	159
	160
	161	dnl
	162	dnl If GNU ld is in use, check to see if tricky linker opts can be used. If
	163	dnl the native linker is in use, all variables will be defined to something
	164	dnl safe (like an empty string).
	165	dnl
	166	dnl Defines:
	167	dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
	168	dnl OPT_LDFLAGS='-Wl,-O1' if possible
	169	dnl LD (as a side effect of testing)
	170	dnl Sets:
	171	dnl with_gnu_ld
	172	dnl libitm_gnu_ld_version (possibly)
	173	dnl
	174	dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
	175	dnl set libitm_gnu_ld_version to 12345. Zeros cause problems.
176	dnl
177	AC_DEFUN([LIBITM_CHECK_LINKER_FEATURES], [
178	# If we're not using GNU ld, then there's no point in even trying these
179	# tests. Check for that first. We should have already tested for gld
180	# by now (in libtool), but require it now just to be safe...
181	test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
182	test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
183	AC_REQUIRE([AC_PROG_LD])
184	AC_REQUIRE([AC_PROG_AWK])
185
186	# The name set by libtool depends on the version of libtool. Shame on us
187	# for depending on an impl detail, but c'est la vie. Older versions used
188	# ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
189	# top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
190	# makes sense). We'll test with_gnu_ld everywhere else, so if that isn't
191	# set (hence we're using an older libtool), then set it.
192	if test x${with_gnu_ld+set} != xset; then
193	if test x${ac_cv_prog_gnu_ld+set} != xset; then
194	# We got through "ac_require(ac_prog_ld)" and still not set? Huh?
195	with_gnu_ld=no
196	else
197	with_gnu_ld=$ac_cv_prog_gnu_ld
198	fi
199	fi
200
201	# Start by getting the version number. I think the libtool test already
202	# does some of this, but throws away the result.
203	changequote(,)
204	ldver=`$LD --version 2>/dev/null \| head -1 \| \
205	sed -e 's/GNU ld \(version \)\{0,1\}\(([^)]) \)\{0,1\}\([0-9.][0-9.]\).*/\3/'`
206	changequote([,])
207	libitm_gnu_ld_version=`echo $ldver \| \
208	$AWK -F. '{ if (NF<3) [$]3=0; print ([$]1100+[$]2)100+[$]3 }'`
209
210	# Set --gc-sections.
211	if test "$with_gnu_ld" = "notbroken"; then
212	# GNU ld it is! Joy and bunny rabbits!
213
214	# All these tests are for C++; save the language and the compiler flags.
215	# Need to do this so that g++ won't try to link in libstdc++
216	ac_test_CFLAGS="${CFLAGS+set}"
217	ac_save_CFLAGS="$CFLAGS"
218	CFLAGS='-x c++ -Wl,--gc-sections'
219
220	# Check for -Wl,--gc-sections
221	# XXX This test is broken at the moment, as symbols required for linking
222	# are now in libsupc++ (not built yet). In addition, this test has
223	# cored on solaris in the past. In addition, --gc-sections doesn't
224	# really work at the moment (keeps on discarding used sections, first
225	# .eh_frame and now some of the glibc sections for iconv).
226	# Bzzzzt. Thanks for playing, maybe next time.
227	AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
228	AC_TRY_RUN([
229	int main(void)
230	{
231	try { throw 1; }
232	catch (...) { };
233	return 0;
234	}
235	], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
236	if test "$ac_test_CFLAGS" = set; then
237	CFLAGS="$ac_save_CFLAGS"
238	else
239	# this is the suspicious part
240	CFLAGS=''
241	fi
242	if test "$ac_sectionLDflags" = "yes"; then
243	SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
244	fi
245	AC_MSG_RESULT($ac_sectionLDflags)
246	fi
247
248	# Set linker optimization flags.
249	if test x"$with_gnu_ld" = x"yes"; then
250	OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
251	fi
252
253	AC_SUBST(SECTION_LDFLAGS)
254	AC_SUBST(OPT_LDFLAGS)
255	])
256
257
258	dnl
259	dnl Add version tags to symbols in shared library (or not), additionally
260	dnl marking other symbols as private/local (or not).
261	dnl
262	dnl --enable-symvers=style adds a version script to the linker call when
263	dnl creating the shared library. The choice of version script is
264	dnl controlled by 'style'.
265	dnl --disable-symvers does not.
266	dnl + Usage: LIBITM_ENABLE_SYMVERS[(DEFAULT)]
267	dnl Where DEFAULT is either 'yes' or 'no'. Passing `yes' tries to
268	dnl choose a default style based on linker characteristics. Passing
269	dnl 'no' disables versioning.
270	dnl
271	AC_DEFUN([LIBITM_ENABLE_SYMVERS], [
272
273	LIBITM_ENABLE(symvers,yes,[=STYLE],
274	[enables symbol versioning of the shared library],
275	[permit yes\|no\|gnu])
276
277	# If we never went through the LIBITM_CHECK_LINKER_FEATURES macro, then we
278	# don't know enough about $LD to do tricks...
279	AC_REQUIRE([LIBITM_CHECK_LINKER_FEATURES])
280	# FIXME The following test is too strict, in theory.
281	if test $enable_shared = no \|\|
282	test "x$LD" = x \|\|
283	test x$libitm_gnu_ld_version = x; then
284	enable_symvers=no
285	fi
286
287	# Check to see if libgcc_s exists, indicating that shared libgcc is possible.
288	if test $enable_symvers != no; then
289	AC_MSG_CHECKING([for shared libgcc])
290	ac_save_CFLAGS="$CFLAGS"
291	CFLAGS=' -lgcc_s'
292	AC_TRY_LINK(, [return 0;], libitm_shared_libgcc=yes, libitm_shared_libgcc=no)
293	CFLAGS="$ac_save_CFLAGS"
294	if test $libitm_shared_libgcc = no; then
295	cat > conftest.c <<EOF
296	int main (void) { return 0; }
297	EOF
298	changequote(,)dnl
299	libitm_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
300	-shared -shared-libgcc -o conftest.so \
301	conftest.c -v 2>&1 >/dev/null \
302	\| sed -n 's/^.* -lgcc_s\([^ ]\) .$/\1/p'`
303	changequote([,])dnl
304	rm -f conftest.c conftest.so
305	if test x${libitm_libgcc_s_suffix+set} = xset; then
306	CFLAGS=" -lgcc_s$libitm_libgcc_s_suffix"
307	AC_TRY_LINK(, [return 0;], libitm_shared_libgcc=yes)
308	CFLAGS="$ac_save_CFLAGS"
309	fi
310	fi
311	AC_MSG_RESULT($libitm_shared_libgcc)
312	fi
313
314	# For GNU ld, we need at least this version. The format is described in
315	# LIBITM_CHECK_LINKER_FEATURES above.
316	libitm_min_gnu_ld_version=21400
317	# XXXXXXXXXXX libitm_gnu_ld_version=21390
318
319	# Check to see if unspecified "yes" value can win, given results above.
320	# Change "yes" into either "no" or a style name.
321	if test $enable_symvers = yes; then
322	if test $with_gnu_ld = yes &&
323	test $libitm_shared_libgcc = yes;
324	then
325	if test $libitm_gnu_ld_version -ge $libitm_min_gnu_ld_version ; then
326	enable_symvers=gnu
327	else
328	# The right tools, the right setup, but too old. Fallbacks?
329	AC_MSG_WARN(=== Linker version $libitm_gnu_ld_version is too old for)
330	AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
331	AC_MSG_WARN(=== You would need to upgrade your binutils to version)
332	AC_MSG_WARN(=== $libitm_min_gnu_ld_version or later and rebuild GCC.)
333	if test $libitm_gnu_ld_version -ge 21200 ; then
334	# Globbing fix is present, proper block support is not.
335	dnl AC_MSG_WARN([=== Dude, you are soooo close. Maybe we can fake it.])
336	dnl enable_symvers=???
337	AC_MSG_WARN([=== Symbol versioning will be disabled.])
338	enable_symvers=no
339	else
340	# 2.11 or older.
341	AC_MSG_WARN([=== Symbol versioning will be disabled.])
342	enable_symvers=no
343	fi
344	fi
345	else
346	# just fail for now
347	AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
348	AC_MSG_WARN([=== either you are not using a supported linker, or you are])
349	AC_MSG_WARN([=== not building a shared libgcc_s (which is required).])
350	AC_MSG_WARN([=== Symbol versioning will be disabled.])
351	enable_symvers=no
352	fi
353	fi
354
355	AM_CONDITIONAL(LIBITM_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
356	AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
357	])