m4/ax_sys_weak_alias.m4

   1 # SPDX-FileCopyrightText: 2008 Kevin L. Mitchell <klmitch@mit.edu>
   2 #
   3 # SPDX-License-Identifier: FSFAP
   4 #
   5 # ===========================================================================
   6 #    https://www.gnu.org/software/autoconf-archive/ax_sys_weak_alias.html
   7 # ===========================================================================
   8 #
   9 # SYNOPSIS
  10 #
  11 #   AX_SYS_WEAK_ALIAS
  12 #
  13 # DESCRIPTION
  14 #
  15 #   Determines whether weak aliases are supported on the system, and if so,
  16 #   what scheme is used to declare them. Also checks to see if aliases can
  17 #   cross object file boundaries, as some systems don't permit them to.
  18 #
  19 #   Most systems permit something called a "weak alias" or "weak symbol."
  20 #   These aliases permit a library to provide a stub form of a routine
  21 #   defined in another library, thus allowing the first library to operate
  22 #   even if the other library is not linked. This macro will check for
  23 #   support of weak aliases, figure out what schemes are available, and
  24 #   determine some characteristics of the weak alias support -- primarily,
  25 #   whether a weak alias declared in one object file may be referenced from
  26 #   another object file.
  27 #
  28 #   There are four known schemes of declaring weak symbols; each scheme is
  29 #   checked in turn, and the first one found is preferred. Note that only
  30 #   one of the mentioned preprocessor macros will be defined!
  31 #
  32 #   1. Function attributes
  33 #
  34 #   This scheme was first introduced by the GNU C compiler, and attaches
  35 #   attributes to particular functions. It is among the easiest to use, and
  36 #   so is the first one checked. If this scheme is detected, the
  37 #   preprocessor macro HAVE_SYS_WEAK_ALIAS_ATTRIBUTE will be defined to 1.
  38 #   This scheme is used as in the following code fragment:
  39 #
  40 #     void __weakf(int c)
  41 #     {
  42 #       /* Function definition... */
  43 #     }
  44 #
  45 #     void weakf(int c) __attribute__((weak, alias("__weakf")));
  46 #
  47 #   2. #pragma weak
  48 #
  49 #   This scheme is in use by many compilers other than the GNU C compiler.
  50 #   It is also particularly easy to use, and fairly portable -- well, as
  51 #   portable as these things get. If this scheme is detected first, the
  52 #   preprocessor macro HAVE_SYS_WEAK_ALIAS_PRAGMA will be defined to 1. This
  53 #   scheme is used as in the following code fragment:
  54 #
  55 #     extern void weakf(int c);
  56 #     #pragma weak weakf = __weakf
  57 #     void __weakf(int c)
  58 #     {
  59 #       /* Function definition... */
  60 #     }
  61 #
  62 #   3. #pragma _HP_SECONDARY_DEF
  63 #
  64 #   This scheme appears to be in use by the HP compiler. As it is rather
  65 #   specialized, this is one of the last schemes checked. If it is the first
  66 #   one detected, the preprocessor macro HAVE_SYS_WEAK_ALIAS_HPSECONDARY
  67 #   will be defined to 1. This scheme is used as in the following code
  68 #   fragment:
  69 #
  70 #     extern void weakf(int c);
  71 #     #pragma _HP_SECONDARY_DEF __weakf weakf
  72 #     void __weakf(int c)
  73 #     {
  74 #       /* Function definition... */
  75 #     }
  76 #
  77 #   4. #pragma _CRI duplicate
  78 #
  79 #   This scheme appears to be in use by the Cray compiler. As it is rather
  80 #   specialized, it too is one of the last schemes checked. If it is the
  81 #   first one detected, the preprocessor macro
  82 #   HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE will be defined to 1. This scheme is
  83 #   used as in the following code fragment:
  84 #
  85 #     extern void weakf(int c);
  86 #     #pragma _CRI duplicate weakf as __weakf
  87 #     void __weakf(int c)
  88 #     {
  89 #       /* Function definition... */
  90 #     }
  91 #
  92 #   In addition to the preprocessor macros listed above, if any scheme is
  93 #   found, the preprocessor macro HAVE_SYS_WEAK_ALIAS will also be defined
  94 #   to 1.
  95 #
  96 #   Once a weak aliasing scheme has been found, a check will be performed to
  97 #   see if weak aliases are honored across object file boundaries. If they
  98 #   are, the HAVE_SYS_WEAK_ALIAS_CROSSFILE preprocessor macro is defined to
  99 #   1.
 100 #
 101 #   This Autoconf macro also makes two substitutions. The first, WEAK_ALIAS,
 102 #   contains the name of the scheme found (one of "attribute", "pragma",
 103 #   "hpsecondary", or "criduplicate"), or "no" if no weak aliasing scheme
 104 #   was found. The second, WEAK_ALIAS_CROSSFILE, is set to "yes" or "no"
 105 #   depending on whether or not weak aliases may cross object file
 106 #   boundaries.
 107 #
 108 # LICENSE
 109 #
 110 #   Copyright (c) 2008 Kevin L. Mitchell <klmitch@mit.edu>
 111 #
 112 #   Copying and distribution of this file, with or without modification, are
 113 #   permitted in any medium without royalty provided the copyright notice
 114 #   and this notice are preserved. This file is offered as-is, without any
 115 #   warranty.
 116
 117 #serial 8
 118
 119 AU_ALIAS([KLM_SYS_WEAK_ALIAS], [AX_SYS_WEAK_ALIAS])
 120 AC_DEFUN([AX_SYS_WEAK_ALIAS], [
 121   # starting point: no aliasing scheme yet...
 122   ax_sys_weak_alias=no
 123
 124   # Figure out what kind of aliasing may be supported...
 125   _AX_SYS_WEAK_ALIAS_ATTRIBUTE
 126   _AX_SYS_WEAK_ALIAS_PRAGMA
 127   _AX_SYS_WEAK_ALIAS_HPSECONDARY
 128   _AX_SYS_WEAK_ALIAS_CRIDUPLICATE
 129
 130   # Do we actually support aliasing?
 131   AC_CACHE_CHECK([how to create weak aliases with $CC],
 132                  [ax_cv_sys_weak_alias],
 133                  [ax_cv_sys_weak_alias=$ax_sys_weak_alias])
 134
 135   # OK, set a #define
 136   AS_IF([test $ax_cv_sys_weak_alias != no], [
 137     AC_DEFINE([HAVE_SYS_WEAK_ALIAS], 1,
 138               [Define this if your system can create weak aliases])
 139   ])
 140
 141   # Can aliases cross object file boundaries?
 142   _AX_SYS_WEAK_ALIAS_CROSSFILE
 143
 144   # OK, remember the results
 145   AC_SUBST([WEAK_ALIAS], [$ax_cv_sys_weak_alias])
 146   AC_SUBST([WEAK_ALIAS_CROSSFILE], [$ax_cv_sys_weak_alias_crossfile])
 147 ])
 148
 149 AC_DEFUN([_AX_SYS_WEAK_ALIAS_ATTRIBUTE],
 150 [ # Test whether compiler accepts __attribute__ form of weak aliasing
 151   AC_CACHE_CHECK([whether $CC accepts function __attribute__((weak,alias()))],
 152   [ax_cv_sys_weak_alias_attribute], [
 153     # We add -Werror if it's gcc to force an error exit if the weak attribute
 154     # isn't understood
 155     AS_IF([test $GCC = yes], [
 156       save_CFLAGS=$CFLAGS
 157       CFLAGS=-Werror])
 158
 159     # Try linking with a weak alias...
 160     AC_LINK_IFELSE([
 161       AC_LANG_PROGRAM([
 162 void __weakf(int c) {}
 163 void weakf(int c) __attribute__((weak, alias("__weakf")));],
 164         [weakf(0)])],
 165       [ax_cv_sys_weak_alias_attribute=yes],
 166       [ax_cv_sys_weak_alias_attribute=no])
 167
 168     # Restore original CFLAGS
 169     AS_IF([test $GCC = yes], [
 170       CFLAGS=$save_CFLAGS])
 171   ])
 172
 173   # What was the result of the test?
 174   AS_IF([test $ax_sys_weak_alias = no &&
 175          test $ax_cv_sys_weak_alias_attribute = yes], [
 176     ax_sys_weak_alias=attribute
 177     AC_DEFINE([HAVE_SYS_WEAK_ALIAS_ATTRIBUTE], 1,
 178               [Define this if weak aliases may be created with __attribute__])
 179   ])
 180 ])
 181
 182 AC_DEFUN([_AX_SYS_WEAK_ALIAS_PRAGMA],
 183 [ # Test whether compiler accepts #pragma form of weak aliasing
 184   AC_CACHE_CHECK([whether $CC supports @%:@pragma weak],
 185   [ax_cv_sys_weak_alias_pragma], [
 186
 187     # Try linking with a weak alias...
 188     AC_LINK_IFELSE([
 189       AC_LANG_PROGRAM([
 190 extern void weakf(int c);
 191 @%:@pragma weak weakf = __weakf
 192 void __weakf(int c) {}],
 193         [weakf(0)])],
 194       [ax_cv_sys_weak_alias_pragma=yes],
 195       [ax_cv_sys_weak_alias_pragma=no])
 196   ])
 197
 198   # What was the result of the test?
 199   AS_IF([test $ax_sys_weak_alias = no &&
 200          test $ax_cv_sys_weak_alias_pragma = yes], [
 201     ax_sys_weak_alias=pragma
 202     AC_DEFINE([HAVE_SYS_WEAK_ALIAS_PRAGMA], 1,
 203               [Define this if weak aliases may be created with @%:@pragma weak])
 204   ])
 205 ])
 206
 207 AC_DEFUN([_AX_SYS_WEAK_ALIAS_HPSECONDARY],
 208 [ # Test whether compiler accepts _HP_SECONDARY_DEF pragma from HP...
 209   AC_CACHE_CHECK([whether $CC supports @%:@pragma _HP_SECONDARY_DEF],
 210   [ax_cv_sys_weak_alias_hpsecondary], [
 211
 212     # Try linking with a weak alias...
 213     AC_LINK_IFELSE([
 214       AC_LANG_PROGRAM([
 215 extern void weakf(int c);
 216 @%:@pragma _HP_SECONDARY_DEF __weakf weakf
 217 void __weakf(int c) {}],
 218         [weakf(0)])],
 219       [ax_cv_sys_weak_alias_hpsecondary=yes],
 220       [ax_cv_sys_weak_alias_hpsecondary=no])
 221   ])
 222
 223   # What was the result of the test?
 224   AS_IF([test $ax_sys_weak_alias = no &&
 225          test $ax_cv_sys_weak_alias_hpsecondary = yes], [
 226     ax_sys_weak_alias=hpsecondary
 227     AC_DEFINE([HAVE_SYS_WEAK_ALIAS_HPSECONDARY], 1,
 228               [Define this if weak aliases may be created with @%:@pragma _HP_SECONDARY_DEF])
 229   ])
 230 ])
 231
 232 AC_DEFUN([_AX_SYS_WEAK_ALIAS_CRIDUPLICATE],
 233 [ # Test whether compiler accepts "_CRI duplicate" pragma from Cray
 234   AC_CACHE_CHECK([whether $CC supports @%:@pragma _CRI duplicate],
 235   [ax_cv_sys_weak_alias_criduplicate], [
 236
 237     # Try linking with a weak alias...
 238     AC_LINK_IFELSE([
 239       AC_LANG_PROGRAM([
 240 extern void weakf(int c);
 241 @%:@pragma _CRI duplicate weakf as __weakf
 242 void __weakf(int c) {}],
 243         [weakf(0)])],
 244       [ax_cv_sys_weak_alias_criduplicate=yes],
 245       [ax_cv_sys_weak_alias_criduplicate=no])
 246   ])
 247
 248   # What was the result of the test?
 249   AS_IF([test $ax_sys_weak_alias = no &&
 250          test $ax_cv_sys_weak_alias_criduplicate = yes], [
 251     ax_sys_weak_alias=criduplicate
 252     AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE], 1,
 253               [Define this if weak aliases may be created with @%:@pragma _CRI duplicate])
 254   ])
 255 ])
 256
 257 dnl Note: This macro is modeled closely on AC_LINK_IFELSE, and in fact
 258 dnl depends on some implementation details of that macro, particularly
 259 dnl its use of _AC_MSG_LOG_CONFTEST to log the failed test program and
 260 dnl its use of ac_link for running the linker.
 261 AC_DEFUN([_AX_SYS_WEAK_ALIAS_CROSSFILE],
 262 [ # Check to see if weak aliases can cross object file boundaries
 263   AC_CACHE_CHECK([whether $CC supports weak aliases across object file boundaries],
 264   [ax_cv_sys_weak_alias_crossfile], [
 265     AS_IF([test $ax_cv_sys_weak_alias = no],
 266           [ax_cv_sys_weak_alias_crossfile=no], [
 267 dnl Must build our own test files...
 268       # conftest1 contains our weak alias definition...
 269       cat >conftest1.$ac_ext <<_ACEOF
 270 /* confdefs.h.  */
 271 _ACEOF
 272       cat confdefs.h >>conftest1.$ac_ext
 273       cat >>conftest1.$ac_ext <<_ACEOF
 274 /* end confdefs.h.  */
 275
 276 @%:@ifndef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE
 277 extern void weakf(int c);
 278 @%:@endif
 279 @%:@if defined(HAVE_SYS_WEAK_ALIAS_PRAGMA)
 280 @%:@pragma weak weakf = __weakf
 281 @%:@elif defined(HAVE_SYS_WEAK_ALIAS_HPSECONDARY)
 282 @%:@pragma _HP_SECONDARY_DEF __weakf weakf
 283 @%:@elif defined(HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE)
 284 @%:@pragma _CRI duplicate weakf as __weakf
 285 @%:@endif
 286 void __weakf(int c) {}
 287 @%:@ifdef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE
 288 void weakf(int c) __attribute((weak, alias("__weakf")));
 289 @%:@endif
 290 _ACEOF
 291       # And conftest2 contains our main routine that calls it
 292       cat >conftest2.$ac_ext <<_ACEOF
 293 /* confdefs.h.  */
 294 _ACEOF
 295       cat confdefs.h >> conftest2.$ac_ext
 296       cat >>conftest2.$ac_ext <<_ACEOF
 297 /* end confdefs.h.  */
 298
 299 extern void weakf(int c);
 300 int
 301 main ()
 302 {
 303   weakf(0);
 304   return 0;
 305 }
 306 _ACEOF
 307       # We must remove the object files (if any) ourselves...
 308       rm -f conftest2.$ac_objext conftest$ac_exeext
 309
 310       # Change ac_link to compile *2* files together
 311       save_aclink=$ac_link
 312       ac_link=`echo "$ac_link" | \
 313                sed -e 's/conftest\(\.\$ac_ext\)/conftest1\1 conftest2\1/'`
 314 dnl Substitute our own routine for logging the conftest
 315 m4_pushdef([_AC_MSG_LOG_CONFTEST],
 316 [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD
 317 echo ">>> conftest1.$ac_ext" >&AS_MESSAGE_LOG_FD
 318 sed "s/^/| /" conftest1.$ac_ext >&AS_MESSAGE_LOG_FD
 319 echo ">>> conftest2.$ac_ext" >&AS_MESSAGE_LOG_FD
 320 sed "s/^/| /" conftest2.$ac_ext >&AS_MESSAGE_LOG_FD
 321 ])dnl
 322       # Since we created the files ourselves, don't use SOURCE argument
 323       AC_LINK_IFELSE(, [ax_cv_sys_weak_alias_crossfile=yes],
 324                      [ax_cv_sys_weak_alias_crossfile=no])
 325 dnl Restore _AC_MSG_LOG_CONFTEST
 326 m4_popdef([_AC_MSG_LOG_CONFTEST])dnl
 327       # Restore ac_link
 328       ac_link=$save_aclink
 329
 330       # We must remove the object files (if any) and C files ourselves...
 331       rm -f conftest1.$ac_ext conftest2.$ac_ext \
 332             conftest1.$ac_objext conftest2.$ac_objext
 333     ])
 334   ])
 335
 336   # What were the results of the test?
 337   AS_IF([test $ax_cv_sys_weak_alias_crossfile = yes], [
 338     AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CROSSFILE], 1,
 339               [Define this if weak aliases in other files are honored])
 340   ])
 341 ])