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