summaryrefslogtreecommitdiff
path: root/neozip/configure
diff options
context:
space:
mode:
Diffstat (limited to 'neozip/configure')
-rwxr-xr-xneozip/configure2667
1 files changed, 2667 insertions, 0 deletions
diff --git a/neozip/configure b/neozip/configure
new file mode 100755
index 0000000000..cfa8947bd2
--- /dev/null
+++ b/neozip/configure
@@ -0,0 +1,2667 @@
+#!/bin/sh
+# configure script for zlib.
+#
+# Normally configure builds both a static and a shared library.
+# If you want to build just a static library, use: ./configure --static
+#
+# To impose specific compiler or flags or install directory, use for example:
+# prefix=$HOME CC=cc CFLAGS="-O4" ./configure
+# or for csh/tcsh users:
+# (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure)
+
+# Incorrect settings of CC or CFLAGS may prevent creating a shared library.
+# If you have problems, try without defining CC and CFLAGS before reporting
+# an error.
+
+# start off configure.log
+echo -------------------- >> configure.log
+echo $0 $* >> configure.log
+date >> configure.log
+
+SRCDIR=$(cd $(dirname $0); pwd)
+BUILDDIR=$(pwd)
+
+# set command prefix for cross-compilation
+if [ -n "${CHOST}" ]; then
+ # normalize the chost before parsing it
+ NORM_CHOST=$(sh "$SRCDIR"/tools/config.sub $CHOST)
+ uname="$(echo "${NORM_CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/')"
+ CROSS_PREFIX="${CHOST}-"
+ ARCH="$(echo "${NORM_CHOST}" | sed -e 's/-.*//')"
+else
+ # BSD systems use uname -p for architecture names vs port names
+ case "$(uname -s)" in
+ *BSD | *bsd* | DragonFly)
+ ARCH="$(uname -p)" ;;
+ *)
+ ARCH="$(uname -m)" ;;
+ esac
+fi
+
+case "${ARCH}" in
+ amd64 | x86_64)
+ case "${CFLAGS}" in
+ *-m32*)
+ ARCH=i686
+ ;;
+ esac
+ ;;
+ i386 | i486 | i586 | i686)
+ case "${CFLAGS}" in
+ *-m64*)
+ ARCH=x86_64
+ ;;
+ esac
+ ;;
+esac
+
+# destination name for windows import library
+IMPORTLIB=
+
+# establish commands for library building
+if "${CROSS_PREFIX}ar" --version >/dev/null 2>/dev/null || test $? -lt 126; then
+ AR=${AR-"${CROSS_PREFIX}ar"}
+ test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
+else
+ AR=${AR-"ar"}
+ test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
+fi
+ARFLAGS=${ARFLAGS-"rc"}
+if "${CROSS_PREFIX}ranlib" --version >/dev/null 2>/dev/null || test $? -lt 126; then
+ RANLIB=${RANLIB-"${CROSS_PREFIX}ranlib"}
+ test -n "${CROSS_PREFIX}" && echo Using ${RANLIB} | tee -a configure.log
+else
+ RANLIB=${RANLIB-"ranlib"}
+fi
+
+# set defaults before processing command line options
+LDCONFIG=${LDCONFIG-"ldconfig"}
+DEFFILE=
+RC=
+RCFLAGS=
+RCOBJS=
+STRIP=
+ARCHS=
+PC_CFLAGS=
+prefix=${prefix-/usr/local}
+exec_prefix=${exec_prefix-'${prefix}'}
+bindir=${bindir-'${exec_prefix}/bin'}
+libdir=${libdir-'${exec_prefix}/lib'}
+sharedlibdir=${sharedlibdir-'${libdir}'}
+includedir=${includedir-'${prefix}/include'}
+installnamedir=${installnamedir-'@rpath'}
+mandir=${mandir-'${prefix}/share/man'}
+shared_ext='.so'
+shared=1
+gzfileops=1
+compat=0
+cover=0
+build32=0
+build64=0
+buildvpclmulqdq=1
+buildarmv8=1
+buildarmv6=1
+buildaltivec=1
+buildpower8=1
+buildpower9=1
+buildneon=1
+buildrvv=1
+buildzbc=1
+builddfltccdeflate=0
+builddfltccinflate=0
+buildcrc32vx=1
+buildcrc32la=1
+floatabi=
+# For CPUs that can benefit from AVX512, it seems GCC generates suboptimal
+# instruction scheduling unless you specify a reasonable -mtune= target
+avx512flag="-mavx512f -mavx512dq -mavx512bw -mavx512vl -mbmi2"
+avx512vnniflag="${avx512flag} -mavx512vnni"
+avx2flag="-mavx2 -mbmi2"
+sse2flag="-msse2"
+ssse3flag="-mssse3"
+sse41flag="-msse4.1"
+sse42flag="-msse4.2"
+pclmulflag="-mpclmul"
+vpclmulflag="-mvpclmulqdq"
+xsaveflag="-mxsave"
+lsxflag="-mlsx"
+lasxflag="-mlasx"
+armv8flag=
+pmulleor3flag=
+neonflag=
+rvvflag=
+rvvzbcflag=
+zbcflag=
+# We need to set defaults so we can test if either RVV or ZBC or both are disabled
+HAVE_RVV_INTRIN=0
+HAVE_ZBC_EXT=0
+armv6flag=
+# Set default for noltoflag based on compiler being gcc compatible or not
+noltoflag=
+vgfmaflag="-march=z13"
+vmxflag="-maltivec"
+symbol_prefix=""
+without_optimizations=0
+without_new_strategies=0
+reducedmem=0
+gcc=0
+nvc=0
+warn=0
+debug=0
+visibility=1
+old_cc="$CC"
+old_cflags="$CFLAGS"
+OBJC='$(OBJZ)'
+PIC_OBJC='$(PIC_OBJZ)'
+INSTALLTARGETS="install-shared install-static"
+UNINSTALLTARGETS="uninstall-shared uninstall-static"
+
+TEST="teststatic"
+
+# leave this script, optionally in a bad way
+leave()
+{
+ if test "$*" != "0"; then
+ echo "** $0 aborting." | tee -a configure.log
+ fi
+ rm -f $test.[co] $test $test$shared_ext $test.gcno ./--version
+ echo -------------------- >> configure.log
+ echo >> configure.log
+ echo >> configure.log
+ exit $1
+}
+
+# process command line options
+while test $# -ge 1
+do
+case "$1" in
+ -h* | --help)
+ echo 'usage:' | tee -a configure.log
+ echo ' configure [--prefix=PREFIX] [--eprefix=EXPREFIX]' | tee -a configure.log
+ echo ' [--static] [--32] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log
+ echo ' [--includedir=INCLUDEDIR] [--installnamedir="@rpath"] [--mandir=MANDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log
+ echo ' [--sprefix=SYMBOL_PREFIX] Adds a prefix to all exported symbols' | tee -a configure.log
+ echo ' [--warn] Enables extra compiler warnings' | tee -a configure.log
+ echo ' [--debug] Enables extra debug prints during operation' | tee -a configure.log
+ echo ' [--zlib-compat] Compiles for zlib-compatible API instead of zlib-ng API' | tee -a configure.log
+ echo ' [--without-gzfileops] Compiles without the gzfile parts of the API enabled' | tee -a configure.log
+ echo ' [--without-optimizations] Compiles without support for optional instruction sets' | tee -a configure.log
+ echo ' [--without-new-strategies] Compiles without using new additional deflate strategies' | tee -a configure.log
+ echo ' [--without-vpclmulqdq] Compiles without x86 VPCLMUL instruction set' | tee -a configure.log
+ echo ' [--without-armv6] Compiles without ARMv6 SIMD instruction set' | tee -a configure.log
+ echo ' [--without-armv8] Compiles without ARMv8 CRC32 instruction set' | tee -a configure.log
+ echo ' [--without-neon] Compiles without ARM Neon SIMD instruction set' | tee -a configure.log
+ echo ' [--without-rvv] Compiles without RISC-V RVV instruction set' | tee -a configure.log
+ echo ' [--without-zbc] Compiles without RISC-V ZBC instruction set' | tee -a configure.log
+ echo ' [--without-altivec] Compiles without PPC AltiVec support' | tee -a configure.log
+ echo ' [--without-power8] Compiles without Power8 instruction set' | tee -a configure.log
+ echo ' [--without-power9] Compiles without Power9 instruction set' | tee -a configure.log
+ echo ' [--with-dfltcc-deflate] Use DEFLATE CONVERSION CALL instruction for compression on IBM Z' | tee -a configure.log
+ echo ' [--with-dfltcc-inflate] Use DEFLATE CONVERSION CALL instruction for decompression on IBM Z' | tee -a configure.log
+ echo ' [--without-crc32-vx] Build without vectorized CRC32 on IBM Z' | tee -a configure.log
+ echo ' [--without-crc32-la] Build without vectorized CRC32 on Loongarch' | tee -a configure.log
+ echo ' [--with-reduced-mem] Reduced memory usage for special cases (reduces performance)' | tee -a configure.log
+ exit 0 ;;
+ -p*=* | --prefix=*) prefix=$(echo $1 | sed 's/.*=//'); shift ;;
+ -e*=* | --eprefix=*) exec_prefix=$(echo $1 | sed 's/.*=//'); shift ;;
+ -m*=* | --sprefix=*) symbol_prefix=$(echo $1 | sed 's/.*=//'); shift ;;
+ -l*=* | --libdir=*) libdir=$(echo $1 | sed 's/.*=//'); shift ;;
+ --sharedlibdir=*) sharedlibdir=$(echo $1 | sed 's/.*=//'); shift ;;
+ -i*=* | --includedir=*) includedir=$(echo $1 | sed 's/.*=//');shift ;;
+ --installnamedir=*) installnamedir=$(echo $1 | sed 's/.*=//'); shift ;;
+ --mandir=*) mandir=$(echo $1 | sed 's/.*=//');shift ;;
+ -u*=* | --uname=*) uname=$(echo $1 | sed 's/.*=//');shift ;;
+ -p* | --prefix) prefix="$2"; shift; shift ;;
+ -e* | --eprefix) exec_prefix="$2"; shift; shift ;;
+ -m* | --sprefix) symbol_prefix="$2"; shift; shift ;;
+ -l* | --libdir) libdir="$2"; shift; shift ;;
+ -i* | --includedir) includedir="$2"; shift; shift ;;
+ -s* | --shared | --enable-shared) shared=1; shift ;;
+ -t | --static) shared=0; shift ;;
+ --zlib-compat) compat=1; shift ;;
+ --without-gzfileops) gzfileops=0; shift ;;
+ --cover) cover=1; shift ;;
+ -3* | --32) build32=1; shift ;;
+ -6* | --64) build64=1; shift ;;
+ --without-vpclmulqdq) buildvpclmulqdq=0; shift ;;
+ --without-armv8) buildarmv8=0; shift ;;
+ # Provided for backward compatibility
+ --without-acle) buildarmv8=0; shift ;;
+ --without-neon) buildneon=0; shift ;;
+ --without-armv6) buildarmv6=0; shift ;;
+ --without-altivec) buildaltivec=0 ; shift ;;
+ --without-rvv) buildrvv=0 ; shift ;;
+ --without-zbc) buildzbc=0 ; shift ;;
+ --without-power8) buildpower8=0 ; shift ;;
+ --without-power9) buildpower9=0 ; shift ;;
+ --with-dfltcc-deflate) builddfltccdeflate=1; shift ;;
+ --with-dfltcc-inflate) builddfltccinflate=1; shift ;;
+ --without-crc32-vx) buildcrc32vx=0; shift ;;
+ --without-crc32-la) buildcrc32la=0; shift ;;
+ --with-reduced-mem) reducedmem=1; shift ;;
+ -a*=* | --archs=*) ARCHS=$(echo $1 | sed 's/.*=//'); shift ;;
+ --sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;;
+ --localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;;
+ -noopt | --without-optimizations) without_optimizations=1; shift;;
+ -oldstrat | --without-new-strategies) without_new_strategies=1; shift;;
+ -w* | --warn) warn=1; shift ;;
+ -d* | --debug) debug=1; shift ;;
+
+ *)
+ echo "unknown option: $1" | tee -a configure.log
+ echo "$0 --help for help" | tee -a configure.log
+ leave 1;;
+ esac
+done
+
+# temporary file name
+test=ztest$$
+
+# put arguments in log, also put test file in log if used in arguments
+show()
+{
+ case "$@" in
+ *$test.c*)
+ echo "=== $test.c ===" >> configure.log
+ cat $test.c >> configure.log
+ echo "===" >> configure.log;;
+ esac
+ echo "$@" >> configure.log
+}
+
+# check for gcc vs. cc and set compile and link flags based on the system identified by uname
+cat > $test.c <<EOF
+extern int getchar();
+int main() {return getchar();}
+EOF
+
+cc=
+if [ -n "$CC" ]; then
+ # if CC contains spaces, check that individual commands exist
+ for c in $CC; do
+ cc1=$(command -v "$c" 2> /dev/null)
+ printf "Checking for $c... " | tee -a configure.log
+ if test -z "${cc1}" -o ! -f "${cc1}"; then
+ echo no | tee -a configure.log
+ leave 1
+ else
+ echo ${cc1} | tee -a configure.log
+ fi
+ if [ -z "$cc" ]; then
+ cc="${cc1}"
+ else
+ cc="${cc} ${cc1}"
+ fi
+ done
+ CC=$cc
+else
+ cc=$(command -v ${CROSS_PREFIX}gcc 2> /dev/null)
+ if test -z "$cc" -o ! -f "$cc"; then
+ cc=$(command -v ${CROSS_PREFIX}cc 2> /dev/null)
+ fi
+ if test -z "$cc" -o ! -f "$cc"; then
+ echo "Couldn't find any usable compiler, please set CC environment variable" | tee -a configure.log
+ leave 1
+ fi
+fi
+
+printf "Checking for compiler... " | tee -a configure.log
+case "$cc" in
+ *gcc*) gcc=1 ;;
+ *clang*) gcc=1 ;;
+ *nvc) gcc=1
+ nvc=1 ;;
+esac
+# nvc requires input file for -v and prints warning, use --version instead as it's supported by all
+case $($cc --version 2>&1) in
+ *gcc*) gcc=1 ;;
+ *clang*) gcc=1 ;;
+ *nvc\ *) gcc=1
+ nvc=1 ;;
+esac
+
+if test $build32 -eq 1; then
+ CFLAGS="${CFLAGS} -m32"
+ SFLAGS="${SFLAGS} -m32"
+ LDFLAGS="${LDFLAGS} -m32"
+fi
+if test $build64 -eq 1; then
+ CFLAGS="${CFLAGS} -m64"
+ SFLAGS="${SFLAGS} -m64"
+ LDFLAGS="${LDFLAGS} -m64"
+fi
+
+# Set library name depending on zlib-compat option
+if test $compat -eq 0; then
+ LIBNAME=libz-ng
+ LIBNAME2=zlib-ng
+ SUFFIX=-ng
+else
+ LIBNAME=libz
+ LIBNAME2=zlib
+ SUFFIX=""
+fi
+
+STATICLIB=${LIBNAME}.a
+MAPNAME=${LIBNAME2}.map
+
+# extract zlib version numbers from zlib.h
+if test $compat -eq 0; then
+ VER=$(sed -n -e '/ZLIBNG_VERSION "/s/.*"\(.*\)".*/\1/p' < ${SRCDIR}/zlib-ng.h.in)
+ VER3=$(sed -n -e '/ZLIBNG_VERSION "/s/.*"\([0-9]*\.[0-9]*\.[0-9]*\).*/\1/p' < ${SRCDIR}/zlib-ng.h.in)
+ VER2=$(sed -n -e '/ZLIBNG_VERSION "/s/.*"\([0-9]*\.[0-9]*\)\..*/\1/p' < ${SRCDIR}/zlib-ng.h.in)
+ VER1=$(sed -n -e '/ZLIBNG_VERSION "/s/.*"\([0-9]*\)\..*/\1/p' < ${SRCDIR}/zlib-ng.h.in)
+else
+ VER=$(sed -n -e '/ZLIB_VERSION "/s/.*"\(.*\)".*/\1/p' < ${SRCDIR}/zlib.h.in)
+ VER3=$(sed -n -e '/ZLIB_VERSION "/s/.*"\([0-9]*\.[0-9]*\.[0-9]*\).*/\1/p' < ${SRCDIR}/zlib.h.in)
+ VER2=$(sed -n -e '/ZLIB_VERSION "/s/.*"\([0-9]*\.[0-9]*\)\..*/\1/p' < ${SRCDIR}/zlib.h.in)
+ VER1=$(sed -n -e '/ZLIB_VERSION "/s/.*"\([0-9]*\)\..*/\1/p' < ${SRCDIR}/zlib.h.in)
+fi
+
+show $cc -c $test.c
+if test "$gcc" -eq 1 && ($cc $CFLAGS -c $test.c) >> configure.log 2>&1; then
+ echo "$cc" | tee -a configure.log
+ CC="$cc"
+ if test "${CFLAGS#*"-std="}" = "$CFLAGS" ; then
+ CFLAGS="${CFLAGS} -std=c11"
+ fi
+
+ # Re-check ARCH if the compiler is a cross-compiler.
+ if $CC -print-multiarch 1> /dev/null 2>&1 && test -n "$($CC -print-multiarch)" 1> /dev/null 2>&1; then
+ CC_ARCH=$($CC $CFLAGS -print-multiarch | sed 's/-.*//g')
+ elif test $nvc -eq 1; then
+ # Not a cross-compiler
+ CC_ARCH=$ARCH
+ else
+ CC_ARCH=$($CC $CFLAGS -dumpmachine | sed 's/-.*//g')
+ fi
+ case $CC_ARCH in
+ i386 | i486 | i586 | i686)
+ # Honor user choice if gcc is multilib and 64-bit is requested
+ if test $build64 -eq 1; then
+ ARCH=x86_64
+ ARCH_64BIT=1
+ else
+ ARCH=$CC_ARCH
+ ARCH_32BIT=1
+ fi ;;
+ amd64 | x86_64)
+ # Honor user choice if gcc is multilib and 32-bit is requested
+ if test $build32 -ne 1; then
+ ARCH=$CC_ARCH
+ ARCH_64BIT=1
+ else
+ ARCH=i686
+ ARCH_32BIT=1
+ fi ;;
+ arm | armeb)
+ ARCH=arm
+ ARCH_32BIT=1
+ if test "${uname}" = "eabi"; then
+ uname=arm
+ fi ;;
+ armv8l)
+ ARCH=armv8-a
+ ARCH_32BIT=1 ;;
+ aarch64 | aarch64_be | arm64)
+ if test "${uname}" = "elf"; then
+ uname=aarch64
+ fi
+ ARCH=aarch64
+ ARCH_64BIT=1 ;;
+ mips | mipsel)
+ ARCH=mips
+ ARCH_32BIT=1 ;;
+ mips64 | mips64el)
+ ARCH=mips64
+ ARCH_64BIT=1 ;;
+ powerpc | ppc)
+ ARCH=powerpc
+ ARCH_32BIT=1 ;;
+ powerpc64 | ppc64)
+ ARCH=powerpc64
+ ARCH_64BIT=1 ;;
+ powerpc64le | ppc64le)
+ ARCH=powerpc64le
+ ARCH_64BIT=1 ;;
+ riscv64)
+ ARCH=riscv64
+ ARCH_64BIT=1 ;;
+ s390x)
+ ARCH=s390x
+ ARCH_64BIT=1 ;;
+ loongarch64)
+ ARCH=loongarch64
+ ARCH_64BIT=1 ;;
+ esac
+ CFLAGS="-O2 ${CFLAGS}"
+ if test -n "${ARCHS}"; then
+ CFLAGS="${CFLAGS} ${ARCHS}"
+ LDFLAGS="${LDFLAGS} ${ARCHS}"
+ fi
+ CFLAGS="${CFLAGS} -Wall"
+ SFLAGS="${CFLAGS} -fPIC"
+ if test "$warn" -eq 1; then
+ CFLAGS="${CFLAGS} -Wextra"
+ fi
+ if test $debug -eq 1; then
+ CFLAGS="${CFLAGS} -DZLIB_DEBUG"
+ SFLAGS="${SFLAGS} -DZLIB_DEBUG"
+ else
+ CFLAGS="${CFLAGS} -DNDEBUG"
+ SFLAGS="${SFLAGS} -DNDEBUG"
+ fi
+ if test -z "$uname"; then
+ uname=$( (uname -s || echo unknown) 2>/dev/null)
+ fi
+ case "$uname" in
+ Linux* | linux* | GNU | GNU/* | solaris* | Haiku)
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.${VER1}" ;;
+ *BSD | *bsd* | DragonFly)
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.${VER1}"
+ LDCONFIG="ldconfig -m" ;;
+ CYGWIN* | Cygwin* | cygwin*)
+ visibility=0
+ ARFLAGS="rcs"
+ SFLAGS="${CFLAGS}"
+ shared_ext='.dll'
+ sharedlibdir='${bindir}'
+ if test $compat -eq 0; then
+ SHAREDLIB=cygz-ng$shared_ext
+ else
+ SHAREDLIB=cygz$shared_ext
+ fi
+ SHAREDLIBM=''
+ SHAREDLIBV=''
+ SHAREDTARGET=$SHAREDLIB
+ IMPORTLIB="${LIBNAME}.dll.a"
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared -Wl,--out-implib,${IMPORTLIB}"
+ LDSHAREDLIBC=""
+ if test $gzfileops -eq 0; then
+ DEFFILE='win32/${LIBNAME2}.def'
+ fi
+ RC="${CROSS_PREFIX}windres"
+ RCFLAGS="-I ${BUILDDIR}"
+ RCOBJS='zlibrc.o'
+ STRIP="${CROSS_PREFIX}strip"
+ EXE='.exe' ;;
+ MSYS* | msys*)
+ visibility=0
+ ARFLAGS="rcs"
+ SFLAGS="${CFLAGS}"
+ shared_ext='.dll'
+ sharedlibdir='${bindir}'
+ if test $compat -eq 0; then
+ SHAREDLIB=msys-z-ng$shared_ext
+ else
+ SHAREDLIB=msys-z$shared_ext
+ fi
+ SHAREDLIBM=''
+ SHAREDLIBV=''
+ SHAREDTARGET=$SHAREDLIB
+ IMPORTLIB="${LIBNAME}.dll.a"
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared -Wl,--out-implib,${IMPORTLIB}"
+ LDSHAREDLIBC=""
+ if test $gzfileops -eq 0; then
+ DEFFILE='win32/${LIBNAME2}.def'
+ fi
+ RC="${CROSS_PREFIX}windres"
+ RCFLAGS="-I ${BUILDDIR}"
+ RCOBJS='zlibrc.o'
+ STRIP="${CROSS_PREFIX}strip"
+ EXE='.exe' ;;
+ MINGW* | mingw*)
+ visibility=0
+ ARFLAGS="rcs"
+ CFLAGS="${CFLAGS} -D_POSIX_C_SOURCE=200809L -D_GNU_SOURCE=1 -Wno-pedantic-ms-format"
+ SFLAGS="${CFLAGS}"
+ shared_ext='.dll'
+ sharedlibdir='${bindir}'
+ SHAREDLIB=${LIBNAME}-$VER1$shared_ext
+ SHAREDLIBM=''
+ SHAREDLIBV=''
+ SHAREDTARGET=$SHAREDLIB
+ IMPORTLIB="${LIBNAME}.dll.a"
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared -Wl,--out-implib=${IMPORTLIB}"
+ LDSHAREDLIBC=""
+ if test $gzfileops -eq 0; then
+ DEFFILE='win32/${LIBNAME2}.def'
+ fi
+ RC="${CROSS_PREFIX}windres"
+ RCFLAGS="-I ${BUILDDIR}"
+ if [ "$CC" = "mingw32-gcc" ]; then
+ case $ARCH in
+ i386 | i486 | i586 | i686) RCFLAGS="${RCFLAGS} -F pe-i386";;
+ esac;
+ fi
+ RCOBJS='zlibrc.o'
+ STRIP="${CROSS_PREFIX}strip"
+ EXE='.exe' ;;
+ QNX*) # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
+ # (alain.bonnefoy@icbt.com)
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared -Wl,-h${LIBNAME}.so.${VER1}" ;;
+ HP-UX*)
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared"
+ case $( (uname -m || echo unknown) 2>/dev/null) in
+ ia64)
+ shared_ext='.so'
+ SHAREDLIB='${LIBNAME}.so' ;;
+ *)
+ shared_ext='.sl'
+ SHAREDLIB='${LIBNAME}.sl' ;;
+ esac ;;
+ Darwin* | darwin*)
+ shared_ext='.dylib'
+ SHAREDLIB=${LIBNAME}$shared_ext
+ SHAREDLIBV=${LIBNAME}.$VER$shared_ext
+ SHAREDLIBM=${LIBNAME}.$VER1$shared_ext
+ SHAREDTARGET=$SHAREDLIBV
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-dynamiclib -install_name ${installnamedir}/${SHAREDLIBM} -compatibility_version ${VER1} -current_version ${VER3}"
+ if "${CROSS_PREFIX}libtool" -V 2>&1 | grep Apple > /dev/null; then
+ AR="${CROSS_PREFIX}libtool"
+ elif libtool -V 2>&1 | grep Apple > /dev/null; then
+ AR="libtool"
+ else
+ AR="/usr/bin/libtool"
+ fi
+ ARFLAGS="-o" ;;
+ aarch64)
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.${VER1}"
+ LDSHAREDLIBC="-Wl,--start-group -lc -lrdimon -Wl,--end-group" ;;
+ *)
+ LDSHARED=${LDSHARED-"$cc"}
+ LDSHAREDFLAGS="-shared" ;;
+ esac
+else
+ # find system name and corresponding cc options
+ CC=${CC-cc}
+ gcc=0
+ echo "$CC" | tee -a configure.log
+ if test -z "$uname"; then
+ uname=$( (uname -sr || echo unknown) 2>/dev/null)
+ fi
+ case "$uname" in
+ HP-UX*) SFLAGS=${CFLAGS-"-O +z"}
+ CFLAGS=${CFLAGS-"-O"}
+ LDSHARED=${LDSHARED-"ld"}
+ LDSHAREDFLAGS="-b"
+ case $( (uname -m || echo unknown) 2>/dev/null) in
+ ia64)
+ shared_ext='.so'
+ SHAREDLIB='${LIBNAME}.so' ;;
+ *)
+ shared_ext='.sl'
+ SHAREDLIB='${LIBNAME}.sl' ;;
+ esac ;;
+ AIX*) # Courtesy of dbakker@arrayasolutions.com
+ SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
+ CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
+ LDSHARED=${LDSHARED-"xlc"}
+ LDSHAREDFLAGS="-G" ;;
+ # send working options for other systems to zlib@gzip.org
+ *) SFLAGS=${CFLAGS-"-O"}
+ CFLAGS=${CFLAGS-"-O"}
+ LDSHARED=${LDSHARED-"cc"}
+ LDSHAREDFLAGS="-shared" ;;
+ esac
+fi
+
+# Symbol versioning
+case "$uname" in
+ CYGWIN* | Cygwin* | cygwin* | MINGW* | mingw* | MSYS* | msys* | Darwin* | darwin*)
+ echo "Checking for Symbol versioning... No."
+ ;;
+ *)
+ if test $shared -eq 1; then
+ echo "Checking for Symbol versioning... Yes."
+ CFLAGS="${CFLAGS} -DHAVE_SYMVER"
+ SFLAGS="${SFLAGS} -DHAVE_SYMVER"
+ else
+ echo "Checking for Symbol versioning... No."
+ fi
+ ;;
+esac
+
+# Simplify some later conditionals
+LINUX=0
+FREEBSD=0
+OPENBSD=0
+
+case "$uname" in
+Linux* | linux*)
+ LINUX=1 ;;
+FreeBSD*)
+ FREEBSD=1 ;;
+OpenBSD*)
+ OPENBSD=1 ;;
+esac
+
+# destination names for shared library if not defined above
+SHAREDLIB=${SHAREDLIB-"${LIBNAME}$shared_ext"}
+SHAREDLIBV=${SHAREDLIBV-"${LIBNAME}$shared_ext.$VER"}
+SHAREDLIBM=${SHAREDLIBM-"${LIBNAME}$shared_ext.$VER1"}
+SHAREDTARGET=${SHAREDTARGET-"${LIBNAME}$shared_ext.$VER"}
+
+echo >> configure.log
+
+# define functions for testing compiler and library characteristics and logging the results
+
+cat > $test.c <<EOF
+#error error
+EOF
+if ($CC -c $CFLAGS $test.c) 2>/dev/null; then
+ try()
+ {
+ show "$@"
+ test "$( ("$@") 2>&1 | tee -a configure.log)" = ""
+ }
+ echo - using any output from compiler to indicate an error >> configure.log
+else
+ try()
+ {
+ show "$@"
+ ( "$@" ) >> configure.log 2>&1
+ ret=$?
+ if test $ret -ne 0; then
+ echo "(exit code $ret)" >> configure.log
+ fi
+ return $ret
+ }
+fi
+
+cat > $test.c << EOF
+int foo() { return 0; }
+EOF
+echo "Checking for obsessive-compulsive compiler options..." >> configure.log
+if try $CC -c $CFLAGS $test.c; then
+ :
+else
+ echo "Compiler error reporting is too harsh for $0 (perhaps remove -Werror)." | tee -a configure.log
+ leave 1
+fi
+
+echo >> configure.log
+
+# see if shared library build supported
+cat > $test.c <<EOF
+extern int getchar();
+int hello() {return getchar();}
+EOF
+if test $shared -eq 1; then
+ printf "Checking for shared library support... " | tee -a configure.log
+ # we must test in two steps (cc then ld), required at least on SunOS 4.x
+ if try $CC -c $SFLAGS $test.c &&
+ try $LDSHARED $LDSHAREDFLAGS $LDFLAGS -o $test$shared_ext $test.o $LDSHAREDLIBC; then
+ echo "Building shared library $SHAREDTARGET with $CC." | tee -a configure.log
+ elif test -z "$old_cc" -a -z "$old_cflags"; then
+ echo "No shared library support." | tee -a configure.log
+ shared=0;
+ else
+ echo 'No shared library support; try without defining CC and CFLAGS' | tee -a configure.log
+ shared=0;
+ fi
+fi
+if test $shared -eq 0; then
+ LDSHARED="$CC"
+ LDSHAREDFLAGS=""
+ ALL="static"
+ SHAREDLIB=""
+ SHAREDLIBV=""
+ SHAREDLIBM=""
+ SHAREDTARGET=""
+ INSTALLTARGETS=install-static
+ UNINSTALLTARGETS=uninstall-static
+ echo Building static library $STATICLIB version $VER with $CC. | tee -a configure.log
+else
+ ALL="static shared"
+ TEST="${TEST} testshared"
+fi
+
+echo >> configure.log
+
+ADDITIONAL_CHECK_FLAGS=""
+
+# Check for -Werror=unguarded-availability compiler support
+echo "" > test.c
+ cat > $test.c <<EOF
+int main() { return 0; }
+EOF
+if $cc $CFLAGS -Werror=unguarded-availability -c $test.c >> configure.log 2>&1; then
+ echo "Checking for -Werror=unguarded-availability... Yes." | tee -a configure.log
+ ADDITIONAL_CHECK_FLAGS="$ADDITIONAL_CHECK_FLAGS -Werror=unguarded-availability"
+else
+ echo "Checking for -Werror=unguarded-availability... No." | tee -a configure.log
+fi
+
+# Check for -Werror=unguarded-availability-new compiler support
+echo "" > test.c
+ cat > $test.c <<EOF
+int main() { return 0; }
+EOF
+if $cc $CFLAGS -Werror=unguarded-availability-new -c $test.c >> configure.log 2>&1; then
+ echo "Checking for -Werror=unguarded-availability-new... Yes." | tee -a configure.log
+ ADDITIONAL_CHECK_FLAGS="$ADDITIONAL_CHECK_FLAGS -Werror=unguarded-availability-new"
+else
+ echo "Checking for -Werror=unguarded-availability-new... No." | tee -a configure.log
+fi
+
+# Check for -Werror=unused-command-line-argument compiler support
+echo "" > test.c
+ cat > $test.c <<EOF
+int main() { return 0; }
+EOF
+if $cc $CFLAGS -Werror=unused-command-line-argument -c $test.c >> configure.log 2>&1; then
+ echo "Checking for -Werror=unused-command-line-argument... Yes." | tee -a configure.log
+ ADDITIONAL_CHECK_FLAGS="$ADDITIONAL_CHECK_FLAGS -Werror=unused-command-line-argument"
+else
+ echo "Checking for -Werror=unused-command-line-argument... No." | tee -a configure.log
+fi
+
+# check for version script support
+cat > $test.c <<EOF
+int foo(void) { return 0; }
+EOF
+cat > $test.map <<EOF
+{
+ global:
+ foo;
+ local:
+ *;
+};
+EOF
+if test $shared -eq 1; then
+ sed < $SRCDIR/zlib${SUFFIX}.map.in "s/@ZLIB_SYMBOL_PREFIX@/$symbol_prefix/g" > zlib${SUFFIX}.map
+ LDVERSIONSCRIPT="-Wl,--version-script,$BUILDDIR/$MAPNAME"
+ if try $CC -c $SFLAGS $test.c && try $LDSHARED $LDVERSIONSCRIPT $LDSHAREDFLAGS $LDFLAGS -o $test$shared_ext $test.o $LDSHAREDLIBC; then
+ echo "Checking for version script support... $LDVERSIONSCRIPT." | tee -a configure.log
+ else
+ echo "Checking for version script support... No." | tee -a configure.log
+ LDVERSIONSCRIPT=""
+ fi
+fi
+echo >> configure.log
+
+# check for large file support, and if none, check for fseeko()
+cat > $test.c <<EOF
+#include <sys/types.h>
+off64_t dummy = 0;
+EOF
+if try $CC -c $CFLAGS -D_LARGEFILE64_SOURCE=1 $test.c; then
+ CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE=1"
+ SFLAGS="${SFLAGS} -D_LARGEFILE64_SOURCE=1"
+ echo "Checking for off64_t... Yes." | tee -a configure.log
+ echo "Checking for fseeko... Yes." | tee -a configure.log
+else
+ echo "Checking for off64_t... No." | tee -a configure.log
+ echo >> configure.log
+ cat > $test.c <<EOF
+#include <sys/types.h>
+int main() {
+ _off64_t dummy = 0;
+ return 0;
+}
+EOF
+ if try $CC $CFLAGS -o $test $test.c $LDSHAREDLIBC; then
+ echo "Checking for _off64_t... Yes." | tee -a configure.log
+ else
+ echo "Checking for _off64_t... No." | tee -a configure.log
+ fi
+ echo >> configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+int main(void) {
+ fseeko(NULL, 0, 0);
+ return 0;
+}
+EOF
+ if try $CC $CFLAGS $ADDITIONAL_CHECK_FLAGS -o $test $test.c $LDSHAREDLIBC; then
+ echo "Checking for fseeko... Yes." | tee -a configure.log
+ else
+ CFLAGS="${CFLAGS} -DNO_FSEEKO"
+ SFLAGS="${SFLAGS} -DNO_FSEEKO"
+ echo "Checking for fseeko... No." | tee -a configure.log
+ fi
+fi
+echo >> configure.log
+
+# check for cpuid support: GNU extensions
+cat > $test.c <<EOF
+#include <cpuid.h>
+#include <stdio.h>
+static inline void cpuid_gnu(int info, unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx) {
+ *eax = *ebx = *ecx = *edx = 0;
+ __cpuid(info, *eax, *ebx, *ecx, *edx);
+}
+
+int main(void) {
+ unsigned int eax, ebx, ecx, edx;
+ cpuid_gnu(0, &eax, &ebx, &ecx, &edx);
+ printf("%d\n", eax);
+ return eax;
+}
+EOF
+if try $CC $CFLAGS -o $test $test.c $LDSHAREDLIBC; then
+ echo "Checking for GNU style __cpuid... Yes." | tee -a configure.log
+ CFLAGS="${CFLAGS} -DHAVE_CPUID_GNU"
+ SFLAGS="${SFLAGS} -DHAVE_CPUID_GNU"
+else
+ echo "Checking for GNU style __cpuid... No." | tee -a configure.log
+fi
+echo >> configure.log
+
+# check for cpuid support: MSVC extensions
+cat > $test.c <<EOF
+#include <intrin.h>
+#include <stdio.h>
+static inline void cpuid_ms(int info, unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx) {
+ unsigned int registers[4];
+ __cpuid((int *)registers, info);
+ *eax = registers[0];
+ *ebx = registers[1];
+ *ecx = registers[2];
+ *edx = registers[3];
+}
+
+int main(void) {
+ unsigned int eax, ebx, ecx, edx;
+ cpuid_ms(0, &eax, &ebx, &ecx, &edx);
+ printf("%d\n", eax);
+ return 0;
+}
+EOF
+if try $CC $CFLAGS -o $test $test.c $LDSHAREDLIBC; then
+ echo "Checking for MS style __cpuid... Yes." | tee -a configure.log
+ CFLAGS="${CFLAGS} -DHAVE_CPUID_MS"
+ SFLAGS="${SFLAGS} -DHAVE_CPUID_MS"
+else
+ echo "Checking for MS style __cpuid... No." | tee -a configure.log
+fi
+echo >> configure.log
+
+# check for strerror() for use by gz* functions
+cat > $test.c <<EOF
+#include <string.h>
+#include <errno.h>
+int main() { return strlen(strerror(errno)); }
+EOF
+if try $CC $CFLAGS $ADDITIONAL_CHECK_FLAGS -o $test $test.c $LDSHAREDLIBC; then
+ echo "Checking for strerror... Yes." | tee -a configure.log
+else
+ CFLAGS="${CFLAGS} -DNO_STRERROR"
+ SFLAGS="${SFLAGS} -DNO_STRERROR"
+ echo "Checking for strerror... No." | tee -a configure.log
+fi
+
+# check for getauxval() or elf_aux_info() for architecture feature detection at run-time
+cat > $test.c <<EOF
+#include <sys/auxv.h>
+int main() {
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+ int test;
+ return elf_aux_info(AT_PAGESZ, &test, sizeof(test));
+#else
+ return getauxval(0);
+#endif
+}
+EOF
+if try $CC $CFLAGS -o $test $test.c $LDSHAREDLIBC; then
+ echo "Checking for getauxval() or elf_aux_info() in sys/auxv.h... Yes." | tee -a configure.log
+ CFLAGS="${CFLAGS} -DHAVE_SYS_AUXV_H"
+ SFLAGS="${SFLAGS} -DHAVE_SYS_AUXV_H"
+else
+ echo "Checking for getauxval() or elf_aux_info() in sys/auxv.h... No." | tee -a configure.log
+fi
+
+# We need to remove consigured files (zconf.h etc) from source directory if building outside of it
+if [ "$SRCDIR" != "$BUILDDIR" ]; then
+ rm -f $SRCDIR/zconf${SUFFIX}.h
+ rm -f $SRCDIR/zlib${SUFFIX}.h
+ rm -f $SRCDIR/zlib_name_mangling${SUFFIX}.h
+fi
+
+# Substitute @ZLIB_SYMBOL_PREFIX@ with $symbol_prefix in gzread_mangle.h, zlib.h and zlib_name_mangling.h
+sed < $SRCDIR/gzread_mangle.h.in "s/@ZLIB_SYMBOL_PREFIX@/$symbol_prefix/g" > gzread_mangle.h
+sed < $SRCDIR/zlib${SUFFIX}.h.in "s/@ZLIB_SYMBOL_PREFIX@/$symbol_prefix/g" > zlib${SUFFIX}.h
+if [ ! -z "$symbol_prefix" ]; then
+ sed < $SRCDIR/zlib_name_mangling${SUFFIX}.h.in "s/@ZLIB_SYMBOL_PREFIX@/$symbol_prefix/g" > zlib_name_mangling${SUFFIX}.h
+else
+ # symbol_prefix is not set, copy the empty mangling header
+ cp -p $SRCDIR/zlib_name_mangling.h.empty zlib_name_mangling${SUFFIX}.h
+fi
+
+# copy clean zconf.h for subsequent edits
+cp -p $SRCDIR/zconf${SUFFIX}.h.in zconf${SUFFIX}.h
+
+echo >> configure.log
+
+# check for unistd.h and save result in zconf.h
+cat > $test.c <<EOF
+#include <unistd.h>
+int main() { return 0; }
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ sed < zconf${SUFFIX}.h "/^#ifdef HAVE_UNISTD_H.* may be/s/def HAVE_UNISTD_H\(.*\) may be/ 1\1 was/" > zconf${SUFFIX}.temp.h
+ mv zconf${SUFFIX}.temp.h zconf${SUFFIX}.h
+ echo "Checking for unistd.h... Yes." | tee -a configure.log
+else
+ sed < zconf${SUFFIX}.h "/^#ifdef HAVE_UNISTD_H.* may be/s/def HAVE_UNISTD_H\(.*\) may be set to #if 1/ 0\1 was set to #if 0/" > zconf${SUFFIX}.temp.h
+ mv zconf${SUFFIX}.temp.h zconf${SUFFIX}.h
+ echo "Checking for unistd.h... No." | tee -a configure.log
+fi
+
+echo >> configure.log
+
+# check for linux/auxvec.h
+cat > $test.c <<EOF
+#include <linux/auxvec.h>
+int main() { return 0; }
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for linux/auxvec.h... Yes." | tee -a configure.log
+ CFLAGS="${CFLAGS} -DHAVE_LINUX_AUXVEC_H"
+ SFLAGS="${SFLAGS} -DHAVE_LINUX_AUXVEC_H"
+else
+ echo "Checking for linux/auxvec.h... No." | tee -a configure.log
+fi
+
+echo >> configure.log
+
+
+# check for ptrdiff_t and save result in zconf.h
+printf "Checking for ptrdiff_t... " | tee -a configure.log
+cat > $test.c <<EOF
+#include <stddef.h>
+int fun(ptrdiff_t *a) { (void)a; return 0; }
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ echo "Yes." | tee -a configure.log
+else
+ echo "No." | tee -a configure.log
+ sed < zconf${SUFFIX}.h "/^#ifdef NEED_PTRDIFF_T.* may be/s/def NEED_PTRDIFF_T\(.*\) may be/ 1\1 was/" > zconf${SUFFIX}.temp.h
+ mv zconf${SUFFIX}.temp.h zconf${SUFFIX}.h
+
+ printf "Checking for sizeof(void *)... " | tee -a configure.log
+ cat > $test.c <<EOF
+#include <stdint.h>
+#define COMPILE_TIME_ASSERT(pred) struct s { int x: (pred) ? 1 : -1; }
+COMPILE_TIME_ASSERT(sizeof(int32_t) == sizeof(void *));
+EOF
+ if try $CC -c $CFLAGS $test.c; then
+ echo "sizeof(int32_t)." | tee -a configure.log
+ sed < zconf${SUFFIX}.h "s/^typedef PTRDIFF_TYPE ptrdiff_t;/typedef int32_t ptrdiff_t;/g" > zconf${SUFFIX}.temp.h
+ mv zconf${SUFFIX}.temp.h zconf${SUFFIX}.h
+ else
+ cat > $test.c <<EOF
+#include <stdint.h>
+#define COMPILE_TIME_ASSERT(pred) struct s { int x: (pred) ? 1 : -1; }
+COMPILE_TIME_ASSERT(sizeof(int64_t) == sizeof(void *));
+EOF
+ if try $CC -c $CFLAGS $test.c; then
+ echo "sizeof(int64_t)." | tee -a configure.log
+ sed < zconf${SUFFIX}.h "s/^typedef PTRDIFF_TYPE ptrdiff_t;/typedef int64_t ptrdiff_t;/g" > zconf${SUFFIX}.temp.h
+ mv zconf${SUFFIX}.temp.h zconf${SUFFIX}.h
+ else
+ echo "unknown." | tee -a configure.log
+ exit 1
+ fi
+ fi
+fi
+
+# if --zlib-compat was requested
+if test $compat -eq 1; then
+ gzfileops=1
+ CFLAGS="${CFLAGS} -DZLIB_COMPAT"
+ SFLAGS="${SFLAGS} -DZLIB_COMPAT"
+ case "$uname" in
+ CYGWIN* | Cygwin* | cygwin* | MSYS* | msys* | MINGW* | mingw*)
+ DEFFILE="win32/zlibcompat.def" ;;
+ esac
+fi
+
+if [ ! -z "$DEFFILE" ]; then
+ mkdir -p win32
+ sed < $SRCDIR/$DEFFILE.in "s/@ZLIB_SYMBOL_PREFIX@/$symbol_prefix/g" > $DEFFILE
+fi
+
+# if --gzfileops was requested
+if test $gzfileops -eq 1; then
+ CFLAGS="${CFLAGS} -DWITH_GZFILEOP"
+ SFLAGS="${SFLAGS} -DWITH_GZFILEOP"
+ OBJC="${OBJC} \$(OBJG)"
+ PIC_OBJC="${PIC_OBJC} \$(PIC_OBJG)"
+else
+ TESTOBJG="\$(OBJG)"
+ PIC_TESTOBJG="\$(OBJG)"
+fi
+
+# enable reduced memory configuration
+if test $reducedmem -eq 1; then
+ echo "Configuring for reduced memory environment." | tee -a configure.log
+ CFLAGS="${CFLAGS} -DHASH_SIZE=32768u -DGZBUFSIZE=8192 -DNO_LIT_MEM"
+fi
+
+# if code coverage testing was requested, use older gcc if defined, e.g. "gcc-4.2" on Mac OS X
+if test $cover -eq 1; then
+ CFLAGS="${CFLAGS} -fprofile-arcs -ftest-coverage"
+ LDFLAGS="${LDFLAGS} -fprofile-arcs -ftest-coverage"
+ if test -n "$GCC_CLASSIC"; then
+ CC=$GCC_CLASSIC
+ fi
+fi
+
+echo >> configure.log
+
+# Check for ANSI C compliant compiler
+cat > $test.c <<EOF
+#include <stdint.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include "zconf${SUFFIX}.h"
+int main() {
+#ifdef STDC
+ return 0;
+#endif
+ return 1;
+}
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for ANSI C compliant compiler... Yes." | tee -a configure.log
+ :
+else
+ echo "Checking for ANSI C compliant compiler... No." | tee -a configure.log
+ echo "Error: ANSI C compatible compiler needed, cannot continue." | tee -a configure.log
+ leave 1
+fi
+
+# Check for -fno-semantic-interposition compiler support
+echo "" > test.c
+ cat > $test.c <<EOF
+int main() { return 0; }
+EOF
+if test "$gcc" -eq 1 && ($cc $CFLAGS $ADDITIONAL_CHECK_FLAGS -fno-semantic-interposition -c $test.c) >> configure.log 2>&1; then
+ echo "Checking for -fno-semantic-interposition... Yes." | tee -a configure.log
+ SFLAGS="$SFLAGS -fno-semantic-interposition"
+else
+ echo "Checking for -fno-semantic-interposition... No." | tee -a configure.log
+fi
+
+# Check for -fno-lto compiler support
+if test $gcc -eq 1 -a $without_optimizations -eq 0; then
+ cat > $test.c <<EOF
+int main() { return 0; }
+EOF
+ if $cc $CFLAGS -fno-lto -c $test.c >> configure.log 2>&1; then
+ echo "Checking for -fno-lto... Yes." | tee -a configure.log
+ noltoflag="-fno-lto"
+ else
+ echo "Checking for -fno-lto... No." | tee -a configure.log
+ noltoflag=""
+ fi
+fi
+
+# see if we can hide zlib internal symbols that are linked between separate source files using hidden
+if test "$gcc" -eq 1 && test "$visibility" -eq 1; then
+ echo >> configure.log
+ cat > $test.c <<EOF
+#define Z_INTERNAL __attribute__((visibility ("hidden")))
+int Z_INTERNAL foo;
+int main() { return 0; }
+EOF
+ if try $CC $CFLAGS $test.c; then
+ CFLAGS="$CFLAGS -DHAVE_VISIBILITY_HIDDEN"
+ SFLAGS="$SFLAGS -DHAVE_VISIBILITY_HIDDEN"
+ echo >> configure.log
+ echo "Checking for attribute(visibility(hidden)) support... Yes." | tee -a configure.log
+ else
+ echo >> configure.log
+ echo "Checking for attribute(visibility(hidden)) support... No." | tee -a configure.log
+ fi
+fi
+
+# see if we can hide zlib internal symbols that are linked between separate source files using internal
+if test "$gcc" -eq 1 && test "$visibility" -eq 1; then
+ echo >> configure.log
+ cat > $test.c <<EOF
+#define Z_INTERNAL __attribute__((visibility ("internal")))
+int Z_INTERNAL foo;
+int main() { return 0; }
+EOF
+ if try $CC $CFLAGS $test.c; then
+ CFLAGS="$CFLAGS -DHAVE_VISIBILITY_INTERNAL"
+ SFLAGS="$SFLAGS -DHAVE_VISIBILITY_INTERNAL"
+ echo >> configure.log
+ echo "Checking for attribute(visibility(internal)) support... Yes." | tee -a configure.log
+ else
+ echo >> configure.log
+ echo "Checking for attribute(visibility(internal)) support... No." | tee -a configure.log
+ fi
+fi
+
+# Check for attribute(aligned) support in compiler
+cat > $test.c << EOF
+int main(void) {
+ __attribute__((aligned(8))) int test = 0;
+ (void)test;
+ return 0;
+}
+EOF
+if try ${CC} ${CFLAGS} $test.c $LDSHAREDLIBC; then
+ echo "Checking for attribute(aligned) ... Yes." | tee -a configure.log
+ CFLAGS="$CFLAGS -DHAVE_ATTRIBUTE_ALIGNED"
+ SFLAGS="$SFLAGS -DHAVE_ATTRIBUTE_ALIGNED"
+else
+ echo "Checking for attribute(aligned) ... No." | tee -a configure.log
+fi
+
+# Check for __builtin_assume_aligned(x,n) support in compiler
+cat > $test.c << EOF
+char *test(char *buffer) {
+ char *abuffer = __builtin_assume_aligned(buffer,64);
+ return abuffer;
+}
+int main() {
+ return 0;
+}
+EOF
+if try ${CC} ${CFLAGS} $test.c $LDSHAREDLIBC; then
+ echo "Checking for __builtin_assume_aligned() ... Yes." | tee -a configure.log
+ CFLAGS="$CFLAGS -DHAVE_BUILTIN_ASSUME_ALIGNED"
+ SFLAGS="$SFLAGS -DHAVE_BUILTIN_ASSUME_ALIGNED"
+else
+ echo "Checking for __builtin_assume_aligned() ... No." | tee -a configure.log
+fi
+
+check_avx2_intrinsics() {
+ # Check whether compiler supports AVX2 intrinsics
+ cat > $test.c << EOF
+#include <immintrin.h>
+__m256i f(__m256i x) {
+ const __m256i y = _mm256_set1_epi16(1);
+ return _mm256_subs_epu16(x, y);
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${avx2flag} $test.c; then
+ echo "Checking for AVX2 intrinsics ... Yes." | tee -a configure.log
+ HAVE_AVX2_INTRIN=1
+ else
+ echo "Checking for AVX2 intrinsics ... No." | tee -a configure.log
+ HAVE_AVX2_INTRIN=0
+ fi
+}
+
+check_avx512_intrinsics() {
+ # Check whether compiler supports AVX512 intrinsics
+ cat > $test.c << EOF
+#include <immintrin.h>
+__m512i f(__m512i y) {
+ __m512i x = _mm512_set1_epi8(2);
+ return _mm512_sub_epi8(x, y);
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${avx512flag} $test.c; then
+ echo "Checking for AVX512 intrinsics ... Yes." | tee -a configure.log
+ HAVE_AVX512_INTRIN=1
+ else
+ echo "Checking for AVX512 intrinsics ... No." | tee -a configure.log
+ HAVE_AVX512_INTRIN=0
+ fi
+}
+
+check_mtune_skylake_avx512_compiler_flag() {
+ # Check whether -mtune=skylake-avx512 works correctly
+ cat > $test.c << EOF
+int main() { return 0; }
+EOF
+ if try $CC -c $CFLAGS -mtune=skylake-avx512 $test.c; then
+ MTUNE_SKYLAKE_AVX512_AVAILABLE=1
+ echo "Check whether -mtune=skylake-avx512 works ... Yes." | tee -a configure.log
+ else
+ echo "Check whether -mtune=skylake-avx512 works ... No." | tee -a configure.log
+ MTUNE_SKYLAKE_AVX512_AVAILABLE=0
+ fi
+}
+
+check_mtune_cascadelake_compiler_flag() {
+ # Check whether -mtune=cascadelake works correctly
+ cat > $test.c << EOF
+int main() { return 0; }
+EOF
+ if try $CC -c $CFLAGS -mtune=cascadelake $test.c; then
+ MTUNE_CASCADELAKE_AVAILABLE=1
+ echo "Check whether -mtune=cascadelake works ... Yes." | tee -a configure.log
+ else
+ echo "Check whether -mtune=cascadelake works ... No." | tee -a configure.log
+ MTUNE_CASCADELAKE_AVAILABLE=0
+ check_mtune_skylake_avx512_compiler_flag
+ fi
+}
+
+check_avx512vnni_intrinsics() {
+ # Check whether compiler supports AVX512-VNNI intrinsics
+ cat > $test.c << EOF
+#include <immintrin.h>
+int main(void) {
+ const __m512i z512 = _mm512_setzero_si512();
+ const __m256i z256 = _mm256_setzero_si256();
+ volatile __m512i r512 = _mm512_dpbusd_epi32(z512, z512, z512);
+ volatile __m256i r256 = _mm256_dpbusd_epi32(z256, z256, z256);
+ (void)r512;
+ (void)r256;
+ return 0;
+}
+EOF
+ if try ${CC} ${CFLAGS} ${avx512vnniflag} $test.c; then
+ echo "Checking for AVX512VNNI intrinsics ... Yes." | tee -a configure.log
+ HAVE_AVX512VNNI_INTRIN=1
+ else
+ echo "Checking for AVX512VNNI intrinsics ... No." | tee -a configure.log
+ HAVE_AVX512VNNI_INTRIN=0
+ fi
+}
+
+check_armv8_intrinsics() {
+ # Check whether -march=armv8-a+crc works correctly
+ cat > $test.c << EOF
+int main() { return 0; }
+EOF
+ if try $CC -c $CFLAGS -march=armv8-a+crc $test.c; then
+ echo "Check whether -march=armv8-a+crc works ... Yes." | tee -a configure.log
+ armv8flag="-march=armv8-a+crc"
+ else
+ echo "Check whether -march=armv8-a+crc works ... No." | tee -a configure.log
+ if try $CC -c $CFLAGS -march=armv8-a+crc+simd $test.c; then
+ echo "Check whether -march=armv8-a+crc+simd works ... Yes." | tee -a configure.log
+ armv8flag="-march=armv8-a+crc+simd"
+ else
+ echo "Check whether -march=armv8-a+crc+simd works ... No." | tee -a configure.log
+ if try $CC -c $CFLAGS -Wa,-march=armv8-a+crc $test.c; then
+ echo "Check whether -Wa,-march=armv8-a+crc works ... Yes." | tee -a configure.log
+ armv8flag="-Wa,-march=armv8-a+crc"
+ else
+ echo "Check whether -Wa,-march=armv8-a+crc works ... No." | tee -a configure.log
+ if try $CC -c $CFLAGS -Wa,-march=armv8-a+crc+simd $test.c; then
+ echo "Check whether -Wa,-march=armv8-a+crc+simd works ... Yes." | tee -a configure.log
+ armv8flag="-Wa,-march=armv8-a+crc+simd"
+ else
+ echo "Check whether -Wa,-march=armv8-a+crc+simd works ... No." | tee -a configure.log
+ fi
+ fi
+ fi
+ fi
+
+ # Check whether compiler supports ARMv8 inline asm
+ cat > $test.c << EOF
+unsigned int f(unsigned int a, unsigned int b) {
+ unsigned int c;
+#ifdef __aarch64__
+ __asm__("crc32w %w0, %w1, %w2" : "=r" (c) : "r"(a), "r"(b));
+#else
+ __asm__("crc32w %0, %1, %2" : "=r" (c) : "r"(a), "r"(b));
+#endif
+ return c;
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${armv8flag} $test.c; then
+ echo "Checking for ARMv8 inline assembly ... Yes." | tee -a configure.log
+ HAVE_ARMV8_INLINE_ASM=1
+ else
+ echo "Checking for ARMv8 inline assembly ... No." | tee -a configure.log
+ HAVE_ARMV8_INLINE_ASM=0
+ fi
+
+ # Check whether compiler supports ARMv8 intrinsics
+ cat > $test.c << EOF
+#include <arm_acle.h>
+unsigned int f(unsigned int a, unsigned int b) {
+ return __crc32w(a, b);
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${armv8flag} $test.c; then
+ echo "Checking for ARMv8 intrinsics ... Yes." | tee -a configure.log
+ HAVE_ARMV8_INTRIN=1
+ else
+ echo "Checking for ARMv8 intrinsics ... No." | tee -a configure.log
+ HAVE_ARMV8_INTRIN=0
+ fi
+}
+
+check_armv8_pmull_eor3_intrinsics() {
+ # Check whether -march=armv8.2-a+crc+crypto+sha3 works correctly
+ cat > $test.c << EOF
+int main() { return 0; }
+EOF
+ if try $CC -c $CFLAGS -march=armv8.2-a+crc+crypto+sha3 $test.c; then
+ echo "Check whether -march=armv8.2-a+crc+crypto+sha3 works ... Yes." | tee -a configure.log
+ pmulleor3flag="-march=armv8.2-a+crc+crypto+sha3"
+ else
+ echo "Check whether -march=armv8.2-a+crc+crypto+sha3 works ... No." | tee -a configure.log
+ if try $CC -c $CFLAGS -march=armv8-a+crc+crypto+sha3 $test.c; then
+ echo "Check whether -march=armv8-a+crc+crypto+sha3 works ... Yes." | tee -a configure.log
+ pmulleor3flag="-march=armv8-a+crc+crypto+sha3"
+ else
+ echo "Check whether -march=armv8-a+crc+crypto+sha3 works ... No." | tee -a configure.log
+ pmulleor3flag=""
+ fi
+ fi
+
+ # Check whether compiler supports ARMv8 PMULL + EOR3 intrinsics
+ if test -n "$pmulleor3flag"; then
+ cat > $test.c << EOF
+#include <arm_neon.h>
+poly128_t f(poly64_t a, poly64_t b) {
+ return vmull_p64(a, b);
+}
+uint64x2_t g(uint64x2_t a, uint64x2_t b, uint64x2_t c) {
+ return veor3q_u64(a, b, c);
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${pmulleor3flag} $test.c; then
+ echo "Checking for ARMv8 PMULL+EOR3 intrinsics ... Yes." | tee -a configure.log
+ HAVE_PMULL_EOR3_INTRIN=1
+ else
+ echo "Checking for ARMv8 PMULL+EOR3 intrinsics ... No." | tee -a configure.log
+ HAVE_PMULL_EOR3_INTRIN=0
+ fi
+ else
+ HAVE_PMULL_EOR3_INTRIN=0
+ fi
+}
+
+check_neon_compiler_flag() {
+ if test "$ARCH" = "aarch64"; then
+ neonflag="-march=armv8-a+simd"
+ else
+ neonflag="-mfpu=neon"
+ fi
+ # Check whether neon flag is available on ARM processors.
+ cat > $test.c << EOF
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+ # include <arm64_neon.h>
+ #else
+ # include <arm_neon.h>
+#endif
+int main() { return 0; }
+EOF
+ if try $CC -c $CFLAGS $neonflag $test.c; then
+ NEON_AVAILABLE=1
+ echo "Check whether $neonflag is available ... Yes." | tee -a configure.log
+ else
+ NEON_AVAILABLE=0
+ echo "Check whether $neonflag is available ... No." | tee -a configure.log
+ fi
+}
+
+check_neon_ld4_intrinsics() {
+ cat > $test.c << EOF
+#if defined(_MSC_VER) && (defined(_M_ARM64) || defined(_M_ARM64EC))
+# include <arm64_neon.h>
+#else
+# include <arm_neon.h>
+#endif
+int32x4x4_t f(int var[16]) { return vld1q_s32_x4(var); }
+int main(void) { return 0; }
+EOF
+ if try $CC -c $CFLAGS $neonflag $test.c; then
+ NEON_HAS_LD4=1
+ echo "check whether compiler supports 4 wide register loads ... Yes." | tee -a configure.log
+ else
+ NEON_HAS_LD4=0
+ echo "check whether compiler supports 4 wide register loads ... No." | tee -a configure.log
+ fi
+}
+
+check_armv6_intrinsics() {
+ # Check whether -march=armv6 works correctly
+ cat > $test.c << EOF
+int main() { return 0; }
+EOF
+ if try $CC -c $CFLAGS -march=armv6 $test.c; then
+ armv6flag=-march=armv6
+ echo "Check whether -march=armv6 works ... Yes." | tee -a configure.log
+ else
+ echo "Check whether -march=armv6 works ... No." | tee -a configure.log
+ if try $CC -c $CFLAGS -Wa,-march=armv6 $test.c; then
+ armv6flag=-Wa,-march=armv6
+ echo "Check whether -Wa,-march=armv6 works ... Yes." | tee -a configure.log
+ else
+ echo "Check whether -Wa,-march=armv6 works ... No." | tee -a configure.log
+ fi
+ fi
+
+ # Check whether compiler supports ARMv6 inline asm
+ cat > $test.c << EOF
+unsigned int f(unsigned int a, unsigned int b) {
+ unsigned int c;
+ __asm__("uqsub16 %0, %1, %2" : "=r" (c) : "r" (a), "r" (b));
+ return c;
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${armv6flag} $test.c; then
+ echo "Checking for ARMv6 inline assembly ... Yes." | tee -a configure.log
+ HAVE_ARMV6_INLINE_ASM=1
+ else
+ echo "Checking for ARMv6 inline assembly ... No." | tee -a configure.log
+ HAVE_ARMV6_INLINE_ASM=0
+ fi
+
+ # Check whether compiler supports ARMv6 intrinsics
+ cat > $test.c << EOF
+#include <arm_acle.h>
+unsigned int f(unsigned int a, unsigned int b) {
+ return __uqsub16(a, b);
+}
+int main(void) { return f(1, 2); }
+EOF
+ if try ${CC} ${CFLAGS} ${armv6flag} $test.c; then
+ echo "Checking for ARMv6 intrinsics ... Yes." | tee -a configure.log
+ HAVE_ARMV6_INTRIN=1
+ else
+ echo "Checking for ARMv6 intrinsics ... No." | tee -a configure.log
+ HAVE_ARMV6_INTRIN=0
+ fi
+}
+
+check_pclmulqdq_intrinsics() {
+ # Check whether compiler supports PCLMULQDQ intrinsics
+ cat > $test.c << EOF
+#include <immintrin.h>
+#include <wmmintrin.h>
+__m128i f(__m128i a, __m128i b) { return _mm_clmulepi64_si128(a, b, 0x10); }
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${pclmulflag} $test.c; then
+ echo "Checking for PCLMULQDQ intrinsics ... Yes." | tee -a configure.log
+ HAVE_PCLMULQDQ_INTRIN=1
+ else
+ echo "Checking for PCLMULQDQ intrinsics ... No." | tee -a configure.log
+ HAVE_PCLMULQDQ_INTRIN=0
+ fi
+}
+
+check_vpclmulqdq_intrinsics() {
+ # Check whether compiler supports VPCLMULQDQ intrinsics
+ cat > $test.c << EOF
+#include <immintrin.h>
+#include <wmmintrin.h>
+__m256i f(__m256i a) {
+ __m256i b = _mm256_setzero_si256();
+ return _mm256_clmulepi64_epi128(a, b, 0x10);
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${vpclmulflag} ${avx2flag} $test.c; then
+ echo "Checking for VPCLMULQDQ intrinsics ... Yes." | tee -a configure.log
+ HAVE_VPCLMULQDQ_INTRIN=1
+ else
+ echo "Checking for VPCLMULQDQ intrinsics ... No." | tee -a configure.log
+ HAVE_VPCLMULQDQ_INTRIN=0
+ fi
+}
+
+check_xsave_intrinsics() {
+ # Check whether compiler supports XSAVE intrinsics
+ cat > $test.c << EOF
+#ifdef _MSC_VER
+# include <intrin.h>
+#elif __GNUC__ == 8 && __GNUC_MINOR__ > 1
+# include <xsaveintrin.h>
+#else
+# include <immintrin.h>
+#endif
+unsigned int f(unsigned int a) { return (int) _xgetbv(a); }
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${xsaveflag} $test.c; then
+ echo "Checking for XSAVE intrinsics ... Yes." | tee -a configure.log
+ HAVE_XSAVE_INTRIN=1
+ else
+ echo "Checking for XSAVE intrinsics ... No." | tee -a configure.log
+ HAVE_XSAVE_INTRIN=0
+ fi
+}
+
+check_ppc_intrinsics() {
+ cat > $test.c << EOF
+#include <altivec.h>
+int main(void)
+{
+ vector int a = vec_splats(0);
+ vector int b = vec_splats(0);
+ a = vec_add(a, b);
+ return 0;
+}
+EOF
+ if test $buildaltivec -eq 1 && try ${CC} ${CFLAGS} -maltivec $test.c; then
+ echo "Checking for AltiVec intrinsics ... Yes." | tee -a configure.log
+ HAVE_ALTIVEC_INTRIN=1
+ else
+ echo "Checking for AltiVec intrinsics ... No." | tee -a configure.log
+ HAVE_ALTIVEC_INTRIN=0
+ fi
+ if test $buildaltivec -eq 1 && try ${CC} ${CFLAGS} -maltivec -mno-vsx $test.c; then
+ echo "Checking if -mno-vsx is supported ... Yes." | tee -a configure.log
+ vmxflag="$vmxflag -mno-vsx"
+ else
+ echo "Checking if -mno-vsx is supported ... No." | tee -a configure.log
+ fi
+ cat > $test.c << EOF
+#ifdef __FreeBSD__
+#include <machine/cpu.h>
+#endif
+#include <sys/auxv.h>
+int main() {
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+ unsigned long hwcap;
+ elf_aux_info(AT_HWCAP, &hwcap, sizeof(hwcap));
+ return (hwcap & PPC_FEATURE_HAS_ALTIVEC);
+#else
+ return (getauxval(AT_HWCAP) & PPC_FEATURE_HAS_ALTIVEC);
+#endif
+}
+EOF
+ if try $CC -c $CFLAGS -maltivec $test.c; then
+ HAVE_VMX=1
+ echo "Check whether VMX instructions are available ... Yes." | tee -a configure.log
+ else
+ HAVE_VMX=0
+ echo "Check whether VMX instructions are available ... No." | tee -a configure.log
+ fi
+}
+
+check_power8_intrinsics() {
+ # Check whether features needed by POWER8 optimisations are available
+ cat > $test.c << EOF
+#ifdef __FreeBSD__
+#include <machine/cpu.h>
+#endif
+#include <sys/auxv.h>
+int main() {
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+ unsigned long hwcap;
+ elf_aux_info(AT_HWCAP2, &hwcap, sizeof(hwcap));
+ return (hwcap & PPC_FEATURE2_ARCH_2_07);
+#else
+ return (getauxval(AT_HWCAP2) & PPC_FEATURE2_ARCH_2_07);
+#endif
+}
+EOF
+ if test $buildpower8 -eq 1 && try $CC -c $CFLAGS -mcpu=power8 $test.c; then
+ HAVE_POWER8_INTRIN=1
+ echo "Check whether POWER8 instructions are available ... Yes." | tee -a configure.log
+ else
+ HAVE_POWER8_INTRIN=0
+ echo "Check whether POWER8 instructions are available ... No." | tee -a configure.log
+ fi
+}
+
+check_power9_intrinsics() {
+ # Check whether features needed by POWER9 optimisations are available
+ cat > $test.c << EOF
+#ifdef __FreeBSD__
+#include <machine/cpu.h>
+#endif
+#include <sys/auxv.h>
+int main() {
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+ unsigned long hwcap;
+ elf_aux_info(AT_HWCAP2, &hwcap, sizeof(hwcap));
+ return (hwcap & PPC_FEATURE2_ARCH_3_00);
+#else
+ return (getauxval(AT_HWCAP2) & PPC_FEATURE2_ARCH_3_00);
+#endif
+}
+EOF
+ if test $buildpower9 -eq 1 && try $CC -c $CFLAGS -mcpu=power9 $test.c; then
+ HAVE_POWER9_INTRIN=1
+ echo "Check whether POWER9 instructions are available ... Yes." | tee -a configure.log
+ else
+ HAVE_POWER9_INTRIN=0
+ echo "Check whether POWER9 instructions are available ... No." | tee -a configure.log
+ fi
+}
+
+check_sse2_intrinsics() {
+ # Check whether compiler supports SSE2 intrinsics
+ cat > $test.c << EOF
+#include <immintrin.h>
+__m128i f(__m128i x, __m128i y) { return _mm_sad_epu8(x, y); }
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${sse2flag} $test.c; then
+ echo "Checking for SSE2 intrinsics ... Yes." | tee -a configure.log
+ HAVE_SSE2_INTRIN=1
+ else
+ echo "Checking for SSE2 intrinsics ... No." | tee -a configure.log
+ HAVE_SSE2_INTRIN=0
+ fi
+}
+
+check_sse41_intrinsics() {
+ # Check whether compiler supports SSE4.1 intrinsics
+ cat > $test.c << EOF
+#include <smmintrin.h>
+__m128i f(__m128i a, __m128i b) { return _mm_min_epi32(a, b); }
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${sse41flag} $test.c; then
+ echo "Checking for SSE4.1 intrinsics ... Yes." | tee -a configure.log
+ HAVE_SSE41_INTRIN=1
+ else
+ echo "Checking for SSE4.1 intrinsics ... No." | tee -a configure.log
+ HAVE_SSE41_INTRIN=0
+ fi
+}
+
+check_sse42_intrinsics() {
+ # Check whether compiler supports SSE4.2 intrinsics
+ cat > $test.c << EOF
+#include <nmmintrin.h>
+unsigned int f(unsigned int a, unsigned int b) { return _mm_crc32_u32(a, b); }
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${sse42flag} $test.c; then
+ echo "Checking for SSE4.2 intrinsics ... Yes." | tee -a configure.log
+ HAVE_SSE42_INTRIN=1
+ else
+ echo "Checking for SSE4.2 intrinsics ... No." | tee -a configure.log
+ HAVE_SSE42_INTRIN=0
+ fi
+}
+
+check_ssse3_intrinsics() {
+ # Check whether compiler supports SSSE3 intrinsics
+ cat > $test.c << EOF
+#include <immintrin.h>
+__m128i f(__m128i u) {
+ __m128i v = _mm_set1_epi32(1);
+ return _mm_hadd_epi32(u, v);
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${ssse3flag} $test.c; then
+ echo "Checking for SSSE3 intrinsics ... Yes." | tee -a configure.log
+ HAVE_SSSE3_INTRIN=1
+ else
+ echo "Checking for SSSE3 intrinsics ... No." | tee -a configure.log
+ HAVE_SSSE3_INTRIN=0
+ fi
+}
+
+check_vgfma_intrinsics() {
+ # Check whether "VECTOR GALOIS FIELD MULTIPLY SUM AND ACCUMULATE" intrinsic is available
+ printf "Checking for -mzarch... " | tee -a configure.log
+ if try $CC -x c -c /dev/null -o /dev/null -mzarch; then
+ echo Yes. | tee -a configure.log
+ vgfmaflag="${vgfmaflag} -mzarch"
+ else
+ echo No. | tee -a configure.log
+ fi
+ printf "Checking for -fzvector... " | tee -a configure.log
+ if try $CC -x c -c /dev/null -o /dev/null -fzvector; then
+ echo Yes. | tee -a configure.log
+ vgfmaflag="${vgfmaflag} -fzvector"
+ else
+ echo No. | tee -a configure.log
+ fi
+ cat > $test.c << EOF
+#include <vecintrin.h>
+int main(void) {
+ unsigned long long a __attribute__((vector_size(16))) = { 0 };
+ unsigned long long b __attribute__((vector_size(16))) = { 0 };
+ unsigned char c __attribute__((vector_size(16))) = { 0 };
+ c = vec_gfmsum_accum_128(a, b, c);
+ return c[0];
+}
+EOF
+ printf "Checking for VGFMA support... " | tee -a configure.log
+ if try $CC -c $CFLAGS $vgfmaflag $test.c; then
+ HAVE_VGFMA_INTRIN=1
+ echo "Yes." | tee -a configure.log
+ else
+ HAVE_VGFMA_INTRIN=0
+ echo "No." | tee -a configure.log
+ fi
+}
+
+check_la64_crc_intrinsics() {
+ # Check whether "crc" intrinsic is available
+
+ cat > $test.c << EOF
+#include <larchintrin.h>
+int main(void) {
+ char ch = 'a';
+ int crc = __crc_w_b_w(ch, 0);
+ return crc;
+}
+EOF
+ printf "Checking for CRC support... " | tee -a configure.log
+ if try $CC -c $CFLAGS $test.c; then
+ HAVE_LA64_CRC_INTRIN=1
+ echo "Yes." | tee -a configure.log
+ else
+ HAVE_LA64_CRC_INTRIN=0
+ echo "No." | tee -a configure.log
+ fi
+}
+
+check_lsx_intrinsics() {
+ # Check whether compiler supports LSX intrinsics
+ cat > $test.c << EOF
+#include <lsxintrin.h>
+__m128i f(__m128i a, __m128i b) {
+ return __lsx_vabsd_b(a, b);
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${lsxflag} $test.c; then
+ echo "Checking for LSX intrinsics ... Yes." | tee -a configure.log
+ HAVE_LSX_INTRIN=1
+ else
+ echo "Checking for LSX intrinsics ... No." | tee -a configure.log
+ HAVE_LSX_INTRIN=0
+ fi
+}
+
+check_lasx_intrinsics() {
+ # Check whether compiler supports LASX intrinsics
+ cat > $test.c << EOF
+#include <lasxintrin.h>
+__m256i f(__m256i a, __m256i b) {
+ return __lasx_xvabsd_b(a, b);
+}
+int main(void) { return 0; }
+EOF
+ if try ${CC} ${CFLAGS} ${lasxflag} $test.c; then
+ echo "Checking for LASX intrinsics ... Yes." | tee -a configure.log
+ HAVE_LASX_INTRIN=1
+ else
+ echo "Checking for LASX intrinsics ... No." | tee -a configure.log
+ HAVE_LASX_INTRIN=0
+ fi
+}
+
+check_rvv_compiler_flag() {
+ cat > $test.c << EOF
+int main() { return 0; }
+EOF
+ if try $CC -c $CFLAGS -march=rv64gcv $test.c; then
+ echo "Check whether -march=rv64gcv works ... Yes." | tee -a configure.log
+ rvvflag="-march=rv64gcv"
+ else
+ echo "Check whether -march=rv64gcv works ... No." | tee -a configure.log
+ if try $CC -c $CFLAGS -march=rv64gc_zve64x $test.c; then
+ echo "Check whether -march=rv64gc_zve64x works ... Yes." | tee -a configure.log
+ rvvflag="-march=rv64gc_zve64x"
+ else
+ echo "Check whether -march=rv64gc_zve64x works ... No." | tee -a configure.log
+ rvvflag=""
+ fi
+ fi
+
+ cat > $test.c << EOF
+#include <riscv_vector.h>
+int main(void) {
+ size_t vl = __riscv_vsetvlmax_e8m1();
+ return vl;
+}
+EOF
+ if [ -n "$rvvflag" ] && try ${CC} ${CFLAGS} ${rvvflag} $test.c; then
+ echo "Checking for RISC-V Vector intrinsics ... Yes." | tee -a configure.log
+ HAVE_RVV_INTRIN=1
+ rvvzbcflag="${rvvflag}"
+ else
+ echo "Checking for RISC-V Vector intrinsics ... No." | tee -a configure.log
+ HAVE_RVV_INTRIN=0
+ fi
+}
+
+check_zbc_compiler_flag() {
+ cat > $test.c << EOF
+int main() { return 0; }
+EOF
+ if try $CC -c $CFLAGS -march=rv64gc_zbc $test.c; then
+ echo "Check whether -march=rv64gc_zbc works ... Yes." | tee -a configure.log
+ zbcflag="-march=rv64gc_zbc"
+ if test $buildrvv -eq 1 -a "$HAVE_RVV_INTRIN" -eq 1; then
+ rvvzbcflag="${rvvflag}_zbc"
+ else
+ rvvzbcflag="${zbcflag}"
+ fi
+ else
+ echo "Check whether -march=rv64gc_zbc works ... No." | tee -a configure.log
+ zbcflag=""
+ fi
+
+ cat > $test.c << EOF
+#include <stdint.h>
+uint64_t f(uint64_t a, uint64_t b) {
+ uint64_t c;
+ __asm__ __volatile__ ("clmul %[result], %[input_a], %[input_b]" : [result] "=r" (c) : [input_a] "r" (a), [input_b] "r" (b));
+ return c;
+}
+int main(void) { return f(1, 2); }
+EOF
+ if [ -n "$zbcflag" ] && try ${CC} ${CFLAGS} ${zbcflag} $test.c; then
+ echo "Checking for RISC-V ZBC extension ... Yes." | tee -a configure.log
+ HAVE_ZBC_EXT=1
+ else
+ echo "Checking for RISC-V ZBC extension ... No." | tee -a configure.log
+ HAVE_ZBC_EXT=0
+ fi
+}
+
+# Check whether to disable deflate_medium and deflate_quick
+if test $without_new_strategies -eq 1; then
+ CFLAGS="${CFLAGS} -DNO_QUICK_STRATEGY -DNO_MEDIUM_STRATEGY"
+ SFLAGS="${SFLAGS} -DNO_QUICK_STRATEGY -DNO_MEDIUM_STRATEGY"
+fi
+
+# CMake can exclude building some of the generic fallback functions,
+# configure does not have the detection code to do so.
+CFLAGS="${CFLAGS} -DWITH_ALL_FALLBACKS"
+SFLAGS="${SFLAGS} -DWITH_ALL_FALLBACKS"
+
+if test $without_optimizations -eq 0; then
+ CFLAGS="${CFLAGS} -DWITH_OPTIM"
+ SFLAGS="${SFLAGS} -DWITH_OPTIM"
+fi
+
+ARCHDIR='arch/generic'
+ARCH_STATIC_OBJS=''
+ARCH_SHARED_OBJS=''
+
+
+# Set ARCH specific FLAGS
+case "${ARCH}" in
+ # x86/amd64 specific optimizations
+ i386 | i486 | i586 | i686 | amd64 | x86_64)
+ ARCHDIR=arch/x86
+
+ # Enable arch-specific optimizations
+ if test $without_optimizations -eq 0; then
+ CFLAGS="${CFLAGS} -DX86_FEATURES"
+ SFLAGS="${SFLAGS} -DX86_FEATURES"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} x86_features.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} x86_features.lo"
+
+ check_xsave_intrinsics
+
+ if test ${HAVE_XSAVE_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_HAVE_XSAVE_INTRIN"
+ SFLAGS="${SFLAGS} -DX86_HAVE_XSAVE_INTRIN"
+ else
+ xsaveflag=""
+ fi
+
+ check_sse2_intrinsics
+
+ if test ${HAVE_SSE2_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_SSE2"
+ SFLAGS="${SFLAGS} -DX86_SSE2"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} chunkset_sse2.o compare256_sse2.o crc32_chorba_sse2.o slide_hash_sse2.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} chunkset_sse2.lo compare256_sse2.lo crc32_chorba_sse2.lo slide_hash_sse2.lo"
+ fi
+
+ check_ssse3_intrinsics
+
+ if test ${HAVE_SSSE3_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_SSSE3"
+ SFLAGS="${SFLAGS} -DX86_SSSE3"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_ssse3.o chunkset_ssse3.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_ssse3.lo chunkset_ssse3.lo"
+ fi
+
+ check_sse41_intrinsics
+
+ if test ${HAVE_SSE41_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_SSE41"
+ SFLAGS="${SFLAGS} -DX86_SSE41"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_chorba_sse41.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_chorba_sse41.lo"
+ fi
+
+ check_sse42_intrinsics
+
+ if test ${HAVE_SSE42_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_SSE42"
+ SFLAGS="${SFLAGS} -DX86_SSE42"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_sse42.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_sse42.lo"
+ fi
+
+ check_pclmulqdq_intrinsics
+
+ if test ${HAVE_PCLMULQDQ_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_PCLMULQDQ_CRC"
+ SFLAGS="${SFLAGS} -DX86_PCLMULQDQ_CRC"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_pclmulqdq.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_pclmulqdq.lo"
+ fi
+
+ check_avx2_intrinsics
+
+ if test ${HAVE_AVX2_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_AVX2"
+ SFLAGS="${SFLAGS} -DX86_AVX2"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} slide_hash_avx2.o chunkset_avx2.o compare256_avx2.o adler32_avx2.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} slide_hash_avx2.lo chunkset_avx2.lo compare256_avx2.lo adler32_avx2.lo"
+ fi
+
+ check_avx512_intrinsics
+
+ if test ${HAVE_AVX512_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_AVX512"
+ SFLAGS="${SFLAGS} -DX86_AVX512"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_avx512.o chunkset_avx512.o compare256_avx512.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_avx512.lo chunkset_avx512.lo compare256_avx512.lo"
+ fi
+
+ check_mtune_cascadelake_compiler_flag
+
+ if test ${MTUNE_CASCADELAKE_AVAILABLE} -eq 1; then
+ avx512flag="${avx512flag} -mtune=cascadelake"
+ avx512vnniflag="${avx512vnniflag} -mtune=cascadelake"
+ else
+ if test ${MTUNE_SKYLAKE_AVX512_AVAILABLE} -eq 1; then
+ avx512flag="${avx512flag} -mtune=skylake-avx512"
+ avx512vnniflag="${avx512vnniflag} -mtune=skylake-avx512"
+ fi
+ fi
+
+ check_avx512vnni_intrinsics
+
+ if test ${HAVE_AVX512VNNI_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_AVX512VNNI"
+ SFLAGS="${SFLAGS} -DX86_AVX512VNNI"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_avx512_vnni.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_avx512_vnni.lo"
+ fi
+
+ if test $buildvpclmulqdq -eq 1 && test ${HAVE_PCLMULQDQ_INTRIN} -eq 1 && test ${HAVE_AVX2_INTRIN} -eq 1; then
+ check_vpclmulqdq_intrinsics
+
+ if test ${HAVE_VPCLMULQDQ_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_VPCLMULQDQ_AVX2"
+ SFLAGS="${SFLAGS} -DX86_VPCLMULQDQ_AVX2"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_vpclmulqdq_avx2.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_vpclmulqdq_avx2.lo"
+
+ if test ${HAVE_AVX512_INTRIN} -eq 1; then
+ CFLAGS="${CFLAGS} -DX86_VPCLMULQDQ_AVX512"
+ SFLAGS="${SFLAGS} -DX86_VPCLMULQDQ_AVX512"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_vpclmulqdq_avx512.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_vpclmulqdq_avx512.lo"
+ fi
+ fi
+ fi
+ fi
+ ;;
+
+ # ARM specific optimizations
+ arm* | aarch64)
+ case "${ARCH}" in
+ arm*)
+ [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=arm
+ ;;
+ aarch64)
+ [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=aarch64
+ buildarmv6=0
+ ;;
+ esac
+
+ ARCHDIR=arch/arm
+
+ cat > $test.c << EOF
+int main() { return 0; }
+EOF
+ if try $CC -c $SFLAGS $test.c -mfloat-abi=softfp &&
+ try $LDSHARED $LDSHAREDFLAGS $LDFLAGS -o $test$shared_ext $test.o $LDSHAREDLIBC; then
+ floatabi="-mfloat-abi=softfp"
+ else
+ if try $CC -c $SFLAGS $test.c -mfloat-abi=hard &&
+ try $LDSHARED $LDSHAREDFLAGS $LDFLAGS -o $test$shared_ext $test.o $LDSHAREDLIBC; then
+ floatabi="-mfloat-abi=hard"
+ fi
+ fi
+
+ if [ -z $floatabi ]; then
+ echo "ARM floating point arch not auto-detected" | tee -a configure.log
+ else
+ echo "ARM floating point arch: ${floatabi}" | tee -a configure.log
+
+ CFLAGS="${CFLAGS} ${floatabi}"
+ SFLAGS="${SFLAGS} ${floatabi}"
+ fi
+
+ if test $without_optimizations -eq 0; then
+ CFLAGS="${CFLAGS} -DARM_FEATURES"
+ SFLAGS="${SFLAGS} -DARM_FEATURES"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} arm_features.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} arm_features.lo"
+
+ cat > $test.c <<EOF
+#include <arm_acle.h>
+EOF
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for arm_acle.h... Yes." | tee -a configure.log
+ CFLAGS="${CFLAGS} -DHAVE_ARM_ACLE_H"
+ SFLAGS="${SFLAGS} -DHAVE_ARM_ACLE_H"
+ else
+ echo "Checking for arm_acle.h... No." | tee -a configure.log
+ fi
+
+ if test $buildneon -eq 1; then
+ check_neon_compiler_flag
+
+ if test $NEON_AVAILABLE -eq 1; then
+ CFLAGS="${CFLAGS} -DARM_NEON"
+ SFLAGS="${SFLAGS} -DARM_NEON"
+
+ check_neon_ld4_intrinsics
+
+ if test $NEON_HAS_LD4 -eq 1; then
+ CFLAGS="${CFLAGS} -DARM_NEON_HASLD4"
+ SFLAGS="${SFLAGS} -DARM_NEON_HASLD4"
+ fi
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o chunkset_neon.o compare256_neon.o slide_hash_neon.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo chunkset_neon.lo compare256_neon.lo slide_hash_neon.lo"
+ fi
+ fi
+
+ if test $buildarmv6 -eq 1; then
+ check_armv6_intrinsics
+
+ if test $HAVE_ARMV6_INTRIN -eq 1 || test $HAVE_ARMV6_INLINE_ASM -eq 1; then
+ CFLAGS="${CFLAGS} -DARM_SIMD"
+ SFLAGS="${SFLAGS} -DARM_SIMD"
+
+ if test $HAVE_ARMV6_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DARM_SIMD_INTRIN"
+ SFLAGS="${SFLAGS} -DARM_SIMD_INTRIN"
+ fi
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} slide_hash_armv6.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} slide_hash_armv6.lo"
+ fi
+ fi
+
+ if test $buildarmv8 -eq 1; then
+ check_armv8_intrinsics
+
+ if test $HAVE_ARMV8_INTRIN -eq 1 || test $HAVE_ARMV8_INLINE_ASM -eq 1; then
+ CFLAGS="${CFLAGS} -DARM_CRC32"
+ SFLAGS="${SFLAGS} -DARM_CRC32"
+
+ if test $HAVE_ARMV8_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DARM_CRC32_INTRIN"
+ SFLAGS="${SFLAGS} -DARM_CRC32_INTRIN"
+ fi
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_armv8.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_armv8.lo"
+
+ # Check for PMULL support (requires NEON too)
+ if test $buildneon -eq 1 && test $NEON_AVAILABLE -eq 1; then
+ # Check for PMULL+EOR3 support (ARMv8.2-A SHA3 extension)
+ check_armv8_pmull_eor3_intrinsics
+
+ if test $HAVE_PMULL_EOR3_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DARM_PMULL_EOR3"
+ SFLAGS="${SFLAGS} -DARM_PMULL_EOR3"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_armv8_pmull_eor3.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_armv8_pmull_eor3.lo"
+ fi
+ fi
+ fi
+ fi
+ fi
+ ;;
+ powerpc*)
+ case "${ARCH}" in
+ powerpc)
+ [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=ppc
+ ;;
+ powerpc64)
+ [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=ppc64
+ ;;
+ powerpc64le)
+ [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=ppc64le
+ ;;
+ esac
+
+ ARCHDIR=arch/power
+
+ if test $without_optimizations -eq 0; then
+
+ check_ppc_intrinsics
+ check_power8_intrinsics
+ check_power9_intrinsics
+
+ if test $HAVE_VMX -eq 1; then
+ CFLAGS="${CFLAGS} -DPPC_FEATURES"
+ SFLAGS="${SFLAGS} -DPPC_FEATURES"
+ fi
+ if test $HAVE_VMX -eq 1 -o $HAVE_POWER8_INTRIN -eq 1; then
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} power_features.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} power_features.lo"
+ fi
+ if test $HAVE_VMX -eq 1 -a $HAVE_ALTIVEC_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DPPC_VMX"
+ SFLAGS="${SFLAGS} -DPPC_VMX"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_vmx.o slide_hash_vmx.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_vmx.lo slide_hash_vmx.lo"
+ fi
+ if test $HAVE_POWER8_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DPOWER8_VSX -DPOWER_FEATURES"
+ SFLAGS="${SFLAGS} -DPOWER8_VSX -DPOWER_FEATURES"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_power8.o chunkset_power8.o slide_hash_power8.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_power8.lo chunkset_power8.lo slide_hash_power8.lo"
+ case "${ARCH}" in
+ powerpc64*)
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_power8.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_power8.lo"
+ CFLAGS="${CFLAGS} -DPOWER8_VSX_CRC32"
+ SFLAGS="${SFLAGS} -DPOWER8_VSX_CRC32"
+ ;;
+ esac
+ fi
+ if test $HAVE_POWER9_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DPOWER9 -DPOWER_FEATURES"
+ SFLAGS="${SFLAGS} -DPOWER9 -DPOWER_FEATURES"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} compare256_power9.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} compare256_power9.lo"
+ fi
+ fi
+ ;;
+ riscv64)
+ [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=riscv64
+ ARCHDIR=arch/riscv
+
+ if test $without_optimizations -eq 0; then
+ if test $buildrvv -eq 1 -o $buildzbc -eq 1; then
+ CFLAGS="${CFLAGS} -DRISCV_FEATURES"
+ SFLAGS="${SFLAGS} -DRISCV_FEATURES"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} riscv_features.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} riscv_features.lo"
+ cat > $test.c <<EOF
+#include <asm/hwprobe.h>
+EOF
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for asm/hwprobe.h... Yes." | tee -a configure.log
+ CFLAGS="${CFLAGS} -DHAVE_ASM_HWPROBE_H"
+ SFLAGS="${SFLAGS} -DHAVE_ASM_HWPROBE_H"
+ else
+ echo "Checking for asm/hwprobe.h... No." | tee -a configure.log
+ fi
+ fi
+ if test $buildrvv -eq 1; then
+ check_rvv_compiler_flag
+
+ if test $HAVE_RVV_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DRISCV_FEATURES -DRISCV_RVV"
+ SFLAGS="${SFLAGS} -DRISCV_FEATURES -DRISCV_RVV"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_rvv.o chunkset_rvv.o compare256_rvv.o slide_hash_rvv.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_rvv.lo chunkset_rvv.lo compare256_rvv.lo slide_hash_rvv.lo"
+
+ ARCH="${ARCH}+rvv"
+ fi
+ fi
+ if test $buildzbc -eq 1; then
+ check_zbc_compiler_flag
+
+ if test $HAVE_ZBC_EXT -eq 1; then
+ CFLAGS="${CFLAGS} -DRISCV_CRC32_ZBC"
+ SFLAGS="${SFLAGS} -DRISCV_CRC32_ZBC"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_zbc.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_zbc.lo"
+ fi
+ fi
+ fi
+ ;;
+ s390x)
+ [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=s390x
+ ARCHDIR=arch/s390
+
+ if test $without_optimizations -eq 0; then
+ if test $buildcrc32vx -eq 1; then
+ CFLAGS="${CFLAGS} -DS390_FEATURES"
+ SFLAGS="${SFLAGS} -DS390_FEATURES"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} s390_features.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} s390_features.lo"
+ fi
+
+ if test $builddfltccdeflate -eq 1; then
+ CFLAGS="${CFLAGS} -DS390_DFLTCC_DEFLATE"
+ SFLAGS="${SFLAGS} -DS390_DFLTCC_DEFLATE"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} dfltcc_deflate.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} dfltcc_deflate.lo"
+ ARCH="${ARCH}+dfltcc-deflate"
+ fi
+
+ if test $builddfltccinflate -eq 1; then
+ CFLAGS="${CFLAGS} -DS390_DFLTCC_INFLATE"
+ SFLAGS="${SFLAGS} -DS390_DFLTCC_INFLATE"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} dfltcc_inflate.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} dfltcc_inflate.lo"
+ ARCH="${ARCH}+dfltcc-inflate"
+ fi
+
+ if test $buildcrc32vx -eq 1; then
+ check_vgfma_intrinsics
+ if test $HAVE_VGFMA_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DS390_CRC32_VX"
+ SFLAGS="${SFLAGS} -DS390_CRC32_VX"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32-vx.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32-vx.lo"
+ ARCH="${ARCH}+crc32-vx"
+ fi
+ fi
+ fi
+ ;;
+ # loongarch specific optimizations
+ loongarch64)
+ ARCHDIR=arch/loongarch
+
+ # Enable arch-specific optimizations
+ if test $without_optimizations -eq 0; then
+ CFLAGS="${CFLAGS} -DLOONGARCH_FEATURES"
+ SFLAGS="${SFLAGS} -DLOONGARCH_FEATURES"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} loongarch_features.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} loongarch_features.lo"
+
+ if test $buildcrc32la -eq 1; then
+ check_la64_crc_intrinsics
+ if test $HAVE_LA64_CRC_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DLOONGARCH_CRC"
+ SFLAGS="${SFLAGS} -DLOONGARCH_CRC"
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_la.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_la.lo"
+ fi
+ fi
+
+ check_lsx_intrinsics
+ if test $HAVE_LSX_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DLOONGARCH_LSX"
+ SFLAGS="${SFLAGS} -DLOONGARCH_LSX"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_lsx.o chunkset_lsx.o compare256_lsx.o slide_hash_lsx.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_lsx.lo chunkset_lsx.lo compare256_lsx.lo slide_hash_lsx.lo"
+ fi
+
+ check_lasx_intrinsics
+ if test $HAVE_LASX_INTRIN -eq 1; then
+ CFLAGS="${CFLAGS} -DLOONGARCH_LASX"
+ SFLAGS="${SFLAGS} -DLOONGARCH_LASX"
+
+ ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_lasx.o chunkset_lasx.o compare256_lasx.o slide_hash_lasx.o"
+ ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_lasx.lo chunkset_lasx.lo compare256_lasx.lo slide_hash_lasx.lo"
+ fi
+ fi
+ ;;
+
+ *)
+ [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=$ARCH
+ ;;
+esac
+
+echo "Uname: $uname"
+echo "ARCH: ${ARCH}"
+echo "Using arch directory: ${ARCHDIR}"
+echo "Architecture-specific static object files:${ARCH_STATIC_OBJS}"
+echo "Architecture-specific shared object files:${ARCH_SHARED_OBJS}"
+
+# show the results in the log
+echo >> configure.log
+echo ALL = $ALL >> configure.log
+echo AR = $AR >> configure.log
+echo ARFLAGS = $ARFLAGS >> configure.log
+echo CC = $CC >> configure.log
+echo CFLAGS = $CFLAGS >> configure.log
+echo EXE = $EXE >> configure.log
+echo LDCONFIG = $LDCONFIG >> configure.log
+echo LDFLAGS = $LDFLAGS >> configure.log
+echo LDSHARED = $LDSHARED >> configure.log
+echo LDSHAREDFLAGS = $LDSHAREDFLAGS >> configure.log
+echo LDSHAREDLIBC = $LDSHAREDLIBC >> configure.log
+echo DEFFILE = $DEFFILE >> configure.log
+echo RC = $RC >> configure.log
+echo RCFLAGS = $RCFLAGS >> configure.log
+echo RCOBJS = $RCOBJS >> configure.log
+echo STRIP = $STRIP >> configure.log
+echo OBJC = $OBJC >> configure.log
+echo TESTOBJG = $TESTOBJG >> configure.log
+echo PIC_TESTOBJG = $PIC_TESTOBJG >> configure.log
+echo PIC_OBJC = $PIC_OBJC >> configure.log
+echo RANLIB = $RANLIB >> configure.log
+echo SFLAGS = $SFLAGS >> configure.log
+echo SHAREDLIB = $SHAREDLIB >> configure.log
+echo SHAREDLIBM = $SHAREDLIBM >> configure.log
+echo SHAREDLIBV = $SHAREDLIBV >> configure.log
+echo SHAREDTARGET = $SHAREDTARGET >> configure.log
+echo IMPORTLIB = $IMPORTLIB >> configure.log
+echo INSTALLTARGETS = $INSTALLTARGETS >> configure.log
+echo UNINSTALLTARGETS = $UNINSTALLTARGETS >> configure.log
+echo SRCDIR = $SRCDIR >> configure.log
+echo BUILDDIR = $BUILDDIR >> configure.log
+echo STATICLIB = $STATICLIB >> configure.log
+echo TEST = $TEST >> configure.log
+echo VER = $VER >> configure.log
+echo exec_prefix = $exec_prefix >> configure.log
+echo includedir = $includedir >> configure.log
+echo installnamedir = $installnamedir >> configure.log
+echo bindir = $bindir >> configure.log
+echo libdir = $libdir >> configure.log
+echo mandir = $mandir >> configure.log
+echo prefix = $prefix >> configure.log
+echo symbol_prefix = $symbol_prefix >> configure.log
+echo sharedlibdir = $sharedlibdir >> configure.log
+echo uname = $uname >> configure.log
+echo sse2flag = $sse2flag >> configure.log
+echo ssse3flag = $ssse3flag >> configure.log
+echo sse42flag = $sse42flag >> configure.log
+echo pclmulflag = $pclmulflag >> configure.log
+echo vpclmulflag = $vpclmulflag >> configure.log
+echo xsaveflag = $xsaveflag >> configure.log
+echo armv8flag = $armv8flag >> configure.log
+echo pmulleor3flag = $pmulleor3flag >> configure.log
+echo neonflag = $neonflag >> configure.log
+echo armv6flag = $armv6flag >> configure.log
+echo lsxflag = $lsxflag >> configure.log
+echo lasxflag = $lasxflag >> configure.log
+echo ARCHDIR = ${ARCHDIR} >> configure.log
+echo ARCH_STATIC_OBJS = ${ARCH_STATIC_OBJS} >> configure.log
+echo ARCH_SHARED_OBJS = ${ARCH_SHARED_OBJS} >> configure.log
+
+# Handle sed incompatibilities when using -i
+replace_in_file() {
+ if [ "$OS" = 'Darwin' ]; then
+ sed -i '.tmp' -e "$1" "$2"
+ else
+ sed -i'.tmp' -e "$1" "$2"
+ fi
+}
+
+# update Makefile with the configure results
+
+INCLUDES="-I$SRCDIR"
+if [ "$SRCDIR" != "$BUILDDIR" ]; then INCLUDES="-I$BUILDDIR ${INCLUDES}"; fi
+
+sed < $SRCDIR/Makefile.in "
+/^CC *=/s#=.*#=$CC#
+/^CFLAGS *=/s#=.*#=$CFLAGS#
+/^SFLAGS *=/s#=.*#=$SFLAGS#
+/^LDFLAGS *=/s#=.*#=$LDFLAGS#
+/^LDSHARED *=/s#=.*#=$LDSHARED#
+/^LDSHAREDFLAGS *=/s#=.*#=$LDSHAREDFLAGS#
+/^LDVERSIONSCRIPT *=/s#=.*#=$LDVERSIONSCRIPT#
+/^LIBNAME1 *=/s#=.*#=$LIBNAME#
+/^LIBNAME2 *=/s#=.*#=$LIBNAME2#
+/^SUFFIX *=/s#=.*#=$SUFFIX#
+/^STATICLIB *=/s#=.*#=$STATICLIB#
+/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
+/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
+/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
+/^SHAREDTARGET *=/s#=.*#=$SHAREDTARGET#
+/^IMPORTLIB *=/s#=.*#=$IMPORTLIB#
+/^VER *=/s#=.*#=$VER#
+/^VER1 *=/s#=.*#=$VER1#
+/^AR *=/s#=.*#=$AR#
+/^ARFLAGS *=/s#=.*#=$ARFLAGS#
+/^RANLIB *=/s#=.*#=$RANLIB#
+/^LDCONFIG *=/s#=.*#=$LDCONFIG#
+/^LDSHAREDLIBC *=/s#=.*#=$LDSHAREDLIBC#
+/^DEFFILE *=/s#=.*#=$DEFFILE#
+/^RC *=/s#=.*#=$RC#
+/^RCFLAGS *=/s#=.*#=$RCFLAGS#
+/^RCOBJS *=/s#=.*#=$RCOBJS#
+/^STRIP *=/s#=.*#=$STRIP#
+/^EXE *=/s#=.*#=$EXE#
+/^prefix *=/s#=.*#= $prefix#
+/^exec_prefix *=/s#=.*#= $exec_prefix#
+/^bindir *=/s#=.*#= $bindir#
+/^symbol_prefix *=/s#=.*#= $symbol_prefix#
+/^libdir *=/s#=.*#= $libdir#
+/^sharedlibdir *=/s#=.*#= $sharedlibdir#
+/^includedir *=/s#=.*#= $includedir#
+/^installnamedir *=/s#=.*#= $installnamedir#
+/^mandir *=/s#=.*#= $mandir#
+/^SRCDIR *=/s#=.*#=$SRCDIR#
+/^INCLUDES *=/s#=.*#=$INCLUDES#
+/^OBJC *=/s#=.*#= $OBJC#
+/^TESTOBJG *=/s#=.*#= $TESTOBJG#
+/^PIC_TESTOBJG *=/s#=.*#= $PIC_TESTOBJG#
+/^PIC_OBJC *=/s#=.*#= $PIC_OBJC#
+/^all: */s#:.*#: $ALL#
+/^install-libs: */s#:.*#: $INSTALLTARGETS#
+/^uninstall-libs: */s#:.*#: $UNINSTALLTARGETS#
+/^ARCHDIR *=/s#=.*#=$ARCHDIR#
+/^ARCH_STATIC_OBJS *=/s#=.*#=$ARCH_STATIC_OBJS#
+/^ARCH_SHARED_OBJS *=/s#=.*#=$ARCH_SHARED_OBJS#
+" > Makefile
+
+# Append header files dependencies.
+for file in $SRCDIR/*.c $SRCDIR/test/*.c $SRCDIR/test/fuzz/*.c $SRCDIR/$ARCHDIR/*.c $SRCDIR/tools/*.c; do
+ if test ! -f $file; then
+ continue
+ fi
+
+ short_name=$(echo $file | sed -e "s#$SRCDIR/##g")
+ incs=$(grep -h include $file | sed -n 's/# *include *"\(.*\.h\)".*/\1/p' | sort | uniq)
+ includes=$(for i in $incs; do
+ # Check that the include file exists in the current dir,
+ # otherwise it may be one of the system include header.
+ if test -e $SRCDIR/$i; then
+ printf " \$(SRCDIR)/$i"
+ fi
+ # We also need to check whether the include file is in the ARCHDIR.
+ if test -e $SRCDIR/$ARCHDIR/$i; then
+ printf " \$(SRCDIR)/$ARCHDIR/$i"
+ fi
+ done)
+ obj=$(basename $(echo $file | sed -e 's/\.c/\.o/g' -e 's#^\./##g'))
+ lobj=$(basename $(echo $file | sed -e 's/\.c/\.lo/g' -e 's#^\./##g'))
+
+ if grep -q "^$obj:" Makefile; then
+ # Replace the existing line with a line with all dependences.
+ $(replace_in_file "s#$obj:.*#$obj: \$(SRCDIR)/$short_name $includes#g" Makefile)
+ else
+ # Append at the end of Makefile a new line with the header dependences.
+ echo "$obj: \$(SRCDIR)/$short_name $includes" >> Makefile
+
+ # In case this is one of the ARCHDIR files, append a dependence line
+ # that will force the `$(MAKE) -C $(ARCHDIR)` generic rule. Without this
+ # we would only execute the copy rule from ARCHDIR to SRCDIR.
+ if test -e $SRCDIR/$ARCHDIR/$(basename $file); then
+ echo "$ARCHDIR/$obj: \$(SRCDIR)/$short_name $includes" >> Makefile
+ fi
+ fi
+
+ if grep -q "^$lobj:" Makefile; then
+ # Replace the existing line with a line with all dependences.
+ $(replace_in_file "s#$lobj:.*#$lobj: \$(SRCDIR)/$short_name $includes#g" Makefile)
+ else
+ # Append at the end of Makefile a new line with the header dependences.
+ echo "$lobj: \$(SRCDIR)/$short_name $includes" >> Makefile
+ fi
+done
+
+# Generate Makefile in arch dir
+mkdir -p $ARCHDIR
+
+sed < $SRCDIR/$ARCHDIR/Makefile.in "
+/^CC *=/s#=.*#=$CC#
+/^CFLAGS *=/s#=.*#=$CFLAGS#
+/^SFLAGS *=/s#=.*#=$SFLAGS#
+/^LDFLAGS *=/s#=.*#=$LDFLAGS#
+/^INCLUDES *=/s#=.*#=$INCLUDES#
+/^SUFFIX *=/s#=.*#=$SUFFIX#
+/^SRCDIR *=/s#=.*#=$SRCDIR/$ARCHDIR#
+/^SRCTOP *=/s#=.*#=$SRCDIR#
+/^BUILDDIR *=/s#=.*#=$BUILDDIR#
+/^AVX2FLAG *=/s#=.*#=$avx2flag#
+/^AVX512FLAG *=/s#=.*#=$avx512flag#
+/^AVX512VNNIFLAG *=/s#=.*#=$avx512vnniflag#
+/^SSE2FLAG *=/s#=.*#=$sse2flag#
+/^SSSE3FLAG *=/s#=.*#=$ssse3flag#
+/^SSE41FLAG *=/s#=.*#=$sse41flag#
+/^SSE42FLAG *=/s#=.*#=$sse42flag#
+/^PCLMULFLAG *=/s#=.*#=$pclmulflag#
+/^VPCLMULFLAG *=/s#=.*#=$vpclmulflag#
+/^XSAVEFLAG *=/s#=.*#=$xsaveflag#
+/^ARMV8FLAG *=/s#=.*#=$armv8flag#
+/^PMULLEOR3FLAG *=/s#=.*#=$pmulleor3flag#
+/^NEONFLAG *=/s#=.*#=$neonflag#
+/^ARMV6FLAG *=/s#=.*#=$armv6flag#
+/^NOLTOFLAG *=/s#=.*#=$noltoflag#
+/^VGFMAFLAG *=/s#=.*#=$vgfmaflag#
+/^PPCFLAGS *=/s#=.*#=$vmxflag#
+/^RVVFLAG *=/s#=.*#=$rvvflag#
+/^RVVZBCFLAG *=/s#=.*#=$rvvzbcflag#
+/^ZBCFLAG *=/s#=.*#=$zbcflag#
+/^LSXFLAG *=/s#=.*#=$lsxflag#
+/^LASXFLAG *=/s#=.*#=$lasxflag#
+" > $ARCHDIR/Makefile
+
+# Append header files dependencies.
+for file in $SRCDIR/$ARCHDIR/*.c; do
+ if test ! -f $file; then
+ continue
+ fi
+
+ incs=$(grep -h include $file | sed -n 's/# *include *"\(.*\.h\)".*/\1/p' | sort | uniq)
+ includes=$(for i in $incs; do
+ # Check that the include file exists in the current dir,
+ # otherwise it may be one of the system include header.
+ if test -e $SRCDIR/$i; then
+ printf " \$(SRCTOP)/$i"
+ fi
+ # We also need to check whether the include file is in the ARCHDIR.
+ if test -e $SRCDIR/$ARCHDIR/$i; then
+ printf " \$(SRCDIR)/$i"
+ fi
+ done)
+ obj=$(basename $(echo $file | sed -e 's/\.c/\.o/g' -e 's#^\./##g'))
+ lobj=$(basename $(echo $file | sed -e 's/\.c/\.lo/g' -e 's#^\./##g'))
+ short_name=$(basename $file)
+ if grep -q "^$obj:" $ARCHDIR/Makefile; then
+ # Replace the existing line with a line with all dependences.
+ $(replace_in_file "s#$obj:.*#$obj: \$(SRCDIR)/$short_name $includes#g" $ARCHDIR/Makefile)
+ else
+ # Append at the end of Makefile a new line with the header dependences.
+ echo "$obj: \$(SRCDIR)/$short_name $includes" >> $ARCHDIR/Makefile
+ fi
+
+ if grep -q "^$lobj:" $ARCHDIR/Makefile; then
+ # Replace the existing line with a line with all dependences.
+ $(replace_in_file "s#$lobj:.*#$lobj: \$(SRCDIR)/$short_name $includes#g" $ARCHDIR/Makefile)
+ else
+ # Append at the end of Makefile a new line with the header dependences.
+ echo "$lobj: \$(SRCDIR)/$short_name $includes" >> $ARCHDIR/Makefile
+ fi
+done
+
+# Generate Makefile in generic arch dir
+mkdir -p arch/generic
+
+sed < $SRCDIR/arch/generic/Makefile.in "
+/^CC *=/s#=.*#=$CC#
+/^CFLAGS *=/s#=.*#=$CFLAGS#
+/^SFLAGS *=/s#=.*#=$SFLAGS#
+/^INCLUDES *=/s#=.*#=$INCLUDES#
+/^SRCDIR *=/s#=.*#=$SRCDIR/arch/generic#
+/^SRCTOP *=/s#=.*#=$SRCDIR#
+/^BUILDDIR *=/s#=.*#=$BUILDDIR#
+" > arch/generic/Makefile
+
+## TODO: Process header dependencies
+
+# Emscripten does not support large amounts of data via stdin/out
+# https://github.com/emscripten-core/emscripten/issues/16755#issuecomment-1102732849
+if test "$CHOST" != "wasm32"; then
+ TEST="${TEST} ghtests"
+fi
+
+# Determine emulator to use when running tests
+if test -z "$EMU_RUN" && test $QEMU_ARCH; then
+ EMU_RUN="qemu-$QEMU_ARCH -L /usr/${CHOST}/"
+fi
+if test -n "$EMU_RUN"; then
+ echo "Using cross-compile emulator: $EMU_RUN"
+fi
+
+if test $gzfileops -eq 1; then
+ PC_CFLAGS="-DWITH_GZFILEOP"
+fi
+
+# Generate Makefile in test dir
+mkdir -p test
+sed < $SRCDIR/test/Makefile.in "
+/^CC *=/s#=.*#=$CC#
+/^CFLAGS *=/s#=.*#=$CFLAGS#
+/^LDFLAGS *=/s#=.*#=$LDFLAGS#
+/^EXE *=/s#=.*#=$EXE#
+/^alltests: */s#:.*#: $TEST#
+/^SRCDIR *=/s#=.*#=$SRCDIR/test#
+/^SRCTOP *=/s#=.*#=$SRCDIR#
+/^EMU_RUN *=/s#=.*#=$EMU_RUN#
+/^LIBNAME *=/s#=.*#=$LIBNAME#
+" > test/Makefile
+
+# create zlib.pc with the configure results
+sed < $SRCDIR/zlib.pc.in "
+/^CC *=/s#=.*#=$CC#
+/^CFLAGS *=/s#=.*#=$CFLAGS#
+/^LDFLAGS *=/s#=.*#=$LDFLAGS#
+/^LDSHARED *=/s#=.*#=$LDSHARED#
+/^LDSHAREDFLAGS *=/s#=.*#=$LDSHAREDFLAGS#
+/^STATICLIB *=/s#=.*#=$STATICLIB#
+/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
+/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
+/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
+/^IMPORTLIB *=/s#=.*#=$IMPORTLIB#
+/^AR *=/s#=.*#=$AR#
+/^ARFLAGS *=/s#=.*#=$ARFLAGS#
+/^RANLIB *=/s#=.*#=$RANLIB#
+/^EXE *=/s#=.*#=$EXE#
+/^prefix *=/s#=.*#=$prefix#
+/^exec_prefix *=/s#=.*#=$exec_prefix#
+/^bindir *=/s#=.*#=$bindir#
+/^symbol_prefix *=/s#=.*#=$symbol_prefix#
+/^libdir *=/s#=.*#=$libdir#
+/^sharedlibdir *=/s#=.*#=$sharedlibdir#
+/^includedir *=/s#=.*#=$includedir#
+/^installnamedir *=/s#=.*#=$installnamedir#
+/^mandir *=/s#=.*#=$mandir#
+/^LDFLAGS *=/s#=.*#=$LDFLAGS#
+" | sed -e "
+s/\@VERSION\@/$VER/g;
+s/\@SUFFIX\@/$SUFFIX/g;
+s/\@PKG_CONFIG_CFLAGS\@/$PC_CFLAGS/g;
+" > ${LIBNAME2}.pc
+
+# done
+leave 0
generated by cgit 0.0.5-2-1-g0f52 (git 2.46.0) at 2026-04-05 19:40:17 +0000