From: Michael Jeanson Date: Wed, 14 Apr 2021 15:19:00 +0000 (-0400) Subject: fix: we used weak symbols not weak aliases X-Git-Tag: v0.13.0~15 X-Git-Url: https://git.liburcu.org/?p=userspace-rcu.git;a=commitdiff_plain;h=7afcc7685532e13f39fc13d505c96a3e5581d4d3 fix: we used weak symbols not weak aliases Remove the configure test for weak aliases since we don't use them and they are not supported on macOs. Change-Id: If245dfe02c9ec990e16e1a90983ba9d8f1eb9f4b Signed-off-by: Michael Jeanson Signed-off-by: Mathieu Desnoyers --- diff --git a/configure.ac b/configure.ac index 89b34ae..690fe8f 100644 --- a/configure.ac +++ b/configure.ac @@ -79,11 +79,6 @@ AS_IF([test "x$ax_cv___attribute__" != "xyes"], # Make sure we have pthread support AX_PTHREAD([], [AC_MSG_ERROR([Could not configure pthread support])]) -# Make sure the C compiler supports weak symbols -AX_SYS_WEAK_ALIAS -AS_IF([test "x$ax_cv_sys_weak_alias" = "xno"], - [AC_MSG_ERROR([Your platform doesn't support weak symbols.])]) - # Checks for typedefs, structures, and compiler characteristics. AC_C_INLINE AC_C_TYPEOF diff --git a/m4/ax_sys_weak_alias.m4 b/m4/ax_sys_weak_alias.m4 deleted file mode 100644 index 733b1dd..0000000 --- a/m4/ax_sys_weak_alias.m4 +++ /dev/null @@ -1,337 +0,0 @@ -# =========================================================================== -# https://www.gnu.org/software/autoconf-archive/ax_sys_weak_alias.html -# =========================================================================== -# -# SYNOPSIS -# -# AX_SYS_WEAK_ALIAS -# -# DESCRIPTION -# -# Determines whether weak aliases are supported on the system, and if so, -# what scheme is used to declare them. Also checks to see if aliases can -# cross object file boundaries, as some systems don't permit them to. -# -# Most systems permit something called a "weak alias" or "weak symbol." -# These aliases permit a library to provide a stub form of a routine -# defined in another library, thus allowing the first library to operate -# even if the other library is not linked. This macro will check for -# support of weak aliases, figure out what schemes are available, and -# determine some characteristics of the weak alias support -- primarily, -# whether a weak alias declared in one object file may be referenced from -# another object file. -# -# There are four known schemes of declaring weak symbols; each scheme is -# checked in turn, and the first one found is preferred. Note that only -# one of the mentioned preprocessor macros will be defined! -# -# 1. Function attributes -# -# This scheme was first introduced by the GNU C compiler, and attaches -# attributes to particular functions. It is among the easiest to use, and -# so is the first one checked. If this scheme is detected, the -# preprocessor macro HAVE_SYS_WEAK_ALIAS_ATTRIBUTE will be defined to 1. -# This scheme is used as in the following code fragment: -# -# void __weakf(int c) -# { -# /* Function definition... */ -# } -# -# void weakf(int c) __attribute__((weak, alias("__weakf"))); -# -# 2. #pragma weak -# -# This scheme is in use by many compilers other than the GNU C compiler. -# It is also particularly easy to use, and fairly portable -- well, as -# portable as these things get. If this scheme is detected first, the -# preprocessor macro HAVE_SYS_WEAK_ALIAS_PRAGMA will be defined to 1. This -# scheme is used as in the following code fragment: -# -# extern void weakf(int c); -# #pragma weak weakf = __weakf -# void __weakf(int c) -# { -# /* Function definition... */ -# } -# -# 3. #pragma _HP_SECONDARY_DEF -# -# This scheme appears to be in use by the HP compiler. As it is rather -# specialized, this is one of the last schemes checked. If it is the first -# one detected, the preprocessor macro HAVE_SYS_WEAK_ALIAS_HPSECONDARY -# will be defined to 1. This scheme is used as in the following code -# fragment: -# -# extern void weakf(int c); -# #pragma _HP_SECONDARY_DEF __weakf weakf -# void __weakf(int c) -# { -# /* Function definition... */ -# } -# -# 4. #pragma _CRI duplicate -# -# This scheme appears to be in use by the Cray compiler. As it is rather -# specialized, it too is one of the last schemes checked. If it is the -# first one detected, the preprocessor macro -# HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE will be defined to 1. This scheme is -# used as in the following code fragment: -# -# extern void weakf(int c); -# #pragma _CRI duplicate weakf as __weakf -# void __weakf(int c) -# { -# /* Function definition... */ -# } -# -# In addition to the preprocessor macros listed above, if any scheme is -# found, the preprocessor macro HAVE_SYS_WEAK_ALIAS will also be defined -# to 1. -# -# Once a weak aliasing scheme has been found, a check will be performed to -# see if weak aliases are honored across object file boundaries. If they -# are, the HAVE_SYS_WEAK_ALIAS_CROSSFILE preprocessor macro is defined to -# 1. -# -# This Autoconf macro also makes two substitutions. The first, WEAK_ALIAS, -# contains the name of the scheme found (one of "attribute", "pragma", -# "hpsecondary", or "criduplicate"), or "no" if no weak aliasing scheme -# was found. The second, WEAK_ALIAS_CROSSFILE, is set to "yes" or "no" -# depending on whether or not weak aliases may cross object file -# boundaries. -# -# LICENSE -# -# Copyright (c) 2008 Kevin L. Mitchell -# -# Copying and distribution of this file, with or without modification, are -# permitted in any medium without royalty provided the copyright notice -# and this notice are preserved. This file is offered as-is, without any -# warranty. - -#serial 8 - -AU_ALIAS([KLM_SYS_WEAK_ALIAS], [AX_SYS_WEAK_ALIAS]) -AC_DEFUN([AX_SYS_WEAK_ALIAS], [ - # starting point: no aliasing scheme yet... - ax_sys_weak_alias=no - - # Figure out what kind of aliasing may be supported... - _AX_SYS_WEAK_ALIAS_ATTRIBUTE - _AX_SYS_WEAK_ALIAS_PRAGMA - _AX_SYS_WEAK_ALIAS_HPSECONDARY - _AX_SYS_WEAK_ALIAS_CRIDUPLICATE - - # Do we actually support aliasing? - AC_CACHE_CHECK([how to create weak aliases with $CC], - [ax_cv_sys_weak_alias], - [ax_cv_sys_weak_alias=$ax_sys_weak_alias]) - - # OK, set a #define - AS_IF([test $ax_cv_sys_weak_alias != no], [ - AC_DEFINE([HAVE_SYS_WEAK_ALIAS], 1, - [Define this if your system can create weak aliases]) - ]) - - # Can aliases cross object file boundaries? - _AX_SYS_WEAK_ALIAS_CROSSFILE - - # OK, remember the results - AC_SUBST([WEAK_ALIAS], [$ax_cv_sys_weak_alias]) - AC_SUBST([WEAK_ALIAS_CROSSFILE], [$ax_cv_sys_weak_alias_crossfile]) -]) - -AC_DEFUN([_AX_SYS_WEAK_ALIAS_ATTRIBUTE], -[ # Test whether compiler accepts __attribute__ form of weak aliasing - AC_CACHE_CHECK([whether $CC accepts function __attribute__((weak,alias()))], - [ax_cv_sys_weak_alias_attribute], [ - # We add -Werror if it's gcc to force an error exit if the weak attribute - # isn't understood - AS_IF([test $GCC = yes], [ - save_CFLAGS=$CFLAGS - CFLAGS=-Werror]) - - # Try linking with a weak alias... - AC_LINK_IFELSE([ - AC_LANG_PROGRAM([ -void __weakf(int c) {} -void weakf(int c) __attribute__((weak, alias("__weakf")));], - [weakf(0)])], - [ax_cv_sys_weak_alias_attribute=yes], - [ax_cv_sys_weak_alias_attribute=no]) - - # Restore original CFLAGS - AS_IF([test $GCC = yes], [ - CFLAGS=$save_CFLAGS]) - ]) - - # What was the result of the test? - AS_IF([test $ax_sys_weak_alias = no && - test $ax_cv_sys_weak_alias_attribute = yes], [ - ax_sys_weak_alias=attribute - AC_DEFINE([HAVE_SYS_WEAK_ALIAS_ATTRIBUTE], 1, - [Define this if weak aliases may be created with __attribute__]) - ]) -]) - -AC_DEFUN([_AX_SYS_WEAK_ALIAS_PRAGMA], -[ # Test whether compiler accepts #pragma form of weak aliasing - AC_CACHE_CHECK([whether $CC supports @%:@pragma weak], - [ax_cv_sys_weak_alias_pragma], [ - - # Try linking with a weak alias... - AC_LINK_IFELSE([ - AC_LANG_PROGRAM([ -extern void weakf(int c); -@%:@pragma weak weakf = __weakf -void __weakf(int c) {}], - [weakf(0)])], - [ax_cv_sys_weak_alias_pragma=yes], - [ax_cv_sys_weak_alias_pragma=no]) - ]) - - # What was the result of the test? - AS_IF([test $ax_sys_weak_alias = no && - test $ax_cv_sys_weak_alias_pragma = yes], [ - ax_sys_weak_alias=pragma - AC_DEFINE([HAVE_SYS_WEAK_ALIAS_PRAGMA], 1, - [Define this if weak aliases may be created with @%:@pragma weak]) - ]) -]) - -AC_DEFUN([_AX_SYS_WEAK_ALIAS_HPSECONDARY], -[ # Test whether compiler accepts _HP_SECONDARY_DEF pragma from HP... - AC_CACHE_CHECK([whether $CC supports @%:@pragma _HP_SECONDARY_DEF], - [ax_cv_sys_weak_alias_hpsecondary], [ - - # Try linking with a weak alias... - AC_LINK_IFELSE([ - AC_LANG_PROGRAM([ -extern void weakf(int c); -@%:@pragma _HP_SECONDARY_DEF __weakf weakf -void __weakf(int c) {}], - [weakf(0)])], - [ax_cv_sys_weak_alias_hpsecondary=yes], - [ax_cv_sys_weak_alias_hpsecondary=no]) - ]) - - # What was the result of the test? - AS_IF([test $ax_sys_weak_alias = no && - test $ax_cv_sys_weak_alias_hpsecondary = yes], [ - ax_sys_weak_alias=hpsecondary - AC_DEFINE([HAVE_SYS_WEAK_ALIAS_HPSECONDARY], 1, - [Define this if weak aliases may be created with @%:@pragma _HP_SECONDARY_DEF]) - ]) -]) - -AC_DEFUN([_AX_SYS_WEAK_ALIAS_CRIDUPLICATE], -[ # Test whether compiler accepts "_CRI duplicate" pragma from Cray - AC_CACHE_CHECK([whether $CC supports @%:@pragma _CRI duplicate], - [ax_cv_sys_weak_alias_criduplicate], [ - - # Try linking with a weak alias... - AC_LINK_IFELSE([ - AC_LANG_PROGRAM([ -extern void weakf(int c); -@%:@pragma _CRI duplicate weakf as __weakf -void __weakf(int c) {}], - [weakf(0)])], - [ax_cv_sys_weak_alias_criduplicate=yes], - [ax_cv_sys_weak_alias_criduplicate=no]) - ]) - - # What was the result of the test? - AS_IF([test $ax_sys_weak_alias = no && - test $ax_cv_sys_weak_alias_criduplicate = yes], [ - ax_sys_weak_alias=criduplicate - AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE], 1, - [Define this if weak aliases may be created with @%:@pragma _CRI duplicate]) - ]) -]) - -dnl Note: This macro is modeled closely on AC_LINK_IFELSE, and in fact -dnl depends on some implementation details of that macro, particularly -dnl its use of _AC_MSG_LOG_CONFTEST to log the failed test program and -dnl its use of ac_link for running the linker. -AC_DEFUN([_AX_SYS_WEAK_ALIAS_CROSSFILE], -[ # Check to see if weak aliases can cross object file boundaries - AC_CACHE_CHECK([whether $CC supports weak aliases across object file boundaries], - [ax_cv_sys_weak_alias_crossfile], [ - AS_IF([test $ax_cv_sys_weak_alias = no], - [ax_cv_sys_weak_alias_crossfile=no], [ -dnl Must build our own test files... - # conftest1 contains our weak alias definition... - cat >conftest1.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF - cat confdefs.h >>conftest1.$ac_ext - cat >>conftest1.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -@%:@ifndef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE -extern void weakf(int c); -@%:@endif -@%:@if defined(HAVE_SYS_WEAK_ALIAS_PRAGMA) -@%:@pragma weak weakf = __weakf -@%:@elif defined(HAVE_SYS_WEAK_ALIAS_HPSECONDARY) -@%:@pragma _HP_SECONDARY_DEF __weakf weakf -@%:@elif defined(HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE) -@%:@pragma _CRI duplicate weakf as __weakf -@%:@endif -void __weakf(int c) {} -@%:@ifdef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE -void weakf(int c) __attribute((weak, alias("__weakf"))); -@%:@endif -_ACEOF - # And conftest2 contains our main routine that calls it - cat >conftest2.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF - cat confdefs.h >> conftest2.$ac_ext - cat >>conftest2.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -extern void weakf(int c); -int -main () -{ - weakf(0); - return 0; -} -_ACEOF - # We must remove the object files (if any) ourselves... - rm -f conftest2.$ac_objext conftest$ac_exeext - - # Change ac_link to compile *2* files together - save_aclink=$ac_link - ac_link=`echo "$ac_link" | \ - sed -e 's/conftest\(\.\$ac_ext\)/conftest1\1 conftest2\1/'` -dnl Substitute our own routine for logging the conftest -m4_pushdef([_AC_MSG_LOG_CONFTEST], -[echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD -echo ">>> conftest1.$ac_ext" >&AS_MESSAGE_LOG_FD -sed "s/^/| /" conftest1.$ac_ext >&AS_MESSAGE_LOG_FD -echo ">>> conftest2.$ac_ext" >&AS_MESSAGE_LOG_FD -sed "s/^/| /" conftest2.$ac_ext >&AS_MESSAGE_LOG_FD -])dnl - # Since we created the files ourselves, don't use SOURCE argument - AC_LINK_IFELSE(, [ax_cv_sys_weak_alias_crossfile=yes], - [ax_cv_sys_weak_alias_crossfile=no]) -dnl Restore _AC_MSG_LOG_CONFTEST -m4_popdef([_AC_MSG_LOG_CONFTEST])dnl - # Restore ac_link - ac_link=$save_aclink - - # We must remove the object files (if any) and C files ourselves... - rm -f conftest1.$ac_ext conftest2.$ac_ext \ - conftest1.$ac_objext conftest2.$ac_objext - ]) - ]) - - # What were the results of the test? - AS_IF([test $ax_cv_sys_weak_alias_crossfile = yes], [ - AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CROSSFILE], 1, - [Define this if weak aliases in other files are honored]) - ]) -])