m4/attributes.m4

   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([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([$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(
 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([
 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 ])