[thirdparty/kmod.git] / m4 / attributes.m4

dnl Macros to check the presence of generic (non-typed) symbols.
dnl Copyright (c) 2006-2008 Diego Pettenò <flameeyes@gmail.com>
dnl Copyright (c) 2006-2008 xine project
dnl Copyright (c) 2012 Lucas De Marchi <lucas.de.marchi@gmail.com>
dnl
dnl This program is free software; you can redistribute it and/or modify
dnl it under the terms of the GNU General Public License as published by
dnl the Free Software Foundation; either version 2, or (at your option)
dnl any later version.
dnl
dnl This program is distributed in the hope that it will be useful,
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
dnl GNU General Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License
dnl along with this program; if not, write to the Free Software
dnl Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
dnl 02110-1301, USA.
dnl
dnl As a special exception, the copyright owners of the
dnl macro gives unlimited permission to copy, distribute and modify the
dnl configure scripts that are the output of Autoconf when processing the
dnl Macro. You need not follow the terms of the GNU General Public
dnl License when using or distributing such scripts, even though portions
dnl of the text of the Macro appear in them. The GNU General Public
dnl License (GPL) does govern all other use of the material that
dnl constitutes the Autoconf Macro.
dnl
dnl This special exception to the GPL applies to versions of the
dnl Autoconf Macro released by this project. When you make and
dnl distribute a modified version of the Autoconf Macro, you may extend
dnl this special exception to the GPL to apply to your modified version as
dnl well.

dnl Check if flag in a envvar is supported by compiler and append
dnl "backup" variable
dnl CC_CHECK_FLAG_APPEND([WHERE-TO-APPEND], [ENV-VAR], [FLAG])
AC_DEFUN([CC_CHECK_FLAG_APPEND], [
  AC_CACHE_CHECK([if $CC supports flag $3 in envvar $2],
                 AS_TR_SH([cc_cv_$2_$3]),
		 [eval "AS_TR_SH([cc_save_$2])='${$2}'"
		  eval "AS_TR_SH([$2])='-Werror $3'"
		  AC_COMPILE_IFELSE([AC_LANG_SOURCE([int a = 0; int main(void) { return a; } ])],
                                    [eval "AS_TR_SH([cc_cv_$2_$3])='yes'"],
                                    [eval "AS_TR_SH([cc_cv_$2_$3])='no'"])
		  eval "AS_TR_SH([$2])='$cc_save_$2'"])

  AS_IF([eval test x$]AS_TR_SH([cc_cv_$2_$3])[ = xyes],
        [eval "$1='${$1} $3'"])
])

dnl CC_CHECK_FLAGS_APPEND([WHERE-TO-APPEND], [ENV-VAR], [FLAG1 FLAG2])
AC_DEFUN([CC_CHECK_FLAGS_APPEND], [
  for flag in $3; do
    CC_CHECK_FLAG_APPEND($1, $2, $flag)
  done
])


dnl Check if the flag is supported by linker
dnl CC_CHECK_LDFLAGS_SILENT([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
AC_DEFUN([CC_CHECK_LDFLAGS_SILENT], [
  AC_CACHE_VAL(AS_TR_SH([cc_cv_ldflags_$1]),
    [ac_save_LDFLAGS="$LDFLAGS"
     LDFLAGS="$LDFLAGS $1"
     AC_LINK_IFELSE([AC_LANG_SOURCE([int main() { return 1; }])],
       [eval "AS_TR_SH([cc_cv_ldflags_$1])='yes'"],
       [eval "AS_TR_SH([cc_cv_ldflags_$1])="])
     LDFLAGS="$ac_save_LDFLAGS"
    ])

  AS_IF([eval test x$]AS_TR_SH([cc_cv_ldflags_$1])[ = xyes],
    [$2], [$3])
])

dnl Check if the flag is supported by linker (cacheable)
dnl CC_CHECK_LDFLAGS([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])

AC_DEFUN([CC_CHECK_LDFLAGS], [
  AC_CACHE_CHECK([if $CC supports $1 flag],
    AS_TR_SH([cc_cv_ldflags_$1]),
    CC_CHECK_LDFLAGS_SILENT([$1]) dnl Don't execute actions here!
  )

  AS_IF([eval test x$]AS_TR_SH([cc_cv_ldflags_$1])[ = xyes],
    [$2], [$3])
])

dnl define the LDFLAGS_NOUNDEFINED variable with the correct value for
dnl the current linker to avoid undefined references in a shared object.
AC_DEFUN([CC_NOUNDEFINED], [
  dnl We check $host for which systems to enable this for.
  AC_REQUIRE([AC_CANONICAL_HOST])

  case $host in
     dnl FreeBSD (et al.) does not complete linking for shared objects when pthreads
     dnl are requested, as different implementations are present; to avoid problems
     dnl use -Wl,-z,defs only for those platform not behaving this way.
     *-freebsd* | *-openbsd*) ;;
     *)
        dnl First of all check for the --no-undefined variant of GNU ld. This allows
        dnl for a much more readable commandline, so that people can understand what
        dnl it does without going to look for what the heck -z defs does.
        for possible_flags in "-Wl,--no-undefined" "-Wl,-z,defs"; do
          CC_CHECK_LDFLAGS([$possible_flags], [LDFLAGS_NOUNDEFINED="$possible_flags"])
	  break
        done
	;;
  esac

  AC_SUBST([LDFLAGS_NOUNDEFINED])
])

dnl Check for a -Werror flag or equivalent. -Werror is the GCC
dnl and ICC flag that tells the compiler to treat all the warnings
dnl as fatal. We usually need this option to make sure that some
dnl constructs (like attributes) are not simply ignored.
dnl
dnl Other compilers don't support -Werror per se, but they support
dnl an equivalent flag:
dnl  - Sun Studio compiler supports -errwarn=%all
AC_DEFUN([CC_CHECK_WERROR], [
  AC_CACHE_CHECK(
    [for $CC way to treat warnings as errors],
    [cc_cv_werror],
    [CC_CHECK_CFLAGS_SILENT([-Werror], [cc_cv_werror=-Werror],
      [CC_CHECK_CFLAGS_SILENT([-errwarn=%all], [cc_cv_werror=-errwarn=%all])])
    ])
])

AC_DEFUN([CC_CHECK_ATTRIBUTE], [
  AC_REQUIRE([CC_CHECK_WERROR])
  AC_CACHE_CHECK([if $CC supports __attribute__(( ifelse([$2], , [$1], [$2]) ))],
    AS_TR_SH([cc_cv_attribute_$1]),
    [ac_save_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS $cc_cv_werror"
     AC_COMPILE_IFELSE([AC_LANG_SOURCE([$3])],
       [eval "AS_TR_SH([cc_cv_attribute_$1])='yes'"],
       [eval "AS_TR_SH([cc_cv_attribute_$1])='no'"])
     CFLAGS="$ac_save_CFLAGS"
    ])

  AS_IF([eval test x$]AS_TR_SH([cc_cv_attribute_$1])[ = xyes],
    [AC_DEFINE(
       AS_TR_CPP([SUPPORT_ATTRIBUTE_$1]), 1,
         [Define this if the compiler supports __attribute__(( ifelse([$2], , [$1], [$2]) ))]
         )
     $4],
    [$5])
])

AC_DEFUN([CC_ATTRIBUTE_CONSTRUCTOR], [
  CC_CHECK_ATTRIBUTE(
    [constructor],,
    [void __attribute__((constructor)) ctor() { int a; }],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_FORMAT], [
  CC_CHECK_ATTRIBUTE(
    [format], [format(printf, n, n)],
    [void __attribute__((format(printf, 1, 2))) printflike(const char *fmt, ...) { fmt = (void *)0; }],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_FORMAT_ARG], [
  CC_CHECK_ATTRIBUTE(
    [format_arg], [format_arg(printf)],
    [char *__attribute__((format_arg(1))) gettextlike(const char *fmt) { fmt = (void *)0; }],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_VISIBILITY], [
  CC_CHECK_ATTRIBUTE(
    [visibility_$1], [visibility("$1")],
    [void __attribute__((visibility("$1"))) $1_function() { }],
    [$2], [$3])
])

AC_DEFUN([CC_ATTRIBUTE_NONNULL], [
  CC_CHECK_ATTRIBUTE(
    [nonnull], [nonnull()],
    [void __attribute__((nonnull())) some_function(void *foo, void *bar) { foo = (void*)0; bar = (void*)0; }],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_UNUSED], [
  CC_CHECK_ATTRIBUTE(
    [unused], ,
    [void some_function(void *foo, __attribute__((unused)) void *bar);],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_SENTINEL], [
  CC_CHECK_ATTRIBUTE(
    [sentinel], ,
    [void some_function(void *foo, ...) __attribute__((sentinel));],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_DEPRECATED], [
  CC_CHECK_ATTRIBUTE(
    [deprecated], ,
    [void some_function(void *foo, ...) __attribute__((deprecated));],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_ALIAS], [
  CC_CHECK_ATTRIBUTE(
    [alias], [weak, alias],
    [void other_function(void *foo) { }
     void some_function(void *foo) __attribute__((weak, alias("other_function")));],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_MALLOC], [
  CC_CHECK_ATTRIBUTE(
    [malloc], ,
    [void * __attribute__((malloc)) my_alloc(int n);],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_PACKED], [
  CC_CHECK_ATTRIBUTE(
    [packed], ,
    [struct astructure { char a; int b; long c; void *d; } __attribute__((packed));],
    [$1], [$2])
])

AC_DEFUN([CC_ATTRIBUTE_CONST], [
  CC_CHECK_ATTRIBUTE(
    [const], ,
    [int __attribute__((const)) twopow(int n) { return 1 << n; } ],
    [$1], [$2])
])

AC_DEFUN([CC_FLAG_VISIBILITY], [
  AC_REQUIRE([CC_CHECK_WERROR])
  AC_CACHE_CHECK([if $CC supports -fvisibility=hidden],
    [cc_cv_flag_visibility],
    [cc_flag_visibility_save_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS $cc_cv_werror"
     CC_CHECK_CFLAGS_SILENT([-fvisibility=hidden],
	cc_cv_flag_visibility='yes',
	cc_cv_flag_visibility='no')
     CFLAGS="$cc_flag_visibility_save_CFLAGS"])

  AS_IF([test "x$cc_cv_flag_visibility" = "xyes"],
    [AC_DEFINE([SUPPORT_FLAG_VISIBILITY], 1,
       [Define this if the compiler supports the -fvisibility flag])
     $1],
    [$2])
])

AC_DEFUN([CC_FUNC_EXPECT], [
  AC_REQUIRE([CC_CHECK_WERROR])
  AC_CACHE_CHECK([if compiler has __builtin_expect function],
    [cc_cv_func_expect],
    [ac_save_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS $cc_cv_werror"
     AC_COMPILE_IFELSE([AC_LANG_SOURCE(
       [int some_function() {
        int a = 3;
        return (int)__builtin_expect(a, 3);
	}])],
       [cc_cv_func_expect=yes],
       [cc_cv_func_expect=no])
     CFLAGS="$ac_save_CFLAGS"
    ])

  AS_IF([test "x$cc_cv_func_expect" = "xyes"],
    [AC_DEFINE([SUPPORT__BUILTIN_EXPECT], 1,
     [Define this if the compiler supports __builtin_expect() function])
     $1],
    [$2])
])

AC_DEFUN([CC_ATTRIBUTE_ALIGNED], [
  AC_REQUIRE([CC_CHECK_WERROR])
  AC_CACHE_CHECK([highest __attribute__ ((aligned ())) supported],
    [cc_cv_attribute_aligned],
    [ac_save_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS $cc_cv_werror"
     for cc_attribute_align_try in 64 32 16 8 4 2; do
        AC_COMPILE_IFELSE([AC_LANG_SOURCE([
          int main() {
            static char c __attribute__ ((aligned($cc_attribute_align_try))) = 0;
            return c;
          }])], [cc_cv_attribute_aligned=$cc_attribute_align_try; break])
     done
     CFLAGS="$ac_save_CFLAGS"
  ])

  if test "x$cc_cv_attribute_aligned" != "x"; then
     AC_DEFINE_UNQUOTED([ATTRIBUTE_ALIGNED_MAX], [$cc_cv_attribute_aligned],
       [Define the highest alignment supported])
  fi
])
Commit	Line	Data
822ce234 GSB	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
e48f3765	4	dnl Copyright (c) 2012 Lucas De Marchi <lucas.de.marchi@gmail.com>
822ce234 GSB	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
e48f3765 LDM	36	dnl Check if flag in a envvar is supported by compiler and append
	37	dnl "backup" variable
	38	dnl CC_CHECK_FLAG_APPEND([WHERE-TO-APPEND], [ENV-VAR], [FLAG])
	39	AC_DEFUN([CC_CHECK_FLAG_APPEND], [
	40	AC_CACHE_CHECK([if $CC supports flag $3 in envvar $2],
	41	AS_TR_SH([cc_cv_$2_$3]),
	42	[eval "AS_TR_SH([cc_save_$2])='${$2}'"
7812d88c	43	eval "AS_TR_SH([$2])='-Werror $3'"
e48f3765 LDM	44	AC_COMPILE_IFELSE([AC_LANG_SOURCE([int a = 0; int main(void) { return a; } ])],
	45	[eval "AS_TR_SH([cc_cv_$2_$3])='yes'"],
	46	[eval "AS_TR_SH([cc_cv_$2_$3])='no'"])
	47	eval "AS_TR_SH([$2])='$cc_save_$2'"])
	48
	49	AS_IF([eval test x$]AS_TR_SH([cc_cv_$2_$3])[ = xyes],
	50	[eval "$1='${$1} $3'"])
822ce234 GSB	51	])
822ce234 GSB	52
e48f3765 LDM	53	dnl CC_CHECK_FLAGS_APPEND([WHERE-TO-APPEND], [ENV-VAR], [FLAG1 FLAG2])
	54	AC_DEFUN([CC_CHECK_FLAGS_APPEND], [
	55	for flag in $3; do
	56	CC_CHECK_FLAG_APPEND($1, $2, $flag)
	57	done
822ce234 GSB	58	])
822ce234 GSB	59
822ce234	60
822ce234	61
00ff5766 RW	62	dnl Check if the flag is supported by linker
00ff5766 RW	63	dnl CC_CHECK_LDFLAGS_SILENT([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
00ff5766 RW	64	AC_DEFUN([CC_CHECK_LDFLAGS_SILENT], [
00ff5766 RW	65	AC_CACHE_VAL(AS_TR_SH([cc_cv_ldflags_$1]),
822ce234 GSB	66	[ac_save_LDFLAGS="$LDFLAGS"
822ce234 GSB	67	LDFLAGS="$LDFLAGS $1"
00ff5766	68	AC_LINK_IFELSE([AC_LANG_SOURCE([int main() { return 1; }])],
822ce234 GSB	69	[eval "AS_TR_SH([cc_cv_ldflags_$1])='yes'"],
	70	[eval "AS_TR_SH([cc_cv_ldflags_$1])="])
	71	LDFLAGS="$ac_save_LDFLAGS"
	72	])
	73
	74	AS_IF([eval test x$]AS_TR_SH([cc_cv_ldflags_$1])[ = xyes],
	75	[$2], [$3])
	76	])
	77
00ff5766 RW	78	dnl Check if the flag is supported by linker (cacheable)
	79	dnl CC_CHECK_LDFLAGS([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
	80
	81	AC_DEFUN([CC_CHECK_LDFLAGS], [
	82	AC_CACHE_CHECK([if $CC supports $1 flag],
	83	AS_TR_SH([cc_cv_ldflags_$1]),
	84	CC_CHECK_LDFLAGS_SILENT([$1]) dnl Don't execute actions here!
	85	)
	86
	87	AS_IF([eval test x$]AS_TR_SH([cc_cv_ldflags_$1])[ = xyes],
	88	[$2], [$3])
	89	])
	90
822ce234 GSB	91	dnl define the LDFLAGS_NOUNDEFINED variable with the correct value for
	92	dnl the current linker to avoid undefined references in a shared object.
	93	AC_DEFUN([CC_NOUNDEFINED], [
	94	dnl We check $host for which systems to enable this for.
	95	AC_REQUIRE([AC_CANONICAL_HOST])
	96
	97	case $host in
	98	dnl FreeBSD (et al.) does not complete linking for shared objects when pthreads
	99	dnl are requested, as different implementations are present; to avoid problems
	100	dnl use -Wl,-z,defs only for those platform not behaving this way.
	101	-freebsd \| -openbsd) ;;
	102	*)
	103	dnl First of all check for the --no-undefined variant of GNU ld. This allows
	104	dnl for a much more readable commandline, so that people can understand what
	105	dnl it does without going to look for what the heck -z defs does.
	106	for possible_flags in "-Wl,--no-undefined" "-Wl,-z,defs"; do
	107	CC_CHECK_LDFLAGS([$possible_flags], [LDFLAGS_NOUNDEFINED="$possible_flags"])
	108	break
	109	done
	110	;;
	111	esac
	112
	113	AC_SUBST([LDFLAGS_NOUNDEFINED])
	114	])
	115
	116	dnl Check for a -Werror flag or equivalent. -Werror is the GCC
	117	dnl and ICC flag that tells the compiler to treat all the warnings
	118	dnl as fatal. We usually need this option to make sure that some
	119	dnl constructs (like attributes) are not simply ignored.
	120	dnl
	121	dnl Other compilers don't support -Werror per se, but they support
	122	dnl an equivalent flag:
	123	dnl - Sun Studio compiler supports -errwarn=%all
	124	AC_DEFUN([CC_CHECK_WERROR], [
	125	AC_CACHE_CHECK(
	126	[for $CC way to treat warnings as errors],
	127	[cc_cv_werror],
	128	[CC_CHECK_CFLAGS_SILENT([-Werror], [cc_cv_werror=-Werror],
	129	[CC_CHECK_CFLAGS_SILENT([-errwarn=%all], [cc_cv_werror=-errwarn=%all])])
	130	])
	131	])
	132
	133	AC_DEFUN([CC_CHECK_ATTRIBUTE], [
	134	AC_REQUIRE([CC_CHECK_WERROR])
	135	AC_CACHE_CHECK([if $CC supports __attribute__(( ifelse([$2], , [$1], [$2]) ))],
	136	AS_TR_SH([cc_cv_attribute_$1]),
	137	[ac_save_CFLAGS="$CFLAGS"
	138	CFLAGS="$CFLAGS $cc_cv_werror"
	139	AC_COMPILE_IFELSE([AC_LANG_SOURCE([$3])],
	140	[eval "AS_TR_SH([cc_cv_attribute_$1])='yes'"],
	141	[eval "AS_TR_SH([cc_cv_attribute_$1])='no'"])
	142	CFLAGS="$ac_save_CFLAGS"
	143	])
	144
	145	AS_IF([eval test x$]AS_TR_SH([cc_cv_attribute_$1])[ = xyes],
	146	[AC_DEFINE(
	147	AS_TR_CPP([SUPPORT_ATTRIBUTE_$1]), 1,
	148	[Define this if the compiler supports __attribute__(( ifelse([$2], , [$1], [$2]) ))]
	149	)
	150	$4],
	151	[$5])
	152	])
	153
	154	AC_DEFUN([CC_ATTRIBUTE_CONSTRUCTOR], [
155	CC_CHECK_ATTRIBUTE(
156	[constructor],,
157	[void __attribute__((constructor)) ctor() { int a; }],
158	[$1], [$2])
159	])
160
161	AC_DEFUN([CC_ATTRIBUTE_FORMAT], [
162	CC_CHECK_ATTRIBUTE(
163	[format], [format(printf, n, n)],
164	[void __attribute__((format(printf, 1, 2))) printflike(const char fmt, ...) { fmt = (void )0; }],
165	[$1], [$2])
166	])
167
168	AC_DEFUN([CC_ATTRIBUTE_FORMAT_ARG], [
169	CC_CHECK_ATTRIBUTE(
170	[format_arg], [format_arg(printf)],
171	[char __attribute__((format_arg(1))) gettextlike(const char fmt) { fmt = (void *)0; }],
172	[$1], [$2])
173	])
174
175	AC_DEFUN([CC_ATTRIBUTE_VISIBILITY], [
176	CC_CHECK_ATTRIBUTE(
177	[visibility_$1], [visibility("$1")],
178	[void __attribute__((visibility("$1"))) $1_function() { }],
179	[$2], [$3])
180	])
181
182	AC_DEFUN([CC_ATTRIBUTE_NONNULL], [
183	CC_CHECK_ATTRIBUTE(
184	[nonnull], [nonnull()],
185	[void __attribute__((nonnull())) some_function(void foo, void bar) { foo = (void)0; bar = (void)0; }],
186	[$1], [$2])
187	])
188
189	AC_DEFUN([CC_ATTRIBUTE_UNUSED], [
190	CC_CHECK_ATTRIBUTE(
191	[unused], ,
192	[void some_function(void foo, __attribute__((unused)) void bar);],
193	[$1], [$2])
194	])
195
196	AC_DEFUN([CC_ATTRIBUTE_SENTINEL], [
197	CC_CHECK_ATTRIBUTE(
198	[sentinel], ,
199	[void some_function(void *foo, ...) __attribute__((sentinel));],
200	[$1], [$2])
201	])
202
203	AC_DEFUN([CC_ATTRIBUTE_DEPRECATED], [
204	CC_CHECK_ATTRIBUTE(
205	[deprecated], ,
206	[void some_function(void *foo, ...) __attribute__((deprecated));],
207	[$1], [$2])
208	])
209
210	AC_DEFUN([CC_ATTRIBUTE_ALIAS], [
211	CC_CHECK_ATTRIBUTE(
212	[alias], [weak, alias],
213	[void other_function(void *foo) { }
214	void some_function(void *foo) __attribute__((weak, alias("other_function")));],
215	[$1], [$2])
216	])
217
218	AC_DEFUN([CC_ATTRIBUTE_MALLOC], [
219	CC_CHECK_ATTRIBUTE(
220	[malloc], ,
221	[void * __attribute__((malloc)) my_alloc(int n);],
222	[$1], [$2])
223	])
224
225	AC_DEFUN([CC_ATTRIBUTE_PACKED], [
226	CC_CHECK_ATTRIBUTE(
227	[packed], ,
228	[struct astructure { char a; int b; long c; void *d; } __attribute__((packed));],
229	[$1], [$2])
230	])
231
232	AC_DEFUN([CC_ATTRIBUTE_CONST], [
233	CC_CHECK_ATTRIBUTE(
234	[const], ,
235	[int __attribute__((const)) twopow(int n) { return 1 << n; } ],
236	[$1], [$2])
237	])
238
239	AC_DEFUN([CC_FLAG_VISIBILITY], [
240	AC_REQUIRE([CC_CHECK_WERROR])
241	AC_CACHE_CHECK([if $CC supports -fvisibility=hidden],
242	[cc_cv_flag_visibility],
243	[cc_flag_visibility_save_CFLAGS="$CFLAGS"
244	CFLAGS="$CFLAGS $cc_cv_werror"
245	CC_CHECK_CFLAGS_SILENT([-fvisibility=hidden],
246	cc_cv_flag_visibility='yes',
247	cc_cv_flag_visibility='no')
248	CFLAGS="$cc_flag_visibility_save_CFLAGS"])
249
250	AS_IF([test "x$cc_cv_flag_visibility" = "xyes"],
251	[AC_DEFINE([SUPPORT_FLAG_VISIBILITY], 1,
252	[Define this if the compiler supports the -fvisibility flag])
253	$1],
254	[$2])
255	])
256
257	AC_DEFUN([CC_FUNC_EXPECT], [
258	AC_REQUIRE([CC_CHECK_WERROR])
259	AC_CACHE_CHECK([if compiler has __builtin_expect function],
260	[cc_cv_func_expect],
261	[ac_save_CFLAGS="$CFLAGS"
262	CFLAGS="$CFLAGS $cc_cv_werror"
263	AC_COMPILE_IFELSE([AC_LANG_SOURCE(
264	[int some_function() {
265	int a = 3;
266	return (int)__builtin_expect(a, 3);
267	}])],
268	[cc_cv_func_expect=yes],
269	[cc_cv_func_expect=no])
270	CFLAGS="$ac_save_CFLAGS"
271	])
272
273	AS_IF([test "x$cc_cv_func_expect" = "xyes"],
274	[AC_DEFINE([SUPPORT__BUILTIN_EXPECT], 1,
275	[Define this if the compiler supports __builtin_expect() function])
276	$1],
277	[$2])
278	])
279
280	AC_DEFUN([CC_ATTRIBUTE_ALIGNED], [
281	AC_REQUIRE([CC_CHECK_WERROR])
282	AC_CACHE_CHECK([highest __attribute__ ((aligned ())) supported],
283	[cc_cv_attribute_aligned],
284	[ac_save_CFLAGS="$CFLAGS"
285	CFLAGS="$CFLAGS $cc_cv_werror"
286	for cc_attribute_align_try in 64 32 16 8 4 2; do
287	AC_COMPILE_IFELSE([AC_LANG_SOURCE([
288	int main() {
289	static char c __attribute__ ((aligned($cc_attribute_align_try))) = 0;
290	return c;
291	}])], [cc_cv_attribute_aligned=$cc_attribute_align_try; break])
292	done
293	CFLAGS="$ac_save_CFLAGS"
294	])
295
296	if test "x$cc_cv_attribute_aligned" != "x"; then
297	AC_DEFINE_UNQUOTED([ATTRIBUTE_ALIGNED_MAX], [$cc_cv_attribute_aligned],
298	[Define the highest alignment supported])
299	fi
300	])