~registry/kmod/master

« back to all changes in this revision

Viewing changes to m4/attributes.m4

  • Committer: Lucas De Marchi
  • Date: 2011-12-12 12:30:01 UTC
  • mfrom: (161.1.30)
  • Revision ID: git-v1:2fee2f13ce5f6b17dd672389de422217c56105e2
Merge branch 'use-mmap'

Conflicts:
        libkmod/libkmod.c

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
dnl Macros to check the presence of generic (non-typed) symbols.
 
2
dnl Copyright (c) 2006-2008 Diego Pettenò <flameeyes@gmail.com>
 
3
dnl Copyright (c) 2006-2008 xine project
 
4
dnl
 
5
dnl This program is free software; you can redistribute it and/or modify
 
6
dnl it under the terms of the GNU General Public License as published by
 
7
dnl the Free Software Foundation; either version 2, or (at your option)
 
8
dnl any later version.
 
9
dnl
 
10
dnl This program is distributed in the hope that it will be useful,
 
11
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
dnl GNU General Public License for more details.
 
14
dnl
 
15
dnl You should have received a copy of the GNU General Public License
 
16
dnl along with this program; if not, write to the Free Software
 
17
dnl Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 
18
dnl 02110-1301, USA.
 
19
dnl
 
20
dnl As a special exception, the copyright owners of the
 
21
dnl macro gives unlimited permission to copy, distribute and modify the
 
22
dnl configure scripts that are the output of Autoconf when processing the
 
23
dnl Macro. You need not follow the terms of the GNU General Public
 
24
dnl License when using or distributing such scripts, even though portions
 
25
dnl of the text of the Macro appear in them. The GNU General Public
 
26
dnl License (GPL) does govern all other use of the material that
 
27
dnl constitutes the Autoconf Macro.
 
28
dnl
 
29
dnl This special exception to the GPL applies to versions of the
 
30
dnl Autoconf Macro released by this project. When you make and
 
31
dnl distribute a modified version of the Autoconf Macro, you may extend
 
32
dnl this special exception to the GPL to apply to your modified version as
 
33
dnl well.
 
34
 
 
35
dnl Check if the flag is supported by compiler
 
36
dnl CC_CHECK_CFLAGS_SILENT([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
 
37
 
 
38
AC_DEFUN([CC_CHECK_CFLAGS_SILENT], [
 
39
  AC_CACHE_VAL(AS_TR_SH([cc_cv_cflags_$1]),
 
40
    [ac_save_CFLAGS="$CFLAGS"
 
41
     CFLAGS="$CFLAGS $1"
 
42
     AC_COMPILE_IFELSE([AC_LANG_SOURCE([int a;])],
 
43
       [eval "AS_TR_SH([cc_cv_cflags_$1])='yes'"],
 
44
       [eval "AS_TR_SH([cc_cv_cflags_$1])='no'"])
 
45
     CFLAGS="$ac_save_CFLAGS"
 
46
    ])
 
47
 
 
48
  AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes],
 
49
    [$2], [$3])
 
50
])
 
51
 
 
52
dnl Check if the flag is supported by compiler (cacheable)
 
53
dnl CC_CHECK_CFLAGS([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
 
54
 
 
55
AC_DEFUN([CC_CHECK_CFLAGS], [
 
56
  AC_CACHE_CHECK([if $CC supports $1 flag],
 
57
    AS_TR_SH([cc_cv_cflags_$1]),
 
58
    CC_CHECK_CFLAGS_SILENT([$1]) dnl Don't execute actions here!
 
59
  )
 
60
 
 
61
  AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes],
 
62
    [$2], [$3])
 
63
])
 
64
 
 
65
dnl CC_CHECK_CFLAG_APPEND(FLAG, [action-if-found], [action-if-not-found])
 
66
dnl Check for CFLAG and appends them to CFLAGS if supported
 
67
AC_DEFUN([CC_CHECK_CFLAG_APPEND], [
 
68
  AC_CACHE_CHECK([if $CC supports $1 flag],
 
69
    AS_TR_SH([cc_cv_cflags_$1]),
 
70
    CC_CHECK_CFLAGS_SILENT([$1]) dnl Don't execute actions here!
 
71
  )
 
72
 
 
73
  AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes],
 
74
    [CFLAGS="$CFLAGS $1"; DEBUG_CFLAGS="$DEBUG_CFLAGS $1"; $2], [$3])
 
75
])
 
76
 
 
77
dnl CC_CHECK_CFLAGS_APPEND([FLAG1 FLAG2], [action-if-found], [action-if-not])
 
78
AC_DEFUN([CC_CHECK_CFLAGS_APPEND], [
 
79
  for flag in $1; do
 
80
    CC_CHECK_CFLAG_APPEND($flag, [$2], [$3])
 
81
  done
 
82
])
 
83
 
 
84
dnl Check if the flag is supported by linker (cacheable)
 
85
dnl CC_CHECK_LDFLAGS([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
 
86
 
 
87
AC_DEFUN([CC_CHECK_LDFLAGS], [
 
88
  AC_CACHE_CHECK([if $CC supports $1 flag],
 
89
    AS_TR_SH([cc_cv_ldflags_$1]),
 
90
    [ac_save_LDFLAGS="$LDFLAGS"
 
91
     LDFLAGS="$LDFLAGS $1"
 
92
     AC_LINK_IFELSE([int main() { return 1; }],
 
93
       [eval "AS_TR_SH([cc_cv_ldflags_$1])='yes'"],
 
94
       [eval "AS_TR_SH([cc_cv_ldflags_$1])="])
 
95
     LDFLAGS="$ac_save_LDFLAGS"
 
96
    ])
 
97
 
 
98
  AS_IF([eval test x$]AS_TR_SH([cc_cv_ldflags_$1])[ = xyes],
 
99
    [$2], [$3])
 
100
])
 
101
 
 
102
dnl define the LDFLAGS_NOUNDEFINED variable with the correct value for
 
103
dnl the current linker to avoid undefined references in a shared object.
 
104
AC_DEFUN([CC_NOUNDEFINED], [
 
105
  dnl We check $host for which systems to enable this for.
 
106
  AC_REQUIRE([AC_CANONICAL_HOST])
 
107
 
 
108
  case $host in
 
109
     dnl FreeBSD (et al.) does not complete linking for shared objects when pthreads
 
110
     dnl are requested, as different implementations are present; to avoid problems
 
111
     dnl use -Wl,-z,defs only for those platform not behaving this way.
 
112
     *-freebsd* | *-openbsd*) ;;
 
113
     *)
 
114
        dnl First of all check for the --no-undefined variant of GNU ld. This allows
 
115
        dnl for a much more readable commandline, so that people can understand what
 
116
        dnl it does without going to look for what the heck -z defs does.
 
117
        for possible_flags in "-Wl,--no-undefined" "-Wl,-z,defs"; do
 
118
          CC_CHECK_LDFLAGS([$possible_flags], [LDFLAGS_NOUNDEFINED="$possible_flags"])
 
119
          break
 
120
        done
 
121
        ;;
 
122
  esac
 
123
 
 
124
  AC_SUBST([LDFLAGS_NOUNDEFINED])
 
125
])
 
126
 
 
127
dnl Check for a -Werror flag or equivalent. -Werror is the GCC
 
128
dnl and ICC flag that tells the compiler to treat all the warnings
 
129
dnl as fatal. We usually need this option to make sure that some
 
130
dnl constructs (like attributes) are not simply ignored.
 
131
dnl
 
132
dnl Other compilers don't support -Werror per se, but they support
 
133
dnl an equivalent flag:
 
134
dnl  - Sun Studio compiler supports -errwarn=%all
 
135
AC_DEFUN([CC_CHECK_WERROR], [
 
136
  AC_CACHE_CHECK(
 
137
    [for $CC way to treat warnings as errors],
 
138
    [cc_cv_werror],
 
139
    [CC_CHECK_CFLAGS_SILENT([-Werror], [cc_cv_werror=-Werror],
 
140
      [CC_CHECK_CFLAGS_SILENT([-errwarn=%all], [cc_cv_werror=-errwarn=%all])])
 
141
    ])
 
142
])
 
143
 
 
144
AC_DEFUN([CC_CHECK_ATTRIBUTE], [
 
145
  AC_REQUIRE([CC_CHECK_WERROR])
 
146
  AC_CACHE_CHECK([if $CC supports __attribute__(( ifelse([$2], , [$1], [$2]) ))],
 
147
    AS_TR_SH([cc_cv_attribute_$1]),
 
148
    [ac_save_CFLAGS="$CFLAGS"
 
149
     CFLAGS="$CFLAGS $cc_cv_werror"
 
150
     AC_COMPILE_IFELSE([AC_LANG_SOURCE([$3])],
 
151
       [eval "AS_TR_SH([cc_cv_attribute_$1])='yes'"],
 
152
       [eval "AS_TR_SH([cc_cv_attribute_$1])='no'"])
 
153
     CFLAGS="$ac_save_CFLAGS"
 
154
    ])
 
155
 
 
156
  AS_IF([eval test x$]AS_TR_SH([cc_cv_attribute_$1])[ = xyes],
 
157
    [AC_DEFINE(
 
158
       AS_TR_CPP([SUPPORT_ATTRIBUTE_$1]), 1,
 
159
         [Define this if the compiler supports __attribute__(( ifelse([$2], , [$1], [$2]) ))]
 
160
         )
 
161
     $4],
 
162
    [$5])
 
163
])
 
164
 
 
165
AC_DEFUN([CC_ATTRIBUTE_CONSTRUCTOR], [
 
166
  CC_CHECK_ATTRIBUTE(
 
167
    [constructor],,
 
168
    [void __attribute__((constructor)) ctor() { int a; }],
 
169
    [$1], [$2])
 
170
])
 
171
 
 
172
AC_DEFUN([CC_ATTRIBUTE_FORMAT], [
 
173
  CC_CHECK_ATTRIBUTE(
 
174
    [format], [format(printf, n, n)],
 
175
    [void __attribute__((format(printf, 1, 2))) printflike(const char *fmt, ...) { fmt = (void *)0; }],
 
176
    [$1], [$2])
 
177
])
 
178
 
 
179
AC_DEFUN([CC_ATTRIBUTE_FORMAT_ARG], [
 
180
  CC_CHECK_ATTRIBUTE(
 
181
    [format_arg], [format_arg(printf)],
 
182
    [char *__attribute__((format_arg(1))) gettextlike(const char *fmt) { fmt = (void *)0; }],
 
183
    [$1], [$2])
 
184
])
 
185
 
 
186
AC_DEFUN([CC_ATTRIBUTE_VISIBILITY], [
 
187
  CC_CHECK_ATTRIBUTE(
 
188
    [visibility_$1], [visibility("$1")],
 
189
    [void __attribute__((visibility("$1"))) $1_function() { }],
 
190
    [$2], [$3])
 
191
])
 
192
 
 
193
AC_DEFUN([CC_ATTRIBUTE_NONNULL], [
 
194
  CC_CHECK_ATTRIBUTE(
 
195
    [nonnull], [nonnull()],
 
196
    [void __attribute__((nonnull())) some_function(void *foo, void *bar) { foo = (void*)0; bar = (void*)0; }],
 
197
    [$1], [$2])
 
198
])
 
199
 
 
200
AC_DEFUN([CC_ATTRIBUTE_UNUSED], [
 
201
  CC_CHECK_ATTRIBUTE(
 
202
    [unused], ,
 
203
    [void some_function(void *foo, __attribute__((unused)) void *bar);],
 
204
    [$1], [$2])
 
205
])
 
206
 
 
207
AC_DEFUN([CC_ATTRIBUTE_SENTINEL], [
 
208
  CC_CHECK_ATTRIBUTE(
 
209
    [sentinel], ,
 
210
    [void some_function(void *foo, ...) __attribute__((sentinel));],
 
211
    [$1], [$2])
 
212
])
 
213
 
 
214
AC_DEFUN([CC_ATTRIBUTE_DEPRECATED], [
 
215
  CC_CHECK_ATTRIBUTE(
 
216
    [deprecated], ,
 
217
    [void some_function(void *foo, ...) __attribute__((deprecated));],
 
218
    [$1], [$2])
 
219
])
 
220
 
 
221
AC_DEFUN([CC_ATTRIBUTE_ALIAS], [
 
222
  CC_CHECK_ATTRIBUTE(
 
223
    [alias], [weak, alias],
 
224
    [void other_function(void *foo) { }
 
225
     void some_function(void *foo) __attribute__((weak, alias("other_function")));],
 
226
    [$1], [$2])
 
227
])
 
228
 
 
229
AC_DEFUN([CC_ATTRIBUTE_MALLOC], [
 
230
  CC_CHECK_ATTRIBUTE(
 
231
    [malloc], ,
 
232
    [void * __attribute__((malloc)) my_alloc(int n);],
 
233
    [$1], [$2])
 
234
])
 
235
 
 
236
AC_DEFUN([CC_ATTRIBUTE_PACKED], [
 
237
  CC_CHECK_ATTRIBUTE(
 
238
    [packed], ,
 
239
    [struct astructure { char a; int b; long c; void *d; } __attribute__((packed));],
 
240
    [$1], [$2])
 
241
])
 
242
 
 
243
AC_DEFUN([CC_ATTRIBUTE_CONST], [
 
244
  CC_CHECK_ATTRIBUTE(
 
245
    [const], ,
 
246
    [int __attribute__((const)) twopow(int n) { return 1 << n; } ],
 
247
    [$1], [$2])
 
248
])
 
249
 
 
250
AC_DEFUN([CC_FLAG_VISIBILITY], [
 
251
  AC_REQUIRE([CC_CHECK_WERROR])
 
252
  AC_CACHE_CHECK([if $CC supports -fvisibility=hidden],
 
253
    [cc_cv_flag_visibility],
 
254
    [cc_flag_visibility_save_CFLAGS="$CFLAGS"
 
255
     CFLAGS="$CFLAGS $cc_cv_werror"
 
256
     CC_CHECK_CFLAGS_SILENT([-fvisibility=hidden],
 
257
        cc_cv_flag_visibility='yes',
 
258
        cc_cv_flag_visibility='no')
 
259
     CFLAGS="$cc_flag_visibility_save_CFLAGS"])
 
260
 
 
261
  AS_IF([test "x$cc_cv_flag_visibility" = "xyes"],
 
262
    [AC_DEFINE([SUPPORT_FLAG_VISIBILITY], 1,
 
263
       [Define this if the compiler supports the -fvisibility flag])
 
264
     $1],
 
265
    [$2])
 
266
])
 
267
 
 
268
AC_DEFUN([CC_FUNC_EXPECT], [
 
269
  AC_REQUIRE([CC_CHECK_WERROR])
 
270
  AC_CACHE_CHECK([if compiler has __builtin_expect function],
 
271
    [cc_cv_func_expect],
 
272
    [ac_save_CFLAGS="$CFLAGS"
 
273
     CFLAGS="$CFLAGS $cc_cv_werror"
 
274
     AC_COMPILE_IFELSE([AC_LANG_SOURCE(
 
275
       [int some_function() {
 
276
        int a = 3;
 
277
        return (int)__builtin_expect(a, 3);
 
278
        }])],
 
279
       [cc_cv_func_expect=yes],
 
280
       [cc_cv_func_expect=no])
 
281
     CFLAGS="$ac_save_CFLAGS"
 
282
    ])
 
283
 
 
284
  AS_IF([test "x$cc_cv_func_expect" = "xyes"],
 
285
    [AC_DEFINE([SUPPORT__BUILTIN_EXPECT], 1,
 
286
     [Define this if the compiler supports __builtin_expect() function])
 
287
     $1],
 
288
    [$2])
 
289
])
 
290
 
 
291
AC_DEFUN([CC_ATTRIBUTE_ALIGNED], [
 
292
  AC_REQUIRE([CC_CHECK_WERROR])
 
293
  AC_CACHE_CHECK([highest __attribute__ ((aligned ())) supported],
 
294
    [cc_cv_attribute_aligned],
 
295
    [ac_save_CFLAGS="$CFLAGS"
 
296
     CFLAGS="$CFLAGS $cc_cv_werror"
 
297
     for cc_attribute_align_try in 64 32 16 8 4 2; do
 
298
        AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 
299
          int main() {
 
300
            static char c __attribute__ ((aligned($cc_attribute_align_try))) = 0;
 
301
            return c;
 
302
          }])], [cc_cv_attribute_aligned=$cc_attribute_align_try; break])
 
303
     done
 
304
     CFLAGS="$ac_save_CFLAGS"
 
305
  ])
 
306
 
 
307
  if test "x$cc_cv_attribute_aligned" != "x"; then
 
308
     AC_DEFINE_UNQUOTED([ATTRIBUTE_ALIGNED_MAX], [$cc_cv_attribute_aligned],
 
309
       [Define the highest alignment supported])
 
310
  fi
 
311
])