/usr/share/aclocal/ax_sys_weak_alias.m4 is in autoconf-archive 20140228-1.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 | # ===========================================================================
# http://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 prefered. 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 6
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])
])
])
|