# AC_CHECK_FASTCALL([if-ok],[if-notok])

 # Test if the compiler recognizes __attribute__((regparm(3))) - we don't 

 # currently check if it actually works correctly, but probably should...

 # -----------------------

 AC_DEFUN([AC_CHECK_FASTCALL], [

 AC_MSG_CHECKING([support for fastcall calling conventions]);

 save_CFLAGS="$CFLAGS"

 CFLAGS="-Werror $save_CFLAGS"

 AC_RUN_IFELSE([

   AC_LANG_SOURCE([[

 int __attribute__((regparm(3))) foo(int a, int b) { return a+b; }

 int main(int argc, char *argv[])

 {

    return foo( 1, 2 ) == 3 ? 0 : 1;

 }]])], [ 

    AC_MSG_RESULT([yes])

    $1 ], [ 

    AC_MSG_RESULT([no])

    $2 ], [

       AC_MSG_RESULT([no])

    $2 ])

 CFLAGS="$save_CFLAGS"

 ])

 # AC_CHECK_FORCEINLINE([if-ok],[if-notok])

 # Test if the compiler recognizes __attribute__((always_inline))

 # -----------------------

 AC_DEFUN([AC_CHECK_FORCEINLINE], [

 AC_MSG_CHECKING([support for force inlining]);

 AC_COMPILE_IFELSE([

   AC_LANG_SOURCE([[

 static int __attribute__((always_inline)) foo(int a, int b) { return a+b; }

 int main(int argc, char *argv[])

 {

    return foo( 1, 2 ) == 3 ? 0 : 1;

 }]])], [ 

    FORCEINLINE="__attribute__((always_inline))"

    AC_MSG_RESULT([$FORCEINLINE])

    $1 ], [ 

    FORCEINLINE=""

    AC_MSG_RESULT([no])

    $2 ])

 ])

 # AC_CHECK_FRAME_ADDRESS([if-ok],[if-notok])

 # Test if the compiler will let us modify the return address on the stack

 # via __builtin_frame_address()

 # -----------------------

 AC_DEFUN([AC_CHECK_FRAME_ADDRESS], [

 AC_MSG_CHECKING([if we have a working __builtin_frame_address()]);

 AC_RUN_IFELSE([

   AC_LANG_SOURCE([[

 void * __attribute__((noinline)) first_arg( void *x, void *y ) { return x; }

 int __attribute__((noinline)) foo( int arg, void *exc )

 {

     if( arg < 2 ) {

         *(((void * volatile *)__builtin_frame_address(0))+1) = exc;

     }

     return 0;

 }

 int main(int argc, char *argv[])

 {

    goto *first_arg(&&start, &&except);

 start:

    return foo( argc, &&except ) + 1;

 except:

    return 0;

 }]])], [ 

    AC_MSG_RESULT([yes])

    $1 ], [ 

    AC_MSG_RESULT([no])

    $2 ], [

    AC_MSG_RESULT([no])

    $2 ] )

 ])

 # AC_CC_VERSION([if-gcc], [if-icc],[if-other])

 # Check which C compiler we're using and branch accordingly, eg to set

 # different optimization flags. Currently recognizes gcc and icc

 # ---------------

 AC_DEFUN([AC_CC_VERSION], [

 _GCC_VERSION=`$CC --version | $SED -ne '/gcc/p'`

 _ICC_VERSION=`$CC --version | $SED -ne '/(ICC)/p'`

 AC_MSG_CHECKING([CC version])

 if test -n "$_ICC_VERSION"; then

    AC_MSG_RESULT([ICC])

    [ $2 ]

 elif test -n "$_GCC_VERSION"; then

    AC_MSG_RESULT([GCC])

    [ $1 ] 

 else 

    AC_MSG_RESULT([Unknown])

    [ $3 ]

 fi

 ]);

 # AC_OBJC_VERSION([if-gcc],[if-other], [if-none])

 # Check which objective C compiler we're using and branch accordingly.

 AC_DEFUN([AC_OBJC_VERSION], [

 AC_MSG_CHECKING([OBJC version])

 if test -n "$OBJC"; then

   _GOBJC_VERSION=`$OBJC --version | $SED -ne '/(GCC)/p'`

   if test -n "$_GOBJC_VERSION"; then

     AC_MSG_RESULT([GCC])

     [ $1 ]

   else 

     AC_MSG_RESULT([Unknown])

     [ $2 ]

   fi

 else

   AC_MSG_RESULT([None])

   [ $3 ]

 fi

 ]);

 # Check if the given C compiler flag is supported, and if so add it to CFLAGS

 AC_DEFUN([AC_CHECK_CFLAG], [

 AC_LANG_PUSH([C])

 AC_MSG_CHECKING([if $CC supports $1])

 save_CFLAGS="$CFLAGS"

 CFLAGS="$1 $CFLAGS"

 AC_COMPILE_IFELSE([

   AC_LANG_SOURCE([int main() { return 0; }])], [

    AC_MSG_RESULT([yes])

    $2 ], [ 

    CFLAGS="$save_CFLAGS"

    AC_MSG_RESULT([no])

    $3 ])

 AC_LANG_POP([C])

 ])

 # Check if the given OBJC compiler flag is supported, and if so add it to OBJCFLAGS

 AC_DEFUN([AC_CHECK_OBJCFLAG], [

 AC_LANG_PUSH([Objective C])

 AC_MSG_CHECKING([if $OBJC supports $1])

 save_OBJCFLAGS="$OBJCFLAGS"

 OBJCFLAGS="$1 $OBJCFLAGS"

 AC_COMPILE_IFELSE([

   AC_LANG_SOURCE([int main() { return 0; }])], [

    AC_MSG_RESULT([yes])

    $2 ], [ 

    OBJCFLAGS="$save_OBJCFLAGS"

    AC_MSG_RESULT([no])

    $3 ])

 AC_LANG_POP([Objective C])

 ])

 # AC_HAVE_OBJC([if-present],[if-not-present])

 # Check if we have a working Objective-C compiler

 AC_DEFUN([AC_HAVE_OBJC], [

 AC_PROG_OBJC

 AC_MSG_CHECKING([for a working Objective-C compiler])

 AC_LANG_PUSH([Objective C])dnl

 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@interface Foo @end]], [])],

    [AC_MSG_RESULT([yes])

     $1 ],

    [AC_MSG_RESULT([No])

     $2 ]);

 AC_LANG_POP([Objective C])

 ]);