]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - m4/ax_sys_weak_alias.m4
New upstream version 1.2.4
[quagga-debian.git] / m4 / ax_sys_weak_alias.m4
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 ])