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 AC_CONFIG_SRCDIR([Likely.h])
  16 AC_CONFIG_HEADERS([config.h])
  17 AX_PREFIX_CONFIG_H([folly-config.h], [folly], [config.h])
  18 AC_CONFIG_AUX_DIR([build-aux])
  19
  20 AM_INIT_AUTOMAKE([foreign dist-bzip2 nostdinc subdir-objects])
  21
  22 AC_CONFIG_MACRO_DIR([m4])
  23
  24 AX_CONFIG_FEATURE_DEFAULT_DISABLED
  25 AX_CONFIG_FEATURE(
  26         [deprecated-assoc],
  27         [supports deprecated associative containers (hash_map/hash_set)],
  28         [HAVE_DEPRECATED_ASSOC],
  29         [Define if you want to support deprecated associative containers])
  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 # Checks for glog and gflags
  57 # There are no symbols with C linkage, so we do a try-run
  58 AC_HAVE_LIBRARY([gflags],[],[AC_MSG_ERROR(
  59                 [Please install google-gflags library])])
  60 AC_CACHE_CHECK(
  61   [for gflags viability],
  62   [folly_cv_prog_cc_gflags],
  63   [AC_RUN_IFELSE(
  64     [AC_LANG_SOURCE[
  65       #include <gflags/gflags.h>
  66       DEFINE_bool(folly_truthy, true, "Sample truthy flag");
  67       DEFINE_bool(folly_falsey, false, "Sample falsey flag");
  68       int main(int argc, char** argv) {
  69         return (FLAGS_folly_truthy && !FLAGS_folly_falsey) ? 0 : 1;
  70       }
  71     ]],
  72     [folly_cv_prog_cc_gflags=yes],
  73     [folly_cv_prog_cc_gflags=no]
  74   )]
  75 )
  76
  77 if test "$folly_cv_prog_cc_gflags" != "yes"; then
  78   AC_MSG_ERROR(["libgflags invalid, see config.log for details"])
  79 fi
  80
  81 AC_HAVE_LIBRARY([glog],[],[AC_MSG_ERROR(
  82                 [Please install google-glog library])])
  83 AC_CACHE_CHECK(
  84   [for glog viability],
  85   [folly_cv_prog_cc_glog],
  86   [AC_RUN_IFELSE(
  87     [AC_LANG_SOURCE[
  88       #include <glog/logging.h>
  89       int main(int argc, char** argv) {
  90         google::InitGoogleLogging(argv[0]);
  91         google::ShutdownGoogleLogging();
  92         return 0;
  93       }
  94     ]],
  95     [folly_cv_prog_cc_glog=yes],
  96     [folly_cv_prog_cc_glog=no]
  97   )]
  98 )
  99
 100 if test "$folly_cv_prog_cc_glog" != "yes"; then
 101   AC_MSG_ERROR(["libglog invalid, see config.log for details"])
 102 fi
 103
 104 AC_CHECK_LIB(ssl,
 105         SSL_ctrl,
 106         [],
 107         [AC_MSG_ERROR(["Error: libssl required"])])
 108
 109 # check for boost libs
 110 AX_BOOST_BASE([1.51.0], [], [AC_MSG_ERROR(
 111               [Please install boost >= 1.51.0 (context, thread, program_options, regex, system and chrono)])])
 112 AX_BOOST_CONTEXT
 113 AX_BOOST_PROGRAM_OPTIONS
 114 AX_BOOST_THREAD
 115 AX_BOOST_REGEX
 116 AX_BOOST_SYSTEM
 117 AX_BOOST_FILESYSTEM
 118 AX_BOOST_CHRONO
 119
 120 # Check for python interpreter
 121 AM_PATH_PYTHON
 122
 123 # Checks for header files.
 124 AC_HEADER_STDC
 125 AC_CHECK_HEADERS([fcntl.h features.h inttypes.h limits.h sched.h stdint.h stdlib.h string.h sys/time.h unistd.h mutex.h malloc.h byteswap.h bits/functexcept.h bits/c++config.h])
 126
 127 AC_CHECK_HEADER(double-conversion/double-conversion.h, [], [AC_MSG_ERROR(
 128                 [Couldn't find double-conversion.h, please download from \
 129                  https://github.com/google/double-conversion/])], [])
 130 AC_CHECK_LIB([double-conversion],[ceil],[],[AC_MSG_ERROR(
 131              [Please install double-conversion library])])
 132
 133 AC_CHECK_LIB([event], [event_set], [], [AC_MSG_ERROR([Unable to find libevent])])
 134
 135 AC_CHECK_LIB([jemalloc], [xallocx])
 136
 137 # Checks for typedefs, structures, and compiler characteristics.
 138 AC_HEADER_STDBOOL
 139 AC_C_CONST
 140 AC_C_INLINE
 141 AC_TYPE_SIZE_T
 142 AC_HEADER_TIME
 143 AC_C_VOLATILE
 144 AC_CHECK_TYPE([__int128], AC_DEFINE([HAVE_INT128_T], [1], [Define if we have __int128]))
 145 AC_CHECK_TYPES([ptrdiff_t, pthread_spinlock_t])
 146
 147 AC_CACHE_CHECK(
 148   [for ifunc support],
 149   [folly_cv_prog_cc_ifunc],
 150   [AC_COMPILE_IFELSE(
 151     [AC_LANG_SOURCE[
 152       #pragma GCC diagnostic error "-Wattributes"
 153       extern "C" void (*test_ifunc(void))() { return 0; }
 154       void func() __attribute__((ifunc("test_ifunc")));]
 155     ],
 156     [folly_cv_prog_cc_ifunc=yes],
 157     [folly_cv_prog_cc_ifunc=no])])
 158
 159 if test "$folly_cv_prog_cc_ifunc" = "yes"; then
 160   AC_DEFINE([HAVE_IFUNC], [1], [Define to 1 if the compiler supports ifunc])
 161 fi
 162
 163 AC_CACHE_CHECK(
 164   [for final and override support],
 165   [folly_cv_c_final_override],
 166   [AC_COMPILE_IFELSE(
 167     [AC_LANG_SOURCE[class C { virtual void f() final {} virtual void g() {} };
 168                     class D : public C { virtual void g() override {} };]],
 169     [folly_cv_c_final_override=yes],
 170     [folly_cv_c_final_override=no])])
 171
 172 if test "$folly_cv_c_final_override" = "yes"; then
 173   final_val=final
 174   override_val=override
 175 else
 176   final_val=
 177   override_val=
 178 fi
 179
 180 AC_DEFINE_UNQUOTED(
 181   [FINAL], [$final_val],
 182   [Define to "final" if the compiler supports C++11 "final"])
 183 AC_DEFINE_UNQUOTED(
 184   [OVERRIDE], [$override_val],
 185   [Define to "override" if the compiler supports C++11 "override"])
 186
 187 AC_CACHE_CHECK(
 188   [for std::this_thread::sleep_for],
 189   [folly_cv_func_this_thread_sleep_for],
 190   [AC_COMPILE_IFELSE(
 191     [AC_LANG_SOURCE[
 192       #include <thread>
 193       #include <chrono>
 194       void func() { std::this_thread::sleep_for(std::chrono::seconds(1)); }]],
 195     [folly_cv_func_this_thread_sleep_for=yes],
 196     [folly_cv_func_this_thread_sleep_for=no])])
 197
 198 if test "$folly_cv_func_this_thread_sleep_for" = yes; then
 199     AC_DEFINE([HAVE_STD__THIS_THREAD__SLEEP_FOR], [1],
 200               [Define to 1 if std::this_thread::sleep_for() is defined.])
 201 fi
 202
 203 AC_CACHE_CHECK(
 204   [for constexpr strlen],
 205   [folly_cv_func_constexpr_strlen],
 206   [AC_COMPILE_IFELSE(
 207     [AC_LANG_SOURCE[
 208       #include <cstring>
 209       static constexpr int val = strlen("foo");]],
 210     [folly_cv_func_constexpr_strlen=yes],
 211     [folly_cv_func_constexpr_strlen=no])])
 212
 213 if test "$folly_cv_func_constexpr_strlen" = yes; then
 214     AC_DEFINE([HAVE_CONSTEXPR_STRLEN], [1],
 215               [Define to 1 if strlen(3) is constexpr.])
 216 fi
 217
 218 AC_CACHE_CHECK(
 219   [for libc++],
 220   [folly_cv_lib_libcpp],
 221   [AC_COMPILE_IFELSE(
 222     [AC_LANG_SOURCE[
 223       #include <type_traits>
 224       #if !_LIBCPP_VERSION
 225       #error No libc++
 226       #endif
 227       void func() {}]
 228     ],
 229     [folly_cv_lib_libcpp=yes],
 230     [folly_cv_lib_libcpp=no])])
 231
 232 if test "$folly_cv_lib_libcpp" = yes; then
 233   AC_DEFINE([USE_LIBCPP], [1], [Define to 1 if we are using libc++.])
 234 fi
 235
 236 AC_CACHE_CHECK(
 237   [for c++11 atomic support without GNU Atomic library],
 238   [folly_cv_lib_libatomic],
 239   [AC_LINK_IFELSE(
 240     [AC_LANG_SOURCE[
 241       #include <atomic>
 242       int main() {
 243         struct Test { int val; };
 244         std::atomic<Test> s;
 245         s.is_lock_free();
 246       }
 247     ]],
 248     [folly_cv_lib_libatomic=yes],
 249     [folly_cv_lib_libatomic=no])])
 250
 251 if test "$folly_cv_lib_libatomic" = no; then
 252   AC_HAVE_LIBRARY([atomic],[],[AC_MSG_ERROR(
 253                   [Please install the GNU Atomic library])])
 254 fi
 255
 256 AC_CACHE_CHECK(
 257   [for liblinux-vdso support],
 258   [folly_cv_lib_liblinux_vdso],
 259   [AC_RUN_IFELSE(
 260     [AC_LANG_PROGRAM[
 261       #include <dlfcn.h>
 262       int main() {
 263         void *h = dlopen("linux-vdso.so.1", RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
 264         if (h == nullptr) {
 265           return -1;
 266         }
 267         dlclose(h);
 268         return 0;
 269       }
 270     ]],
 271     [folly_cv_lib_liblinux_vdso=yes],
 272     [folly_cv_lib_liblinux_vdso=no])])
 273
 274 if test "$folly_cv_lib_liblinux_vdso" = yes; then
 275   AC_DEFINE([HAVE_LINUX_VDSO], [1], [Define to 1 if liblinux-vdso is available])
 276 fi
 277
 278 AC_CACHE_CHECK(
 279   [for usable std::is_trivially_copyable],
 280   [folly_cv_decl_std_is_trivially_copyable],
 281   [AC_COMPILE_IFELSE(
 282     [AC_LANG_SOURCE[
 283       #include <type_traits>
 284       const bool val = std::is_trivially_copyable<bool>::value;]
 285     ],
 286     [folly_cv_decl_std_is_trivially_copyable=yes],
 287     [folly_cv_decl_std_is_trivially_copyable=no])])
 288
 289 if test "$folly_cv_decl_std_is_trivially_copyable" = yes; then
 290   AC_DEFINE([HAVE_STD__IS_TRIVIALLY_COPYABLE], [1],
 291             [Define to 1 if we have a usable std::is_trivially_copyable<T>
 292              implementation.])
 293 fi
 294
 295 AC_CACHE_CHECK(
 296   [gflags namespace],
 297   [folly_cv_decl_gflags_namespace],
 298   [AC_COMPILE_IFELSE(
 299     [AC_LANG_SOURCE[
 300       #include <gflags/gflags.h>
 301       void foo() { gflags::GetArgv(); }]
 302     ],
 303     [folly_cv_decl_gflags_namespace=gflags],
 304     [AC_COMPILE_IFELSE(
 305       [AC_LANG_SOURCE[
 306         #include <gflags/gflags.h>
 307         void foo() { google::GetArgv(); }]
 308       ],
 309       [folly_cv_decl_gflags_namespace=google],
 310       [folly_cv_decl_gflags_namespace=error])])])
 311
 312 if test "$folly_cv_decl_gflags_namespace" = error; then
 313   AC_MSG_ERROR([Cannot determine gflags namespace])
 314 else
 315   AC_DEFINE_UNQUOTED(
 316     [GFLAGS_NAMESPACE], [$folly_cv_decl_gflags_namespace],
 317     [Define to gflags namespace (usually "google" or "gflags")])
 318   if test "$folly_cv_decl_gflags_namespace" != gflags; then
 319      AC_DEFINE([UNUSUAL_GFLAGS_NAMESPACE], [1],
 320                [Define to 1 if the gflags namespace is not "gflags"])
 321   fi
 322 fi
 323
 324 # Figure out if we support weak symbols. If not, we will link in some null
 325 # stubs for functions that would otherwise be weak.
 326 AC_CACHE_CHECK(
 327   [for weak symbol support],
 328   [folly_cv_prog_cc_weak_symbols],
 329   [AC_LINK_IFELSE(
 330     [AC_LANG_SOURCE[
 331       extern "C" void configure_link_extern_weak_test() __attribute__((weak));
 332       int main(int argc, char** argv) {
 333           return configure_link_extern_weak_test == nullptr;
 334       }]],
 335     [folly_cv_prog_cc_weak_symbols="yes"],
 336     [folly_cv_prog_cc_weak_symbols="no"])])
 337
 338 if test "$folly_cv_prog_cc_weak_symbols" = yes; then
 339   AC_DEFINE([HAVE_WEAK_SYMBOLS], [1],
 340             [Define to 1 if the linker supports weak symbols.])
 341 fi
 342
 343 # Figure out whether the architecture supports unaligned accesses
 344 AC_CACHE_CHECK(
 345   [for unaligned access support],
 346   [folly_cv_prog_cc_unaligned_access],
 347   [AC_RUN_IFELSE(
 348     [AC_LANG_SOURCE[
 349       int main(int argc, char** argv) {
 350         char buf[64] = {0};
 351         unsigned long *ptr = (unsigned long *)(buf + 1);
 352         *ptr = 0xdeadbeef;
 353         return (*ptr & 0xff) == 0xef ? 0 : 1;
 354       }
 355     ]],
 356     [folly_cv_prog_cc_unaligned_access=yes],
 357     [folly_cv_prog_cc_unaligned_access=no])])
 358
 359 if test "$folly_cv_prog_cc_unaligned_access" = "yes"; then
 360   AC_DEFINE([HAVE_UNALIGNED_ACCESS], [1], [Define to 1 if the architecture allows unaligned accesses])
 361 fi
 362
 363 AC_CACHE_CHECK(
 364   [for vsnprintf reporting bad format strings],
 365   [folly_cv_prog_vsnprintf_bad_format],
 366   [AC_RUN_IFELSE(
 367     [AC_LANG_SOURCE[
 368       #include <stdio.h>
 369
 370       int main(int argc, char** argv) {
 371           char buf[256];
 372           return vsnprintf(buf, sizeof(buf), "%", 1) < 0 ? 0 : 1;
 373       }]],
 374     [folly_cv_prog_vsnprintf_bad_format="yes"],
 375     [folly_cv_prog_vsnprintf_bad_format="no"])])
 376
 377 if test "$folly_cv_prog_vsnprintf_bad_format" = yes; then
 378   AC_DEFINE([HAVE_VSNPRINTF_ERRORS], [1],
 379             [Define to 1 if the vsnprintf supports returning errors on bad format strings.])
 380 fi
 381
 382 AC_SEARCH_LIBS([cplus_demangle_v3_callback], [iberty_pic iberty])
 383 if test "$ac_cv_search_cplus_demangle_v3_callback" != "no" ; then
 384   AC_DEFINE([HAVE_CPLUS_DEMANGLE_V3_CALLBACK], [1],
 385             [Define to 1 if we have cplus_demangle_v3_callback.])
 386 fi
 387
 388 # Check for clock_gettime(2). This is not in an AC_CHECK_FUNCS() because we
 389 # want to link with librt if necessary.
 390 AC_SEARCH_LIBS([clock_gettime], [rt],
 391   AC_DEFINE(
 392     [HAVE_CLOCK_GETTIME],
 393     [1],
 394     [Define to 1 if we support clock_gettime(2).]),
 395   [])
 396
 397 # Check for pthread_atfork(3). This is not in an AC_CHECK_FUNCS() because we
 398 # want to include pthread.h if necessary.
 399 AC_CACHE_CHECK(
 400   [for pthread_atfork support],
 401   [folly_cv_prog_cc_pthread_atfork],
 402   [AC_COMPILE_IFELSE(
 403     [AC_LANG_SOURCE[
 404       #include <pthread.h>
 405       void func() {pthread_atfork(NULL, NULL, NULL);}]
 406     ],
 407     [folly_cv_prog_cc_pthread_atfork=yes],
 408     [folly_cv_prog_cc_pthread_atfork=no])])
 409
 410 if test "$folly_cv_prog_cc_pthread_atfork" = "yes"; then
 411   AC_DEFINE([HAVE_PTHREAD_ATFORK], [1], [Define to 1 if the compiler supports pthread_atfork])
 412 fi
 413
 414 # Check for XSI-compatible strerror_r as default implementation
 415 AC_CACHE_CHECK(
 416   [for XSI style strerror_r support],
 417   [folly_cv_prog_cc_xsi_strerror_r],
 418   [AC_RUN_IFELSE(
 419     [AC_LANG_SOURCE[
 420       #include <string.h>
 421       #include <errno.h>
 422       int main(int argc, char** argv) {
 423         char buf[1024];
 424         buf[0] = 0;
 425         int ret = strerror_r(ENOMEM, buf, sizeof(buf));
 426         return ret;
 427       }
 428     ]],
 429     [folly_cv_prog_cc_xsi_strerror_r=yes],
 430     [folly_cv_prog_cc_xsi_strerror_r=no])])
 431
 432 if test "$folly_cv_prog_cc_xsi_strerror_r" = "yes"; then
 433   AC_DEFINE([HAVE_XSI_STRERROR_R], [1], [Define to 1 if the runtime supports XSI-style strerror_r])
 434 fi
 435
 436 AC_CACHE_CHECK(
 437   [for ext/random and __gnu_cxx::sfmt19937],
 438   [folly_cv_prog_cc_have_extrandom_sfmt19937],
 439   [AC_COMPILE_IFELSE(
 440     [AC_LANG_SOURCE[
 441       #include <ext/random>
 442       int main(int argc, char** argv) {
 443         __gnu_cxx::sfmt19937 rng;
 444         return 0;
 445       }
 446     ]],
 447     [folly_cv_prog_cc_have_extrandom_sfmt19937=yes],
 448     [folly_cv_prog_cc_have_extrandom_sfmt19937=no])])
 449
 450 AC_CACHE_CHECK(
 451   [for VLA (variable-length array) support],
 452   [folly_cv_prog_cc_have_vla],
 453   [AC_COMPILE_IFELSE(
 454     [AC_LANG_SOURCE[
 455       int main(int argc, char** argv) {
 456         unsigned size = argc;
 457         char data[size];
 458         return 0;
 459       }
 460     ]],
 461     [folly_cv_prog_cc_have_vla=yes],
 462     [folly_cv_prog_cc_have_vla=no])])
 463
 464 test "$folly_cv_prog_cc_have_vla" = yes && have_vla=1 || have_vla=0
 465 AC_DEFINE_UNQUOTED(
 466   [HAVE_VLA],
 467   [$have_vla],
 468   [Define to 1 if the compiler has VLA (variable-length array) support,
 469    otherwise define to 0])
 470
 471 # Checks for library functions.
 472 AC_CHECK_FUNCS([getdelim \
 473                 gettimeofday \
 474                 memmove \
 475                 memset \
 476                 pow \
 477                 strerror \
 478                 sched_yield \
 479                 malloc_size \
 480                 malloc_usable_size \
 481                 memrchr \
 482                 pipe2 \
 483                 preadv \
 484                 pwritev \
 485               ])
 486
 487 AC_CHECK_HEADER([lz4.h], AC_CHECK_LIB([lz4], [LZ4_decompress_safe]))
 488 AC_CHECK_HEADER([snappy.h], AC_CHECK_LIB([snappy], [main]))
 489 AC_CHECK_HEADER([zlib.h], AC_CHECK_LIB([z], [main]))
 490 AC_CHECK_HEADER([lzma.h], AC_CHECK_LIB([lzma], [main]))
 491 AC_CHECK_HEADER([zstd.h], AC_CHECK_LIB([zstd], [main]))
 492
 493 AC_ARG_ENABLE([follytestmain],
 494    AS_HELP_STRING([--enable-follytestmain], [enables using main function from folly for tests]),
 495    [follytestmain=${enableval}], [follytestmain=no])
 496
 497 use_follytestmain=yes
 498 if test "x${follytestmain}" = "xyes"; then
 499    AC_CHECK_HEADERS([libdwarf.h dwarf.h],, AC_MSG_ERROR([Please install libdwarf development package]))
 500    AC_CHECK_HEADERS([libelf.h elf.h],, AC_MSG_ERROR([Please install libelf development package]))
 501    AC_CHECK_HEADERS([libunwind.h],, AC_MSG_ERROR([Please install libinwind development package]))
 502 else
 503    AC_CHECK_HEADERS([libdwarf.h dwarf.h],, [use_follytestmain=no])
 504    AC_CHECK_HEADERS([libelf.h elf.h],, [use_follytestmain=no])
 505    AC_CHECK_HEADERS([libunwind.h],, [use_follytestmain=no])
 506 fi
 507
 508 AC_ARG_ENABLE([mobile],
 509    AS_HELP_STRING([--enable-mobile],
 510                   [enables using main function from folly for tests]),
 511                   [mobile=${enableval}], [mobile=no])
 512 AS_IF([test "x${mobile}" = "xyes"], [
 513     AC_DEFINE([MOBILE], [1],
 514               [Define to 1 for compiler guards for mobile targets.])
 515 ])
 516
 517 # Include directory that contains "folly" so #include <folly/Foo.h> works
 518 AM_CPPFLAGS='-I$(top_srcdir)/..'
 519 AM_CPPFLAGS="$AM_CPPFLAGS $BOOST_CPPFLAGS"
 520 AM_LDFLAGS="$AM_LDFLAGS $BOOST_CONTEXT_LIB $BOOST_PROGRAM_OPTIONS_LIB"
 521 AM_LDFLAGS="$AM_LDFLAGS $BOOST_THREAD_LIB $BOOST_FILESYSTEM_LIB"
 522 AM_LDFLAGS="$AM_LDFLAGS $BOOST_SYSTEM_LIB $BOOST_REGEX_LIB -lpthread"
 523 AM_LDFLAGS="$AM_LDFLAGS $BOOST_CHRONO_LIB"
 524
 525 AC_SUBST([AM_CPPFLAGS])
 526 AC_SUBST([AM_LDFLAGS])
 527
 528 AM_CONDITIONAL([HAVE_STD_THREAD], [test "$ac_cv_header_features" = "yes"])
 529 AM_CONDITIONAL([HAVE_X86_64], [test "$build_cpu" = "x86_64"])
 530 AM_CONDITIONAL([HAVE_PPC64], [test "$build_cpu" = "powerpc64le"])
 531 AM_CONDITIONAL([RUN_ARCH_SPECIFIC_TESTS], [test "$build_cpu" = "x86_64" || test "$build_cpu" = "powerpc64le"])
 532 AM_CONDITIONAL([HAVE_LINUX], [test "$build_os" == "linux-gnu"])
 533 AM_CONDITIONAL([HAVE_WEAK_SYMBOLS],
 534                [test "$folly_cv_prog_cc_weak_symbols" = "yes"])
 535 AM_CONDITIONAL([HAVE_BITS_FUNCTEXCEPT_H], [test "$ac_cv_header_bits_functexcept_h" = "yes"])
 536 AM_CONDITIONAL([HAVE_EXTRANDOM_SFMT19937],
 537                [test "$folly_cv_prog_cc_have_extrandom_sfmt19937" = "yes"])
 538 AM_CONDITIONAL([FOLLY_TESTMAIN], [test "x${use_follytestmain}" = "xyes"])
 539
 540 # Output
 541 AC_CONFIG_FILES([Makefile
 542                  test/Makefile
 543                  test/function_benchmark/Makefile
 544                  experimental/Makefile
 545                  experimental/symbolizer/Makefile
 546                  init/Makefile])
 547 AC_OUTPUT