1151 lines
33 KiB
Plaintext
1151 lines
33 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], 34)
|
|
m4_define([pixman_micro], 0)
|
|
|
|
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])
|
|
|
|
AM_MAINTAINER_MODE
|
|
|
|
# Suppress verbose compile lines
|
|
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
|
|
|
|
AC_CONFIG_HEADERS(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
|
|
CFLAGS="$save_CFLAGS $CFLAGS"
|
|
LDFLAGS="$save_LDFLAGS $LDFLAGS"
|
|
LIBS="$save_LIBS $LIBS"
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([$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 "x$test_CFLAGS" = "x" && \
|
|
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([-Wdeclaration-after-statement])
|
|
PIXMAN_CHECK_CFLAG([-Wno-unused-local-typedefs])
|
|
PIXMAN_CHECK_CFLAG([-fno-strict-aliasing])
|
|
|
|
dnl =========================================================================
|
|
dnl OpenMP for the test suite?
|
|
dnl
|
|
|
|
# Check for OpenMP support only when autoconf support that (require autoconf >=2.62)
|
|
OPENMP_CFLAGS=
|
|
m4_ifdef([AC_OPENMP], [AC_OPENMP])
|
|
|
|
if test "x$enable_openmp" = "xyes" && test "x$ac_cv_prog_c_openmp" = "xunsupported" ; then
|
|
AC_MSG_WARN([OpenMP support requested but found unsupported])
|
|
fi
|
|
|
|
dnl May not fail to link without -Wall -Werror added
|
|
dnl So try to link only when openmp is supported
|
|
dnl ac_cv_prog_c_openmp is not defined when --disable-openmp is used
|
|
if test "x$ac_cv_prog_c_openmp" != "xunsupported" && test "x$ac_cv_prog_c_openmp" != "x"; then
|
|
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])
|
|
fi
|
|
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 Loongson Multimedia Instructions
|
|
|
|
if test "x$LS_CFLAGS" = "x" ; then
|
|
LS_CFLAGS="-march=loongson2f"
|
|
fi
|
|
|
|
have_loongson_mmi=no
|
|
AC_MSG_CHECKING(whether to use Loongson MMI assembler)
|
|
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS=" $LS_CFLAGS $CFLAGS -I$srcdir"
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[
|
|
#ifndef __mips_loongson_vector_rev
|
|
#error "Loongson Multimedia Instructions are only available on Loongson"
|
|
#endif
|
|
#if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4))
|
|
#error "Need GCC >= 4.4 for Loongson MMI compilation"
|
|
#endif
|
|
#include "pixman/loongson-mmintrin.h"
|
|
int main () {
|
|
union {
|
|
__m64 v;
|
|
char c[8];
|
|
} a = { .c = {1, 2, 3, 4, 5, 6, 7, 8} };
|
|
int b = 4;
|
|
__m64 c = _mm_srli_pi16 (a.v, b);
|
|
return 0;
|
|
}]])], have_loongson_mmi=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(loongson-mmi,
|
|
[AC_HELP_STRING([--disable-loongson-mmi],
|
|
[disable Loongson MMI fast paths])],
|
|
[enable_loongson_mmi=$enableval], [enable_loongson_mmi=auto])
|
|
|
|
if test $enable_loongson_mmi = no ; then
|
|
have_loongson_mmi=disabled
|
|
fi
|
|
|
|
if test $have_loongson_mmi = yes ; then
|
|
AC_DEFINE(USE_LOONGSON_MMI, 1, [use Loongson Multimedia Instructions])
|
|
else
|
|
LS_CFLAGS=
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_loongson_mmi)
|
|
if test $enable_loongson_mmi = yes && test $have_loongson_mmi = no ; then
|
|
AC_MSG_ERROR([Loongson MMI not detected])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_LOONGSON_MMI, test $have_loongson_mmi = yes)
|
|
|
|
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([AC_LANG_SOURCE([[
|
|
#if defined(__GNUC__) && (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4))
|
|
#error "Need GCC >= 3.4 for MMX intrinsics"
|
|
#endif
|
|
#include <mmintrin.h>
|
|
#include <stdint.h>
|
|
|
|
/* Check support for block expressions */
|
|
#define _mm_shuffle_pi16(A, N) \
|
|
({ \
|
|
__m64 ret; \
|
|
\
|
|
/* Some versions of clang will choke on K */ \
|
|
asm ("pshufw %2, %1, %0\n\t" \
|
|
: "=y" (ret) \
|
|
: "y" (A), "K" ((const int8_t)N) \
|
|
); \
|
|
\
|
|
ret; \
|
|
})
|
|
|
|
int main () {
|
|
__m64 v = _mm_cvtsi32_si64 (1);
|
|
__m64 w;
|
|
|
|
w = _mm_shuffle_pi16(v, 5);
|
|
|
|
/* Some versions of clang will choke on this */
|
|
asm ("pmulhuw %1, %0\n\t"
|
|
: "+y" (w)
|
|
: "y" (v)
|
|
);
|
|
|
|
return _mm_cvtsi64_si32 (v);
|
|
}]])], have_mmx_intrinsics=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(mmx,
|
|
[AC_HELP_STRING([--disable-mmx],
|
|
[disable x86 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_X86_MMX, 1, [use x86 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([x86 MMX intrinsics not detected])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_X86_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="-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([AC_LANG_SOURCE([[
|
|
#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 param;
|
|
int main () {
|
|
__m128i a = _mm_set1_epi32 (param), b = _mm_set1_epi32 (param + 1), c;
|
|
c = _mm_xor_si128 (a, b);
|
|
return _mm_cvtsi128_si32(c);
|
|
}]])], 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 Check for SSSE3
|
|
|
|
if test "x$SSSE3_CFLAGS" = "x" ; then
|
|
SSSE3_CFLAGS="-mssse3 -Winline"
|
|
fi
|
|
|
|
have_ssse3_intrinsics=no
|
|
AC_MSG_CHECKING(whether to use SSSE3 intrinsics)
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS="$SSSE3_CFLAGS $CFLAGS"
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
|
#include <mmintrin.h>
|
|
#include <xmmintrin.h>
|
|
#include <emmintrin.h>
|
|
#include <tmmintrin.h>
|
|
int param;
|
|
int main () {
|
|
__m128i a = _mm_set1_epi32 (param), b = _mm_set1_epi32 (param + 1), c;
|
|
c = _mm_maddubs_epi16 (a, b);
|
|
return _mm_cvtsi128_si32(c);
|
|
}]])], have_ssse3_intrinsics=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(ssse3,
|
|
[AC_HELP_STRING([--disable-ssse3],
|
|
[disable SSSE3 fast paths])],
|
|
[enable_ssse3=$enableval], [enable_ssse3=auto])
|
|
|
|
if test $enable_ssse3 = no ; then
|
|
have_ssse3_intrinsics=disabled
|
|
fi
|
|
|
|
if test $have_ssse3_intrinsics = yes ; then
|
|
AC_DEFINE(USE_SSSE3, 1, [use SSSE3 compiler intrinsics])
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_ssse3_intrinsics)
|
|
if test $enable_ssse3 = yes && test $have_ssse3_intrinsics = no ; then
|
|
AC_MSG_ERROR([SSSE3 intrinsics not detected])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_SSSE3, test $have_ssse3_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([AC_LANG_SOURCE([[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(LS_CFLAGS)
|
|
AC_SUBST(IWMMXT_CFLAGS)
|
|
AC_SUBST(MMX_CFLAGS)
|
|
AC_SUBST(MMX_LDFLAGS)
|
|
AC_SUBST(SSE2_CFLAGS)
|
|
AC_SUBST(SSE2_LDFLAGS)
|
|
AC_SUBST(SSSE3_CFLAGS)
|
|
|
|
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([AC_LANG_SOURCE([[
|
|
#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([AC_LANG_SOURCE([[
|
|
.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([AC_LANG_SOURCE([[
|
|
.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 IWMMXT
|
|
|
|
AC_ARG_ENABLE(arm-iwmmxt,
|
|
[AC_HELP_STRING([--disable-arm-iwmmxt],
|
|
[disable ARM IWMMXT fast paths])],
|
|
[enable_iwmmxt=$enableval], [enable_iwmmxt=auto])
|
|
|
|
AC_ARG_ENABLE(arm-iwmmxt2,
|
|
[AC_HELP_STRING([--disable-arm-iwmmxt2],
|
|
[build ARM IWMMXT fast paths with -march=iwmmxt instead of -march=iwmmxt2])],
|
|
[enable_iwmmxt2=$enableval], [enable_iwmmxt2=auto])
|
|
|
|
if test "x$IWMMXT_CFLAGS" = "x" ; then
|
|
IWMMXT_CFLAGS="-flax-vector-conversions -Winline -march=iwmmxt"
|
|
if test $enable_iwmmxt2 != no ; then
|
|
IWMMXT_CFLAGS="${IWMMXT_CFLAGS}2"
|
|
fi
|
|
fi
|
|
|
|
have_iwmmxt_intrinsics=no
|
|
AC_MSG_CHECKING(whether to use ARM IWMMXT intrinsics)
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS="$CFLAGS $IWMMXT_CFLAGS"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
|
#ifndef __arm__
|
|
#error "IWMMXT is only available on ARM"
|
|
#endif
|
|
#ifndef __IWMMXT__
|
|
#error "IWMMXT not enabled (with -march=iwmmxt)"
|
|
#endif
|
|
#if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
|
|
#error "Need GCC >= 4.8 for IWMMXT intrinsics"
|
|
#endif
|
|
#include <mmintrin.h>
|
|
int main () {
|
|
union {
|
|
__m64 v;
|
|
char c[8];
|
|
} a = { .c = {1, 2, 3, 4, 5, 6, 7, 8} };
|
|
int b = 4;
|
|
__m64 c = _mm_srli_si64 (a.v, b);
|
|
}]])], have_iwmmxt_intrinsics=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
if test $enable_iwmmxt = no ; then
|
|
have_iwmmxt_intrinsics=disabled
|
|
fi
|
|
|
|
if test $have_iwmmxt_intrinsics = yes ; then
|
|
AC_DEFINE(USE_ARM_IWMMXT, 1, [use ARM IWMMXT compiler intrinsics])
|
|
else
|
|
IWMMXT_CFLAGS=
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_iwmmxt_intrinsics)
|
|
if test $enable_iwmmxt = yes && test $have_iwmmxt_intrinsics = no ; then
|
|
AC_MSG_ERROR([IWMMXT intrinsics not detected])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_ARM_IWMMXT, test $have_iwmmxt_intrinsics = yes)
|
|
|
|
dnl ==========================================================================
|
|
dnl Check if assembler is gas compatible and supports MIPS DSPr2 instructions
|
|
|
|
have_mips_dspr2=no
|
|
AC_MSG_CHECKING(whether to use MIPS DSPr2 assembler)
|
|
xserver_save_CFLAGS=$CFLAGS
|
|
CFLAGS="-mdspr2 $CFLAGS"
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
|
#if !(defined(__mips__) && __mips_isa_rev >= 2)
|
|
#error MIPS DSPr2 is currently only available on MIPS32r2 platforms.
|
|
#endif
|
|
int
|
|
main ()
|
|
{
|
|
int c = 0, a = 0, b = 0;
|
|
__asm__ __volatile__ (
|
|
"precr.qb.ph %[c], %[a], %[b] \n\t"
|
|
: [c] "=r" (c)
|
|
: [a] "r" (a), [b] "r" (b)
|
|
);
|
|
return c;
|
|
}]])], have_mips_dspr2=yes)
|
|
CFLAGS=$xserver_save_CFLAGS
|
|
|
|
AC_ARG_ENABLE(mips-dspr2,
|
|
[AC_HELP_STRING([--disable-mips-dspr2],
|
|
[disable MIPS DSPr2 fast paths])],
|
|
[enable_mips_dspr2=$enableval], [enable_mips_dspr2=auto])
|
|
|
|
if test $enable_mips_dspr2 = no ; then
|
|
have_mips_dspr2=disabled
|
|
fi
|
|
|
|
if test $have_mips_dspr2 = yes ; then
|
|
AC_DEFINE(USE_MIPS_DSPR2, 1, [use MIPS DSPr2 assembly optimizations])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_MIPS_DSPR2, test $have_mips_dspr2 = yes)
|
|
|
|
AC_MSG_RESULT($have_mips_dspr2)
|
|
if test $enable_mips_dspr2 = yes && test $have_mips_dspr2 = no ; then
|
|
AC_MSG_ERROR([MIPS DSPr2 instructions 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([AC_LANG_SOURCE([[
|
|
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 Static test programs
|
|
|
|
AC_ARG_ENABLE(static-testprogs,
|
|
[AC_HELP_STRING([--enable-static-testprogs],
|
|
[build test programs as static binaries [default=no]])],
|
|
[enable_static_testprogs=$enableval], [enable_static_testprogs=no])
|
|
|
|
TESTPROGS_EXTRA_LDFLAGS=
|
|
if test "x$enable_static_testprogs" = "xyes" ; then
|
|
TESTPROGS_EXTRA_LDFLAGS="-all-static"
|
|
fi
|
|
AC_SUBST(TESTPROGS_EXTRA_LDFLAGS)
|
|
|
|
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 >= 2.16 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 >= 2.16 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)
|
|
|
|
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(mmap, have_mmap=yes, have_mmap=no)
|
|
if test x$have_mmap = xyes; then
|
|
AC_DEFINE(HAVE_MMAP, 1, [Whether we have mmap()])
|
|
fi
|
|
|
|
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_HEADER([fenv.h],
|
|
[AC_DEFINE(HAVE_FENV_H, [1], [Define to 1 if we have <fenv.h>])])
|
|
|
|
AC_CHECK_LIB(m, feenableexcept, have_feenableexcept=yes, have_feenableexcept=no)
|
|
if test x$have_feenableexcept = xyes; then
|
|
AC_DEFINE(HAVE_FEENABLEEXCEPT, 1, [Whether we have feenableexcept()])
|
|
fi
|
|
|
|
AC_CHECK_DECL([FE_DIVBYZERO],
|
|
[AC_DEFINE(HAVE_FEDIVBYZERO, 1, [Whether we have FE_DIVBYZERO])],
|
|
[],
|
|
[[#include <fenv.h>]])
|
|
|
|
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 Check for missing sqrtf() as, e.g., for Solaris 9
|
|
|
|
AC_SEARCH_LIBS([sqrtf], [m], [],
|
|
[AC_DEFINE([sqrtf], [sqrt],
|
|
[Define to sqrt if you do not have the `sqrtf' function.])])
|
|
|
|
dnl =====================================
|
|
dnl Thread local storage
|
|
|
|
AC_MSG_CHECKING(for thread local storage (TLS) support)
|
|
AC_CACHE_VAL(ac_cv_tls, [
|
|
ac_cv_tls=none
|
|
keywords="__thread __declspec(thread)"
|
|
for kw in $keywords ; do
|
|
AC_TRY_COMPILE([
|
|
#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
|
|
|
|
int $kw test;], [], [ac_cv_tls=$kw; break])
|
|
done
|
|
])
|
|
AC_MSG_RESULT($ac_cv_tls)
|
|
|
|
if test "$ac_cv_tls" != "none"; then
|
|
AC_DEFINE_UNQUOTED([TLS], $ac_cv_tls, [The compiler supported TLS storage class])
|
|
fi
|
|
|
|
dnl
|
|
dnl posix tls
|
|
dnl
|
|
|
|
m4_define([pthread_test_program],AC_LANG_SOURCE([[dnl
|
|
#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;
|
|
}
|
|
]]))
|
|
|
|
AC_DEFUN([PIXMAN_CHECK_PTHREAD],[dnl
|
|
if test "z$support_for_pthreads" != "zyes"; then
|
|
PIXMAN_LINK_WITH_ENV(
|
|
[$1], [pthread_test_program],
|
|
[PTHREAD_CFLAGS="$CFLAGS"
|
|
PTHREAD_LIBS="$LIBS"
|
|
PTHREAD_LDFLAGS="$LDFLAGS"
|
|
support_for_pthreads=yes])
|
|
fi
|
|
])
|
|
|
|
support_for_pthreads=no
|
|
|
|
AC_MSG_CHECKING(for pthreads)
|
|
|
|
PIXMAN_CHECK_PTHREAD([CFLAGS="-pthread"; LDFLAGS="-pthread"])
|
|
PIXMAN_CHECK_PTHREAD([CFLAGS="-D_REENTRANT"; LIBS="-lpthread"])
|
|
PIXMAN_CHECK_PTHREAD([CFLAGS="-D_REENTRANT"; LDFLAGS="-lroot"])
|
|
|
|
if test $support_for_pthreads = yes; then
|
|
AC_DEFINE([HAVE_PTHREADS], [], [Whether pthreads is supported])
|
|
if test $ac_cv_tls = none ; then
|
|
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_RESULT($support_for_pthreads)
|
|
|
|
AC_SUBST(TOOLCHAIN_SUPPORTS__THREAD)
|
|
AC_SUBST(HAVE_PTHREADS)
|
|
AC_SUBST(PTHREAD_LDFLAGS)
|
|
AC_SUBST(PTHREAD_LIBS)
|
|
AC_SUBST(PTHREAD_CFLAGS)
|
|
|
|
dnl =====================================
|
|
dnl __attribute__((constructor))
|
|
|
|
support_for_attribute_constructor=no
|
|
|
|
AC_MSG_CHECKING(for __attribute__((constructor)))
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[
|
|
#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7))
|
|
/* attribute 'constructor' is supported since gcc 2.7, but some compilers
|
|
* may only pretend to be gcc, so let's try to actually use it
|
|
*/
|
|
static int x = 1;
|
|
static void __attribute__((constructor)) constructor_function () { x = 0; }
|
|
int main (void) { return x; }
|
|
#else
|
|
#error not gcc or gcc version is older than 2.7
|
|
#endif
|
|
]])], support_for_attribute_constructor=yes)
|
|
|
|
if test x$support_for_attribute_constructor = xyes; then
|
|
AC_DEFINE([TOOLCHAIN_SUPPORTS_ATTRIBUTE_CONSTRUCTOR],
|
|
[],[Whether the tool chain supports __attribute__((constructor))])
|
|
fi
|
|
|
|
AC_MSG_RESULT($support_for_attribute_constructor)
|
|
AC_SUBST(TOOLCHAIN_SUPPORTS_ATTRIBUTE_CONSTRUCTOR)
|
|
|
|
dnl =====================================
|
|
dnl __float128
|
|
|
|
support_for_float128=no
|
|
|
|
AC_MSG_CHECKING(for __float128)
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[
|
|
__float128 a = 1.0Q, b = 2.0Q; int main (void) { return a + b; }
|
|
]])], support_for_float128=yes)
|
|
|
|
if test x$support_for_float128 = xyes; then
|
|
AC_DEFINE([HAVE_FLOAT128], [], [Whether the tool chain supports __float128])
|
|
fi
|
|
|
|
AC_MSG_RESULT($support_for_float128)
|
|
|
|
dnl =====================================
|
|
dnl __builtin_clz
|
|
|
|
support_for_builtin_clz=no
|
|
|
|
AC_MSG_CHECKING(for __builtin_clz)
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[
|
|
unsigned int x = 11; int main (void) { return __builtin_clz(x); }
|
|
]])], support_for_builtin_clz=yes)
|
|
|
|
if test x$support_for_builtin_clz = xyes; then
|
|
AC_DEFINE([HAVE_BUILTIN_CLZ], [], [Whether the compiler supports __builtin_clz])
|
|
fi
|
|
|
|
AC_MSG_RESULT($support_for_builtin_clz)
|
|
|
|
dnl =====================================
|
|
dnl GCC vector extensions
|
|
|
|
support_for_gcc_vector_extensions=no
|
|
|
|
AC_MSG_CHECKING(for GCC vector extensions)
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[
|
|
unsigned int __attribute__ ((vector_size(16))) e, a, b;
|
|
int main (void) { e = a - ((b << 27) + (b >> (32 - 27))) + 1; return e[0]; }
|
|
]])], support_for_gcc_vector_extensions=yes)
|
|
|
|
if test x$support_for_gcc_vector_extensions = xyes; then
|
|
AC_DEFINE([HAVE_GCC_VECTOR_EXTENSIONS], [],
|
|
[Whether the compiler supports GCC vector extensions])
|
|
fi
|
|
|
|
AC_MSG_RESULT($support_for_gcc_vector_extensions)
|
|
|
|
dnl ==================
|
|
dnl libpng
|
|
|
|
AC_ARG_ENABLE(libpng, AS_HELP_STRING([--enable-libpng], [Build support for libpng (default: auto)]),
|
|
[have_libpng=$enableval], [have_libpng=auto])
|
|
|
|
case x$have_libpng in
|
|
xyes) PKG_CHECK_MODULES(PNG, [libpng]) ;;
|
|
xno) ;;
|
|
*) PKG_CHECK_MODULES(PNG, [libpng], have_libpng=yes, have_libpng=no) ;;
|
|
esac
|
|
|
|
if test x$have_libpng = xyes; then
|
|
AC_DEFINE([HAVE_LIBPNG], [1], [Whether we have libpng])
|
|
fi
|
|
|
|
AC_SUBST(HAVE_LIBPNG)
|
|
|
|
AC_OUTPUT([pixman-1.pc
|
|
pixman-1-uninstalled.pc
|
|
Makefile
|
|
pixman/Makefile
|
|
pixman/pixman-version.h
|
|
demos/Makefile
|
|
test/Makefile])
|
|
|
|
m4_if(m4_eval(pixman_minor % 2), [1], [
|
|
echo
|
|
echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
|
|
echo
|
|
echo " Thanks for testing this development snapshot of pixman. Please"
|
|
echo " report any problems you find, either by sending email to "
|
|
echo
|
|
echo " pixman@lists.freedesktop.org"
|
|
echo
|
|
echo " or by filing a bug at "
|
|
echo
|
|
echo " https://bugs.freedesktop.org/enter_bug.cgi?product=pixman "
|
|
echo
|
|
echo " If you are looking for a stable release of pixman, please note "
|
|
echo " that stable releases have _even_ minor version numbers. Ie., "
|
|
echo " pixman-0.]m4_eval(pixman_minor & ~1)[.x are stable releases, whereas pixman-$PIXMAN_VERSION_MAJOR.$PIXMAN_VERSION_MINOR.$PIXMAN_VERSION_MICRO is a "
|
|
echo " development snapshot that may contain bugs and experimental "
|
|
echo " features. "
|
|
echo
|
|
echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
|
|
echo
|
|
])
|