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