mirror of
https://github.com/php/php-src.git
synced 2025-08-21 01:45:16 +02:00
2079b09854
Some headers were checked multiple times in the main configure.ac file and in the bundled extensions or SAPIs themselves. Also many of these checks are then used accross other extensions or SAPIs so a central configure.ac makes most sense for these checks.
541 lines
14 KiB
Text
541 lines
14 KiB
Text
dnl This file contains Zend specific autoconf macros.
|
|
|
|
dnl
|
|
dnl ZEND_CHECK_FLOAT_PRECISION
|
|
dnl
|
|
dnl x87 floating point internal precision control checks
|
|
dnl See: http://wiki.php.net/rfc/rounding
|
|
dnl
|
|
AC_DEFUN([ZEND_CHECK_FLOAT_PRECISION],[
|
|
AC_MSG_CHECKING([for usable _FPU_SETCW])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <fpu_control.h>
|
|
]],[[
|
|
fpu_control_t fpu_oldcw, fpu_cw;
|
|
volatile double result;
|
|
double a = 2877.0;
|
|
volatile double b = 1000000.0;
|
|
|
|
_FPU_GETCW(fpu_oldcw);
|
|
fpu_cw = (fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_SINGLE) | _FPU_DOUBLE;
|
|
_FPU_SETCW(fpu_cw);
|
|
result = a / b;
|
|
_FPU_SETCW(fpu_oldcw);
|
|
]])],[ac_cfp_have__fpu_setcw=yes],[ac_cfp_have__fpu_setcw=no])
|
|
if test "$ac_cfp_have__fpu_setcw" = "yes" ; then
|
|
AC_DEFINE(HAVE__FPU_SETCW, 1, [whether _FPU_SETCW is present and usable])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for usable fpsetprec])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <machine/ieeefp.h>
|
|
]],[[
|
|
fp_prec_t fpu_oldprec;
|
|
volatile double result;
|
|
double a = 2877.0;
|
|
volatile double b = 1000000.0;
|
|
|
|
fpu_oldprec = fpgetprec();
|
|
fpsetprec(FP_PD);
|
|
result = a / b;
|
|
fpsetprec(fpu_oldprec);
|
|
]])], [ac_cfp_have_fpsetprec=yes], [ac_cfp_have_fpsetprec=no])
|
|
if test "$ac_cfp_have_fpsetprec" = "yes" ; then
|
|
AC_DEFINE(HAVE_FPSETPREC, 1, [whether fpsetprec is present and usable])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for usable _controlfp])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <float.h>
|
|
]],[[
|
|
unsigned int fpu_oldcw;
|
|
volatile double result;
|
|
double a = 2877.0;
|
|
volatile double b = 1000000.0;
|
|
|
|
fpu_oldcw = _controlfp(0, 0);
|
|
_controlfp(_PC_53, _MCW_PC);
|
|
result = a / b;
|
|
_controlfp(fpu_oldcw, _MCW_PC);
|
|
]])], [ac_cfp_have__controlfp=yes], [ac_cfp_have__controlfp=no])
|
|
if test "$ac_cfp_have__controlfp" = "yes" ; then
|
|
AC_DEFINE(HAVE__CONTROLFP, 1, [whether _controlfp is present usable])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for usable _controlfp_s])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <float.h>
|
|
]],[[
|
|
unsigned int fpu_oldcw, fpu_cw;
|
|
volatile double result;
|
|
double a = 2877.0;
|
|
volatile double b = 1000000.0;
|
|
|
|
_controlfp_s(&fpu_cw, 0, 0);
|
|
fpu_oldcw = fpu_cw;
|
|
_controlfp_s(&fpu_cw, _PC_53, _MCW_PC);
|
|
result = a / b;
|
|
_controlfp_s(&fpu_cw, fpu_oldcw, _MCW_PC);
|
|
]])], [ac_cfp_have__controlfp_s=yes], [ac_cfp_have__controlfp_s=no])
|
|
if test "$ac_cfp_have__controlfp_s" = "yes" ; then
|
|
AC_DEFINE(HAVE__CONTROLFP_S, 1, [whether _controlfp_s is present and usable])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
AC_MSG_CHECKING([whether FPU control word can be manipulated by inline assembler])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
/* nothing */
|
|
]],[[
|
|
unsigned int oldcw, cw;
|
|
volatile double result;
|
|
double a = 2877.0;
|
|
volatile double b = 1000000.0;
|
|
|
|
__asm__ __volatile__ ("fnstcw %0" : "=m" (*&oldcw));
|
|
cw = (oldcw & ~0x0 & ~0x300) | 0x200;
|
|
__asm__ __volatile__ ("fldcw %0" : : "m" (*&cw));
|
|
|
|
result = a / b;
|
|
|
|
__asm__ __volatile__ ("fldcw %0" : : "m" (*&oldcw));
|
|
]])], [ac_cfp_have_fpu_inline_asm_x86=yes], [ac_cfp_have_fpu_inline_asm_x86=no])
|
|
if test "$ac_cfp_have_fpu_inline_asm_x86" = "yes" ; then
|
|
AC_DEFINE(HAVE_FPU_INLINE_ASM_X86, 1, [whether FPU control word can be manipulated by inline assembler])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl LIBZEND_BASIC_CHECKS
|
|
dnl
|
|
dnl Basic checks specific for the Zend engine library.
|
|
dnl
|
|
AC_DEFUN([LIBZEND_BASIC_CHECKS],[
|
|
AC_REQUIRE([AC_PROG_CC])
|
|
|
|
AC_CHECK_HEADERS([cpuid.h])
|
|
|
|
dnl
|
|
dnl LIBZEND_DLSYM_CHECK
|
|
dnl
|
|
dnl Ugly hack to check if dlsym() requires a leading underscore in symbol name.
|
|
dnl
|
|
AC_DEFUN([LIBZEND_DLSYM_CHECK],[
|
|
AC_MSG_CHECKING([whether dlsym() requires a leading underscore in symbol names])
|
|
_LT_AC_TRY_DLOPEN_SELF([
|
|
AC_MSG_RESULT(no)
|
|
], [
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(DLSYM_NEEDS_UNDERSCORE, 1, [Define if dlsym() requires a leading underscore in symbol names. ])
|
|
], [
|
|
AC_MSG_RESULT(no)
|
|
], [])
|
|
])
|
|
|
|
dnl Checks for library functions.
|
|
AC_CHECK_FUNCS(getpid kill finite fpclass sigsetjmp)
|
|
|
|
AC_CHECK_DECLS([isfinite, isnan, isinf], [], [], [[#include <math.h>]])
|
|
|
|
ZEND_CHECK_FLOAT_PRECISION
|
|
|
|
dnl Test whether double cast to long preserves least significant bits.
|
|
AC_MSG_CHECKING(whether double cast to long preserves least significant bits)
|
|
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <limits.h>
|
|
|
|
int main()
|
|
{
|
|
if (sizeof(long) == 4) {
|
|
double d = (double) LONG_MIN * LONG_MIN + 2e9;
|
|
|
|
if ((long) d == 2e9 && (long) -d == -2e9) {
|
|
exit(0);
|
|
}
|
|
} else if (sizeof(long) == 8) {
|
|
double correct = 18e18 - ((double) LONG_MIN * -2); /* Subtract ULONG_MAX + 1 */
|
|
|
|
if ((long) 18e18 == correct) { /* On 64-bit, only check between LONG_MAX and ULONG_MAX */
|
|
exit(0);
|
|
}
|
|
}
|
|
exit(1);
|
|
}
|
|
]])], [
|
|
AC_DEFINE([ZEND_DVAL_TO_LVAL_CAST_OK], 1, [Define if double cast to long preserves least significant bits])
|
|
AC_MSG_RESULT(yes)
|
|
], [
|
|
AC_MSG_RESULT(no)
|
|
], [
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
])
|
|
|
|
dnl
|
|
dnl LIBZEND_OTHER_CHECKS
|
|
dnl
|
|
AC_DEFUN([LIBZEND_OTHER_CHECKS],[
|
|
|
|
AC_ARG_ENABLE([maintainer-zts],
|
|
[AS_HELP_STRING([--enable-maintainer-zts],
|
|
[Enable thread safety - for code maintainers only!!])],
|
|
[ZEND_MAINTAINER_ZTS=$enableval],
|
|
[ZEND_MAINTAINER_ZTS=no])
|
|
|
|
AC_ARG_ENABLE([inline-optimization],
|
|
[AS_HELP_STRING([--disable-inline-optimization],
|
|
[If building zend_execute.lo fails, try this switch])],
|
|
[ZEND_INLINE_OPTIMIZATION=$enableval],
|
|
[ZEND_INLINE_OPTIMIZATION=yes])
|
|
|
|
AC_MSG_CHECKING(whether to enable thread-safety)
|
|
AC_MSG_RESULT($ZEND_MAINTAINER_ZTS)
|
|
|
|
AC_MSG_CHECKING(whether to enable inline optimization for GCC)
|
|
AC_MSG_RESULT($ZEND_INLINE_OPTIMIZATION)
|
|
|
|
AC_MSG_CHECKING(whether to enable Zend debugging)
|
|
AC_MSG_RESULT($ZEND_DEBUG)
|
|
|
|
if test "$ZEND_DEBUG" = "yes"; then
|
|
AC_DEFINE(ZEND_DEBUG,1,[ ])
|
|
echo " $CFLAGS" | grep ' -g' >/dev/null || DEBUG_CFLAGS="-g"
|
|
if test "$CFLAGS" = "-g -O2"; then
|
|
CFLAGS=-g
|
|
fi
|
|
else
|
|
AC_DEFINE(ZEND_DEBUG,0,[ ])
|
|
fi
|
|
|
|
test -n "$GCC" && CFLAGS="$CFLAGS -Wall -Wno-strict-aliasing"
|
|
test -n "$DEBUG_CFLAGS" && CFLAGS="$CFLAGS $DEBUG_CFLAGS"
|
|
|
|
if test "$ZEND_MAINTAINER_ZTS" = "yes"; then
|
|
AC_DEFINE(ZTS,1,[ ])
|
|
CFLAGS="$CFLAGS -DZTS"
|
|
fi
|
|
|
|
changequote({,})
|
|
if test -n "$GCC" && test "$ZEND_INLINE_OPTIMIZATION" != "yes"; then
|
|
INLINE_CFLAGS=`echo $ac_n "$CFLAGS $ac_c" | sed s/-O[0-9s]*//`
|
|
else
|
|
INLINE_CFLAGS="$CFLAGS"
|
|
fi
|
|
changequote([,])
|
|
|
|
AC_C_INLINE
|
|
|
|
AC_SUBST(INLINE_CFLAGS)
|
|
|
|
AC_MSG_CHECKING(target system is Darwin)
|
|
if echo "$target" | grep "darwin" > /dev/null; then
|
|
AC_DEFINE([DARWIN], 1, [Define if the target system is darwin])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
dnl Test and set the alignment define for ZEND_MM. This also does the
|
|
dnl logarithmic test for ZEND_MM.
|
|
AC_MSG_CHECKING(for MM alignment and log values)
|
|
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <stdio.h>
|
|
|
|
typedef union _mm_align_test {
|
|
void *ptr;
|
|
double dbl;
|
|
long lng;
|
|
} mm_align_test;
|
|
|
|
#if (defined (__GNUC__) && __GNUC__ >= 2)
|
|
#define ZEND_MM_ALIGNMENT (__alignof__ (mm_align_test))
|
|
#else
|
|
#define ZEND_MM_ALIGNMENT (sizeof(mm_align_test))
|
|
#endif
|
|
|
|
int main()
|
|
{
|
|
int i = ZEND_MM_ALIGNMENT;
|
|
int zeros = 0;
|
|
FILE *fp;
|
|
|
|
while (i & ~0x1) {
|
|
zeros++;
|
|
i = i >> 1;
|
|
}
|
|
|
|
fp = fopen("conftest.zend", "w");
|
|
fprintf(fp, "%d %d\n", ZEND_MM_ALIGNMENT, zeros);
|
|
fclose(fp);
|
|
|
|
exit(0);
|
|
}
|
|
]])], [
|
|
LIBZEND_MM_ALIGN=`cat conftest.zend | cut -d ' ' -f 1`
|
|
LIBZEND_MM_ALIGN_LOG2=`cat conftest.zend | cut -d ' ' -f 2`
|
|
AC_DEFINE_UNQUOTED(ZEND_MM_ALIGNMENT, $LIBZEND_MM_ALIGN, [ ])
|
|
AC_DEFINE_UNQUOTED(ZEND_MM_ALIGNMENT_LOG2, $LIBZEND_MM_ALIGN_LOG2, [ ])
|
|
], [], [
|
|
dnl Cross compilation needs something here.
|
|
LIBZEND_MM_ALIGN=8
|
|
])
|
|
|
|
AC_MSG_RESULT(done)
|
|
|
|
AC_CHECK_FUNCS(mremap)
|
|
|
|
AC_ARG_ENABLE([zend-signals],
|
|
[AS_HELP_STRING([--disable-zend-signals],
|
|
[whether to enable zend signal handling])],
|
|
[ZEND_SIGNALS=$enableval],
|
|
[ZEND_SIGNALS=yes])
|
|
|
|
AC_CHECK_FUNC(sigaction, [
|
|
AC_DEFINE(HAVE_SIGACTION, 1, [Whether sigaction() is available])
|
|
], [
|
|
ZEND_SIGNALS=no
|
|
])
|
|
if test "$ZEND_SIGNALS" = "yes"; then
|
|
AC_DEFINE(ZEND_SIGNALS, 1, [Use zend signal handling])
|
|
CFLAGS="$CFLAGS -DZEND_SIGNALS"
|
|
fi
|
|
|
|
AC_MSG_CHECKING(whether to enable zend signal handling)
|
|
AC_MSG_RESULT($ZEND_SIGNALS)
|
|
|
|
])
|
|
|
|
AC_MSG_CHECKING(whether /dev/urandom exists)
|
|
if test -r "/dev/urandom" && test -c "/dev/urandom"; then
|
|
AC_DEFINE([HAVE_DEV_URANDOM], 1, [Define if the target system has /dev/urandom device])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(whether /dev/arandom exists)
|
|
if test -r "/dev/arandom" && test -c "/dev/arandom"; then
|
|
AC_DEFINE([HAVE_DEV_ARANDOM], 1, [Define if the target system has /dev/arandom device])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
AC_ARG_ENABLE([gcc-global-regs],
|
|
[AS_HELP_STRING([--disable-gcc-global-regs],
|
|
[whether to enable GCC global register variables])],
|
|
[ZEND_GCC_GLOBAL_REGS=$enableval],
|
|
[ZEND_GCC_GLOBAL_REGS=yes])
|
|
|
|
AC_MSG_CHECKING(for global register variables support)
|
|
if test "$ZEND_GCC_GLOBAL_REGS" != "no"; then
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#if defined(__GNUC__)
|
|
# define ZEND_GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
|
|
#else
|
|
# define ZEND_GCC_VERSION 0
|
|
#endif
|
|
#if defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(i386)
|
|
# define ZEND_VM_FP_GLOBAL_REG "%esi"
|
|
# define ZEND_VM_IP_GLOBAL_REG "%edi"
|
|
#elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__x86_64__)
|
|
# define ZEND_VM_FP_GLOBAL_REG "%r14"
|
|
# define ZEND_VM_IP_GLOBAL_REG "%r15"
|
|
#elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__powerpc64__)
|
|
# define ZEND_VM_FP_GLOBAL_REG "r28"
|
|
# define ZEND_VM_IP_GLOBAL_REG "r29"
|
|
#elif defined(__IBMC__) && ZEND_GCC_VERSION >= 4002 && defined(__powerpc64__)
|
|
# define ZEND_VM_FP_GLOBAL_REG "r28"
|
|
# define ZEND_VM_IP_GLOBAL_REG "r29"
|
|
#elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__aarch64__)
|
|
# define ZEND_VM_FP_GLOBAL_REG "x27"
|
|
# define ZEND_VM_IP_GLOBAL_REG "x28"
|
|
#else
|
|
# error "global register variables are not supported"
|
|
#endif
|
|
typedef int (*opcode_handler_t)(void);
|
|
register void *FP __asm__(ZEND_VM_FP_GLOBAL_REG);
|
|
register const opcode_handler_t *IP __asm__(ZEND_VM_IP_GLOBAL_REG);
|
|
int emu(const opcode_handler_t *ip, void *fp) {
|
|
const opcode_handler_t *orig_ip = IP;
|
|
void *orig_fp = FP;
|
|
IP = ip;
|
|
FP = fp;
|
|
while ((*ip)());
|
|
FP = orig_fp;
|
|
IP = orig_ip;
|
|
}
|
|
]], [[
|
|
]])], [
|
|
ZEND_GCC_GLOBAL_REGS=yes
|
|
], [
|
|
ZEND_GCC_GLOBAL_REGS=no
|
|
])
|
|
fi
|
|
if test "$ZEND_GCC_GLOBAL_REGS" = "yes"; then
|
|
AC_DEFINE([HAVE_GCC_GLOBAL_REGS], 1, [Define if the target system has support for global register variables])
|
|
else
|
|
HAVE_GCC_GLOBAL_REGS=no
|
|
fi
|
|
AC_MSG_RESULT($ZEND_GCC_GLOBAL_REGS)
|
|
|
|
dnl Check if atof() accepts NAN.
|
|
AC_CACHE_CHECK(whether atof() accepts NAN, ac_cv_atof_accept_nan,[
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifdef HAVE_ISNAN
|
|
#define zend_isnan(a) isnan(a)
|
|
#elif defined(HAVE_FPCLASS)
|
|
#define zend_isnan(a) ((fpclass(a) == FP_SNAN) || (fpclass(a) == FP_QNAN))
|
|
#else
|
|
#define zend_isnan(a) 0
|
|
#endif
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
return zend_isnan(atof("NAN")) ? 0 : 1;
|
|
}
|
|
]])],[
|
|
ac_cv_atof_accept_nan=yes
|
|
],[
|
|
ac_cv_atof_accept_nan=no
|
|
],[
|
|
ac_cv_atof_accept_nan=no
|
|
])])
|
|
if test "$ac_cv_atof_accept_nan" = "yes"; then
|
|
AC_DEFINE([HAVE_ATOF_ACCEPTS_NAN], 1, [whether atof() accepts NAN])
|
|
fi
|
|
|
|
dnl Check if atof() accepts INF.
|
|
AC_CACHE_CHECK(whether atof() accepts INF, ac_cv_atof_accept_inf,[
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifdef HAVE_ISINF
|
|
#define zend_isinf(a) isinf(a)
|
|
#elif defined(INFINITY)
|
|
/* Might not work, but is required by ISO C99 */
|
|
#define zend_isinf(a) (((a)==INFINITY)?1:0)
|
|
#elif defined(HAVE_FPCLASS)
|
|
#define zend_isinf(a) ((fpclass(a) == FP_PINF) || (fpclass(a) == FP_NINF))
|
|
#else
|
|
#define zend_isinf(a) 0
|
|
#endif
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
return zend_isinf(atof("INF")) && zend_isinf(atof("-INF")) ? 0 : 1;
|
|
}
|
|
]])],[
|
|
ac_cv_atof_accept_inf=yes
|
|
],[
|
|
ac_cv_atof_accept_inf=no
|
|
],[
|
|
ac_cv_atof_accept_inf=no
|
|
])])
|
|
if test "$ac_cv_atof_accept_inf" = "yes"; then
|
|
AC_DEFINE([HAVE_ATOF_ACCEPTS_INF], 1, [whether atof() accepts INF])
|
|
fi
|
|
|
|
dnl Check if HUGE_VAL == INF.
|
|
AC_CACHE_CHECK(whether HUGE_VAL == INF, ac_cv_huge_val_inf,[
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifdef HAVE_ISINF
|
|
#define zend_isinf(a) isinf(a)
|
|
#elif defined(INFINITY)
|
|
/* Might not work, but is required by ISO C99 */
|
|
#define zend_isinf(a) (((a)==INFINITY)?1:0)
|
|
#elif defined(HAVE_FPCLASS)
|
|
#define zend_isinf(a) ((fpclass(a) == FP_PINF) || (fpclass(a) == FP_NINF))
|
|
#else
|
|
#define zend_isinf(a) 0
|
|
#endif
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
return zend_isinf(HUGE_VAL) ? 0 : 1;
|
|
}
|
|
]])],[
|
|
ac_cv_huge_val_inf=yes
|
|
],[
|
|
ac_cv_huge_val_inf=no
|
|
],[
|
|
ac_cv_huge_val_inf=yes
|
|
])])
|
|
dnl This is the most probable fallback so we assume yes in case of cross compile.
|
|
if test "$ac_cv_huge_val_inf" = "yes"; then
|
|
AC_DEFINE([HAVE_HUGE_VAL_INF], 1, [whether HUGE_VAL == INF])
|
|
fi
|
|
|
|
dnl Check if HUGE_VAL + -HUGEVAL == NAN.
|
|
AC_CACHE_CHECK(whether HUGE_VAL + -HUGEVAL == NAN, ac_cv_huge_val_nan,[
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifdef HAVE_ISNAN
|
|
#define zend_isnan(a) isnan(a)
|
|
#elif defined(HAVE_FPCLASS)
|
|
#define zend_isnan(a) ((fpclass(a) == FP_SNAN) || (fpclass(a) == FP_QNAN))
|
|
#else
|
|
#define zend_isnan(a) 0
|
|
#endif
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
#if defined(__sparc__) && !(__GNUC__ >= 3)
|
|
/* prevent bug #27830 */
|
|
return 1;
|
|
#else
|
|
return zend_isnan(HUGE_VAL + -HUGE_VAL) ? 0 : 1;
|
|
#endif
|
|
}
|
|
]])],[
|
|
ac_cv_huge_val_nan=yes
|
|
],[
|
|
ac_cv_huge_val_nan=no
|
|
],[
|
|
ac_cv_huge_val_nan=yes
|
|
])])
|
|
dnl This is the most probable fallback so we assume yes in case of cross compile.
|
|
if test "$ac_cv_huge_val_nan" = "yes"; then
|
|
AC_DEFINE([HAVE_HUGE_VAL_NAN], 1, [whether HUGE_VAL + -HUGEVAL == NAN])
|
|
fi
|
|
|
|
dnl Check whether __cpuid_count is available.
|
|
AC_CACHE_CHECK(whether __cpuid_count is available, ac_cv_cpuid_count_available, [
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <cpuid.h>
|
|
]], [[
|
|
unsigned eax, ebx, ecx, edx;
|
|
__cpuid_count(0, 0, eax, ebx, ecx, edx);
|
|
]])], [
|
|
ac_cv_cpuid_count_available=yes
|
|
], [
|
|
ac_cv_cpuid_count_available=no
|
|
])])
|
|
if test "$ac_cv_cpuid_count_available" = "yes"; then
|
|
AC_DEFINE([HAVE_CPUID_COUNT], 1, [whether __cpuid_count is available])
|
|
fi
|