2013-08-26 23:37:08 -07:00
|
|
|
AC_PREREQ([2.65])
|
2017-02-20 02:57:35 -07:00
|
|
|
AC_INIT([libsodium],[1.0.12],
|
2013-04-27 11:42:27 -07:00
|
|
|
[https://github.com/jedisct1/libsodium/issues],
|
2013-04-27 16:39:23 -07:00
|
|
|
[libsodium],
|
2013-04-27 11:42:27 -07:00
|
|
|
[https://github.com/jedisct1/libsodium])
|
2014-11-02 17:49:17 -07:00
|
|
|
AC_CONFIG_AUX_DIR([build-aux])
|
2013-01-19 17:02:02 -07:00
|
|
|
AC_CONFIG_MACRO_DIR([m4])
|
2013-04-18 06:24:07 -07:00
|
|
|
AC_CONFIG_SRCDIR([src/libsodium/sodium/version.c])
|
2013-01-19 17:02:02 -07:00
|
|
|
AC_CANONICAL_HOST
|
2013-08-05 11:19:13 -07:00
|
|
|
AM_INIT_AUTOMAKE([1.11 dist-bzip2 tar-ustar foreign subdir-objects])
|
2013-01-20 19:06:07 -07:00
|
|
|
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
|
2013-01-19 17:02:02 -07:00
|
|
|
AM_MAINTAINER_MODE
|
|
|
|
AM_DEP_TRACK
|
|
|
|
|
|
|
|
AC_SUBST(VERSION)
|
|
|
|
ISODATE=`date +%Y-%m-%d`
|
|
|
|
AC_SUBST(ISODATE)
|
|
|
|
|
2015-11-14 07:33:15 -07:00
|
|
|
SODIUM_LIBRARY_VERSION_MAJOR=9
|
2017-02-20 02:57:35 -07:00
|
|
|
SODIUM_LIBRARY_VERSION_MINOR=4
|
2015-11-14 07:33:15 -07:00
|
|
|
DLL_VERSION=8
|
2017-02-20 02:57:35 -07:00
|
|
|
SODIUM_LIBRARY_VERSION=20:0:2
|
2014-05-12 14:07:48 -07:00
|
|
|
# | | |
|
|
|
|
# +------+ | +---+
|
|
|
|
# | | |
|
|
|
|
# current:revision:age
|
|
|
|
# | | |
|
|
|
|
# | | +- increment if interfaces have been added
|
|
|
|
# | | set to zero if interfaces have been removed
|
|
|
|
# | | or changed
|
|
|
|
# | +- increment if source code has changed
|
|
|
|
# | set to zero if current is incremented
|
|
|
|
# +- increment if interfaces have been added, removed or changed
|
2013-03-31 15:22:43 -07:00
|
|
|
AC_SUBST(SODIUM_LIBRARY_VERSION_MAJOR)
|
|
|
|
AC_SUBST(SODIUM_LIBRARY_VERSION_MINOR)
|
2013-01-20 18:51:57 -07:00
|
|
|
AC_SUBST(SODIUM_LIBRARY_VERSION)
|
2013-04-23 21:24:35 -07:00
|
|
|
AC_SUBST(DLL_VERSION)
|
2013-01-20 18:51:57 -07:00
|
|
|
|
2016-12-28 23:51:50 -07:00
|
|
|
AC_LANG_ASSERT(C)
|
2013-07-07 22:25:20 -07:00
|
|
|
LX_CFLAGS=${CFLAGS-NONE}
|
|
|
|
|
2014-12-21 01:51:32 -07:00
|
|
|
dnl Path check
|
|
|
|
|
2016-06-15 00:50:45 -07:00
|
|
|
AS_IF([pwd | fgrep ' ' > /dev/null 2>&1],
|
|
|
|
[AC_MSG_ERROR([The build directory contains whitespaces - This can cause tests/installation to fail due to limitations of some libtool versions])]
|
2014-12-21 01:51:32 -07:00
|
|
|
)
|
|
|
|
|
2013-07-07 21:46:44 -07:00
|
|
|
dnl Switches
|
|
|
|
|
2013-07-07 22:20:27 -07:00
|
|
|
AC_ARG_ENABLE(ssp,
|
2013-07-07 22:38:51 -07:00
|
|
|
[AS_HELP_STRING(--disable-ssp,Do not compile with -fstack-protector)],
|
2013-07-07 22:20:27 -07:00
|
|
|
[
|
|
|
|
AS_IF([test "x$enableval" = "xno"], [
|
|
|
|
enable_ssp="no"
|
|
|
|
], [
|
|
|
|
enable_ssp="yes"
|
|
|
|
])
|
|
|
|
],
|
|
|
|
[
|
|
|
|
enable_ssp="yes"
|
|
|
|
])
|
|
|
|
|
2013-07-07 21:46:44 -07:00
|
|
|
AC_ARG_ENABLE(asm,
|
|
|
|
[AS_HELP_STRING(--disable-asm,Disable assembly implementations)],
|
|
|
|
[
|
|
|
|
AS_IF([test "x$enableval" = "xno"], [
|
|
|
|
enable_asm="no"
|
|
|
|
], [
|
|
|
|
enable_asm="yes"
|
|
|
|
])
|
|
|
|
],
|
|
|
|
[
|
|
|
|
enable_asm="yes"
|
|
|
|
])
|
|
|
|
|
2016-04-28 12:31:18 -07:00
|
|
|
AS_IF([test "x$EMSCRIPTEN" != "x"], [
|
2013-07-07 21:46:44 -07:00
|
|
|
enable_asm="no"
|
2016-04-28 12:31:18 -07:00
|
|
|
AC_MSG_WARN([compiling to JavaScript - asm implementations disabled])
|
|
|
|
])
|
|
|
|
AS_IF([test "$host_os" = "nacl" -o "$host_os" = "pnacl"], [
|
|
|
|
enable_asm="no"
|
|
|
|
AC_MSG_WARN([compiling to Native Client - asm implementations disabled])
|
2013-07-07 21:46:44 -07:00
|
|
|
])
|
|
|
|
|
2013-07-07 22:29:58 -07:00
|
|
|
AC_ARG_ENABLE(pie,
|
2013-07-07 22:35:34 -07:00
|
|
|
[AS_HELP_STRING(--disable-pie,Do not produce position independent executables)],
|
2013-07-07 22:29:58 -07:00
|
|
|
enable_pie=$enableval, enable_pie="maybe")
|
|
|
|
|
2014-08-04 14:30:07 -07:00
|
|
|
AS_CASE([$host_os], [mingw*|cygwin*|msys], [enable_pie="no"])
|
2013-09-08 22:06:27 -07:00
|
|
|
|
2013-07-07 21:46:44 -07:00
|
|
|
AC_ARG_ENABLE(blocking-random,
|
2014-12-23 12:24:23 -07:00
|
|
|
[AS_HELP_STRING(--enable-blocking-random,Enable this switch only if /dev/urandom is totally broken on the target platform)],
|
2013-08-18 13:06:00 -07:00
|
|
|
[
|
|
|
|
AS_IF([test "x$enableval" = "xyes"], [
|
2014-12-23 12:24:23 -07:00
|
|
|
AC_DEFINE([USE_BLOCKING_RANDOM], [1], [/dev/urandom is insecure on the target platform])
|
2013-08-18 13:06:00 -07:00
|
|
|
])
|
|
|
|
])
|
2013-07-07 21:46:44 -07:00
|
|
|
|
2014-07-09 20:24:04 -07:00
|
|
|
AC_ARG_ENABLE(minimal,
|
|
|
|
[AS_HELP_STRING(--enable-minimal,
|
2014-07-14 18:43:46 -07:00
|
|
|
[Only compile the minimum set of functions required for the high-level API])],
|
2014-07-09 20:24:04 -07:00
|
|
|
[
|
|
|
|
AS_IF([test "x$enableval" = "xyes"], [
|
|
|
|
enable_minimal="yes"
|
|
|
|
], [
|
|
|
|
enable_minimal="no"
|
|
|
|
])
|
|
|
|
],
|
|
|
|
[
|
|
|
|
enable_minimal="no"
|
|
|
|
])
|
|
|
|
AM_CONDITIONAL([MINIMAL], [test x$enable_minimal = xyes])
|
|
|
|
|
2016-04-18 11:54:46 -07:00
|
|
|
AC_ARG_WITH(pthreads, AC_HELP_STRING([--with-pthreads],
|
|
|
|
[use pthreads library, or --without-pthreads to disable threading support.]),
|
|
|
|
[ ], [withval="yes"])
|
|
|
|
|
|
|
|
AS_IF([test "x$withval" = "xyes"], [
|
|
|
|
AX_PTHREAD([
|
2016-04-18 15:24:46 -07:00
|
|
|
AC_DEFINE([HAVE_PTHREAD], [1], [Define if you have POSIX threads libraries and header files])
|
2016-04-18 11:54:46 -07:00
|
|
|
LIBS="$PTHREAD_LIBS $LIBS"
|
|
|
|
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
|
|
|
|
CC="$PTHREAD_CC"])
|
|
|
|
])
|
|
|
|
|
2013-07-07 21:46:44 -07:00
|
|
|
AC_ARG_WITH(safecode,
|
|
|
|
[AS_HELP_STRING(--with-safecode,For maintainers only - please do not use)],
|
|
|
|
[AS_IF([test "x$withval" = "xyes"], [
|
|
|
|
AC_ARG_VAR([SAFECODE_HOME], [set to the safecode base directory])
|
|
|
|
: ${SAFECODE_HOME:=/opt/safecode}
|
|
|
|
LDFLAGS="$LDFLAGS -L${SAFECODE_HOME}/lib"
|
|
|
|
LIBS="$LIBS -lsc_dbg_rt -lpoolalloc_bitmap -lstdc++"
|
|
|
|
CFLAGS="$CFLAGS -fmemsafety"
|
|
|
|
])
|
|
|
|
])
|
|
|
|
|
2013-07-07 22:25:20 -07:00
|
|
|
AC_ARG_ENABLE(debug,
|
|
|
|
[AS_HELP_STRING(--enable-debug,For maintainers only - please do not use)],
|
|
|
|
[
|
2013-08-18 13:06:00 -07:00
|
|
|
AS_IF([test "x$enableval" = "xyes"], [
|
|
|
|
AS_IF([test "x$LX_CFLAGS" = "xNONE"], [
|
|
|
|
nxflags=""
|
|
|
|
for flag in `echo $CFLAGS`; do
|
2013-09-08 10:44:07 -07:00
|
|
|
AS_CASE([$flag],
|
|
|
|
[-O*], [ ],
|
|
|
|
[-g*], [ ],
|
|
|
|
[*], [AS_VAR_APPEND([nxflags], [" $flag"])])
|
2013-08-18 13:06:00 -07:00
|
|
|
done
|
|
|
|
CFLAGS="$nxflags -O0 -g3"
|
|
|
|
])
|
|
|
|
CPPFLAGS="$CPPFLAGS -DDEBUG=1"
|
2013-07-07 22:25:20 -07:00
|
|
|
])
|
|
|
|
])
|
|
|
|
|
2015-12-05 09:56:42 -07:00
|
|
|
AC_ARG_ENABLE(opt,
|
|
|
|
[AS_HELP_STRING(--enable-opt,Optimize for the native CPU - The resulting library will be faster but not portable)],
|
|
|
|
[
|
|
|
|
AS_IF([test "x$enableval" = "xyes"], [
|
2016-03-24 02:55:47 -07:00
|
|
|
CFLAGS="$CFLAGS -O3 -march=native"
|
2016-03-08 04:53:23 -07:00
|
|
|
LDFLAGS="$LDFLAGS -O3 -march=native"])
|
2015-12-05 09:56:42 -07:00
|
|
|
])
|
|
|
|
|
2013-07-07 21:46:44 -07:00
|
|
|
AC_SUBST([MAINT])
|
|
|
|
|
2016-03-05 17:32:02 -07:00
|
|
|
AX_VALGRIND_CHECK
|
|
|
|
|
2013-07-07 21:46:44 -07:00
|
|
|
dnl Checks
|
|
|
|
|
2013-01-19 17:02:02 -07:00
|
|
|
AC_PROG_CC_C99
|
2013-04-27 10:21:32 -07:00
|
|
|
AM_PROG_AS
|
2013-01-19 17:02:02 -07:00
|
|
|
AC_USE_SYSTEM_EXTENSIONS
|
2014-11-02 20:24:08 -07:00
|
|
|
|
2015-08-02 04:53:22 -07:00
|
|
|
AC_CHECK_DEFINE([__native_client__], [NATIVECLIENT="yes"], [])
|
|
|
|
|
2015-08-01 18:36:52 -07:00
|
|
|
AC_CHECK_DEFINE([_FORTIFY_SOURCE], [], [
|
|
|
|
AX_CHECK_COMPILE_FLAG([-D_FORTIFY_SOURCE=2],
|
|
|
|
[CPPFLAGS="$CPPFLAGS -D_FORTIFY_SOURCE=2"])
|
|
|
|
])
|
2013-01-19 17:02:02 -07:00
|
|
|
|
2013-04-24 08:46:39 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([-fvisibility=hidden],
|
|
|
|
[CFLAGS="$CFLAGS -fvisibility=hidden"])
|
|
|
|
|
2014-08-04 14:30:07 -07:00
|
|
|
AS_CASE([$host_os], [cygwin*|mingw*|msys|pw32*|cegcc*], [ ], [
|
2016-12-28 23:51:50 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([-fPIC], [CFLAGS="$CFLAGS -fPIC"])
|
2013-04-24 13:08:25 -07:00
|
|
|
])
|
2013-01-19 17:02:02 -07:00
|
|
|
|
|
|
|
AS_IF([test "$enable_pie" != "no"],[
|
|
|
|
AX_CHECK_COMPILE_FLAG([-fPIE], [
|
2016-12-28 23:51:50 -07:00
|
|
|
AX_CHECK_LINK_FLAG([-pie], [
|
|
|
|
[CFLAGS="$CFLAGS -fPIE"
|
|
|
|
LDFLAGS="$LDFLAGS -pie"]
|
2013-01-19 17:02:02 -07:00
|
|
|
])
|
|
|
|
])
|
|
|
|
])
|
|
|
|
|
|
|
|
AX_CHECK_COMPILE_FLAG([-fno-strict-aliasing], [CFLAGS="$CFLAGS -fno-strict-aliasing"])
|
2014-11-25 13:19:08 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([-fno-strict-overflow], [CFLAGS="$CFLAGS -fno-strict-overflow"], [
|
|
|
|
AX_CHECK_COMPILE_FLAG([-fwrapv], [CFLAGS="$CFLAGS -fwrapv"])
|
|
|
|
])
|
2013-01-19 17:02:02 -07:00
|
|
|
|
2016-03-24 11:11:21 -07:00
|
|
|
AS_IF([test "$GCC" = "yes" ], [
|
|
|
|
AS_CASE([$host_cpu],
|
|
|
|
[i?86|amd64|x86_64], [
|
|
|
|
AC_COMPILE_IFELSE(
|
|
|
|
[AC_LANG_SOURCE([
|
|
|
|
#if !defined(__clang__) && defined(__GNUC__) && ((__GNUC__ << 8) | __GNUC_MINOR__) < 0x403
|
|
|
|
# error old gcc
|
|
|
|
#endif
|
|
|
|
int main(void) { return 0; }
|
|
|
|
])],,[
|
|
|
|
AX_CHECK_COMPILE_FLAG([-flax-vector-conversions], [CFLAGS="$CFLAGS -flax-vector-conversions"])
|
|
|
|
])
|
|
|
|
]
|
|
|
|
)
|
|
|
|
])
|
|
|
|
|
2014-02-22 18:07:52 -07:00
|
|
|
LIBTOOL_OLD_FLAGS="$LIBTOOL_EXTRA_FLAGS"
|
|
|
|
LIBTOOL_EXTRA_FLAGS="$LIBTOOL_EXTRA_FLAGS -version-info $SODIUM_LIBRARY_VERSION"
|
2014-02-20 09:54:05 -07:00
|
|
|
AC_ARG_ENABLE(soname-versions,
|
2014-09-14 13:56:02 -07:00
|
|
|
[AC_HELP_STRING([--enable-soname-versions], [enable soname versions (must be disabled for Android) (default: enabled)])],
|
2014-02-20 09:54:05 -07:00
|
|
|
[
|
2015-10-10 11:10:26 -07:00
|
|
|
AS_IF([test "x$enableval" = "xno"], [
|
2014-02-22 18:07:52 -07:00
|
|
|
LIBTOOL_EXTRA_FLAGS="$LIBTOOL_OLD_FLAGS -avoid-version"
|
2014-02-20 09:54:05 -07:00
|
|
|
])
|
|
|
|
]
|
|
|
|
)
|
2013-07-07 22:20:27 -07:00
|
|
|
|
2013-09-08 10:44:07 -07:00
|
|
|
AS_CASE([$host_os],
|
2014-08-04 14:30:07 -07:00
|
|
|
[cygwin*|mingw*|msys|pw32*|cegcc*], [
|
2013-01-19 17:02:02 -07:00
|
|
|
AX_CHECK_LINK_FLAG([-Wl,--dynamicbase], [LDFLAGS="$LDFLAGS -Wl,--dynamicbase"])
|
2015-12-27 12:53:08 -07:00
|
|
|
AX_CHECK_LINK_FLAG([-Wl,--high-entropy-va], [LDFLAGS="$LDFLAGS -Wl,--high-entropy-va"])
|
2013-01-19 17:02:02 -07:00
|
|
|
AX_CHECK_LINK_FLAG([-Wl,--nxcompat], [LDFLAGS="$LDFLAGS -Wl,--nxcompat"])
|
2013-09-08 10:44:07 -07:00
|
|
|
])
|
2013-07-07 22:20:27 -07:00
|
|
|
|
|
|
|
AS_IF([test "x$enable_ssp" != "xno"],[
|
2013-09-08 10:44:07 -07:00
|
|
|
|
|
|
|
AS_CASE([$host_os],
|
2014-08-04 14:30:07 -07:00
|
|
|
[cygwin*|mingw*|msys|pw32*|cegcc*], [ ],
|
2014-09-14 13:25:29 -07:00
|
|
|
[*], [
|
2013-01-19 17:02:02 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([-fstack-protector], [
|
|
|
|
AX_CHECK_LINK_FLAG([-fstack-protector],
|
|
|
|
[CFLAGS="$CFLAGS -fstack-protector"]
|
|
|
|
)
|
|
|
|
])
|
2013-09-08 10:44:07 -07:00
|
|
|
])
|
2013-07-07 22:20:27 -07:00
|
|
|
])
|
2013-01-19 17:02:02 -07:00
|
|
|
|
|
|
|
AX_CHECK_COMPILE_FLAG([-Wwrite-strings], [CFLAGS="$CFLAGS -Wwrite-strings"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([-Wdiv-by-zero], [CFLAGS="$CFLAGS -Wdiv-by-zero"])
|
2013-01-21 21:50:50 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([-Wsometimes-uninitialized], [CFLAGS="$CFLAGS -Wsometimes-uninitialized"])
|
2013-01-19 17:02:02 -07:00
|
|
|
|
|
|
|
AC_ARG_VAR([CWFLAGS], [define to compilation flags for generating extra warnings])
|
|
|
|
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wall], [CWFLAGS="$CWFLAGS -Wall"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wextra], [CWFLAGS="$CWFLAGS -Wextra"])
|
|
|
|
|
|
|
|
AC_MSG_CHECKING(for clang)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
|
|
|
|
#ifndef __clang__
|
|
|
|
be sad
|
|
|
|
#endif
|
|
|
|
]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wno-unknown-warning-option],
|
2013-04-26 22:00:00 -07:00
|
|
|
[CWFLAGS="$CWFLAGS -Wno-unknown-warning-option"])
|
|
|
|
],
|
2013-01-19 17:02:02 -07:00
|
|
|
[AC_MSG_RESULT(no)
|
|
|
|
])
|
|
|
|
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wbad-function-cast], [CWFLAGS="$CWFLAGS -Wbad-function-cast"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wcast-align], [CWFLAGS="$CWFLAGS -Wcast-align"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wcast-qual], [CWFLAGS="$CWFLAGS -Wcast-qual"])
|
2016-03-26 16:42:45 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wduplicated-cond], [CWFLAGS="$CWFLAGS -Wduplicated-cond"])
|
2013-01-19 17:02:02 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wfloat-equal], [CWFLAGS="$CWFLAGS -Wfloat-equal"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wformat=2], [CWFLAGS="$CWFLAGS -Wformat=2"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wmissing-declarations], [CWFLAGS="$CWFLAGS -Wmissing-declarations"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wmissing-prototypes], [CWFLAGS="$CWFLAGS -Wmissing-prototypes"])
|
2016-03-26 16:42:45 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wnested-externs], [CWFLAGS="$CWFLAGS -Wnested-externs"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wno-unknown-pragmas], [CWFLAGS="$CWFLAGS -Wno-unknown-pragmas"])
|
2013-01-19 17:02:02 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wnormalized=id], [CWFLAGS="$CWFLAGS -Wnormalized=id"])
|
2016-03-26 16:42:45 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wnull-dereference], [CWFLAGS="$CWFLAGS -Wnull-dereference"])
|
2013-01-19 17:02:02 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wpointer-arith], [CWFLAGS="$CWFLAGS -Wpointer-arith"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wredundant-decls], [CWFLAGS="$CWFLAGS -Wredundant-decls"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wstrict-prototypes], [CWFLAGS="$CWFLAGS -Wstrict-prototypes"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wswitch-enum], [CWFLAGS="$CWFLAGS -Wswitch-enum"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wvariable-decl], [CWFLAGS="$CWFLAGS -Wvariable-decl"])
|
2017-01-19 13:26:46 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wno-type-limits], [CWFLAGS="$CWFLAGS -Wno-type-limits"])
|
2013-01-19 17:02:02 -07:00
|
|
|
|
|
|
|
AX_CHECK_LINK_FLAG([-Wl,-z,relro], [LDFLAGS="$LDFLAGS -Wl,-z,relro"])
|
|
|
|
AX_CHECK_LINK_FLAG([-Wl,-z,now], [LDFLAGS="$LDFLAGS -Wl,-z,now"])
|
|
|
|
AX_CHECK_LINK_FLAG([-Wl,-z,noexecstack], [LDFLAGS="$LDFLAGS -Wl,-z,noexecstack"])
|
|
|
|
|
2013-01-19 17:37:13 -07:00
|
|
|
LT_INIT
|
|
|
|
AC_SUBST(LIBTOOL_DEPS)
|
|
|
|
|
2013-01-19 17:02:02 -07:00
|
|
|
AC_ARG_VAR([AR], [path to the ar utility])
|
|
|
|
AC_CHECK_TOOL([AR], [ar], [ar])
|
|
|
|
|
2013-04-25 09:37:04 -07:00
|
|
|
dnl Checks for headers
|
2013-04-26 22:53:07 -07:00
|
|
|
|
2016-04-30 07:08:52 -07:00
|
|
|
AS_IF([test "x$EMSCRIPTEN" = "x" -a "$host_os" != "pnacl"], [
|
2014-05-09 20:26:43 -07:00
|
|
|
|
|
|
|
AC_MSG_CHECKING(for MMX instructions set)
|
2015-10-10 11:10:26 -07:00
|
|
|
oldcflags="$CFLAGS"
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mmmx], [CFLAGS="$CFLAGS -mmmx"])
|
2014-05-09 20:26:43 -07:00
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
#pragma GCC target("mmx")
|
|
|
|
#include <mmintrin.h>
|
|
|
|
]], [[ __m64 x = _mm_setzero_si64(); ]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
2015-10-10 10:23:39 -07:00
|
|
|
AC_DEFINE([HAVE_MMINTRIN_H], [1], [mmx is available])
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mmmx], [CFLAGS_MMX="-mmmx"])],
|
2014-05-09 20:26:43 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
2015-10-10 11:10:26 -07:00
|
|
|
CFLAGS="$oldcflags"
|
2014-05-09 20:26:43 -07:00
|
|
|
|
|
|
|
AC_MSG_CHECKING(for SSE2 instructions set)
|
2015-10-10 11:10:26 -07:00
|
|
|
oldcflags="$CFLAGS"
|
|
|
|
AX_CHECK_COMPILE_FLAG([-msse2], [CFLAGS="$CFLAGS -msse2"])
|
2014-05-09 20:26:43 -07:00
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
#pragma GCC target("sse2")
|
2015-10-10 09:32:10 -07:00
|
|
|
#ifndef __SSE2__
|
|
|
|
# define __SSE2__
|
|
|
|
#endif
|
2014-05-09 20:26:43 -07:00
|
|
|
#include <emmintrin.h>
|
2015-12-29 15:18:28 -07:00
|
|
|
]], [[ __m128d x = _mm_setzero_pd();
|
2016-03-24 11:18:15 -07:00
|
|
|
__m128i y = _mm_srli_epi64(_mm_setzero_si128(), 26); ]])],
|
2014-05-09 20:26:43 -07:00
|
|
|
[AC_MSG_RESULT(yes)
|
2015-10-10 10:23:39 -07:00
|
|
|
AC_DEFINE([HAVE_EMMINTRIN_H], [1], [sse2 is available])
|
|
|
|
AX_CHECK_COMPILE_FLAG([-msse2], [CFLAGS_SSE2="-msse2"])],
|
2014-05-09 20:26:43 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
2015-10-10 11:10:26 -07:00
|
|
|
CFLAGS="$oldcflags"
|
2014-05-09 20:26:43 -07:00
|
|
|
|
2015-10-10 11:10:26 -07:00
|
|
|
oldcflags="$CFLAGS"
|
|
|
|
AX_CHECK_COMPILE_FLAG([-msse3], [CFLAGS="$CFLAGS -msse3"])
|
2014-05-09 20:26:43 -07:00
|
|
|
AC_MSG_CHECKING(for SSE3 instructions set)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
#pragma GCC target("sse3")
|
|
|
|
#include <pmmintrin.h>
|
|
|
|
]], [[ __m128 x = _mm_addsub_ps(_mm_cvtpd_ps(_mm_setzero_pd()),
|
|
|
|
_mm_cvtpd_ps(_mm_setzero_pd())); ]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
2015-10-10 10:23:39 -07:00
|
|
|
AC_DEFINE([HAVE_PMMINTRIN_H], [1], [sse3 is available])
|
|
|
|
AX_CHECK_COMPILE_FLAG([-msse3], [CFLAGS_SSE3="-msse3"])],
|
2014-05-09 20:26:43 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
2015-10-10 11:10:26 -07:00
|
|
|
CFLAGS="$oldcflags"
|
2014-05-09 20:26:43 -07:00
|
|
|
|
2015-10-10 11:10:26 -07:00
|
|
|
oldcflags="$CFLAGS"
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mssse3], [CFLAGS="$CFLAGS -mssse3"])
|
2014-05-14 22:34:27 -07:00
|
|
|
AC_MSG_CHECKING(for SSSE3 instructions set)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
#pragma GCC target("ssse3")
|
|
|
|
#include <tmmintrin.h>
|
|
|
|
]], [[ __m64 x = _mm_abs_pi32(_m_from_int(0)); ]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
2015-10-10 10:23:39 -07:00
|
|
|
AC_DEFINE([HAVE_TMMINTRIN_H], [1], [ssse3 is available])
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mssse3], [CFLAGS_SSSE3="-mssse3"])],
|
|
|
|
[AC_MSG_RESULT(no)])
|
2015-10-10 11:10:26 -07:00
|
|
|
CFLAGS="$oldcflags"
|
2015-10-10 10:23:39 -07:00
|
|
|
|
2015-10-10 11:10:26 -07:00
|
|
|
oldcflags="$CFLAGS"
|
|
|
|
AX_CHECK_COMPILE_FLAG([-msse4.1], [CFLAGS="$CFLAGS -msse4.1"])
|
2015-10-10 10:23:39 -07:00
|
|
|
AC_MSG_CHECKING(for SSE4.1 instructions set)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
#pragma GCC target("sse4.1")
|
|
|
|
#include <smmintrin.h>
|
|
|
|
]], [[ __m128i x = _mm_minpos_epu16(_mm_setzero_si128()); ]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
|
|
|
AC_DEFINE([HAVE_SMMINTRIN_H], [1], [sse4.1 is available])
|
2015-10-31 22:09:04 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([-msse4.1], [CFLAGS_SSE41="-msse4.1"])],
|
2014-05-14 22:34:27 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
2015-10-10 11:10:26 -07:00
|
|
|
CFLAGS="$oldcflags"
|
2015-10-10 08:57:47 -07:00
|
|
|
|
2015-11-03 06:18:43 -07:00
|
|
|
oldcflags="$CFLAGS"
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mavx], [CFLAGS="$CFLAGS -mavx"])
|
|
|
|
AC_MSG_CHECKING(for AVX instructions set)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
2016-04-30 07:08:52 -07:00
|
|
|
#ifdef __native_client__
|
|
|
|
# error NativeClient detected - Avoiding AVX opcodes
|
|
|
|
#endif
|
2015-11-03 06:18:43 -07:00
|
|
|
#pragma GCC target("avx")
|
|
|
|
#include <immintrin.h>
|
|
|
|
]], [[ _mm256_zeroall(); ]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
|
|
|
AC_DEFINE([HAVE_AVXINTRIN_H], [1], [AVX is available])
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mavx], [CFLAGS_AVX="-mavx"])],
|
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
CFLAGS="$oldcflags"
|
|
|
|
|
2016-03-17 03:08:36 -07:00
|
|
|
oldcflags="$CFLAGS"
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mavx2], [CFLAGS="$CFLAGS -mavx2"])
|
|
|
|
AC_MSG_CHECKING(for AVX2 instructions set)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
2016-04-30 07:08:52 -07:00
|
|
|
#ifdef __native_client__
|
|
|
|
# error NativeClient detected - Avoiding AVX2 opcodes
|
|
|
|
#endif
|
2016-03-17 03:08:36 -07:00
|
|
|
#pragma GCC target("avx2")
|
|
|
|
#include <immintrin.h>
|
2016-08-04 11:58:48 -07:00
|
|
|
]], [[
|
|
|
|
__m256 x = _mm256_set1_ps(3.14);
|
|
|
|
__m256 y = _mm256_permutevar8x32_ps(x, _mm256_set1_epi32(42));
|
|
|
|
return _mm256_movemask_ps(_mm256_cmp_ps(x, y, _CMP_NEQ_OQ));
|
|
|
|
]])],
|
2016-03-17 03:08:36 -07:00
|
|
|
[AC_MSG_RESULT(yes)
|
|
|
|
AC_DEFINE([HAVE_AVX2INTRIN_H], [1], [AVX2 is available])
|
2016-08-03 17:26:24 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([-mavx2], [CFLAGS_AVX2="-mavx2"])
|
2016-04-03 01:41:28 -07:00
|
|
|
AC_MSG_CHECKING(if _mm256_broadcastsi128_si256 is correctly defined)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
2016-04-30 07:08:52 -07:00
|
|
|
#ifdef __native_client__
|
|
|
|
# error NativeClient detected - Avoiding AVX2 opcodes
|
|
|
|
#endif
|
2016-04-03 01:41:28 -07:00
|
|
|
#pragma GCC target("avx2")
|
|
|
|
#include <immintrin.h>
|
|
|
|
]], [[ __m256i y = _mm256_broadcastsi128_si256(_mm_setzero_si128()); ]])],
|
|
|
|
[AC_MSG_RESULT(yes)],
|
|
|
|
[AC_MSG_RESULT(no)
|
|
|
|
AC_DEFINE([_mm256_broadcastsi128_si256], [_mm_broadcastsi128_si256],
|
|
|
|
[Define to the local name of _mm256_broadcastsi128_si256])])
|
|
|
|
],
|
2016-03-17 03:08:36 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
CFLAGS="$oldcflags"
|
|
|
|
|
2015-10-10 11:10:26 -07:00
|
|
|
oldcflags="$CFLAGS"
|
|
|
|
AX_CHECK_COMPILE_FLAG([-maes], [CFLAGS="$CFLAGS -maes"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mpclmul], [CFLAGS="$CFLAGS -mpclmul"])
|
2015-10-10 08:57:47 -07:00
|
|
|
AC_MSG_CHECKING(for AESNI instructions set and PCLMULQDQ)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
2016-04-29 13:29:34 -07:00
|
|
|
#ifdef __native_client__
|
2016-04-30 07:08:52 -07:00
|
|
|
# error NativeClient detected - Avoiding AESNI opcodes
|
2016-04-29 13:29:34 -07:00
|
|
|
#endif
|
2015-10-10 08:57:47 -07:00
|
|
|
#pragma GCC target("aes")
|
|
|
|
#pragma GCC target("pclmul")
|
|
|
|
#include <wmmintrin.h>
|
|
|
|
]], [[ __m128i x = _mm_aesimc_si128(_mm_setzero_si128());
|
|
|
|
__m128i y = _mm_clmulepi64_si128(_mm_setzero_si128(), _mm_setzero_si128(), 0);]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
2015-10-10 09:21:33 -07:00
|
|
|
AC_DEFINE([HAVE_WMMINTRIN_H], [1], [aesni is available])
|
2015-10-10 10:23:39 -07:00
|
|
|
AX_CHECK_COMPILE_FLAG([-maes], [CFLAGS_AESNI="-maes"])
|
|
|
|
AX_CHECK_COMPILE_FLAG([-mpclmul], [CFLAGS_PCLMUL="-mpclmul"])
|
2015-10-10 09:21:33 -07:00
|
|
|
],
|
2015-10-10 08:57:47 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
2015-10-10 11:10:26 -07:00
|
|
|
CFLAGS="$oldcflags"
|
|
|
|
|
2013-04-25 19:47:21 -07:00
|
|
|
])
|
2013-04-25 09:37:04 -07:00
|
|
|
|
2015-10-10 10:23:39 -07:00
|
|
|
AC_SUBST(CFLAGS_MMX)
|
|
|
|
AC_SUBST(CFLAGS_SSE2)
|
|
|
|
AC_SUBST(CFLAGS_SSE3)
|
|
|
|
AC_SUBST(CFLAGS_SSSE3)
|
2015-10-31 22:09:04 -07:00
|
|
|
AC_SUBST(CFLAGS_SSE41)
|
2016-03-17 02:45:11 -07:00
|
|
|
AC_SUBST(CFLAGS_AVX)
|
|
|
|
AC_SUBST(CFLAGS_AVX2)
|
2015-10-10 10:23:39 -07:00
|
|
|
AC_SUBST(CFLAGS_AESNI)
|
|
|
|
AC_SUBST(CFLAGS_PCLMUL)
|
|
|
|
|
2014-01-01 07:56:50 -07:00
|
|
|
AC_CHECK_HEADERS([sys/mman.h])
|
|
|
|
|
2013-01-19 17:02:02 -07:00
|
|
|
dnl Checks for typedefs, structures, and compiler characteristics.
|
|
|
|
|
2013-09-24 13:23:48 -07:00
|
|
|
AC_C_INLINE
|
2016-03-24 01:24:35 -07:00
|
|
|
AS_CASE([$host_cpu],
|
2016-03-24 11:11:21 -07:00
|
|
|
[i?86|amd64|x86_64],
|
2016-03-24 01:24:35 -07:00
|
|
|
[ac_cv_c_bigendian=no]
|
|
|
|
)
|
2013-04-19 16:25:13 -07:00
|
|
|
AC_C_BIGENDIAN(
|
|
|
|
AC_DEFINE(NATIVE_BIG_ENDIAN, 1, [machine is bigendian]),
|
|
|
|
AC_DEFINE(NATIVE_LITTLE_ENDIAN, 1, [machine is littleendian]),
|
2016-03-24 01:05:09 -07:00
|
|
|
AC_MSG_ERROR([unknown endianness]),
|
|
|
|
AC_MSG_ERROR([universal endianness is not supported - compile separately and use lipo(1)])
|
2013-04-19 16:25:13 -07:00
|
|
|
)
|
2013-01-19 17:02:02 -07:00
|
|
|
|
2013-04-27 13:40:22 -07:00
|
|
|
AC_MSG_CHECKING(whether __STDC_LIMIT_MACROS is required)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
#include <limits.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
]], [[
|
|
|
|
(void) SIZE_MAX;
|
|
|
|
(void) UINT64_MAX;
|
|
|
|
]])],
|
2013-04-27 13:42:55 -07:00
|
|
|
[AC_MSG_RESULT(no)],
|
2013-04-27 13:40:22 -07:00
|
|
|
[AC_MSG_RESULT(yes)
|
2013-04-27 13:42:55 -07:00
|
|
|
CPPFLAGS="$CPPFLAGS -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS"
|
2013-04-27 13:40:22 -07:00
|
|
|
])
|
|
|
|
|
2013-04-27 10:21:32 -07:00
|
|
|
HAVE_AMD64_ASM_V=0
|
2013-04-28 09:41:00 -07:00
|
|
|
AS_IF([test "$enable_asm" != "no"],[
|
2015-11-04 15:29:27 -07:00
|
|
|
AC_MSG_CHECKING(whether we can use x86_64 asm code)
|
2013-04-28 09:41:00 -07:00
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
]], [[
|
2013-04-27 10:21:32 -07:00
|
|
|
#if defined(__amd64) || defined(__amd64__) || defined(__x86_64__)
|
2014-08-04 16:24:11 -07:00
|
|
|
# if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(_WIN32) || defined(_WIN64)
|
|
|
|
# error Windows x86_64 calling conventions are not supported yet
|
|
|
|
# endif
|
2013-04-27 10:21:32 -07:00
|
|
|
/* neat */
|
|
|
|
#else
|
2014-08-04 16:29:13 -07:00
|
|
|
# error !x86_64
|
2013-04-27 10:21:32 -07:00
|
|
|
#endif
|
2015-12-06 10:30:00 -07:00
|
|
|
unsigned char i = 0, o = 0, t;
|
|
|
|
__asm__ __volatile__ ("pxor %%xmm12, %%xmm6 \n"
|
|
|
|
"movb (%[i]), %[t] \n"
|
|
|
|
"addb %[t], (%[o]) \n"
|
|
|
|
: [t] "=&r"(t)
|
|
|
|
: [o] "D"(&o), [i] "S"(&i)
|
|
|
|
: "memory", "flags", "cc");
|
2013-04-27 10:21:32 -07:00
|
|
|
]])],
|
2013-04-28 09:41:00 -07:00
|
|
|
[AC_MSG_RESULT(yes)
|
2015-11-04 15:29:27 -07:00
|
|
|
AC_DEFINE([HAVE_AMD64_ASM], [1], [x86_64 asm code can be used])
|
2013-04-28 09:41:00 -07:00
|
|
|
HAVE_AMD64_ASM_V=1],
|
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
])
|
2013-04-27 10:21:32 -07:00
|
|
|
AM_CONDITIONAL([HAVE_AMD64_ASM], [test $HAVE_AMD64_ASM_V = 1])
|
|
|
|
AC_SUBST(HAVE_AMD64_ASM_V)
|
|
|
|
|
2015-11-04 15:29:27 -07:00
|
|
|
HAVE_AVX_ASM_V=0
|
|
|
|
AS_IF([test "$enable_asm" != "no"],[
|
|
|
|
AC_MSG_CHECKING(whether we can assemble AVX opcodes)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
]], [[
|
|
|
|
#if defined(__amd64) || defined(__amd64__) || defined(__x86_64__)
|
|
|
|
# if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(_WIN32) || defined(_WIN64)
|
|
|
|
# error Windows x86_64 calling conventions are not supported yet
|
|
|
|
# endif
|
|
|
|
/* neat */
|
|
|
|
#else
|
|
|
|
# error !x86_64
|
|
|
|
#endif
|
2015-11-13 17:21:55 -07:00
|
|
|
__asm__ __volatile__ ("vpunpcklqdq %xmm0,%xmm13,%xmm0");
|
2015-11-04 15:29:27 -07:00
|
|
|
]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
|
|
|
AC_DEFINE([HAVE_AVX_ASM], [1], [AVX opcodes are supported])
|
|
|
|
HAVE_AVX_ASM_V=1],
|
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
])
|
|
|
|
AM_CONDITIONAL([HAVE_AVX_ASM], [test $HAVE_AVX_ASM_V = 1])
|
|
|
|
AC_SUBST(HAVE_AVX_ASM_V)
|
|
|
|
|
2013-03-17 18:40:14 -07:00
|
|
|
AC_MSG_CHECKING(for 128-bit arithmetic)
|
2013-04-21 10:14:38 -07:00
|
|
|
HAVE_TI_MODE_V=0
|
2013-03-17 18:40:14 -07:00
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
2015-11-15 10:16:15 -07:00
|
|
|
#if !defined(__GNUC__) && !defined(__SIZEOF_INT128__)
|
|
|
|
# error mode(TI) is a gcc extension, and __int128 is not available
|
2013-04-21 10:14:38 -07:00
|
|
|
#endif
|
2013-04-27 14:28:18 -07:00
|
|
|
#if defined(__clang__) && !defined(__x86_64__)
|
2015-11-15 10:16:15 -07:00
|
|
|
# error clang does not properly handle the 128-bit type on 32-bit systems
|
2013-04-21 10:14:38 -07:00
|
|
|
#endif
|
2013-09-21 20:07:50 -07:00
|
|
|
#ifndef NATIVE_LITTLE_ENDIAN
|
2015-11-15 10:16:15 -07:00
|
|
|
# error libsodium currently expects a little endian CPU for the 128-bit type
|
2013-09-21 20:07:50 -07:00
|
|
|
#endif
|
2015-11-04 14:07:36 -07:00
|
|
|
#ifdef __EMSCRIPTEN__
|
2014-05-20 10:53:31 -07:00
|
|
|
# error emscripten currently supports only shift operations on integers \
|
|
|
|
# larger than 64 bits
|
|
|
|
#endif
|
2015-11-15 10:16:15 -07:00
|
|
|
#include <stddef.h>
|
2013-09-08 02:15:12 -07:00
|
|
|
#include <stdint.h>
|
2015-11-15 10:16:15 -07:00
|
|
|
#if defined(__SIZEOF_INT128__)
|
|
|
|
typedef unsigned __int128 uint128_t;
|
|
|
|
#else
|
2013-03-17 18:40:14 -07:00
|
|
|
typedef unsigned uint128_t __attribute__((mode(TI)));
|
2015-11-15 10:16:15 -07:00
|
|
|
#endif
|
2013-09-08 02:25:48 -07:00
|
|
|
void fcontract(uint128_t *t) {
|
|
|
|
*t += 0x8000000000000 - 1;
|
2013-09-08 02:15:12 -07:00
|
|
|
}
|
|
|
|
]], [[
|
|
|
|
(void) fcontract;
|
2013-03-17 18:40:14 -07:00
|
|
|
]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
2013-04-19 07:08:43 -07:00
|
|
|
AC_DEFINE([HAVE_TI_MODE], [1], [gcc TI mode is available])
|
2013-04-21 10:14:38 -07:00
|
|
|
HAVE_TI_MODE_V=1],
|
2013-03-17 18:40:14 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
2013-04-21 10:14:38 -07:00
|
|
|
AM_CONDITIONAL([HAVE_TI_MODE], [test $HAVE_TI_MODE_V = 1])
|
|
|
|
AC_SUBST(HAVE_TI_MODE_V)
|
2013-03-17 18:40:14 -07:00
|
|
|
|
2013-04-25 18:59:55 -07:00
|
|
|
HAVE_CPUID_V=0
|
2016-07-06 07:23:50 -07:00
|
|
|
AS_IF([test "$enable_asm" != "no" -o "$host_alias" = "x86_64-nacl"],[
|
2014-05-02 14:40:39 -07:00
|
|
|
AC_MSG_CHECKING(for cpuid instruction)
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
|
2014-05-02 21:24:31 -07:00
|
|
|
unsigned int cpu_info[4];
|
|
|
|
__asm__ __volatile__ ("xchgl %%ebx, %k1; cpuid; xchgl %%ebx, %k1" :
|
|
|
|
"=a" (cpu_info[0]), "=&r" (cpu_info[1]),
|
|
|
|
"=c" (cpu_info[2]), "=d" (cpu_info[3]) :
|
2014-05-06 12:31:08 -07:00
|
|
|
"0" (0U), "2" (0U));
|
2014-05-02 14:40:39 -07:00
|
|
|
]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
|
|
|
AC_DEFINE([HAVE_CPUID], [1], [cpuid instruction is available])
|
|
|
|
HAVE_CPUID_V=1],
|
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
])
|
2013-04-25 18:59:55 -07:00
|
|
|
AC_SUBST(HAVE_CPUID_V)
|
|
|
|
|
2016-03-22 13:26:39 -07:00
|
|
|
asm_hide_symbol="unsupported"
|
2016-04-30 07:23:02 -07:00
|
|
|
AS_IF([test "$enable_asm" != "no" -o "$host_os" = "nacl"],[
|
2016-03-22 13:26:39 -07:00
|
|
|
AC_MSG_CHECKING(if the .private_extern asm directive is supported)
|
2016-03-24 02:55:47 -07:00
|
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[ ]], [[
|
2016-03-22 12:42:07 -07:00
|
|
|
__asm__ __volatile__ (".private_extern dummy_symbol \n"
|
|
|
|
".private_extern _dummy_symbol \n"
|
|
|
|
".globl dummy_symbol \n"
|
|
|
|
".globl _dummy_symbol \n"
|
|
|
|
"dummy_symbol: \n"
|
|
|
|
"_dummy_symbol: \n"
|
|
|
|
" nop \n"
|
|
|
|
);
|
|
|
|
]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
2016-03-22 13:26:39 -07:00
|
|
|
asm_hide_symbol=".private_extern"],
|
2016-03-22 12:42:07 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
2016-03-22 13:26:39 -07:00
|
|
|
|
|
|
|
AC_MSG_CHECKING(if the .hidden asm directive is supported)
|
2016-03-24 02:55:47 -07:00
|
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[ ]], [[
|
2016-03-22 13:26:39 -07:00
|
|
|
__asm__ __volatile__ (".hidden dummy_symbol \n"
|
|
|
|
".hidden _dummy_symbol \n"
|
|
|
|
".globl dummy_symbol \n"
|
|
|
|
".globl _dummy_symbol \n"
|
|
|
|
"dummy_symbol: \n"
|
|
|
|
"_dummy_symbol: \n"
|
|
|
|
" nop \n"
|
|
|
|
);
|
|
|
|
]])],
|
|
|
|
[AC_MSG_RESULT(yes)
|
2016-03-24 02:55:47 -07:00
|
|
|
AS_IF([test "$asm_hide_symbol" = "unsupported"],
|
|
|
|
[asm_hide_symbol=".hidden"],
|
|
|
|
[AC_MSG_NOTICE([unable to reliably tag symbols as private])
|
|
|
|
asm_hide_symbol="unsupported"])
|
|
|
|
],
|
2016-03-22 13:26:39 -07:00
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
|
|
|
|
AS_IF([test "$asm_hide_symbol" != "unsupported"],[
|
|
|
|
AC_DEFINE_UNQUOTED([ASM_HIDE_SYMBOL], [$asm_hide_symbol], [directive to hide symbols])
|
2016-03-22 12:42:07 -07:00
|
|
|
])
|
2016-03-22 13:26:39 -07:00
|
|
|
])
|
2016-03-22 12:42:07 -07:00
|
|
|
|
2014-06-20 21:09:18 -07:00
|
|
|
AC_MSG_CHECKING(if weak symbols are supported)
|
|
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
2016-04-13 00:22:51 -07:00
|
|
|
#if !defined(__ELF__) && !defined(__APPLE_CC__)
|
|
|
|
# error Support for weak symbols may not be available
|
|
|
|
#endif
|
2014-06-20 21:09:18 -07:00
|
|
|
__attribute__((weak)) void __dummy(void *x) { }
|
|
|
|
void f(void *x) { __dummy(x); }
|
|
|
|
]], [[ ]]
|
|
|
|
)],
|
|
|
|
[AC_MSG_RESULT(yes)
|
|
|
|
AC_DEFINE([HAVE_WEAK_SYMBOLS], [1], [weak symbols are supported])],
|
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
|
2015-09-04 06:36:24 -07:00
|
|
|
AC_MSG_CHECKING(if data alignment is required)
|
|
|
|
aligned_access_required=yes
|
2013-09-08 10:39:27 -07:00
|
|
|
AS_CASE([$host_cpu],
|
2016-03-24 11:11:21 -07:00
|
|
|
[i?86|amd64|x86_64|powerpc*|s390*],
|
2015-09-04 06:36:24 -07:00
|
|
|
[aligned_access_required=no],
|
2015-09-03 17:29:34 -07:00
|
|
|
[arm*],
|
|
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
|
|
#ifndef __ARM_FEATURE_UNALIGNED
|
2015-09-04 06:36:24 -07:00
|
|
|
# error data alignment is required
|
2015-09-03 17:29:34 -07:00
|
|
|
#endif
|
2015-09-04 06:36:24 -07:00
|
|
|
]], [[]])], [aligned_access_required=no], [])]
|
2013-09-08 10:39:27 -07:00
|
|
|
)
|
2015-09-04 06:36:24 -07:00
|
|
|
AS_IF([test "x$aligned_access_required" = "xyes"],
|
2015-11-16 14:01:19 -07:00
|
|
|
[AC_MSG_RESULT(yes)],
|
|
|
|
[AC_MSG_RESULT(no)
|
|
|
|
AC_DEFINE([CPU_UNALIGNED_ACCESS], [1], [unaligned memory access is supported])])
|
2013-09-08 10:39:27 -07:00
|
|
|
|
2016-12-16 08:37:12 -07:00
|
|
|
AC_MSG_CHECKING(if atomic operations are supported)
|
|
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[ ]], [[
|
|
|
|
static volatile int _sodium_lock;
|
|
|
|
__sync_lock_test_and_set(&_sodium_lock, 1);
|
|
|
|
__sync_lock_release(&_sodium_lock);
|
|
|
|
]]
|
|
|
|
)],
|
|
|
|
[AC_MSG_RESULT(yes)
|
|
|
|
AC_DEFINE([HAVE_ATOMIC_OPS], [1], [atomic operations are supported])],
|
|
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
|
2013-01-21 20:18:15 -07:00
|
|
|
dnl Checks for functions and headers
|
|
|
|
|
2014-04-22 18:12:49 -07:00
|
|
|
AS_IF([test "x$EMSCRIPTEN" = "x"],[
|
|
|
|
AC_CHECK_FUNCS([arc4random arc4random_buf])
|
2016-04-25 07:13:46 -07:00
|
|
|
AC_CHECK_FUNCS([mmap mlock madvise mprotect explicit_bzero nanosleep])
|
2014-04-22 18:12:49 -07:00
|
|
|
])
|
2015-09-13 06:04:14 -07:00
|
|
|
AC_CHECK_FUNCS([posix_memalign getpid])
|
2013-01-21 20:18:15 -07:00
|
|
|
|
2013-02-04 18:16:46 -07:00
|
|
|
AC_SUBST([LIBTOOL_EXTRA_FLAGS])
|
2013-01-19 17:02:02 -07:00
|
|
|
|
2014-11-24 18:19:55 -07:00
|
|
|
TEST_LDFLAGS=''
|
2014-11-22 15:31:43 -07:00
|
|
|
AS_IF([test "x$EMSCRIPTEN" != "x"],[
|
|
|
|
EXEEXT=.js
|
2016-04-02 03:18:52 -07:00
|
|
|
TEST_LDFLAGS='--memory-init-file 0 --pre-js pre.js.inc -s RESERVED_FUNCTION_POINTERS=8'
|
2014-11-22 15:31:43 -07:00
|
|
|
])
|
2014-11-24 18:19:55 -07:00
|
|
|
AC_SUBST(TEST_LDFLAGS)
|
2015-01-15 03:12:58 -07:00
|
|
|
AM_CONDITIONAL([EMSCRIPTEN], [test "x$EMSCRIPTEN" != "x"])
|
2014-11-22 15:31:43 -07:00
|
|
|
|
2015-06-22 11:02:21 -07:00
|
|
|
AM_CONDITIONAL([NATIVECLIENT], [test "x$NATIVECLIENT" != "x"])
|
|
|
|
|
2016-07-02 01:05:43 -07:00
|
|
|
AC_DEFINE([CONFIGURED], [1], [the build system was properly configured])
|
|
|
|
|
2013-01-19 17:37:13 -07:00
|
|
|
dnl Libtool.
|
|
|
|
|
|
|
|
LT_INIT([dlopen])
|
2013-04-23 21:33:58 -07:00
|
|
|
AC_LIBTOOL_WIN32_DLL
|
|
|
|
gl_LD_OUTPUT_DEF
|
2013-01-19 17:37:13 -07:00
|
|
|
|
2013-01-19 17:02:02 -07:00
|
|
|
dnl Output.
|
|
|
|
|
2014-07-31 22:13:45 -07:00
|
|
|
AH_VERBATIM([NDEBUG], [/* Always evaluate assert() calls */
|
2013-01-19 17:02:02 -07:00
|
|
|
#ifdef NDEBUG
|
|
|
|
#/**/undef/**/ NDEBUG
|
|
|
|
#endif])
|
|
|
|
|
|
|
|
AC_CONFIG_FILES([Makefile
|
2016-10-05 06:36:36 -07:00
|
|
|
contrib/Makefile
|
2013-12-31 08:16:12 -07:00
|
|
|
dist-build/Makefile
|
2014-11-29 14:53:20 -07:00
|
|
|
libsodium.pc
|
2014-12-22 17:14:22 -07:00
|
|
|
libsodium-uninstalled.pc
|
2013-09-30 13:36:31 -07:00
|
|
|
msvc-scripts/Makefile
|
2013-01-19 17:02:02 -07:00
|
|
|
src/Makefile
|
2013-01-20 12:14:35 -07:00
|
|
|
src/libsodium/Makefile
|
|
|
|
src/libsodium/include/Makefile
|
2013-01-20 15:03:05 -07:00
|
|
|
src/libsodium/include/sodium/version.h
|
2013-02-08 13:21:32 -07:00
|
|
|
test/default/Makefile
|
2013-01-20 15:03:05 -07:00
|
|
|
test/Makefile
|
|
|
|
])
|
2013-01-19 17:02:02 -07:00
|
|
|
AC_OUTPUT
|