794 lines
21 KiB
Plaintext
794 lines
21 KiB
Plaintext
dnl Copyright 2005 Red Hat, Inc.
|
|
dnl
|
|
dnl Permission to use, copy, modify, distribute, and sell this software and its
|
|
dnl documentation for any purpose is hereby granted without fee, provided that
|
|
dnl the above copyright notice appear in all copies and that both that
|
|
dnl copyright notice and this permission notice appear in supporting
|
|
dnl documentation, and that the name of Red Hat not be used in
|
|
dnl advertising or publicity pertaining to distribution of the software without
|
|
dnl specific, written prior permission. Red Hat makes no
|
|
dnl representations about the suitability of this software for any purpose. It
|
|
dnl is provided "as is" without express or implied warranty.
|
|
dnl
|
|
dnl RED HAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
dnl INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
dnl EVENT SHALL RED HAT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
dnl CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
dnl DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
dnl TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
dnl PERFORMANCE OF THIS SOFTWARE.
|
|
dnl
|
|
dnl Process this file with autoconf to create configure.
|
|
|
|
AC_PREREQ([2.57])
|
|
|
|
# Pixman versioning scheme
|
|
#
|
|
# - The version in git has an odd MICRO version number
|
|
#
|
|
# - Released versions both development and stable have an even MICRO
|
|
# version number
|
|
#
|
|
# - Released development versions have an odd MINOR number
|
|
#
|
|
# - Released stable versions have an even MINOR number
|
|
#
|
|
# - Versions that break ABI must have a new MAJOR number
|
|
#
|
|
# - If you break the ABI, then at least this must be done:
|
|
#
|
|
# - increment MAJOR
|
|
#
|
|
# - In the first development release where you break ABI, find
|
|
# all instances of "pixman-n" and change them to pixman-(n+1)
|
|
#
|
|
# This needs to be done at least in
|
|
# configure.ac
|
|
# all Makefile.am's
|
|
# pixman-n.pc.in
|
|
#
|
|
# This ensures that binary incompatible versions can be installed
|
|
# in parallel. See http://www106.pair.com/rhp/parallel.html for
|
|
# more information
|
|
#
|
|
|
|
m4_define([pixman_major], 0)
|
|
m4_define([pixman_minor], 20)
|
|
m4_define([pixman_micro], 2)
|
|
|
|
m4_define([pixman_version],[pixman_major.pixman_minor.pixman_micro])
|
|
|
|
AC_INIT(pixman, pixman_version, "pixman@lists.freedesktop.org", pixman)
|
|
AM_INIT_AUTOMAKE([foreign dist-bzip2])
|
|
|
|
# Suppress verbose compile lines
|
|
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
|
|
|
|
AM_CONFIG_HEADER(config.h)
|
|
|
|
AC_CANONICAL_HOST
|
|
|
|
test_CFLAGS=${CFLAGS+set} # We may override autoconf default CFLAGS.
|
|
|
|
AC_PROG_CC
|
|
AM_PROG_AS
|
|
AC_PROG_LIBTOOL
|
|
AC_CHECK_FUNCS([getisax])
|
|
AC_C_BIGENDIAN
|
|
AC_C_INLINE
|
|
|
|
dnl PIXMAN_LINK_WITH_ENV(env-setup, program, true-action, false-action)
|
|
dnl
|
|
dnl Compiles and links the given program in the environment setup by env-setup
|
|
dnl and executes true-action on success and false-action on failure.
|
|
AC_DEFUN([PIXMAN_LINK_WITH_ENV],[dnl
|
|
save_CFLAGS="$CFLAGS"
|
|
save_LDFLAGS="$LDFLAGS"
|
|
save_LIBS="$LIBS"
|
|
CFLAGS=""
|
|
LDFLAGS=""
|
|
LIBS=""
|
|
$1
|
|
AC_LINK_IFELSE(
|
|
[$2],
|
|
[pixman_cc_stderr=`test -f conftest.err && cat conftest.err`
|
|
pixman_cc_flag=yes],
|
|
[pixman_cc_stderr=`test -f conftest.err && cat conftest.err`
|
|
pixman_cc_flag=no])
|
|
|
|
if test "x$pixman_cc_stderr" != "x"; then
|
|
pixman_cc_flag=no
|
|
fi
|
|
|
|
if test "x$pixman_cc_flag" = "xyes"; then
|
|
ifelse([$3], , :, [$3])
|
|
else
|
|
ifelse([$4], , :, [$4])
|
|
fi
|
|
CFLAGS="$save_CFLAGS"
|
|
LDFLAGS="$save_LDFLAGS"
|
|
LIBS="$save_LIBS"
|
|
])
|
|
|
|
dnl Find a -Werror for catching warnings.
|
|
WERROR=
|
|
for w in -Werror -errwarn; do
|
|
if test "z$WERROR" = "z"; then
|
|
AC_MSG_CHECKING([whether the compiler supports $w])
|
|
PIXMAN_LINK_WITH_ENV(
|
|
[CFLAGS=$w],
|
|
[int main(int c, char **v) { (void)c; (void)v; return 0; }],
|
|
[WERROR=$w; yesno=yes], [yesno=no])
|
|
AC_MSG_RESULT($_yesno)
|
|
fi
|
|
done
|
|
|
|
dnl PIXMAN_CHECK_CFLAG(flag, [program])
|
|
dnl Adds flag to CFLAGS if the given program links without warnings or errors.
|
|
AC_DEFUN([PIXMAN_CHECK_CFLAG], [dnl
|
|
AC_MSG_CHECKING([whether the compiler supports $1])
|
|
PIXMAN_LINK_WITH_ENV(
|
|
[CFLAGS="$WERROR $1"],
|
|
[$2
|
|
int main(int c, char **v) { (void)c; (void)v; return 0; }
|
|
],
|
|
[_yesno=yes],
|
|
[_yesno=no])
|
|
if test "x$_yesno" = xyes; then
|
|
CFLAGS="$CFLAGS $1"
|
|
fi
|
|
AC_MSG_RESULT($_yesno)
|
|
])
|
|
|
|
AC_CHECK_SIZEOF(long)
|
|
|
|
# Checks for Sun Studio compilers
|
|
AC_CHECK_DECL([__SUNPRO_C], [SUNCC="yes"], [SUNCC="no"])
|
|
AC_CHECK_DECL([__amd64], [AMD64_ABI="yes"], [AMD64_ABI="no"])
|
|
|
|
# Default CFLAGS to -O -g rather than just the -g from AC_PROG_CC
|
|
# if we're using Sun Studio and neither the user nor a config.site
|
|
# has set CFLAGS.
|
|
if test $SUNCC = yes && \
|
|
test "$test_CFLAGS" == "" && \
|
|
test "$CFLAGS" = "-g"
|
|
then
|
|
CFLAGS="-O -g"
|
|
fi
|
|
|
|
#
|
|
# We ignore pixman_major in the version here because the major version should
|
|
# always be encoded in the actual library name. Ie., the soname is:
|
|
#
|
|
# pixman-$(pixman_major).0.minor.micro
|
|
#
|
|
m4_define([lt_current], [pixman_minor])
|
|
m4_define([lt_revision], [pixman_micro])
|
|
m4_define([lt_age], [pixman_minor])
|
|
|
|
LT_VERSION_INFO="lt_current:lt_revision:lt_age"
|
|
|
|
PIXMAN_VERSION_MAJOR=pixman_major()
|
|
AC_SUBST(PIXMAN_VERSION_MAJOR)
|
|
PIXMAN_VERSION_MINOR=pixman_minor()
|
|
AC_SUBST(PIXMAN_VERSION_MINOR)
|
|
PIXMAN_VERSION_MICRO=pixman_micro()
|
|
AC_SUBST(PIXMAN_VERSION_MICRO)
|
|
|
|
AC_SUBST(LT_VERSION_INFO)
|
|
|
|
# Check for dependencies
|
|
|
|
PIXMAN_CHECK_CFLAG([-Wall])
|
|
PIXMAN_CHECK_CFLAG([-fno-strict-aliasing])
|
|
|
|
AC_PATH_PROG(PERL, perl, no)
|
|
if test "x$PERL" = xno; then
|
|
AC_MSG_ERROR([Perl is required to build pixman.])
|
|
fi
|
|
AC_SUBST(PERL)
|
|
|
|
dnl =========================================================================
|
|
dnl OpenMP for the test suite?
|
|
dnl
|
|
|
|
# Check for OpenMP support (only supported by autoconf >=2.62)
|
|
OPENMP_CFLAGS=
|
|
m4_ifdef([AC_OPENMP], [AC_OPENMP])
|
|
|
|
m4_define([openmp_test_program],[dnl
|
|
#include <stdio.h>
|
|
|
|
extern unsigned int lcg_seed;
|
|
#pragma omp threadprivate(lcg_seed)
|
|
unsigned int lcg_seed;
|
|
|
|
unsigned function(unsigned a, unsigned b)
|
|
{
|
|
lcg_seed ^= b;
|
|
return ((a + b) ^ a ) + lcg_seed;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int i;
|
|
int n1 = 0, n2 = argc;
|
|
unsigned checksum = 0;
|
|
int verbose = argv != NULL;
|
|
unsigned (*test_function)(unsigned, unsigned);
|
|
test_function = function;
|
|
#pragma omp parallel for reduction(+:checksum) default(none) \
|
|
shared(n1, n2, test_function, verbose)
|
|
for (i = n1; i < n2; i++)
|
|
{
|
|
unsigned crc = test_function (i, 0);
|
|
if (verbose)
|
|
printf ("%d: %08X\n", i, crc);
|
|
checksum += crc;
|
|
}
|
|
printf("%u\n", checksum);
|
|
return 0;
|
|
}
|
|
])
|
|
|
|
PIXMAN_LINK_WITH_ENV(
|
|
[CFLAGS="$OPENMP_CFLAGS" LDFLAGS="$OPENMP_CFLAGS"],
|
|
[openmp_test_program],
|
|
[have_openmp=yes],
|
|
[have_openmp=no])
|
|
if test "x$have_openmp" = "xyes"; then
|
|
AC_DEFINE(USE_OPENMP, 1, [use OpenMP in the test suite])
|
|
else
|
|
OPENMP_CFLAGS=""
|
|
fi
|
|
AC_SUBST(OPENMP_CFLAGS)
|
|
|
|
dnl =========================================================================
|
|
dnl -fvisibility stuff
|
|
|
|
PIXMAN_CHECK_CFLAG([-fvisibility=hidden], [dnl
|
|
#if defined(__GNUC__) && (__GNUC__ >= 4)
|
|
#ifdef _WIN32
|
|
#error Have -fvisibility but it is ignored and generates a warning
|
|
#endif
|
|
#else
|
|
error Need GCC 4.0 for visibility
|
|
#endif
|
|
])
|
|
|
|
PIXMAN_CHECK_CFLAG([-xldscope=hidden], [dnl
|
|
#if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
|
|
#else
|
|
error Need Sun Studio 8 for visibility
|
|
#endif
|
|
])
|
|
|
|
dnl ===========================================================================
|
|
dnl Check for MMX
|
|
|
|
if test "x$MMX_CFLAGS" = "x" ; then
|
|
if test "x$SUNCC" = "xyes"; then
|
|
# Sun Studio doesn't have an -xarch=mmx flag, so we have to use sse
|
|
# but if we're building 64-bit, mmx & sse support is on by default and
|
|
# -xarch=sse throws an error instead
|
|
if test "$AMD64_ABI" = "no" ; then
|
|
MMX_CFLAGS="-xarch=sse"
|
|
fi
|
|
else
|
|
MMX_CFLAGS="-mmmx -Winline"
|
|
fi
|
|
fi
|
|
|
|
have_mmx_intrinsics=no
|
|
AC_MSG_CHECKING(whether to use MMX intrinsics)
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS="$MMX_CFLAGS $CFLAGS"
|
|
AC_COMPILE_IFELSE([
|
|
#if defined(__GNUC__) && (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4))
|
|
error "Need GCC >= 3.4 for MMX intrinsics"
|
|
#endif
|
|
#include <mmintrin.h>
|
|
int main () {
|
|
__m64 v = _mm_cvtsi32_si64 (1);
|
|
return _mm_cvtsi64_si32 (v);
|
|
}], have_mmx_intrinsics=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(mmx,
|
|
[AC_HELP_STRING([--disable-mmx],
|
|
[disable MMX fast paths])],
|
|
[enable_mmx=$enableval], [enable_mmx=auto])
|
|
|
|
if test $enable_mmx = no ; then
|
|
have_mmx_intrinsics=disabled
|
|
fi
|
|
|
|
if test $have_mmx_intrinsics = yes ; then
|
|
AC_DEFINE(USE_MMX, 1, [use MMX compiler intrinsics])
|
|
else
|
|
MMX_CFLAGS=
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_mmx_intrinsics)
|
|
if test $enable_mmx = yes && test $have_mmx_intrinsics = no ; then
|
|
AC_MSG_ERROR([MMX intrinsics not detected])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_MMX, test $have_mmx_intrinsics = yes)
|
|
|
|
dnl ===========================================================================
|
|
dnl Check for SSE2
|
|
|
|
if test "x$SSE2_CFLAGS" = "x" ; then
|
|
if test "x$SUNCC" = "xyes"; then
|
|
# SSE2 is enabled by default in the Sun Studio 64-bit environment
|
|
if test "$AMD64_ABI" = "no" ; then
|
|
SSE2_CFLAGS="-xarch=sse2"
|
|
fi
|
|
else
|
|
SSE2_CFLAGS="-mmmx -msse2 -Winline"
|
|
fi
|
|
fi
|
|
|
|
have_sse2_intrinsics=no
|
|
AC_MSG_CHECKING(whether to use SSE2 intrinsics)
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS="$SSE2_CFLAGS $CFLAGS"
|
|
|
|
AC_COMPILE_IFELSE([
|
|
#if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2))
|
|
# if !defined(__amd64__) && !defined(__x86_64__)
|
|
# error "Need GCC >= 4.2 for SSE2 intrinsics on x86"
|
|
# endif
|
|
#endif
|
|
#include <mmintrin.h>
|
|
#include <xmmintrin.h>
|
|
#include <emmintrin.h>
|
|
int main () {
|
|
__m128i a = _mm_set1_epi32 (0), b = _mm_set1_epi32 (0), c;
|
|
c = _mm_xor_si128 (a, b);
|
|
return 0;
|
|
}], have_sse2_intrinsics=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(sse2,
|
|
[AC_HELP_STRING([--disable-sse2],
|
|
[disable SSE2 fast paths])],
|
|
[enable_sse2=$enableval], [enable_sse2=auto])
|
|
|
|
if test $enable_sse2 = no ; then
|
|
have_sse2_intrinsics=disabled
|
|
fi
|
|
|
|
if test $have_sse2_intrinsics = yes ; then
|
|
AC_DEFINE(USE_SSE2, 1, [use SSE2 compiler intrinsics])
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_sse2_intrinsics)
|
|
if test $enable_sse2 = yes && test $have_sse2_intrinsics = no ; then
|
|
AC_MSG_ERROR([SSE2 intrinsics not detected])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_SSE2, test $have_sse2_intrinsics = yes)
|
|
|
|
dnl ===========================================================================
|
|
dnl Other special flags needed when building code using MMX or SSE instructions
|
|
case $host_os in
|
|
solaris*)
|
|
# When building 32-bit binaries, apply a mapfile to ensure that the
|
|
# binaries aren't flagged as only able to run on MMX+SSE capable CPUs
|
|
# since they check at runtime before using those instructions.
|
|
# Not all linkers grok the mapfile format so we check for that first.
|
|
if test "$AMD64_ABI" = "no" ; then
|
|
use_hwcap_mapfile=no
|
|
AC_MSG_CHECKING(whether to use a hardware capability map file)
|
|
hwcap_save_LDFLAGS="$LDFLAGS"
|
|
HWCAP_LDFLAGS='-Wl,-M,$(srcdir)/solaris-hwcap.mapfile'
|
|
LDFLAGS="$LDFLAGS -Wl,-M,pixman/solaris-hwcap.mapfile"
|
|
AC_LINK_IFELSE([int main() { return 0; }],
|
|
use_hwcap_mapfile=yes,
|
|
HWCAP_LDFLAGS="")
|
|
LDFLAGS="$hwcap_save_LDFLAGS"
|
|
AC_MSG_RESULT($use_hwcap_mapfile)
|
|
fi
|
|
if test "x$MMX_LDFLAGS" = "x" ; then
|
|
MMX_LDFLAGS="$HWCAP_LDFLAGS"
|
|
fi
|
|
if test "x$SSE2_LDFLAGS" = "x" ; then
|
|
SSE2_LDFLAGS="$HWCAP_LDFLAGS"
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
AC_SUBST(MMX_CFLAGS)
|
|
AC_SUBST(MMX_LDFLAGS)
|
|
AC_SUBST(SSE2_CFLAGS)
|
|
AC_SUBST(SSE2_LDFLAGS)
|
|
|
|
dnl ===========================================================================
|
|
dnl Check for VMX/Altivec
|
|
if test -n "`$CC -v 2>&1 | grep version | grep Apple`"; then
|
|
VMX_CFLAGS="-faltivec"
|
|
else
|
|
VMX_CFLAGS="-maltivec -mabi=altivec"
|
|
fi
|
|
|
|
have_vmx_intrinsics=no
|
|
AC_MSG_CHECKING(whether to use VMX/Altivec intrinsics)
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS="$VMX_CFLAGS $CFLAGS"
|
|
AC_COMPILE_IFELSE([
|
|
#if defined(__GNUC__) && (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4))
|
|
error "Need GCC >= 3.4 for sane altivec support"
|
|
#endif
|
|
#include <altivec.h>
|
|
int main () {
|
|
vector unsigned int v = vec_splat_u32 (1);
|
|
v = vec_sub (v, v);
|
|
return 0;
|
|
}], have_vmx_intrinsics=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(vmx,
|
|
[AC_HELP_STRING([--disable-vmx],
|
|
[disable VMX fast paths])],
|
|
[enable_vmx=$enableval], [enable_vmx=auto])
|
|
|
|
if test $enable_vmx = no ; then
|
|
have_vmx_intrinsics=disabled
|
|
fi
|
|
|
|
if test $have_vmx_intrinsics = yes ; then
|
|
AC_DEFINE(USE_VMX, 1, [use VMX compiler intrinsics])
|
|
else
|
|
VMX_CFLAGS=
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_vmx_intrinsics)
|
|
if test $enable_vmx = yes && test $have_vmx_intrinsics = no ; then
|
|
AC_MSG_ERROR([VMX intrinsics not detected])
|
|
fi
|
|
|
|
AC_SUBST(VMX_CFLAGS)
|
|
|
|
AM_CONDITIONAL(USE_VMX, test $have_vmx_intrinsics = yes)
|
|
|
|
dnl ==========================================================================
|
|
dnl Check if assembler is gas compatible and supports ARM SIMD instructions
|
|
have_arm_simd=no
|
|
AC_MSG_CHECKING(whether to use ARM SIMD assembler)
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS="-x assembler-with-cpp $CFLAGS"
|
|
AC_COMPILE_IFELSE([[
|
|
.text
|
|
.arch armv6
|
|
.object_arch armv4
|
|
.arm
|
|
.altmacro
|
|
#ifndef __ARM_EABI__
|
|
#error EABI is required (to be sure that calling conventions are compatible)
|
|
#endif
|
|
pld [r0]
|
|
uqadd8 r0, r0, r0]], have_arm_simd=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(arm-simd,
|
|
[AC_HELP_STRING([--disable-arm-simd],
|
|
[disable ARM SIMD fast paths])],
|
|
[enable_arm_simd=$enableval], [enable_arm_simd=auto])
|
|
|
|
if test $enable_arm_simd = no ; then
|
|
have_arm_simd=disabled
|
|
fi
|
|
|
|
if test $have_arm_simd = yes ; then
|
|
AC_DEFINE(USE_ARM_SIMD, 1, [use ARM SIMD assembly optimizations])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_ARM_SIMD, test $have_arm_simd = yes)
|
|
|
|
AC_MSG_RESULT($have_arm_simd)
|
|
if test $enable_arm_simd = yes && test $have_arm_simd = no ; then
|
|
AC_MSG_ERROR([ARM SIMD intrinsics not detected])
|
|
fi
|
|
|
|
dnl ==========================================================================
|
|
dnl Check if assembler is gas compatible and supports NEON instructions
|
|
have_arm_neon=no
|
|
AC_MSG_CHECKING(whether to use ARM NEON assembler)
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS="-x assembler-with-cpp $CFLAGS"
|
|
AC_COMPILE_IFELSE([[
|
|
.text
|
|
.fpu neon
|
|
.arch armv7a
|
|
.object_arch armv4
|
|
.eabi_attribute 10, 0
|
|
.arm
|
|
.altmacro
|
|
#ifndef __ARM_EABI__
|
|
#error EABI is required (to be sure that calling conventions are compatible)
|
|
#endif
|
|
pld [r0]
|
|
vmovn.u16 d0, q0]], have_arm_neon=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(arm-neon,
|
|
[AC_HELP_STRING([--disable-arm-neon],
|
|
[disable ARM NEON fast paths])],
|
|
[enable_arm_neon=$enableval], [enable_arm_neon=auto])
|
|
|
|
if test $enable_arm_neon = no ; then
|
|
have_arm_neon=disabled
|
|
fi
|
|
|
|
if test $have_arm_neon = yes ; then
|
|
AC_DEFINE(USE_ARM_NEON, 1, [use ARM NEON assembly optimizations])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_ARM_NEON, test $have_arm_neon = yes)
|
|
|
|
AC_MSG_RESULT($have_arm_neon)
|
|
if test $enable_arm_neon = yes && test $have_arm_neon = no ; then
|
|
AC_MSG_ERROR([ARM NEON intrinsics not detected])
|
|
fi
|
|
|
|
dnl =========================================================================================
|
|
dnl Check for GNU-style inline assembly support
|
|
|
|
have_gcc_inline_asm=no
|
|
AC_MSG_CHECKING(whether to use GNU-style inline assembler)
|
|
AC_COMPILE_IFELSE([
|
|
int main () {
|
|
/* Most modern architectures have a NOP instruction, so this is a fairly generic test. */
|
|
asm volatile ( "\tnop\n" : : : "cc", "memory" );
|
|
return 0;
|
|
}], have_gcc_inline_asm=yes)
|
|
|
|
AC_ARG_ENABLE(gcc-inline-asm,
|
|
[AC_HELP_STRING([--disable-gcc-inline-asm],
|
|
[disable GNU-style inline assembler])],
|
|
[enable_gcc_inline_asm=$enableval], [enable_gcc_inline_asm=auto])
|
|
|
|
if test $enable_gcc_inline_asm = no ; then
|
|
have_gcc_inline_asm=disabled
|
|
fi
|
|
|
|
if test $have_gcc_inline_asm = yes ; then
|
|
AC_DEFINE(USE_GCC_INLINE_ASM, 1, [use GNU-style inline assembler])
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_gcc_inline_asm)
|
|
if test $enable_gcc_inline_asm = yes && test $have_gcc_inline_asm = no ; then
|
|
AC_MSG_ERROR([GNU-style inline assembler not detected])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_GCC_INLINE_ASM, test $have_gcc_inline_asm = yes)
|
|
|
|
dnl ==============================================
|
|
dnl Timers
|
|
|
|
AC_ARG_ENABLE(timers,
|
|
[AC_HELP_STRING([--enable-timers],
|
|
[enable TIMER_BEGIN and TIMER_END macros [default=no]])],
|
|
[enable_timers=$enableval], [enable_timers=no])
|
|
|
|
if test $enable_timers = yes ; then
|
|
AC_DEFINE(PIXMAN_TIMERS, 1, [enable TIMER_BEGIN/TIMER_END macros])
|
|
fi
|
|
AC_SUBST(PIXMAN_TIMERS)
|
|
|
|
dnl ===================================
|
|
dnl GTK+
|
|
|
|
AC_ARG_ENABLE(gtk,
|
|
[AC_HELP_STRING([--enable-gtk],
|
|
[enable tests using GTK+ [default=auto]])],
|
|
[enable_gtk=$enableval], [enable_gtk=auto])
|
|
|
|
PKG_PROG_PKG_CONFIG
|
|
|
|
if test $enable_gtk = yes ; then
|
|
AC_CHECK_LIB([pixman-1], [pixman_version_string])
|
|
PKG_CHECK_MODULES(GTK, [gtk+-2.0 pixman-1])
|
|
fi
|
|
|
|
if test $enable_gtk = auto ; then
|
|
AC_CHECK_LIB([pixman-1], [pixman_version_string], [enable_gtk=auto], [enable_gtk=no])
|
|
fi
|
|
|
|
if test $enable_gtk = auto ; then
|
|
PKG_CHECK_MODULES(GTK, [gtk+-2.0 pixman-1], [enable_gtk=yes], [enable_gtk=no])
|
|
fi
|
|
|
|
AM_CONDITIONAL(HAVE_GTK, [test "x$enable_gtk" = xyes])
|
|
|
|
AC_SUBST(GTK_CFLAGS)
|
|
AC_SUBST(GTK_LIBS)
|
|
AC_SUBST(DEP_CFLAGS)
|
|
AC_SUBST(DEP_LIBS)
|
|
|
|
dnl =====================================
|
|
dnl posix_memalign, sigaction, alarm, gettimeofday
|
|
|
|
AC_CHECK_FUNC(posix_memalign, have_posix_memalign=yes, have_posix_memalign=no)
|
|
if test x$have_posix_memalign = xyes; then
|
|
AC_DEFINE(HAVE_POSIX_MEMALIGN, 1, [Whether we have posix_memalign()])
|
|
fi
|
|
|
|
AC_CHECK_FUNC(sigaction, have_sigaction=yes, have_sigaction=no)
|
|
if test x$have_sigaction = xyes; then
|
|
AC_DEFINE(HAVE_SIGACTION, 1, [Whether we have sigaction()])
|
|
fi
|
|
|
|
AC_CHECK_FUNC(alarm, have_alarm=yes, have_alarm=no)
|
|
if test x$have_alarm = xyes; then
|
|
AC_DEFINE(HAVE_ALARM, 1, [Whether we have alarm()])
|
|
fi
|
|
|
|
AC_CHECK_HEADER([sys/mman.h],
|
|
[AC_DEFINE(HAVE_SYS_MMAN_H, [1], [Define to 1 if we have <sys/mman.h>])])
|
|
|
|
AC_CHECK_FUNC(mprotect, have_mprotect=yes, have_mprotect=no)
|
|
if test x$have_mprotect = xyes; then
|
|
AC_DEFINE(HAVE_MPROTECT, 1, [Whether we have mprotect()])
|
|
fi
|
|
|
|
AC_CHECK_FUNC(getpagesize, have_getpagesize=yes, have_getpagesize=no)
|
|
if test x$have_getpagesize = xyes; then
|
|
AC_DEFINE(HAVE_GETPAGESIZE, 1, [Whether we have getpagesize()])
|
|
fi
|
|
|
|
AC_CHECK_FUNC(gettimeofday, have_gettimeofday=yes, have_gettimeofday=no)
|
|
AC_CHECK_HEADER(sys/time.h, have_sys_time_h=yes, have_sys_time_h=no)
|
|
if test x$have_gettimeofday = xyes && test x$have_sys_time_h = xyes; then
|
|
AC_DEFINE(HAVE_GETTIMEOFDAY, 1, [Whether we have gettimeofday()])
|
|
fi
|
|
|
|
dnl =====================================
|
|
dnl Thread local storage
|
|
|
|
support_for__thread=no
|
|
|
|
AC_MSG_CHECKING(for __thread)
|
|
AC_LINK_IFELSE([
|
|
#if defined(__MINGW32__) && !(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
|
|
#error This MinGW version has broken __thread support
|
|
#endif
|
|
#ifdef __OpenBSD__
|
|
#error OpenBSD has broken __thread support
|
|
#endif
|
|
static __thread int x ;
|
|
int main () { x = 123; return x; }
|
|
], support_for__thread=yes)
|
|
|
|
if test $support_for__thread = yes; then
|
|
AC_DEFINE([TOOLCHAIN_SUPPORTS__THREAD],[],[Whether the tool chain supports __thread])
|
|
fi
|
|
|
|
AC_MSG_RESULT($support_for__thread)
|
|
|
|
dnl posix tls
|
|
|
|
if test $support_for__thread = no; then
|
|
|
|
support_for_pthread_stubs_setspecific=no
|
|
|
|
AC_MSG_CHECKING(for pthread_setspecific in libpthread_stubs)
|
|
|
|
save_LDFLAGS=$LDFLAGS
|
|
save_CFLAGS=$CFLAGS
|
|
|
|
PKG_CHECK_MODULES(STUBS, pthread-stubs)
|
|
|
|
CFLAGS="${STUBS_CFLAGS}"
|
|
LDFLAGS="${STUBS_LIBS}"
|
|
|
|
AC_LINK_IFELSE([
|
|
#include <pthread.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
|
|
static pthread_once_t once_control = PTHREAD_ONCE_INIT;
|
|
static pthread_key_t key;
|
|
|
|
static void
|
|
make_key (void)
|
|
{
|
|
pthread_key_create (&key, NULL);
|
|
}
|
|
|
|
int
|
|
main ()
|
|
{
|
|
void *value = NULL;
|
|
|
|
if (pthread_once (&once_control, make_key) != 0)
|
|
{
|
|
value = NULL;
|
|
}
|
|
else
|
|
{
|
|
value = pthread_getspecific (key);
|
|
if (!value)
|
|
{
|
|
value = malloc (100);
|
|
pthread_setspecific (key, value);
|
|
}
|
|
}
|
|
}
|
|
], support_for_pthread_stubs_setspecific=yes);
|
|
|
|
CFLAGS=$save_CFLAGS
|
|
LDFLAGS=$save_LDFLAGS
|
|
|
|
if test $support_for_pthread_stubs_setspecific = yes; then
|
|
PTHREAD_LDFLAGS="${STUBS_LIBS}"
|
|
PTHREAD_CFLAGS="${STUBS_CFLAGS}"
|
|
AC_DEFINE([HAVE_PTHREAD_SETSPECIFIC], [], [Whether pthread_setspecific() is supported])
|
|
fi
|
|
|
|
AC_MSG_RESULT($support_for_pthread_stubs_setspecific);
|
|
|
|
fi
|
|
|
|
if test $support_for_pthread_stubs_setspecific = no; then
|
|
|
|
AC_MSG_CHECKING(for pthread_setspecific)
|
|
|
|
save_LDFLAGS=$LDFLAGS
|
|
|
|
LDFLAGS="-pthread"
|
|
|
|
AC_LINK_IFELSE([
|
|
#include <pthread.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
|
|
static pthread_once_t once_control = PTHREAD_ONCE_INIT;
|
|
static pthread_key_t key;
|
|
|
|
static void
|
|
make_key (void)
|
|
{
|
|
pthread_key_create (&key, NULL);
|
|
}
|
|
|
|
int
|
|
main ()
|
|
{
|
|
void *value = NULL;
|
|
|
|
if (pthread_once (&once_control, make_key) != 0)
|
|
{
|
|
value = NULL;
|
|
}
|
|
else
|
|
{
|
|
value = pthread_getspecific (key);
|
|
if (!value)
|
|
{
|
|
value = malloc (100);
|
|
pthread_setspecific (key, value);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
])
|
|
fi
|
|
|
|
|
|
AC_SUBST(TOOLCHAIN_SUPPORTS__THREAD)
|
|
AC_SUBST(HAVE_PTHREAD_SETSPECIFIC)
|
|
AC_SUBST(PTHREAD_LDFLAGS)
|
|
AC_SUBST(PTHREAD_LIBS)
|
|
|
|
AC_OUTPUT([pixman-1.pc
|
|
pixman-1-uninstalled.pc
|
|
Makefile
|
|
pixman/Makefile
|
|
pixman/pixman-version.h
|
|
test/Makefile])
|