Doug VanLeuven | 327c4cd | 2012-12-14 14:58:30 +0200 | [diff] [blame] | 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? |
David Lamparter | b2baffe | 2013-01-27 04:46:02 +0100 | [diff] [blame^] | 170 | AS_IF([test $ax_cv_sys_weak_alias_attribute = yes], [ |
| 171 | test $ax_sys_weak_alias = no && ax_sys_weak_alias=attribute |
Doug VanLeuven | 327c4cd | 2012-12-14 14:58:30 +0200 | [diff] [blame] | 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? |
David Lamparter | b2baffe | 2013-01-27 04:46:02 +0100 | [diff] [blame^] | 194 | AS_IF([test $ax_cv_sys_weak_alias_pragma = yes], [ |
| 195 | test $ax_sys_weak_alias = no && ax_sys_weak_alias=pragma |
Doug VanLeuven | 327c4cd | 2012-12-14 14:58:30 +0200 | [diff] [blame] | 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? |
David Lamparter | b2baffe | 2013-01-27 04:46:02 +0100 | [diff] [blame^] | 218 | AS_IF([test $ax_cv_sys_weak_alias_hpsecondary = yes], [ |
| 219 | test $ax_sys_weak_alias = no && ax_sys_weak_alias=hpsecondary |
Doug VanLeuven | 327c4cd | 2012-12-14 14:58:30 +0200 | [diff] [blame] | 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? |
David Lamparter | b2baffe | 2013-01-27 04:46:02 +0100 | [diff] [blame^] | 242 | AS_IF([test $ax_cv_sys_weak_alias_criduplicate = yes], [ |
| 243 | test $ax_sys_weak_alias = no && ax_sys_weak_alias=criduplicate |
Doug VanLeuven | 327c4cd | 2012-12-14 14:58:30 +0200 | [diff] [blame] | 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); |
Doug VanLeuven | 327c4cd | 2012-12-14 14:58:30 +0200 | [diff] [blame] | 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 |
David Lamparter | b2baffe | 2013-01-27 04:46:02 +0100 | [diff] [blame^] | 277 | @%:@endif |
Doug VanLeuven | 327c4cd | 2012-12-14 14:58:30 +0200 | [diff] [blame] | 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 | ]) |