Annotation of embedaddon/quagga/m4/ax_sys_weak_alias.m4, revision 1.1.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