release/src/router/libsodium/configure.ac

   1 AC_PREREQ([2.65])
   2 AC_INIT([libsodium],[1.0.10],
   3   [https://github.com/jedisct1/libsodium/issues],
   4   [libsodium],
   5   [https://github.com/jedisct1/libsodium])
   6 AC_CONFIG_AUX_DIR([build-aux])
   7 AC_CONFIG_MACRO_DIR([m4])
   8 AC_CONFIG_SRCDIR([src/libsodium/sodium/version.c])
   9 AC_CANONICAL_HOST
  10 AM_INIT_AUTOMAKE([1.11 dist-bzip2 tar-ustar foreign subdir-objects])
  11 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
  12 AM_MAINTAINER_MODE
  13 AM_DEP_TRACK
  14
  15 AC_SUBST(VERSION)
  16 ISODATE=`date +%Y-%m-%d`
  17 AC_SUBST(ISODATE)
  18
  19 SODIUM_LIBRARY_VERSION_MAJOR=9
  20 SODIUM_LIBRARY_VERSION_MINOR=2
  21 DLL_VERSION=8
  22 SODIUM_LIBRARY_VERSION=19:0:1
  23 #                       | | |
  24 #                +------+ | +---+
  25 #                |        |     |
  26 #             current:revision:age
  27 #                |        |     |
  28 #                |        |     +- increment if interfaces have been added
  29 #                |        |        set to zero if interfaces have been removed
  30 #                |        |        or changed
  31 #                |        +- increment if source code has changed
  32 #                |           set to zero if current is incremented
  33 #                +- increment if interfaces have been added, removed or changed
  34 AC_SUBST(SODIUM_LIBRARY_VERSION_MAJOR)
  35 AC_SUBST(SODIUM_LIBRARY_VERSION_MINOR)
  36 AC_SUBST(SODIUM_LIBRARY_VERSION)
  37 AC_SUBST(DLL_VERSION)
  38
  39 LX_CFLAGS=${CFLAGS-NONE}
  40
  41 dnl Path check
  42
  43 AS_IF([test pwd | fgrep ' ' > /dev/null 2>&1],
  44   [AC_MSG_WARN([The build directory contains whitespaces - This can cause tests/installation to fail due to limitations of some libtool versions])]
  45 )
  46
  47 dnl Switches
  48
  49 AC_ARG_ENABLE(ssp,
  50 [AS_HELP_STRING(--disable-ssp,Do not compile with -fstack-protector)],
  51 [
  52   AS_IF([test "x$enableval" = "xno"], [
  53     enable_ssp="no"
  54   ], [
  55     enable_ssp="yes"
  56   ])
  57 ],
  58 [
  59   enable_ssp="yes"
  60 ])
  61
  62 AC_ARG_ENABLE(asm,
  63 [AS_HELP_STRING(--disable-asm,Disable assembly implementations)],
  64 [
  65   AS_IF([test "x$enableval" = "xno"], [
  66     enable_asm="no"
  67   ], [
  68     enable_asm="yes"
  69   ])
  70 ],
  71 [
  72   enable_asm="yes"
  73 ])
  74
  75 AS_IF([test "x$EMSCRIPTEN" != "x"],[
  76   enable_asm="no"
  77   AC_MSG_WARN([compiling to javascript - asm implementations disabled])
  78 ])
  79
  80 AC_ARG_ENABLE(pie,
  81 [AS_HELP_STRING(--disable-pie,Do not produce position independent executables)],
  82  enable_pie=$enableval, enable_pie="maybe")
  83
  84 AS_CASE([$host_os], [mingw*|cygwin*|msys], [enable_pie="no"])
  85
  86 AC_ARG_ENABLE(blocking-random,
  87 [AS_HELP_STRING(--enable-blocking-random,Enable this switch only if /dev/urandom is totally broken on the target platform)],
  88 [
  89   AS_IF([test "x$enableval" = "xyes"], [
  90     AC_DEFINE([USE_BLOCKING_RANDOM], [1], [/dev/urandom is insecure on the target platform])
  91   ])
  92 ])
  93
  94 AC_ARG_ENABLE(minimal,
  95 [AS_HELP_STRING(--enable-minimal,
  96   [Only compile the minimum set of functions required for the high-level API])],
  97 [
  98   AS_IF([test "x$enableval" = "xyes"], [
  99     enable_minimal="yes"
 100   ], [
 101     enable_minimal="no"
 102   ])
 103 ],
 104 [
 105   enable_minimal="no"
 106 ])
 107 AM_CONDITIONAL([MINIMAL], [test x$enable_minimal = xyes])
 108
 109 AC_ARG_WITH(safecode,
 110 [AS_HELP_STRING(--with-safecode,For maintainers only - please do not use)],
 111 [AS_IF([test "x$withval" = "xyes"], [
 112     AC_ARG_VAR([SAFECODE_HOME], [set to the safecode base directory])
 113     : ${SAFECODE_HOME:=/opt/safecode}
 114     LDFLAGS="$LDFLAGS -L${SAFECODE_HOME}/lib"
 115     LIBS="$LIBS -lsc_dbg_rt -lpoolalloc_bitmap -lstdc++"
 116     CFLAGS="$CFLAGS -fmemsafety"
 117   ])
 118 ])
 119
 120 AC_ARG_ENABLE(debug,
 121 [AS_HELP_STRING(--enable-debug,For maintainers only - please do not use)],
 122 [
 123   AS_IF([test "x$enableval" = "xyes"], [
 124     AS_IF([test "x$LX_CFLAGS" = "xNONE"], [
 125       nxflags=""
 126       for flag in `echo $CFLAGS`; do
 127         AS_CASE([$flag],
 128           [-O*], [ ],
 129           [-g*], [ ],
 130           [*], [AS_VAR_APPEND([nxflags], [" $flag"])])
 131       done
 132       CFLAGS="$nxflags -O0 -g3"
 133     ])
 134     CPPFLAGS="$CPPFLAGS -DDEBUG=1"
 135   ])
 136 ])
 137
 138 AC_ARG_ENABLE(opt,
 139 [AS_HELP_STRING(--enable-opt,Optimize for the native CPU - The resulting library will be faster but not portable)],
 140 [
 141   AS_IF([test "x$enableval" = "xyes"], [
 142     CFLAGS="$CFLAGS -O3 -march=native"
 143     LDFLAGS="$LDFLAGS -O3 -march=native"])
 144 ])
 145
 146 AC_SUBST([MAINT])
 147
 148 AX_VALGRIND_CHECK
 149
 150 dnl Checks
 151
 152 AC_PROG_CC_C99
 153 AM_PROG_AS
 154 AC_USE_SYSTEM_EXTENSIONS
 155
 156 AC_CHECK_DEFINE([__native_client__], [NATIVECLIENT="yes"], [])
 157
 158 AC_CHECK_DEFINE([_FORTIFY_SOURCE], [], [
 159   AX_CHECK_COMPILE_FLAG([-D_FORTIFY_SOURCE=2],
 160     [CPPFLAGS="$CPPFLAGS -D_FORTIFY_SOURCE=2"])
 161 ])
 162
 163 AX_CHECK_COMPILE_FLAG([-fvisibility=hidden],
 164   [CFLAGS="$CFLAGS -fvisibility=hidden"])
 165
 166 AS_CASE([$host_os], [cygwin*|mingw*|msys|pw32*|cegcc*], [ ], [
 167   AX_CHECK_COMPILE_FLAG([-fPIC], [
 168     AX_CHECK_LINK_FLAG([-fPIC],
 169       [CFLAGS="$CFLAGS -fPIC"]
 170     )
 171   ])
 172 ])
 173
 174 AS_IF([test "$enable_pie" != "no"],[
 175   AX_CHECK_COMPILE_FLAG([-fPIE], [
 176     AX_CHECK_LINK_FLAG([-fPIE],
 177       [AX_CHECK_LINK_FLAG([-pie],
 178         [CFLAGS="$CFLAGS -fPIE"
 179          LDFLAGS="$LDFLAGS -pie"])
 180     ])
 181   ])
 182 ])
 183
 184 AX_CHECK_COMPILE_FLAG([-fno-strict-aliasing], [CFLAGS="$CFLAGS -fno-strict-aliasing"])
 185 AX_CHECK_COMPILE_FLAG([-fno-strict-overflow], [CFLAGS="$CFLAGS -fno-strict-overflow"], [
 186   AX_CHECK_COMPILE_FLAG([-fwrapv], [CFLAGS="$CFLAGS -fwrapv"])
 187 ])
 188
 189 AS_IF([test "$GCC" = "yes" ], [
 190   AS_CASE([$host_cpu],
 191     [i?86|amd64|x86_64], [
 192       AC_COMPILE_IFELSE(
 193         [AC_LANG_SOURCE([
 194 #if !defined(__clang__) && defined(__GNUC__) && ((__GNUC__ << 8) | __GNUC_MINOR__) < 0x403
 195 # error old gcc
 196 #endif
 197 int main(void) { return 0; }
 198          ])],,[
 199           AX_CHECK_COMPILE_FLAG([-flax-vector-conversions], [CFLAGS="$CFLAGS -flax-vector-conversions"])
 200         ])
 201       ]
 202     )
 203   ])
 204
 205 LIBTOOL_OLD_FLAGS="$LIBTOOL_EXTRA_FLAGS"
 206 LIBTOOL_EXTRA_FLAGS="$LIBTOOL_EXTRA_FLAGS -version-info $SODIUM_LIBRARY_VERSION"
 207 AC_ARG_ENABLE(soname-versions,
 208   [AC_HELP_STRING([--enable-soname-versions], [enable soname versions (must be disabled for Android) (default: enabled)])],
 209     [
 210         AS_IF([test "x$enableval" = "xno"], [
 211           LIBTOOL_EXTRA_FLAGS="$LIBTOOL_OLD_FLAGS -avoid-version"
 212         ])
 213     ]
 214 )
 215
 216 AS_CASE([$host_os],
 217   [cygwin*|mingw*|msys|pw32*|cegcc*], [
 218     AX_CHECK_LINK_FLAG([-Wl,--dynamicbase], [LDFLAGS="$LDFLAGS -Wl,--dynamicbase"])
 219     AX_CHECK_LINK_FLAG([-Wl,--high-entropy-va], [LDFLAGS="$LDFLAGS -Wl,--high-entropy-va"])
 220     AX_CHECK_LINK_FLAG([-Wl,--nxcompat], [LDFLAGS="$LDFLAGS -Wl,--nxcompat"])
 221   ])
 222
 223 AS_IF([test "x$enable_ssp" != "xno"],[
 224
 225 AS_CASE([$host_os],
 226   [cygwin*|mingw*|msys|pw32*|cegcc*], [ ],
 227   [*], [
 228     AX_CHECK_COMPILE_FLAG([-fstack-protector], [
 229       AX_CHECK_LINK_FLAG([-fstack-protector],
 230         [CFLAGS="$CFLAGS -fstack-protector"]
 231       )
 232     ])
 233   ])
 234 ])
 235
 236 AX_CHECK_COMPILE_FLAG([-Wwrite-strings], [CFLAGS="$CFLAGS -Wwrite-strings"])
 237 AX_CHECK_COMPILE_FLAG([-Wdiv-by-zero], [CFLAGS="$CFLAGS -Wdiv-by-zero"])
 238 AX_CHECK_COMPILE_FLAG([-Wsometimes-uninitialized], [CFLAGS="$CFLAGS -Wsometimes-uninitialized"])
 239
 240 AC_ARG_VAR([CWFLAGS], [define to compilation flags for generating extra warnings])
 241
 242 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wall], [CWFLAGS="$CWFLAGS -Wall"])
 243 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wextra], [CWFLAGS="$CWFLAGS -Wextra"])
 244
 245 AC_MSG_CHECKING(for clang)
 246 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
 247 #ifndef __clang__
 248 be sad
 249 #endif
 250 ]])],
 251   [AC_MSG_RESULT(yes)
 252    AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wno-unknown-warning-option],
 253      [CWFLAGS="$CWFLAGS -Wno-unknown-warning-option"])
 254   ],
 255   [AC_MSG_RESULT(no)
 256 ])
 257
 258 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wbad-function-cast], [CWFLAGS="$CWFLAGS -Wbad-function-cast"])
 259 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wcast-align], [CWFLAGS="$CWFLAGS -Wcast-align"])
 260 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wcast-qual], [CWFLAGS="$CWFLAGS -Wcast-qual"])
 261 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wduplicated-cond], [CWFLAGS="$CWFLAGS -Wduplicated-cond"])
 262 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wfloat-equal], [CWFLAGS="$CWFLAGS -Wfloat-equal"])
 263 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wformat=2], [CWFLAGS="$CWFLAGS -Wformat=2"])
 264 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wmissing-declarations], [CWFLAGS="$CWFLAGS -Wmissing-declarations"])
 265 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wmissing-prototypes], [CWFLAGS="$CWFLAGS -Wmissing-prototypes"])
 266 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wnested-externs], [CWFLAGS="$CWFLAGS -Wnested-externs"])
 267 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wno-unknown-pragmas], [CWFLAGS="$CWFLAGS -Wno-unknown-pragmas"])
 268 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wnormalized=id], [CWFLAGS="$CWFLAGS -Wnormalized=id"])
 269 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wnull-dereference], [CWFLAGS="$CWFLAGS -Wnull-dereference"])
 270 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wpointer-arith], [CWFLAGS="$CWFLAGS -Wpointer-arith"])
 271 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wredundant-decls], [CWFLAGS="$CWFLAGS -Wredundant-decls"])
 272 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wstrict-prototypes], [CWFLAGS="$CWFLAGS -Wstrict-prototypes"])
 273 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wswitch-enum], [CWFLAGS="$CWFLAGS -Wswitch-enum"])
 274 AX_CHECK_COMPILE_FLAG([$CWFLAGS -Wvariable-decl], [CWFLAGS="$CWFLAGS -Wvariable-decl"])
 275
 276 AX_CHECK_LINK_FLAG([-Wl,-z,relro], [LDFLAGS="$LDFLAGS -Wl,-z,relro"])
 277 AX_CHECK_LINK_FLAG([-Wl,-z,now], [LDFLAGS="$LDFLAGS -Wl,-z,now"])
 278 AX_CHECK_LINK_FLAG([-Wl,-z,noexecstack], [LDFLAGS="$LDFLAGS -Wl,-z,noexecstack"])
 279
 280 LT_INIT
 281 AC_SUBST(LIBTOOL_DEPS)
 282
 283 AC_ARG_VAR([AR], [path to the ar utility])
 284 AC_CHECK_TOOL([AR], [ar], [ar])
 285
 286 dnl Checks for headers
 287
 288 AS_IF([test "x$EMSCRIPTEN" = "x"],[
 289
 290   AC_MSG_CHECKING(for MMX instructions set)
 291   oldcflags="$CFLAGS"
 292   AX_CHECK_COMPILE_FLAG([-mmmx], [CFLAGS="$CFLAGS -mmmx"])
 293   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 294 #pragma GCC target("mmx")
 295 #include <mmintrin.h>
 296 ]], [[ __m64 x = _mm_setzero_si64(); ]])],
 297     [AC_MSG_RESULT(yes)
 298      AC_DEFINE([HAVE_MMINTRIN_H], [1], [mmx is available])
 299      AX_CHECK_COMPILE_FLAG([-mmmx], [CFLAGS_MMX="-mmmx"])],
 300     [AC_MSG_RESULT(no)])
 301   CFLAGS="$oldcflags"
 302
 303   AC_MSG_CHECKING(for SSE2 instructions set)
 304   oldcflags="$CFLAGS"
 305   AX_CHECK_COMPILE_FLAG([-msse2], [CFLAGS="$CFLAGS -msse2"])
 306   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 307 #pragma GCC target("sse2")
 308 #ifndef __SSE2__
 309 # define __SSE2__
 310 #endif
 311 #include <emmintrin.h>
 312 ]], [[ __m128d x = _mm_setzero_pd();
 313        __m128i y = _mm_srli_epi64(_mm_setzero_si128(), 26); ]])],
 314     [AC_MSG_RESULT(yes)
 315      AC_DEFINE([HAVE_EMMINTRIN_H], [1], [sse2 is available])
 316      AX_CHECK_COMPILE_FLAG([-msse2], [CFLAGS_SSE2="-msse2"])],
 317     [AC_MSG_RESULT(no)])
 318   CFLAGS="$oldcflags"
 319
 320   oldcflags="$CFLAGS"
 321   AX_CHECK_COMPILE_FLAG([-msse3], [CFLAGS="$CFLAGS -msse3"])
 322   AC_MSG_CHECKING(for SSE3 instructions set)
 323   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 324 #pragma GCC target("sse3")
 325 #include <pmmintrin.h>
 326 ]], [[ __m128 x = _mm_addsub_ps(_mm_cvtpd_ps(_mm_setzero_pd()),
 327                                 _mm_cvtpd_ps(_mm_setzero_pd())); ]])],
 328     [AC_MSG_RESULT(yes)
 329      AC_DEFINE([HAVE_PMMINTRIN_H], [1], [sse3 is available])
 330      AX_CHECK_COMPILE_FLAG([-msse3], [CFLAGS_SSE3="-msse3"])],
 331     [AC_MSG_RESULT(no)])
 332   CFLAGS="$oldcflags"
 333
 334   oldcflags="$CFLAGS"
 335   AX_CHECK_COMPILE_FLAG([-mssse3], [CFLAGS="$CFLAGS -mssse3"])
 336   AC_MSG_CHECKING(for SSSE3 instructions set)
 337   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 338 #pragma GCC target("ssse3")
 339 #include <tmmintrin.h>
 340 ]], [[ __m64 x = _mm_abs_pi32(_m_from_int(0)); ]])],
 341     [AC_MSG_RESULT(yes)
 342      AC_DEFINE([HAVE_TMMINTRIN_H], [1], [ssse3 is available])
 343      AX_CHECK_COMPILE_FLAG([-mssse3], [CFLAGS_SSSE3="-mssse3"])],
 344     [AC_MSG_RESULT(no)])
 345   CFLAGS="$oldcflags"
 346
 347   oldcflags="$CFLAGS"
 348   AX_CHECK_COMPILE_FLAG([-msse4.1], [CFLAGS="$CFLAGS -msse4.1"])
 349   AC_MSG_CHECKING(for SSE4.1 instructions set)
 350   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 351 #pragma GCC target("sse4.1")
 352 #include <smmintrin.h>
 353 ]], [[ __m128i x = _mm_minpos_epu16(_mm_setzero_si128()); ]])],
 354     [AC_MSG_RESULT(yes)
 355      AC_DEFINE([HAVE_SMMINTRIN_H], [1], [sse4.1 is available])
 356      AX_CHECK_COMPILE_FLAG([-msse4.1], [CFLAGS_SSE41="-msse4.1"])],
 357     [AC_MSG_RESULT(no)])
 358   CFLAGS="$oldcflags"
 359
 360   oldcflags="$CFLAGS"
 361   AX_CHECK_COMPILE_FLAG([-mavx], [CFLAGS="$CFLAGS -mavx"])
 362   AC_MSG_CHECKING(for AVX instructions set)
 363   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 364 #pragma GCC target("avx")
 365 #include <immintrin.h>
 366 ]], [[ _mm256_zeroall(); ]])],
 367     [AC_MSG_RESULT(yes)
 368      AC_DEFINE([HAVE_AVXINTRIN_H], [1], [AVX is available])
 369      AX_CHECK_COMPILE_FLAG([-mavx], [CFLAGS_AVX="-mavx"])],
 370     [AC_MSG_RESULT(no)])
 371   CFLAGS="$oldcflags"
 372
 373   oldcflags="$CFLAGS"
 374   AX_CHECK_COMPILE_FLAG([-mavx2], [CFLAGS="$CFLAGS -mavx2"])
 375   AC_MSG_CHECKING(for AVX2 instructions set)
 376   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 377 #pragma GCC target("avx2")
 378 #include <immintrin.h>
 379 ]], [[ __m256i x = _mm256_abs_epi8(_mm256_setzero_si256()); ]])],
 380     [AC_MSG_RESULT(yes)
 381      AC_DEFINE([HAVE_AVX2INTRIN_H], [1], [AVX2 is available])
 382      AX_CHECK_COMPILE_FLAG([-mavx2], [CFLAGS_AVX="-mavx2"])
 383      AC_MSG_CHECKING(if _mm256_broadcastsi128_si256 is correctly defined)
 384      AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 385 #pragma GCC target("avx2")
 386 #include <immintrin.h>
 387      ]], [[ __m256i y = _mm256_broadcastsi128_si256(_mm_setzero_si128()); ]])],
 388        [AC_MSG_RESULT(yes)],
 389        [AC_MSG_RESULT(no)
 390         AC_DEFINE([_mm256_broadcastsi128_si256], [_mm_broadcastsi128_si256],
 391                   [Define to the local name of _mm256_broadcastsi128_si256])])
 392      ],
 393     [AC_MSG_RESULT(no)])
 394   CFLAGS="$oldcflags"
 395
 396   oldcflags="$CFLAGS"
 397   AX_CHECK_COMPILE_FLAG([-maes], [CFLAGS="$CFLAGS -maes"])
 398   AX_CHECK_COMPILE_FLAG([-mpclmul], [CFLAGS="$CFLAGS -mpclmul"])
 399   AC_MSG_CHECKING(for AESNI instructions set and PCLMULQDQ)
 400   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 401 #pragma GCC target("aes")
 402 #pragma GCC target("pclmul")
 403 #include <wmmintrin.h>
 404 ]], [[ __m128i x = _mm_aesimc_si128(_mm_setzero_si128());
 405        __m128i y = _mm_clmulepi64_si128(_mm_setzero_si128(), _mm_setzero_si128(), 0);]])],
 406     [AC_MSG_RESULT(yes)
 407      AC_DEFINE([HAVE_WMMINTRIN_H], [1], [aesni is available])
 408      AX_CHECK_COMPILE_FLAG([-maes], [CFLAGS_AESNI="-maes"])
 409      AX_CHECK_COMPILE_FLAG([-mpclmul], [CFLAGS_PCLMUL="-mpclmul"])
 410      ],
 411     [AC_MSG_RESULT(no)])
 412   CFLAGS="$oldcflags"
 413
 414 ])
 415
 416 AC_SUBST(CFLAGS_MMX)
 417 AC_SUBST(CFLAGS_SSE2)
 418 AC_SUBST(CFLAGS_SSE3)
 419 AC_SUBST(CFLAGS_SSSE3)
 420 AC_SUBST(CFLAGS_SSE41)
 421 AC_SUBST(CFLAGS_AVX)
 422 AC_SUBST(CFLAGS_AVX2)
 423 AC_SUBST(CFLAGS_AESNI)
 424 AC_SUBST(CFLAGS_PCLMUL)
 425
 426 AC_CHECK_HEADERS([sys/mman.h])
 427
 428 dnl Checks for typedefs, structures, and compiler characteristics.
 429
 430 AC_C_INLINE
 431 AS_CASE([$host_cpu],
 432   [i?86|amd64|x86_64],
 433     [ac_cv_c_bigendian=no]
 434 )
 435 AC_C_BIGENDIAN(
 436   AC_DEFINE(NATIVE_BIG_ENDIAN, 1, [machine is bigendian]),
 437   AC_DEFINE(NATIVE_LITTLE_ENDIAN, 1, [machine is littleendian]),
 438   AC_MSG_ERROR([unknown endianness]),
 439   AC_MSG_ERROR([universal endianness is not supported - compile separately and use lipo(1)])
 440 )
 441
 442 AC_MSG_CHECKING(whether __STDC_LIMIT_MACROS is required)
 443 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 444 #include <limits.h>
 445 #include <stdint.h>
 446 ]], [[
 447 (void) SIZE_MAX;
 448 (void) UINT64_MAX;
 449 ]])],
 450   [AC_MSG_RESULT(no)],
 451   [AC_MSG_RESULT(yes)
 452    CPPFLAGS="$CPPFLAGS -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS"
 453 ])
 454
 455 HAVE_AMD64_ASM_V=0
 456 AS_IF([test "$enable_asm" != "no"],[
 457   AC_MSG_CHECKING(whether we can use x86_64 asm code)
 458   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 459   ]], [[
 460 #if defined(__amd64) || defined(__amd64__) || defined(__x86_64__)
 461 # if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(_WIN32) || defined(_WIN64)
 462 #  error Windows x86_64 calling conventions are not supported yet
 463 # endif
 464 /* neat */
 465 #else
 466 # error !x86_64
 467 #endif
 468 unsigned char i = 0, o = 0, t;
 469 __asm__ __volatile__ ("pxor %%xmm12, %%xmm6 \n"
 470                       "movb (%[i]), %[t] \n"
 471                       "addb %[t], (%[o]) \n"
 472                       : [t] "=&r"(t)
 473                       : [o] "D"(&o), [i] "S"(&i)
 474                       : "memory", "flags", "cc");
 475 ]])],
 476   [AC_MSG_RESULT(yes)
 477    AC_DEFINE([HAVE_AMD64_ASM], [1], [x86_64 asm code can be used])
 478    HAVE_AMD64_ASM_V=1],
 479   [AC_MSG_RESULT(no)])
 480 ])
 481 AM_CONDITIONAL([HAVE_AMD64_ASM], [test $HAVE_AMD64_ASM_V = 1])
 482 AC_SUBST(HAVE_AMD64_ASM_V)
 483
 484 HAVE_AVX_ASM_V=0
 485 AS_IF([test "$enable_asm" != "no"],[
 486   AC_MSG_CHECKING(whether we can assemble AVX opcodes)
 487   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 488   ]], [[
 489 #if defined(__amd64) || defined(__amd64__) || defined(__x86_64__)
 490 # if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(_WIN32) || defined(_WIN64)
 491 #  error Windows x86_64 calling conventions are not supported yet
 492 # endif
 493 /* neat */
 494 #else
 495 # error !x86_64
 496 #endif
 497 __asm__ __volatile__ ("vpunpcklqdq %xmm0,%xmm13,%xmm0");
 498 ]])],
 499   [AC_MSG_RESULT(yes)
 500    AC_DEFINE([HAVE_AVX_ASM], [1], [AVX opcodes are supported])
 501    HAVE_AVX_ASM_V=1],
 502   [AC_MSG_RESULT(no)])
 503 ])
 504 AM_CONDITIONAL([HAVE_AVX_ASM], [test $HAVE_AVX_ASM_V = 1])
 505 AC_SUBST(HAVE_AVX_ASM_V)
 506
 507 AC_MSG_CHECKING(for 128-bit arithmetic)
 508 HAVE_TI_MODE_V=0
 509 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 510 #if !defined(__GNUC__) && !defined(__SIZEOF_INT128__)
 511 # error mode(TI) is a gcc extension, and __int128 is not available
 512 #endif
 513 #if defined(__clang__) && !defined(__x86_64__)
 514 # error clang does not properly handle the 128-bit type on 32-bit systems
 515 #endif
 516 #ifndef NATIVE_LITTLE_ENDIAN
 517 # error libsodium currently expects a little endian CPU for the 128-bit type
 518 #endif
 519 #ifdef __EMSCRIPTEN__
 520 # error emscripten currently supports only shift operations on integers \
 521 #       larger than 64 bits
 522 #endif
 523 #include <stddef.h>
 524 #include <stdint.h>
 525 #if defined(__SIZEOF_INT128__)
 526 typedef unsigned __int128 uint128_t;
 527 #else
 528 typedef unsigned uint128_t __attribute__((mode(TI)));
 529 #endif
 530 void fcontract(uint128_t *t) {
 531   *t += 0x8000000000000 - 1;
 532 }
 533 ]], [[
 534 (void) fcontract;
 535 ]])],
 536 [AC_MSG_RESULT(yes)
 537  AC_DEFINE([HAVE_TI_MODE], [1], [gcc TI mode is available])
 538  HAVE_TI_MODE_V=1],
 539 [AC_MSG_RESULT(no)])
 540 AM_CONDITIONAL([HAVE_TI_MODE], [test $HAVE_TI_MODE_V = 1])
 541 AC_SUBST(HAVE_TI_MODE_V)
 542
 543 HAVE_CPUID_V=0
 544 AS_IF([test "$enable_asm" != "no"],[
 545   AC_MSG_CHECKING(for cpuid instruction)
 546   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
 547 unsigned int cpu_info[4];
 548 __asm__ __volatile__ ("xchgl %%ebx, %k1; cpuid; xchgl %%ebx, %k1" :
 549                       "=a" (cpu_info[0]), "=&r" (cpu_info[1]),
 550                       "=c" (cpu_info[2]), "=d" (cpu_info[3]) :
 551                       "0" (0U), "2" (0U));
 552   ]])],
 553   [AC_MSG_RESULT(yes)
 554    AC_DEFINE([HAVE_CPUID], [1], [cpuid instruction is available])
 555    HAVE_CPUID_V=1],
 556   [AC_MSG_RESULT(no)])
 557   ])
 558 AC_SUBST(HAVE_CPUID_V)
 559
 560 asm_hide_symbol="unsupported"
 561 AS_IF([test "$enable_asm" != "no"],[
 562   AC_MSG_CHECKING(if the .private_extern asm directive is supported)
 563   AC_LINK_IFELSE([AC_LANG_PROGRAM([[ ]], [[
 564 __asm__ __volatile__ (".private_extern dummy_symbol \n"
 565                       ".private_extern _dummy_symbol \n"
 566                       ".globl dummy_symbol \n"
 567                       ".globl _dummy_symbol \n"
 568                       "dummy_symbol: \n"
 569                       "_dummy_symbol: \n"
 570                       "    nop \n"
 571 );
 572   ]])],
 573   [AC_MSG_RESULT(yes)
 574    asm_hide_symbol=".private_extern"],
 575   [AC_MSG_RESULT(no)])
 576
 577   AC_MSG_CHECKING(if the .hidden asm directive is supported)
 578   AC_LINK_IFELSE([AC_LANG_PROGRAM([[ ]], [[
 579 __asm__ __volatile__ (".hidden dummy_symbol \n"
 580                       ".hidden _dummy_symbol \n"
 581                       ".globl dummy_symbol \n"
 582                       ".globl _dummy_symbol \n"
 583                       "dummy_symbol: \n"
 584                       "_dummy_symbol: \n"
 585                       "    nop \n"
 586 );
 587   ]])],
 588   [AC_MSG_RESULT(yes)
 589    AS_IF([test "$asm_hide_symbol" = "unsupported"],
 590           [asm_hide_symbol=".hidden"],
 591           [AC_MSG_NOTICE([unable to reliably tag symbols as private])
 592            asm_hide_symbol="unsupported"])
 593   ],
 594   [AC_MSG_RESULT(no)])
 595
 596   AS_IF([test "$asm_hide_symbol" != "unsupported"],[
 597     AC_DEFINE_UNQUOTED([ASM_HIDE_SYMBOL], [$asm_hide_symbol], [directive to hide symbols])
 598   ])
 599 ])
 600
 601 AC_MSG_CHECKING(if weak symbols are supported)
 602 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 603 __attribute__((weak)) void __dummy(void *x) { }
 604 void f(void *x) { __dummy(x); }
 605 ]], [[ ]]
 606 )],
 607 [AC_MSG_RESULT(yes)
 608  AC_DEFINE([HAVE_WEAK_SYMBOLS], [1], [weak symbols are supported])],
 609 [AC_MSG_RESULT(no)])
 610
 611 AC_MSG_CHECKING(if data alignment is required)
 612 aligned_access_required=yes
 613 AS_CASE([$host_cpu],
 614   [i?86|amd64|x86_64|powerpc*|s390*],
 615     [aligned_access_required=no],
 616   [arm*],
 617     [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 618 #ifndef __ARM_FEATURE_UNALIGNED
 619 # error data alignment is required
 620 #endif
 621       ]], [[]])], [aligned_access_required=no], [])]
 622 )
 623 AS_IF([test "x$aligned_access_required" = "xyes"],
 624   [AC_MSG_RESULT(yes)],
 625   [AC_MSG_RESULT(no)
 626    AC_DEFINE([CPU_UNALIGNED_ACCESS], [1], [unaligned memory access is supported])])
 627
 628 dnl Checks for functions and headers
 629
 630 AS_IF([test "x$EMSCRIPTEN" = "x"],[
 631   AC_CHECK_FUNCS([arc4random arc4random_buf])
 632   AC_CHECK_FUNCS([mmap mlock madvise mprotect explicit_bzero])
 633 ])
 634 AC_CHECK_FUNCS([posix_memalign getpid])
 635
 636 AC_SUBST([LIBTOOL_EXTRA_FLAGS])
 637
 638 TEST_LDFLAGS=''
 639 AS_IF([test "x$EMSCRIPTEN" != "x"],[
 640   EXEEXT=.js
 641   TEST_LDFLAGS='--memory-init-file 0 --pre-js pre.js.inc -s RESERVED_FUNCTION_POINTERS=8'
 642 ])
 643 AC_SUBST(TEST_LDFLAGS)
 644 AM_CONDITIONAL([EMSCRIPTEN], [test "x$EMSCRIPTEN" != "x"])
 645
 646 AM_CONDITIONAL([NATIVECLIENT], [test "x$NATIVECLIENT" != "x"])
 647
 648 dnl Libtool.
 649
 650 LT_INIT([dlopen])
 651 AC_LIBTOOL_WIN32_DLL
 652 gl_LD_OUTPUT_DEF
 653
 654 dnl Output.
 655
 656 AH_VERBATIM([NDEBUG], [/* Always evaluate assert() calls */
 657 #ifdef NDEBUG
 658 #/**/undef/**/ NDEBUG
 659 #endif])
 660
 661 AC_CONFIG_FILES([Makefile
 662                  dist-build/Makefile
 663                  libsodium.pc
 664                  libsodium-uninstalled.pc
 665                  msvc-scripts/Makefile
 666                  src/Makefile
 667                  src/libsodium/Makefile
 668                  src/libsodium/include/Makefile
 669                  src/libsodium/include/sodium/version.h
 670                  test/default/Makefile
 671                  test/Makefile
 672                  ])
 673 AC_OUTPUT