~lttng/lttng-ust/lttng-ust

« back to all changes in this revision

Viewing changes to config/ax_sys_weak_alias.m4

  • Committer: Mathieu Desnoyers
  • Author(s): Michael Jeanson
  • Date: 2017-05-09 18:52:23 UTC
  • Revision ID: git-v1:093c3f9bbdda113147ab03be62aaa37bd1c786b4
Move m4 scripts to m4 dir

Harmonize build system configuration across our projects.

Signed-off-by: Michael Jeanson <mjeanson@efficios.com>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
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_sys_weak_alias = no &&
171
 
         test $ax_cv_sys_weak_alias_attribute = yes], [
172
 
    ax_sys_weak_alias=attribute
173
 
    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_ATTRIBUTE], 1,
174
 
              [Define this if weak aliases may be created with __attribute__])
175
 
  ])
176
 
])
177
 
 
178
 
AC_DEFUN([_AX_SYS_WEAK_ALIAS_PRAGMA],
179
 
[ # Test whether compiler accepts #pragma form of weak aliasing
180
 
  AC_CACHE_CHECK([whether $CC supports @%:@pragma weak],
181
 
  [ax_cv_sys_weak_alias_pragma], [
182
 
 
183
 
    # Try linking with a weak alias...
184
 
    AC_LINK_IFELSE([
185
 
      AC_LANG_PROGRAM([
186
 
extern void weakf(int c);
187
 
@%:@pragma weak weakf = __weakf
188
 
void __weakf(int c) {}],
189
 
        [weakf(0)])],
190
 
      [ax_cv_sys_weak_alias_pragma=yes],
191
 
      [ax_cv_sys_weak_alias_pragma=no])
192
 
  ])
193
 
 
194
 
  # What was the result of the test?
195
 
  AS_IF([test $ax_sys_weak_alias = no &&
196
 
         test $ax_cv_sys_weak_alias_pragma = yes], [
197
 
    ax_sys_weak_alias=pragma
198
 
    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_PRAGMA], 1,
199
 
              [Define this if weak aliases may be created with @%:@pragma weak])
200
 
  ])
201
 
])
202
 
 
203
 
AC_DEFUN([_AX_SYS_WEAK_ALIAS_HPSECONDARY],
204
 
[ # Test whether compiler accepts _HP_SECONDARY_DEF pragma from HP...
205
 
  AC_CACHE_CHECK([whether $CC supports @%:@pragma _HP_SECONDARY_DEF],
206
 
  [ax_cv_sys_weak_alias_hpsecondary], [
207
 
 
208
 
    # Try linking with a weak alias...
209
 
    AC_LINK_IFELSE([
210
 
      AC_LANG_PROGRAM([
211
 
extern void weakf(int c);
212
 
@%:@pragma _HP_SECONDARY_DEF __weakf weakf
213
 
void __weakf(int c) {}],
214
 
        [weakf(0)])],
215
 
      [ax_cv_sys_weak_alias_hpsecondary=yes],
216
 
      [ax_cv_sys_weak_alias_hpsecondary=no])
217
 
  ])
218
 
 
219
 
  # What was the result of the test?
220
 
  AS_IF([test $ax_sys_weak_alias = no &&
221
 
         test $ax_cv_sys_weak_alias_hpsecondary = yes], [
222
 
    ax_sys_weak_alias=hpsecondary
223
 
    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_HPSECONDARY], 1,
224
 
              [Define this if weak aliases may be created with @%:@pragma _HP_SECONDARY_DEF])
225
 
  ])
226
 
])
227
 
 
228
 
AC_DEFUN([_AX_SYS_WEAK_ALIAS_CRIDUPLICATE],
229
 
[ # Test whether compiler accepts "_CRI duplicate" pragma from Cray
230
 
  AC_CACHE_CHECK([whether $CC supports @%:@pragma _CRI duplicate],
231
 
  [ax_cv_sys_weak_alias_criduplicate], [
232
 
 
233
 
    # Try linking with a weak alias...
234
 
    AC_LINK_IFELSE([
235
 
      AC_LANG_PROGRAM([
236
 
extern void weakf(int c);
237
 
@%:@pragma _CRI duplicate weakf as __weakf
238
 
void __weakf(int c) {}],
239
 
        [weakf(0)])],
240
 
      [ax_cv_sys_weak_alias_criduplicate=yes],
241
 
      [ax_cv_sys_weak_alias_criduplicate=no])
242
 
  ])
243
 
 
244
 
  # What was the result of the test?
245
 
  AS_IF([test $ax_sys_weak_alias = no &&
246
 
         test $ax_cv_sys_weak_alias_criduplicate = yes], [
247
 
    ax_sys_weak_alias=criduplicate
248
 
    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE], 1,
249
 
              [Define this if weak aliases may be created with @%:@pragma _CRI duplicate])
250
 
  ])
251
 
])
252
 
 
253
 
dnl Note: This macro is modeled closely on AC_LINK_IFELSE, and in fact
254
 
dnl depends on some implementation details of that macro, particularly
255
 
dnl its use of _AC_MSG_LOG_CONFTEST to log the failed test program and
256
 
dnl its use of ac_link for running the linker.
257
 
AC_DEFUN([_AX_SYS_WEAK_ALIAS_CROSSFILE],
258
 
[ # Check to see if weak aliases can cross object file boundaries
259
 
  AC_CACHE_CHECK([whether $CC supports weak aliases across object file boundaries],
260
 
  [ax_cv_sys_weak_alias_crossfile], [
261
 
    AS_IF([test $ax_cv_sys_weak_alias = no],
262
 
          [ax_cv_sys_weak_alias_crossfile=no], [
263
 
dnl Must build our own test files...
264
 
      # conftest1 contains our weak alias definition...
265
 
      cat >conftest1.$ac_ext <<_ACEOF
266
 
/* confdefs.h.  */
267
 
_ACEOF
268
 
      cat confdefs.h >>conftest1.$ac_ext
269
 
      cat >>conftest1.$ac_ext <<_ACEOF
270
 
/* end confdefs.h.  */
271
 
 
272
 
@%:@ifndef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE
273
 
extern void weakf(int c);
274
 
@%:@endif
275
 
@%:@if defined(HAVE_SYS_WEAK_ALIAS_PRAGMA)
276
 
@%:@pragma weak weakf = __weakf
277
 
@%:@elif defined(HAVE_SYS_WEAK_ALIAS_HPSECONDARY)
278
 
@%:@pragma _HP_SECONDARY_DEF __weakf weakf
279
 
@%:@elif defined(HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE)
280
 
@%:@pragma _CRI duplicate weakf as __weakf
281
 
@%:@endif
282
 
void __weakf(int c) {}
283
 
@%:@ifdef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE
284
 
void weakf(int c) __attribute((weak, alias("__weakf")));
285
 
@%:@endif
286
 
_ACEOF
287
 
      # And conftest2 contains our main routine that calls it
288
 
      cat >conftest2.$ac_ext <<_ACEOF
289
 
/* confdefs.h.  */
290
 
_ACEOF
291
 
      cat confdefs.h >> conftest2.$ac_ext
292
 
      cat >>conftest2.$ac_ext <<_ACEOF
293
 
/* end confdefs.h.  */
294
 
 
295
 
extern void weakf(int c);
296
 
int
297
 
main ()
298
 
{
299
 
  weakf(0);
300
 
  return 0;
301
 
}
302
 
_ACEOF
303
 
      # We must remove the object files (if any) ourselves...
304
 
      rm -f conftest2.$ac_objext conftest$ac_exeext
305
 
 
306
 
      # Change ac_link to compile *2* files together
307
 
      save_aclink=$ac_link
308
 
      ac_link=`echo "$ac_link" | \
309
 
               sed -e 's/conftest\(\.\$ac_ext\)/conftest1\1 conftest2\1/'`
310
 
dnl Substitute our own routine for logging the conftest
311
 
m4_pushdef([_AC_MSG_LOG_CONFTEST],
312
 
[echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD
313
 
echo ">>> conftest1.$ac_ext" >&AS_MESSAGE_LOG_FD
314
 
sed "s/^/| /" conftest1.$ac_ext >&AS_MESSAGE_LOG_FD
315
 
echo ">>> conftest2.$ac_ext" >&AS_MESSAGE_LOG_FD
316
 
sed "s/^/| /" conftest2.$ac_ext >&AS_MESSAGE_LOG_FD
317
 
])dnl
318
 
      # Since we created the files ourselves, don't use SOURCE argument
319
 
      AC_LINK_IFELSE(, [ax_cv_sys_weak_alias_crossfile=yes],
320
 
                     [ax_cv_sys_weak_alias_crossfile=no])
321
 
dnl Restore _AC_MSG_LOG_CONFTEST
322
 
m4_popdef([_AC_MSG_LOG_CONFTEST])dnl
323
 
      # Restore ac_link
324
 
      ac_link=$save_aclink
325
 
 
326
 
      # We must remove the object files (if any) and C files ourselves...
327
 
      rm -f conftest1.$ac_ext conftest2.$ac_ext \
328
 
            conftest1.$ac_objext conftest2.$ac_objext
329
 
    ])
330
 
  ])
331
 
 
332
 
  # What were the results of the test?
333
 
  AS_IF([test $ax_cv_sys_weak_alias_crossfile = yes], [
334
 
    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CROSSFILE], 1,
335
 
              [Define this if weak aliases in other files are honored])
336
 
  ])
337
 
])