fix: we used weak symbols not weak aliases
authorMichael Jeanson <mjeanson@efficios.com>
Wed, 14 Apr 2021 15:19:00 +0000 (11:19 -0400)
committerMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Thu, 15 Apr 2021 12:27:16 +0000 (08:27 -0400)
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 <mjeanson@efficios.com>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
configure.ac
m4/ax_sys_weak_alias.m4 [deleted file]

index 89b34ae7313ef0b183a625cc2692bd22902ec423..690fe8fa7f1d41b8c4972fc9c0927bc9a42cb4ca 100644 (file)
@@ -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 (file)
index 733b1dd..0000000
+++ /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 <klmitch@mit.edu>
-#
-#   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])
-  ])
-])
This page took 0.049517 seconds and 4 git commands to generate.