1 files changed, 157 insertions, 246 deletions

diff --git a/m4/attributes.m4 b/m4/attributes.m4
index a74280696..3fee49ab5 100644
--- a/m4/attributes.m4
+++ b/m4/attributes.m4
@@ -32,22 +32,43 @@ 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.
 
-AC_DEFUN([CC_CHECK_CFLAGS], [
-  AC_CACHE_CHECK([if $CC supports $1 flag],
-    AS_TR_SH([cc_cv_cflags_$1]),
+AC_DEFUN([CC_CHECK_CFLAGS_SILENT], [
+  AC_CACHE_VAL(AS_TR_SH([cc_cv_cflags_$1]),
     [ac_save_CFLAGS="$CFLAGS"
      CFLAGS="$CFLAGS $1"
      AC_COMPILE_IFELSE([int a;],
        [eval "AS_TR_SH([cc_cv_cflags_$1])='yes'"],
-       [eval "AS_TR_SH([cc_cv_cflags_$1])="])
+       [eval "AS_TR_SH([cc_cv_cflags_$1])='no'"])
      CFLAGS="$ac_save_CFLAGS"
     ])
 
-  if eval test [x$]AS_TR_SH([cc_cv_cflags_$1]) = xyes; then
-    ifelse([$2], , [:], [$2])
-  else
-    ifelse([$3], , [:], [$3])
-  fi
+  AS_IF([test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes],
+    [$2], [$3])
+])
+
+AC_DEFUN([CC_CHECK_CFLAGS], [
+  AC_CACHE_CHECK([if $CC supports $1 flag],
+    AS_TR_SH([cc_cv_cflags_$1]),
+    CC_CHECK_CFLAGS_SILENT([$1]) dnl Don't execute actions here!
+  )
+
+  AS_IF([test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes],
+    [$2], [$3])
+])
+
+AC_DEFUN([CC_CHECK_LDFLAGS], [
+  AC_CACHE_CHECK([if $CC supports $1 flag],
+    AS_TR_SH([cc_cv_ldflags_$1]),
+    [ac_save_LDFLAGS="$LDFLAGS"
+     LDFLAGS="$LDFLAGS $1"
+     AC_LINK_IFELSE([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([test x$]AS_TR_SH([cc_cv_ldflags_$1])[ = xyes],
+    [$2], [$3])
 ])
 
 dnl Check for a -Werror flag or equivalent. -Werror is the GCC
@@ -59,246 +80,159 @@ 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_VAL([cc_cv_werror],
-    [CC_CHECK_CFLAGS([-Werror], [cc_cv_werror=-Werror],
-      [CC_CHECK_CFLAGS([-errwarn=%all], [cc_cv_werror=-errwarn=%all])])
+  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([$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([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], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports __attribute__((constructor))],
-		[cc_cv_attribute_constructor],
-		[AC_COMPILE_IFELSE([
-			void ctor() __attribute__((constructor));
-			void ctor() { int a; };
-			],
-			[cc_cv_attribute_constructor=yes],
-			[cc_cv_attribute_constructor=no])
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_attribute_constructor" = "xyes"; then
-		AC_DEFINE([SUPPORT_ATTRIBUTE_CONSTRUCTOR], 1, [Define this if the compiler supports the constructor attribute])
-		$1
-	else
-		true
-		$2
-	fi
+  CC_CHECK_ATTRIBUTE(
+    [constructor],,
+    [void __attribute__((constructor)) ctor() { int a; }],
+    [$1], [$2])
 ])
 
 AC_DEFUN([CC_ATTRIBUTE_FORMAT], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports __attribute__((format(printf, n, n)))],
-		[cc_cv_attribute_format],
-		[AC_COMPILE_IFELSE([
-			void __attribute__((format(printf, 1, 2))) printflike(const char *fmt, ...) { fmt = (void *)0; }
-			],
-			[cc_cv_attribute_format=yes],
-			[cc_cv_attribute_format=no])
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_attribute_format" = "xyes"; then
-		AC_DEFINE([SUPPORT_ATTRIBUTE_FORMAT], 1, [Define this if the compiler supports the format attribute])
-		$1
-	else
-		true
-		$2
-	fi
+  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], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports __attribute__((format_arg(printf)))],
-		[cc_cv_attribute_format_arg],
-		[AC_COMPILE_IFELSE([
-			char *__attribute__((format_arg(1))) gettextlike(const char *fmt) { fmt = (void *)0; }
-			],
-			[cc_cv_attribute_format_arg=yes],
-			[cc_cv_attribute_format_arg=no])
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_attribute_format_arg" = "xyes"; then
-		AC_DEFINE([SUPPORT_ATTRIBUTE_FORMAT_ARG], 1, [Define this if the compiler supports the format_arg attribute])
-		$1
-	else
-		true
-		$2
-	fi
+  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], [
-  AC_REQUIRE([CC_CHECK_WERROR])
-  AC_CACHE_CHECK([if $CC supports __attribute__((visibility("$1")))],
-    AS_TR_SH([cc_cv_attribute_visibility_$1]),
-    [ac_save_CFLAGS="$CFLAGS"
-     CFLAGS="$CFLAGS $cc_cv_werror"
-     AC_COMPILE_IFELSE([void __attribute__((visibility("$1"))) $1_function() { }],
-       [eval "AS_TR_SH([cc_cv_attribute_visibility_$1])='yes'"],
-       [eval "AS_TR_SH([cc_cv_attribute_visibility_$1])='no'"])
-     CFLAGS="$ac_save_CFLAGS"
-    ])
-
-  if eval test [x$]AS_TR_SH([cc_cv_attribute_visibility_$1]) = xyes; then
-    AC_DEFINE(AS_TR_CPP([SUPPORT_ATTRIBUTE_VISIBILITY_$1]), 1, [Define this if the compiler supports __attribute__((visibility("$1")))])
-    ifelse([$2], , [:], [$2])
-  else
-    ifelse([$3], , [:], [$3])
-  fi
-])
-
-AC_DEFUN([CC_FLAG_VISIBILITY], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports -fvisibility=hidden],
-		[cc_cv_flag_visibility],
-		[
-		save_CFLAGS=$CFLAGS
-		CFLAGS="$CFLAGS -fvisibility=hidden"
-		AC_COMPILE_IFELSE([int a;],
-			[cc_cv_flag_visibility=yes],
-			[cc_cv_flag_visibility=no])
-		CFLAGS="$save_CFLAGS"
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_flag_visibility" = "xyes"; then
-		AC_DEFINE([SUPPORT_FLAG_VISIBILITY], 1, [Define this if the compiler supports the -fvisibility flag])
-		$1
-	else
-		true
-		$2
-	fi
+  CC_CHECK_ATTRIBUTE(
+    [visibility_$1], [visibility("$1")],
+    [void __attribute__((visibility("$1"))) $1_function() { }],
+    [$2], [$3])
 ])
 
 AC_DEFUN([CC_ATTRIBUTE_NONNULL], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports __attribute__((nonnull()))],
-		[cc_cv_attribute_nonnull],
-		[AC_COMPILE_IFELSE([
-			void some_function(void *foo, void *bar) __attribute__((nonnull()));
-			void some_function(void *foo, void *bar) { foo = (void *)0; bar = (void *)0; }
-			],
-			[cc_cv_attribute_nonnull=yes],
-			[cc_cv_attribute_nonnull=no])
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_attribute_nonnull" = "xyes"; then
-		AC_DEFINE([SUPPORT_ATTRIBUTE_NONNULL], 1, [Define this if the compiler supports the nonnull attribute])
-		$1
-	else
-		true
-		$2
-	fi
+  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], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports __attribute__((unused))],
-		[cc_cv_attribute_unused],
-		[AC_COMPILE_IFELSE([
-			void some_function(void *foo, __attribute__((unused)) void *bar);
-			],
-			[cc_cv_attribute_unused=yes],
-			[cc_cv_attribute_unused=no])
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_attribute_unused" = "xyes"; then
-		AC_DEFINE([SUPPORT_ATTRIBUTE_UNUSED], 1, [Define this if the compiler supports the unused attribute])
-		$1
-	else
-		true
-		$2
-	fi
+  CC_CHECK_ATTRIBUTE(
+    [unused], ,
+    [void some_function(void *foo, __attribute__((unused)) void *bar);],
+    [$1], [$2])
 ])
 
-AC_DEFUN([CC_FUNC_EXPECT], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler has __builtin_expect function],
-		[cc_cv_func_expect],
-		[AC_COMPILE_IFELSE([
-			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"
-	
-	if test "x$cc_cv_func_expect" = "xyes"; then
-		AC_DEFINE([SUPPORT__BUILTIN_EXPECT], 1, [Define this if the compiler supports __builtin_expect() function])
-		$1
-	else
-		true
-		$2
-	fi
+AC_DEFUN([CC_ATTRIBUTE_SENTINEL], [
+  CC_CHECK_ATTRIBUTE(
+    [sentinel], ,
+    [void some_function(void *foo, ...) __attribute__((sentinel));],
+    [$1], [$2])
 ])
 
-AC_DEFUN([CC_ATTRIBUTE_SENTINEL], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports __attribute__((sentinel))],
-		[cc_cv_attribute_sentinel],
-		[AC_COMPILE_IFELSE([
-			void some_function(void *foo, ...) __attribute__((sentinel));
-			],
-			[cc_cv_attribute_sentinel=yes],
-			[cc_cv_attribute_sentinel=no])
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_attribute_sentinel" = "xyes"; then
-		AC_DEFINE([SUPPORT_ATTRIBUTE_SENTINEL], 1, [Define this if the compiler supports the sentinel attribute])
-		$1
-	else
-		true
-		$2
-	fi
+AC_DEFUN([CC_ATTRIBUTE_DEPRECATED], [
+  CC_CHECK_ATTRIBUTE(
+    [deprecated], ,
+    [void some_function(void *foo, ...) __attribute__((deprecated));],
+    [$1], [$2])
 ])
 
 AC_DEFUN([CC_ATTRIBUTE_ALIAS], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports __attribute__((weak, alias))],
-		[cc_cv_attribute_alias],
-		[AC_COMPILE_IFELSE([
-			void other_function(void *foo) { }
-			void some_function(void *foo) __attribute__((weak, alias("other_function")));
-			],
-			[cc_cv_attribute_alias=yes],
-			[cc_cv_attribute_alias=no])
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_attribute_alias" = "xyes"; then
-		AC_DEFINE([SUPPORT_ATTRIBUTE_ALIAS], 1, [Define this if the compiler supports the alias attribute])
-		$1
-	else
-		true
-		$2
-	fi
+  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(
+       [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], [
@@ -322,26 +256,3 @@ AC_DEFUN([CC_ATTRIBUTE_ALIGNED], [
        [Define the highest alignment supported])
   fi
 ])
-
-AC_DEFUN([CC_ATTRIBUTE_DEPRECATED], [
-	AC_REQUIRE([CC_CHECK_WERROR])
-	ac_save_CFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS $cc_cv_werror"
-	AC_CACHE_CHECK([if compiler supports __attribute__((deprecated))],
-		[cc_cv_attribute_alias],
-		[AC_COMPILE_IFELSE([
-			void some_function(void) __attribute__((deprecated));
-			],
-			[cc_cv_attribute_deprecated=yes],
-			[cc_cv_attribute_deprecated=no])
-		])
-	CFLAGS="$ac_save_CFLAGS"
-	
-	if test "x$cc_cv_attribute_deprecated" = "xyes"; then
-		AC_DEFINE([SUPPORT_ATTRIBUTE_DEPRECATED], 1, [Define this if the compiler supports the deprecated attribute])
-		$1
-	else
-		true
-		$2
-	fi
-])