folly/configure.ac

   1
   2 #                                               -*- Autoconf -*-
   3 # Process this file with autoconf to produce a configure script.
   4
   5 AC_PREREQ(2.59)
   6
   7 m4_define([folly_version_str], m4_esyscmd_s([cat VERSION]))
   8
   9 AC_INIT([folly], m4_translit(folly_version_str, [:], [.]), [folly@fb.com])
  10
  11 # We assume all revisions are backwards incompatible.
  12 LT_VERSION=folly_version_str:0
  13 AC_SUBST([LT_VERSION])
  14
  15 #declare pkg-config variables
  16 PKG_VERSION=m4_join([.], m4_reverse(m4_translit(folly_version_str, [:], [,])))
  17 AC_SUBST([PKG_VERSION])
  18 AC_SUBST([PKG_CXXFLAGS])
  19 AC_SUBST([PKG_DEPS])
  20 AC_SUBST([PKG_LIBS])
  21
  22 AC_CONFIG_SRCDIR([Likely.h])
  23 AC_CONFIG_HEADERS([config.h])
  24 AX_PREFIX_CONFIG_H([folly-config.h], [folly], [config.h])
  25 AC_CONFIG_AUX_DIR([build-aux])
  26
  27 AM_INIT_AUTOMAKE([foreign dist-bzip2 nostdinc subdir-objects])
  28
  29 AC_CONFIG_MACRO_DIR([m4])
  30
  31 AC_PROG_INSTALL
  32 AM_PROG_LIBTOOL
  33
  34 AC_LANG([C++])
  35
  36 # Checks for programs.
  37 AC_PROG_CXX
  38 AC_PROG_CC
  39
  40 AC_CXX_COMPILE_STDCXX_1Y
  41
  42 # Be sure to add any -std option to CXXFLAGS before we invoke any
  43 # AC_COMPILE_IFELSE() or similar macros. Any such macros that are invoked
  44 # before we update CXXFLAGS will not be run with the same options that we use
  45 # during the real build.
  46 STD=""
  47 if test "x$ac_cv_cxx_compile_cxx1y_cxx" = xyes; then
  48    STD="-std=c++1y"
  49 fi
  50 if test "x$ac_cv_cxx_compile_cxx1y_gxx" = xyes; then
  51    STD="-std=gnu++1y"
  52 fi
  53
  54 CXXFLAGS="$STD $CXXFLAGS"
  55
  56 # expose required -std option via pkg-config
  57 PKG_CXXFLAGS=$STD
  58
  59 # See if -Wunknown-warning-option is supported
  60 AC_MSG_CHECKING(
  61   [whether -Wunknown-warning-option is supported])
  62 AC_CACHE_VAL([folly_cv_cxx_unknown_warning_option_support], [
  63   folly_save_CXXFLAGS="$CXXFLAGS"
  64   CXXFLAGS="$CXXFLAGS -Werror=unknown-warning-option"
  65   AC_COMPILE_IFELSE(
  66     [AC_LANG_PROGRAM([[]], [[]])],
  67     [
  68       # The compiler didn't completely error out on -Werror=unknown-warning-option
  69       CXXFLAGS="$CXXFLAGS -Werror=unknown-warning-option -Wthis-is-an-unknown-option-that-should-error"
  70       AC_COMPILE_IFELSE(
  71         [AC_LANG_PROGRAM([[]], [[]])],
  72         [folly_cv_cxx_unknown_warning_option_support=no],
  73         [folly_cv_cxx_unknown_warning_option_support=yes])
  74     ],
  75     [folly_cv_cxx_unknown_warning_option_support=no])
  76   CXXFLAGS="$folly_save_CXXFLAGS"])
  77 AC_MSG_RESULT([$folly_cv_cxx_unknown_warning_option_support])
  78
  79 # See if -Wshadow-local and -Wshadow-compatible-local are supported
  80 AC_MSG_CHECKING(
  81   [whether -Wshadow-local and -Wshadow-compatible-local are supported])
  82 AC_CACHE_VAL([folly_cv_cxx_shadow_local_support], [
  83   folly_save_CXXFLAGS="$CXXFLAGS"
  84   CXXFLAGS="$CXXFLAGS -Wshadow-local -Wshadow-compatible-local"
  85   if test "$folly_cv_cxx_unknown_warning_option_support" = yes; then
  86     CXXFLAGS="$CXXFLAGS -Werror=unknown-warning-option"
  87   fi
  88   AC_COMPILE_IFELSE(
  89     [AC_LANG_PROGRAM([[]], [[]])],
  90     [folly_cv_cxx_shadow_local_support=yes],
  91     [folly_cv_cxx_shadow_local_support=no])
  92   CXXFLAGS="$folly_save_CXXFLAGS"])
  93 AC_MSG_RESULT([$folly_cv_cxx_shadow_local_support])
  94 if test "$folly_cv_cxx_shadow_local_support" = yes; then
  95   AC_DEFINE([HAVE_SHADOW_LOCAL_WARNINGS], [1],
  96   [Define if both -Wshadow-local and -Wshadow-compatible-local are supported.])
  97 fi
  98
  99 # Checks for glog and gflags
 100 # There are no symbols with C linkage, so we do a try-run
 101 AC_HAVE_LIBRARY([gflags],[],[AC_MSG_ERROR(
 102                 [Please install google-gflags library])])
 103 AC_CACHE_CHECK(
 104   [for gflags viability],
 105   [folly_cv_prog_cc_gflags],
 106   [AC_RUN_IFELSE(
 107     [AC_LANG_SOURCE[
 108       #include <gflags/gflags.h>
 109       DEFINE_bool(folly_truthy, true, "Sample truthy flag");
 110       DEFINE_bool(folly_falsey, false, "Sample falsey flag");
 111       int main(int argc, char** argv) {
 112         return (FLAGS_folly_truthy && !FLAGS_folly_falsey) ? 0 : 1;
 113       }
 114     ]],
 115     [folly_cv_prog_cc_gflags=yes],
 116     [folly_cv_prog_cc_gflags=no]
 117   )]
 118 )
 119
 120 if test "$folly_cv_prog_cc_gflags" != "yes"; then
 121   AC_MSG_ERROR(["gflags invalid, see config.log for details"])
 122 fi
 123 FB_CHECK_PKG_CONFIG([GFLAGS], [gflags])
 124
 125 AC_HAVE_LIBRARY([glog],[],[AC_MSG_ERROR(
 126                 [Please install google-glog library])])
 127 AC_CACHE_CHECK(
 128   [for glog viability],
 129   [folly_cv_prog_cc_glog],
 130   [AC_RUN_IFELSE(
 131     [AC_LANG_SOURCE[
 132       #include <glog/logging.h>
 133       int main(int argc, char** argv) {
 134         google::InitGoogleLogging(argv[0]);
 135         google::ShutdownGoogleLogging();
 136         return 0;
 137       }
 138     ]],
 139     [folly_cv_prog_cc_glog=yes],
 140     [folly_cv_prog_cc_glog=no]
 141   )]
 142 )
 143
 144 if test "$folly_cv_prog_cc_glog" != "yes"; then
 145   AC_MSG_ERROR(["libglog invalid, see config.log for details"])
 146 fi
 147 FB_CHECK_PKG_CONFIG([GLOG], [libglog])
 148
 149 AS_IF(
 150   [test "x$OPENSSL_INCLUDES" = "x"],
 151   [
 152     AX_CHECK_OPENSSL([], [AC_MSG_ERROR(["Error: libssl required"])])
 153   ],
 154   [
 155     # AX_CHECK_OPENSSL doesn't seem to play nice with builds started
 156     # via build/bootstrap-osx-homebrew.sh
 157     AC_MSG_WARN(["Using existing OpenSSL flags from environment."])
 158     PKG_CXXFLAGS="$PKG_CXXFLAGS $OPENSSL_INCLUDES"
 159   ]
 160 )
 161 FB_CHECK_PKG_CONFIG([OPENSSL], [openssl])
 162
 163 # check for boost libs
 164 AX_BOOST_BASE([1.51.0], [], [AC_MSG_ERROR(
 165               [Please install boost >= 1.51.0 (context, thread, program_options, regex, system and chrono)])])
 166 AX_BOOST_CONTEXT
 167 AX_BOOST_PROGRAM_OPTIONS
 168 AX_BOOST_THREAD
 169 AX_BOOST_REGEX
 170 AX_BOOST_SYSTEM
 171 AX_BOOST_FILESYSTEM
 172 AX_BOOST_CHRONO
 173
 174 # Check for python interpreter
 175 AM_PATH_PYTHON
 176
 177 # Checks for header files.
 178 AC_HEADER_STDC
 179 AC_CHECK_HEADERS([features.h malloc.h bits/functexcept.h bits/c++config.h])
 180
 181 AC_CHECK_HEADER(double-conversion/double-conversion.h, [], [AC_MSG_ERROR(
 182                 [Couldn't find double-conversion.h, please download from \
 183                  https://github.com/google/double-conversion/])], [])
 184 AC_CHECK_LIB([double-conversion],[ceil],[],[AC_MSG_ERROR(
 185              [Please install double-conversion library])])
 186
 187 AC_CHECK_LIB([event], [event_set], [], [AC_MSG_ERROR([Unable to find libevent])])
 188 FB_CHECK_PKG_CONFIG([EVENT], [libevent])
 189
 190 AC_ARG_WITH([jemalloc], [
 191   --with-jemalloc     Whether to make folly jemalloc aware
 192 ],[
 193   AC_CHECK_LIB([jemalloc], [xallocx],[
 194     AC_DEFINE([USE_JEMALLOC], [1], [Enable jemalloc])
 195   ],[
 196     AC_MSG_ERROR([--with-jemalloc requested, but jemalloc not found])
 197   ])
 198 ])
 199
 200 # Checks for typedefs, structures, and compiler characteristics.
 201 AC_C_CONST
 202 AC_C_INLINE
 203 AC_TYPE_SIZE_T
 204 AC_HEADER_TIME
 205 AC_C_VOLATILE
 206 AC_CHECK_TYPE([__int128], [folly_cv_prog_cc_int128=yes],
 207     [folly_cv_prog_cc_int128=no])
 208 if test "$folly_cv_prog_cc_int128" = "yes"; then
 209   AC_DEFINE([HAVE_INT128_T], [1], [Define if we have __int128])
 210   AC_CACHE_CHECK(
 211     [for __int128 type traits],
 212     [folly_cv_prog_cc_int128traits],
 213     [AC_COMPILE_IFELSE(
 214       [AC_LANG_SOURCE([[
 215 #include <type_traits>
 216 static_assert(
 217   ::std::is_same<::std::make_signed<unsigned __int128>::type, __int128>::value,
 218   "signed form of \`unsigned __uint128\` must be \`__int128\`.");
 219       ]])],
 220       [folly_cv_prog_cc_int128traits=yes],
 221       [folly_cv_prog_cc_int128traits=no])
 222     ])
 223   if test "$folly_cv_prog_cc_int128traits" = "no"; then
 224     AC_DEFINE([SUPPLY_MISSING_INT128_TRAITS], [1], [Define if we need the standard integer traits defined for the type `__int128'.])
 225   fi
 226 fi
 227
 228 AC_CHECK_TYPES([pthread_spinlock_t])
 229
 230 AC_CACHE_CHECK(
 231   [for ifunc support],
 232   [folly_cv_prog_cc_ifunc],
 233   [AC_COMPILE_IFELSE(
 234     [AC_LANG_SOURCE[
 235       #pragma GCC diagnostic error "-Wattributes"
 236       extern "C" void (*test_ifunc(void))() { return 0; }
 237       void func() __attribute__((ifunc("test_ifunc")));]
 238     ],
 239     [folly_cv_prog_cc_ifunc=yes],
 240     [folly_cv_prog_cc_ifunc=no])])
 241
 242 if test "$folly_cv_prog_cc_ifunc" = "yes"; then
 243   AC_DEFINE([HAVE_IFUNC], [1], [Define to 1 if the compiler supports ifunc])
 244 fi
 245
 246 AC_CACHE_CHECK(
 247   [for final and override support],
 248   [folly_cv_c_final_override],
 249   [AC_COMPILE_IFELSE(
 250     [AC_LANG_SOURCE[class C { virtual void f() final {} virtual void g() {} };
 251                     class D : public C { virtual void g() override {} };]],
 252     [folly_cv_c_final_override=yes],
 253     [folly_cv_c_final_override=no])])
 254
 255 if test "$folly_cv_c_final_override" = "yes"; then
 256   final_val=final
 257   override_val=override
 258 else
 259   final_val=
 260   override_val=
 261 fi
 262
 263 AC_DEFINE_UNQUOTED(
 264   [FINAL], [$final_val],
 265   [Define to "final" if the compiler supports C++11 "final"])
 266 AC_DEFINE_UNQUOTED(
 267   [OVERRIDE], [$override_val],
 268   [Define to "override" if the compiler supports C++11 "override"])
 269
 270 AC_CACHE_CHECK(
 271   [for libc++],
 272   [folly_cv_lib_libcpp],
 273   [AC_COMPILE_IFELSE(
 274     [AC_LANG_SOURCE[
 275       #include <type_traits>
 276       #if !_LIBCPP_VERSION
 277       #error No libc++
 278       #endif
 279       void func() {}]
 280     ],
 281     [folly_cv_lib_libcpp=yes],
 282     [folly_cv_lib_libcpp=no])])
 283
 284 if test "$folly_cv_lib_libcpp" = yes; then
 285   AC_DEFINE([USE_LIBCPP], [1], [Define to 1 if we are using libc++.])
 286 fi
 287
 288 AC_CACHE_CHECK(
 289   [for c++11 atomic support without GNU Atomic library],
 290   [folly_cv_lib_libatomic],
 291   [AC_LINK_IFELSE(
 292     [AC_LANG_SOURCE[
 293       #include <atomic>
 294       int main() {
 295         struct Test { int val; };
 296         std::atomic<Test> s;
 297         s.is_lock_free();
 298       }
 299     ]],
 300     [folly_cv_lib_libatomic=yes],
 301     [folly_cv_lib_libatomic=no])])
 302
 303 if test "$folly_cv_lib_libatomic" = no; then
 304   AC_HAVE_LIBRARY([atomic],[],[AC_MSG_ERROR(
 305                   [Please install the GNU Atomic library])])
 306 fi
 307
 308 if test "$build_os" = "linux-gnu"; then
 309   AC_HAVE_LIBRARY([dl],[],[AC_MSG_ERROR(
 310                   [Folly depends on libdl])])
 311 fi
 312
 313 AC_CACHE_CHECK(
 314   [for liblinux-vdso support],
 315   [folly_cv_lib_liblinux_vdso],
 316   [AC_RUN_IFELSE(
 317     [AC_LANG_SOURCE[
 318       #include <dlfcn.h>
 319       int main() {
 320         void *h = dlopen("linux-vdso.so.1", RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
 321         if (h == nullptr) {
 322           return -1;
 323         }
 324         dlclose(h);
 325         return 0;
 326       }
 327     ]],
 328     [folly_cv_lib_liblinux_vdso=yes],
 329     [folly_cv_lib_liblinux_vdso=no])])
 330
 331 if test "$folly_cv_lib_liblinux_vdso" = yes; then
 332   AC_DEFINE([HAVE_LINUX_VDSO], [1], [Define to 1 if liblinux-vdso is available])
 333 fi
 334
 335 AC_DEFINE([HAVE_PTHREAD], [1], [Define to 1 if pthread is avaliable])
 336
 337 AC_CACHE_CHECK(
 338   [for usable std::is_trivially_copyable],
 339   [folly_cv_decl_std_is_trivially_copyable],
 340   [AC_COMPILE_IFELSE(
 341     [AC_LANG_SOURCE[
 342       #include <type_traits>
 343       const bool val = std::is_trivially_copyable<bool>::value;]
 344     ],
 345     [folly_cv_decl_std_is_trivially_copyable=yes],
 346     [folly_cv_decl_std_is_trivially_copyable=no])])
 347
 348 if test "$folly_cv_decl_std_is_trivially_copyable" = yes; then
 349   AC_DEFINE([HAVE_STD__IS_TRIVIALLY_COPYABLE], [1],
 350             [Define to 1 if we have a usable std::is_trivially_copyable<T>
 351              implementation.])
 352 fi
 353
 354 AC_CACHE_CHECK(
 355   [gflags namespace],
 356   [folly_cv_decl_gflags_namespace],
 357   [AC_COMPILE_IFELSE(
 358     [AC_LANG_SOURCE[
 359       #include <gflags/gflags.h>
 360       void foo() { gflags::GetArgv(); }]
 361     ],
 362     [folly_cv_decl_gflags_namespace=gflags],
 363     [AC_COMPILE_IFELSE(
 364       [AC_LANG_SOURCE[
 365         #include <gflags/gflags.h>
 366         void foo() { google::GetArgv(); }]
 367       ],
 368       [folly_cv_decl_gflags_namespace=google],
 369       [folly_cv_decl_gflags_namespace=error])])])
 370
 371 if test "$folly_cv_decl_gflags_namespace" = error; then
 372   AC_MSG_ERROR([Cannot determine gflags namespace])
 373 else
 374   AC_DEFINE_UNQUOTED(
 375     [GFLAGS_NAMESPACE], [$folly_cv_decl_gflags_namespace],
 376     [Define to gflags namespace (usually "google" or "gflags")])
 377   if test "$folly_cv_decl_gflags_namespace" != gflags; then
 378      AC_DEFINE([UNUSUAL_GFLAGS_NAMESPACE], [1],
 379                [Define to 1 if the gflags namespace is not "gflags"])
 380   fi
 381 fi
 382
 383 # Figure out if we support weak symbols. If not, we will link in some null
 384 # stubs for functions that would otherwise be weak.
 385 AC_CACHE_CHECK(
 386   [for weak symbol support],
 387   [folly_cv_prog_cc_weak_symbols],
 388   [AC_LINK_IFELSE(
 389     [AC_LANG_SOURCE[
 390       extern "C" void configure_link_extern_weak_test() __attribute__((weak));
 391       int main(int argc, char** argv) {
 392           return configure_link_extern_weak_test == nullptr;
 393       }]],
 394     [folly_cv_prog_cc_weak_symbols="yes"],
 395     [folly_cv_prog_cc_weak_symbols="no"])])
 396
 397 if test "$folly_cv_prog_cc_weak_symbols" = yes; then
 398   AC_DEFINE([HAVE_WEAK_SYMBOLS], [1],
 399             [Define to 1 if the linker supports weak symbols.])
 400 fi
 401
 402
 403 # Figure out if we support wchar well
 404 AC_CACHE_CHECK(
 405   [for wchar support],
 406   [folly_cv_prog_cc_wchar_support],
 407   [AC_RUN_IFELSE(
 408     [AC_LANG_SOURCE[
 409       #include <cstddef>
 410       #include <cwchar>
 411
 412       int main(int argc, char** argv) {
 413         return wcstol(L"01", nullptr, 10) == 1 ? 0 : 1;
 414       }
 415     ]],
 416     [folly_cv_prog_cc_wchar_support=yes],
 417     [folly_cv_prog_cc_wchar_support=no])])
 418
 419 if test "$folly_cv_prog_cc_wchar_support" = "yes"; then
 420   AC_DEFINE([HAVE_WCHAR_SUPPORT], [1], [Define to 1 if the libc supports wchar well])
 421 fi
 422
 423 # Figure out whether the architecture supports unaligned accesses
 424 AC_CACHE_CHECK(
 425   [for unaligned access support],
 426   [folly_cv_prog_cc_unaligned_access],
 427   [AC_RUN_IFELSE(
 428     [AC_LANG_SOURCE[
 429       int main(int argc, char** argv) {
 430         char buf[64] = {0};
 431         unsigned long *ptr = (unsigned long *)(buf + 1);
 432         *ptr = 0xdeadbeef;
 433         return (*ptr & 0xff) == 0xef ? 0 : 1;
 434       }
 435     ]],
 436     [folly_cv_prog_cc_unaligned_access=yes],
 437     [folly_cv_prog_cc_unaligned_access=no])])
 438
 439 if test "$folly_cv_prog_cc_unaligned_access" = "yes"; then
 440   AC_DEFINE([HAVE_UNALIGNED_ACCESS], [1], [Define to 1 if the architecture allows unaligned accesses])
 441 fi
 442
 443 AC_CACHE_CHECK(
 444   [for vsnprintf reporting bad format strings],
 445   [folly_cv_prog_vsnprintf_bad_format],
 446   [AC_RUN_IFELSE(
 447     [AC_LANG_SOURCE[
 448       #include <stdio.h>
 449
 450       int main(int argc, char** argv) {
 451           char buf[256];
 452           return vsnprintf(buf, sizeof(buf), "%", 1) < 0 ? 0 : 1;
 453       }]],
 454     [folly_cv_prog_vsnprintf_bad_format="yes"],
 455     [folly_cv_prog_vsnprintf_bad_format="no"])])
 456
 457 if test "$folly_cv_prog_vsnprintf_bad_format" = yes; then
 458   AC_DEFINE([HAVE_VSNPRINTF_ERRORS], [1],
 459             [Define to 1 if the vsnprintf supports returning errors on bad format strings.])
 460 fi
 461
 462 AC_SEARCH_LIBS([cplus_demangle_v3_callback], [iberty_pic iberty])
 463 if test "$ac_cv_search_cplus_demangle_v3_callback" != "no" ; then
 464   AC_DEFINE([HAVE_CPLUS_DEMANGLE_V3_CALLBACK], [1],
 465             [Define to 1 if we have cplus_demangle_v3_callback.])
 466 fi
 467
 468 # Check for clock_gettime(2). This is not in an AC_CHECK_FUNCS() because we
 469 # want to link with librt if necessary.
 470 AC_SEARCH_LIBS([clock_gettime], [rt],
 471   AC_DEFINE(
 472     [HAVE_CLOCK_GETTIME],
 473     [1],
 474     [Define to 1 if we support clock_gettime(2).]),
 475   [])
 476
 477 # Check for pthread_atfork(3). This is not in an AC_CHECK_FUNCS() because we
 478 # want to include pthread.h if necessary.
 479 AC_CACHE_CHECK(
 480   [for pthread_atfork support],
 481   [folly_cv_prog_cc_pthread_atfork],
 482   [AC_COMPILE_IFELSE(
 483     [AC_LANG_SOURCE[
 484       #include <pthread.h>
 485       void func() {pthread_atfork(NULL, NULL, NULL);}]
 486     ],
 487     [folly_cv_prog_cc_pthread_atfork=yes],
 488     [folly_cv_prog_cc_pthread_atfork=no])])
 489
 490 if test "$folly_cv_prog_cc_pthread_atfork" = "yes"; then
 491   AC_DEFINE([HAVE_PTHREAD_ATFORK], [1], [Define to 1 if the compiler supports pthread_atfork])
 492 fi
 493
 494 # Check for XSI-compatible strerror_r as default implementation
 495 AC_CACHE_CHECK(
 496   [for XSI style strerror_r support],
 497   [folly_cv_prog_cc_xsi_strerror_r],
 498   [AC_RUN_IFELSE(
 499     [AC_LANG_SOURCE[
 500       #include <string.h>
 501       #include <errno.h>
 502       int main(int argc, char** argv) {
 503         char buf[1024];
 504         buf[0] = 0;
 505         int ret = strerror_r(ENOMEM, buf, sizeof(buf));
 506         return ret;
 507       }
 508     ]],
 509     [folly_cv_prog_cc_xsi_strerror_r=yes],
 510     [folly_cv_prog_cc_xsi_strerror_r=no])])
 511
 512 if test "$folly_cv_prog_cc_xsi_strerror_r" = "yes"; then
 513   AC_DEFINE([HAVE_XSI_STRERROR_R], [1], [Define to 1 if the runtime supports XSI-style strerror_r])
 514 fi
 515
 516 AC_CACHE_CHECK(
 517   [for ext/random and __gnu_cxx::sfmt19937],
 518   [folly_cv_prog_cc_have_extrandom_sfmt19937],
 519   [AC_COMPILE_IFELSE(
 520     [AC_LANG_SOURCE[
 521       #include <ext/random>
 522       int main(int argc, char** argv) {
 523         __gnu_cxx::sfmt19937 rng;
 524         return 0;
 525       }
 526     ]],
 527     [folly_cv_prog_cc_have_extrandom_sfmt19937=yes],
 528     [folly_cv_prog_cc_have_extrandom_sfmt19937=no])])
 529
 530 AC_CACHE_CHECK(
 531   [for VLA (variable-length array) support],
 532   [folly_cv_prog_cc_have_vla],
 533   [AC_COMPILE_IFELSE(
 534     [AC_LANG_SOURCE[
 535       int main(int argc, char** argv) {
 536         unsigned size = argc;
 537         char data[size];
 538         return 0;
 539       }
 540     ]],
 541     [folly_cv_prog_cc_have_vla=yes],
 542     [folly_cv_prog_cc_have_vla=no])])
 543
 544 test "$folly_cv_prog_cc_have_vla" = yes && have_vla=1 || have_vla=0
 545 AC_DEFINE_UNQUOTED(
 546   [HAVE_VLA],
 547   [$have_vla],
 548   [Define to 1 if the compiler has VLA (variable-length array) support,
 549    otherwise define to 0])
 550
 551 AC_CACHE_CHECK(
 552   [for variable template support],
 553   [folly_cv_prog_cc_have_variable_templates],
 554   [AC_COMPILE_IFELSE(
 555     [AC_LANG_SOURCE[
 556       template <class> constexpr bool g = true;
 557       int main() {}
 558     ]],
 559     [folly_cv_prog_cc_have_variable_templates=yes],
 560     [folly_cv_prog_cc_have_variable_templates=no])])
 561
 562 AM_CONDITIONAL(
 563   [HAVE_VARIABLE_TEMPLATES],
 564   [test "x${folly_cv_prog_cc_have_variable_templates}" = "xyes"],
 565   [Define to 1 if the compiler supports variable templates])
 566
 567 # Checks for library functions.
 568 AC_CHECK_FUNCS([malloc_size \
 569                 malloc_usable_size \
 570                 memrchr \
 571                 pipe2 \
 572                 preadv \
 573                 pwritev \
 574               ])
 575
 576 AC_CHECK_HEADER([lz4.h], AC_CHECK_LIB([lz4], [LZ4_decompress_safe]))
 577 AC_CHECK_HEADER([snappy.h], AC_CHECK_LIB([snappy], [main]))
 578 AC_CHECK_HEADER([zlib.h], AC_CHECK_LIB([z], [main]))
 579 AC_CHECK_HEADER([lzma.h], AC_CHECK_LIB([lzma], [main]))
 580 AC_CHECK_HEADER([zstd.h], AC_CHECK_LIB([zstd], [ZSTD_compressStream]))
 581 AC_CHECK_HEADER([bzlib.h], AC_CHECK_LIB([bz2], [main]))
 582 AC_CHECK_HEADER([linux/membarrier.h], AC_DEFINE([HAVE_LINUX_MEMBARRIER_H], [1], [Define to 1 if membarrier.h is available]))
 583
 584 AC_ARG_ENABLE([follytestmain],
 585    AS_HELP_STRING([--enable-follytestmain], [enables using main function from folly for tests]),
 586    [use_follytestmain=${enableval}], [use_follytestmain=yes])
 587
 588 # libdwarf used to install in /usr/include, now installs in /usr/include/libdwarf.
 589 have_libdwarf=no
 590 AC_CHECK_HEADERS([libdwarf/dwarf.h dwarf.h], [have_libdwarf=yes])
 591
 592 AC_ARG_ENABLE([mobile],
 593    AS_HELP_STRING([--enable-mobile],
 594                   [enables using main function from folly for tests]),
 595                   [mobile=${enableval}], [mobile=no])
 596 AS_IF([test "x${mobile}" = "xyes"], [
 597     AC_DEFINE([MOBILE], [1],
 598               [Define to 1 for compiler guards for mobile targets.])
 599 ])
 600
 601 AC_ARG_ENABLE([exception-tracer],
 602     AS_HELP_STRING([--enable-exception-tracer], [enables building exception tracer]),
 603     [build_exception_tracer=${enableval}], [build_exception_tracer=no])
 604
 605 AC_ARG_ENABLE([symbolizer],
 606     AS_HELP_STRING([--enable-symbolizer], [try to build symbolizer if possible]),
 607     [folly_try_use_symbolizer=${enableval}], [folly_try_use_symbolizer=yes])
 608
 609 folly_use_symbolizer=no
 610 if test "$folly_try_use_symbolizer" = yes; then
 611   if test "$build_os" = "linux-gnu" && test "$have_libdwarf" = yes; then
 612       AC_CHECK_HEADER(
 613         [elf.h],
 614         AC_CHECK_LIB([unwind], [backtrace], [folly_use_symbolizer=yes]),
 615       )
 616   fi
 617 fi
 618 if test "$folly_use_symbolizer" = yes; then
 619   AC_DEFINE([USE_SYMBOLIZER], [1], [Define to 1 if we should use the symbolizer in init])
 620 fi
 621
 622
 623 # Include directory that contains "folly" so #include <folly/Foo.h> works
 624 AM_CPPFLAGS='-I$(top_srcdir)/..'
 625 AM_CPPFLAGS="$AM_CPPFLAGS $BOOST_CPPFLAGS $OPENSSL_INCLUDES"
 626 AM_LDFLAGS="$AM_LDFLAGS $BOOST_CONTEXT_LIB $BOOST_PROGRAM_OPTIONS_LIB"
 627 AM_LDFLAGS="$AM_LDFLAGS $BOOST_THREAD_LIB $BOOST_FILESYSTEM_LIB"
 628 AM_LDFLAGS="$AM_LDFLAGS $BOOST_SYSTEM_LIB $BOOST_REGEX_LIB -lpthread"
 629 AM_LDFLAGS="$AM_LDFLAGS $BOOST_CHRONO_LIB"
 630
 631 AM_LDFLAGS="$AM_LDFLAGS $OPENSSL_LDFLAGS $OPENSSL_LIBS"
 632
 633 AC_SUBST([AM_CPPFLAGS])
 634 AC_SUBST([AM_LDFLAGS])
 635
 636 AM_CONDITIONAL([HAVE_STD_THREAD], [test "$ac_cv_header_features" = "yes"])
 637 AM_CONDITIONAL([HAVE_X86_64], [test "$build_cpu" = "x86_64"])
 638 AM_CONDITIONAL([HAVE_PPC64], [test "$build_cpu" = "powerpc64le"])
 639 AM_CONDITIONAL([RUN_ARCH_SPECIFIC_TESTS], [test "$build_cpu" = "x86_64" || test "$build_cpu" = "powerpc64le"])
 640 AM_CONDITIONAL([HAVE_LINUX], [test "$build_os" == "linux-gnu"])
 641 AM_CONDITIONAL([HAVE_WEAK_SYMBOLS],
 642                [test "$folly_cv_prog_cc_weak_symbols" = "yes"])
 643 AM_CONDITIONAL([HAVE_BITS_FUNCTEXCEPT_H], [test "$ac_cv_header_bits_functexcept_h" = "yes"])
 644 AM_CONDITIONAL([HAVE_EXTRANDOM_SFMT19937],
 645                [test "$folly_cv_prog_cc_have_extrandom_sfmt19937" = "yes"])
 646 AM_CONDITIONAL([FOLLY_TESTMAIN], [test "x${use_follytestmain}" = "xyes"])
 647 AM_CONDITIONAL([HAVE_LIBDWARF], [test "x${have_libdwarf}" = "xyes"])
 648 AM_CONDITIONAL([HAVE_BOOST_CONTEXT], [test "x${ax_cv_boost_context}" = "xyes"])
 649 AM_CONDITIONAL([EXCEPTION_TRACER], [test "x${build_exception_tracer}" = "xyes"])
 650 AM_CONDITIONAL([USE_SYMBOLIZER], [test "x${folly_use_symbolizer}" = "xyes"])
 651
 652 # remove pkg-config deps from dependent libraries
 653 # (at least for pkg-config file purposes)
 654 FB_FILTER_PKG_LIBS([$AM_LDFLAGS $LIBS])
 655
 656 # Output
 657 AC_CONFIG_FILES([Makefile
 658                  chrono/test/Makefile
 659                  io/test/Makefile
 660                  libfolly.pc
 661                  test/Makefile
 662                  test/function_benchmark/Makefile
 663                  experimental/Makefile
 664                  experimental/io/test/Makefile
 665                  experimental/logging/Makefile
 666                  experimental/logging/example/Makefile
 667                  experimental/symbolizer/Makefile
 668                  init/Makefile
 669                  stats/test/Makefile])
 670
 671 AM_COND_IF([EXCEPTION_TRACER],
 672            [AC_CONFIG_FILES([experimental/exception_tracer/Makefile])])
 673 AC_OUTPUT