3 # Detects OS we're compiling on and outputs a file specified by the first
4 # argument, which in turn gets read while processing Makefile.
6 # The output will set the following variables:
8 # CXX C++ Compiler path
9 # PLATFORM_LDFLAGS Linker flags
10 # JAVA_LDFLAGS Linker flags for RocksDBJava
11 # JAVA_STATIC_LDFLAGS Linker flags for RocksDBJava static build
12 # PLATFORM_SHARED_EXT Extension for shared libraries
13 # PLATFORM_SHARED_LDFLAGS Flags for building shared library
14 # PLATFORM_SHARED_CFLAGS Flags for compiling objects for shared library
15 # PLATFORM_CCFLAGS C compiler flags
16 # PLATFORM_CXXFLAGS C++ compiler flags. Will contain:
17 # PLATFORM_SHARED_VERSIONED Set to 'true' if platform supports versioned
18 # shared libraries, empty otherwise.
19 # FIND Command for the find utility
20 # WATCH Command for the watch utility
22 # The PLATFORM_CCFLAGS and PLATFORM_CXXFLAGS might include the following:
24 # -DROCKSDB_PLATFORM_POSIX if posix-platform based
25 # -DSNAPPY if the Snappy library is present
26 # -DLZ4 if the LZ4 library is present
27 # -DZSTD if the ZSTD library is present
28 # -DNUMA if the NUMA library is present
29 # -DTBB if the TBB library is present
31 # Using gflags in rocksdb:
32 # Our project depends on gflags, which requires users to take some extra steps
33 # before they can compile the whole repository:
34 # 1. Install gflags. You may download it from here:
35 # https://gflags.github.io/gflags/ (Mac users can `brew install gflags`)
36 # 2. Once installed, add the include path for gflags to your CPATH env var and
37 # the lib path to LIBRARY_PATH. If installed with default settings, the lib
38 # will be /usr/local/lib and the include path will be /usr/local/include
41 if test -z "$OUTPUT"; then
42 echo "usage: $0 <output-filename>" >&2
47 PLATFORM_CXXFLAGS
="-std=c++11"
48 # we currently depend on POSIX platform
49 COMMON_FLAGS
="-DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX"
51 # Default to fbcode gcc on internal fb machines
52 if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt
/gvfs
/third-party
]; then
54 # If we're compiling with TSAN we need pic build
55 PIC_BUILD
=$COMPILE_WITH_TSAN
56 if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then
57 # we need this to build with MySQL. Don't use for other purposes.
58 source "$PWD/build_tools/fbcode_config4.8.1.sh"
59 elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_5xx" ]; then
60 source "$PWD/build_tools/fbcode_config.sh"
62 source "$PWD/build_tools/fbcode_config_platform007.sh"
66 # Delete existing output, if it exists
70 if test -z "$CC"; then
71 if [ -x "$(command -v cc)" ]; then
73 elif [ -x "$(command -v clang)" ]; then
80 if test -z "$CXX"; then
81 if [ -x "$(command -v g++)" ]; then
83 elif [ -x "$(command -v clang++)" ]; then
91 if test -z "$TARGET_OS"; then
95 if test -z "$TARGET_ARCHITECTURE"; then
96 TARGET_ARCHITECTURE
=`uname -m`
99 if test -z "$CLANG_SCAN_BUILD"; then
100 CLANG_SCAN_BUILD
=scan-build
103 if test -z "$CLANG_ANALYZER"; then
104 CLANG_ANALYZER
=$
(command -v clang
++ 2> /dev
/null
)
107 if test -z "$FIND"; then
111 if test -z "$WATCH"; then
115 COMMON_FLAGS
="$COMMON_FLAGS ${CFLAGS}"
118 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS"
119 PLATFORM_SHARED_EXT
="so"
120 PLATFORM_SHARED_LDFLAGS
="-Wl,--no-as-needed -shared -Wl,-soname -Wl,"
121 PLATFORM_SHARED_CFLAGS
="-fPIC"
122 PLATFORM_SHARED_VERSIONED
=true
124 # generic port files (working on all platform by #ifdef) go directly in /port
125 GENERIC_PORT_FILES
=`cd "$ROCKSDB_ROOT"; find port -name '*.cc' | tr "\n" " "`
127 # On GCC, we pick libc's memcmp over GCC's memcmp via -fno-builtin-memcmp
131 COMMON_FLAGS
="$COMMON_FLAGS -DOS_MACOSX"
132 PLATFORM_SHARED_EXT
=dylib
133 PLATFORM_SHARED_LDFLAGS
="-dynamiclib -install_name "
134 # PORT_FILES=port/darwin/darwin_specific.cc
138 COMMON_FLAGS
="$COMMON_FLAGS -DOS_MACOSX -DIOS_CROSS_COMPILE -DROCKSDB_LITE"
139 PLATFORM_SHARED_EXT
=dylib
140 PLATFORM_SHARED_LDFLAGS
="-dynamiclib -install_name "
142 PLATFORM_SHARED_VERSIONED
=
146 COMMON_FLAGS
="$COMMON_FLAGS -DOS_LINUX"
147 if [ -z "$USE_CLANG" ]; then
148 COMMON_FLAGS
="$COMMON_FLAGS -fno-builtin-memcmp"
150 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -latomic"
152 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lpthread -lrt"
153 if test $ROCKSDB_USE_IO_URING; then
155 $CXX $CFLAGS -x c
++ - -luring -o /dev
/null
2>/dev
/null
<<EOF
156 #include <liburing.h>
158 struct io_uring ring;
159 io_uring_queue_init(1, &ring, 0);
163 if [ "$?" = 0 ]; then
164 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -luring"
165 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_IOURING_PRESENT"
168 if test -z "$USE_FOLLY_DISTRIBUTED_MUTEX"; then
169 USE_FOLLY_DISTRIBUTED_MUTEX
=1
171 # PORT_FILES=port/linux/linux_specific.cc
175 COMMON_FLAGS
="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_SOLARIS -m64"
176 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lpthread -lrt -static-libstdc++ -static-libgcc -m64"
177 # PORT_FILES=port/sunos/sunos_specific.cc
182 COMMON_FLAGS
="$COMMON_FLAGS -maix64 -pthread -fno-builtin-memcmp -D_REENTRANT -DOS_AIX -D__STDC_FORMAT_MACROS"
183 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -pthread -lpthread -lrt -maix64 -static-libstdc++ -static-libgcc"
184 # PORT_FILES=port/aix/aix_specific.cc
189 COMMON_FLAGS
="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_FREEBSD"
190 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lpthread"
191 # PORT_FILES=port/freebsd/freebsd_specific.cc
195 COMMON_FLAGS
="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_NETBSD"
196 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lpthread -lgcc_s"
197 # PORT_FILES=port/netbsd/netbsd_specific.cc
202 COMMON_FLAGS
="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_OPENBSD"
203 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -pthread"
204 # PORT_FILES=port/openbsd/openbsd_specific.cc
209 PLATFORM
=OS_DRAGONFLYBSD
210 COMMON_FLAGS
="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_DRAGONFLYBSD"
211 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lpthread"
212 # PORT_FILES=port/dragonfly/dragonfly_specific.cc
216 PLATFORM_SHARED_CFLAGS
=""
217 PLATFORM_CXXFLAGS
="-std=gnu++11"
218 COMMON_FLAGS
="$COMMON_FLAGS -DCYGWIN"
219 if [ -z "$USE_CLANG" ]; then
220 COMMON_FLAGS
="$COMMON_FLAGS -fno-builtin-memcmp"
222 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -latomic"
224 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lpthread -lrt"
225 # PORT_FILES=port/linux/linux_specific.cc
227 OS_ANDROID_CROSSCOMPILE
)
229 COMMON_FLAGS
="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_ANDROID -DROCKSDB_PLATFORM_POSIX"
230 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS " # All pthread features are in the Android C library
231 # PORT_FILES=port/android/android.cc
235 echo "Unknown platform!" >&2
239 PLATFORM_CXXFLAGS
="$PLATFORM_CXXFLAGS ${CXXFLAGS}"
240 JAVA_LDFLAGS
="$PLATFORM_LDFLAGS"
241 JAVA_STATIC_LDFLAGS
="$PLATFORM_LDFLAGS"
243 if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then
244 # Cross-compiling; do not try any compilation tests.
245 # Also don't need any compilation tests if compiling on fbcode
248 if ! test $ROCKSDB_DISABLE_FALLOCATE; then
249 # Test whether fallocate is available
250 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
252 #include <linux/falloc.h>
254 int fd = open("/dev/null", 0);
255 fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, 1024);
258 if [ "$?" = 0 ]; then
259 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_FALLOCATE_PRESENT"
263 if ! test $ROCKSDB_DISABLE_SNAPPY; then
264 # Test whether Snappy library is installed
265 # http://code.google.com/p/snappy/
266 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
270 if [ "$?" = 0 ]; then
271 COMMON_FLAGS
="$COMMON_FLAGS -DSNAPPY"
272 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lsnappy"
273 JAVA_LDFLAGS
="$JAVA_LDFLAGS -lsnappy"
277 if ! test $ROCKSDB_DISABLE_GFLAGS; then
278 # Test whether gflags library is installed
279 # http://gflags.github.io/gflags/
280 # check if the namespace is gflags
281 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<< EOF
282 #include <gflags/gflags.h>
285 if [ "$?" = 0 ]; then
286 COMMON_FLAGS
="$COMMON_FLAGS -DGFLAGS=1"
287 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lgflags"
289 # check if namespace is google
290 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<< EOF
291 #include <gflags/gflags.h>
292 using namespace google;
295 if [ "$?" = 0 ]; then
296 COMMON_FLAGS
="$COMMON_FLAGS -DGFLAGS=google"
297 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lgflags"
302 if ! test $ROCKSDB_DISABLE_ZLIB; then
303 # Test whether zlib library is installed
304 $CXX $CFLAGS $COMMON_FLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
308 if [ "$?" = 0 ]; then
309 COMMON_FLAGS
="$COMMON_FLAGS -DZLIB"
310 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lz"
311 JAVA_LDFLAGS
="$JAVA_LDFLAGS -lz"
315 if ! test $ROCKSDB_DISABLE_BZIP; then
316 # Test whether bzip library is installed
317 $CXX $CFLAGS $COMMON_FLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
321 if [ "$?" = 0 ]; then
322 COMMON_FLAGS
="$COMMON_FLAGS -DBZIP2"
323 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lbz2"
324 JAVA_LDFLAGS
="$JAVA_LDFLAGS -lbz2"
328 if ! test $ROCKSDB_DISABLE_LZ4; then
329 # Test whether lz4 library is installed
330 $CXX $CFLAGS $COMMON_FLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
335 if [ "$?" = 0 ]; then
336 COMMON_FLAGS
="$COMMON_FLAGS -DLZ4"
337 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -llz4"
338 JAVA_LDFLAGS
="$JAVA_LDFLAGS -llz4"
342 if ! test $ROCKSDB_DISABLE_ZSTD; then
343 # Test whether zstd library is installed
344 $CXX $CFLAGS $COMMON_FLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
348 if [ "$?" = 0 ]; then
349 COMMON_FLAGS
="$COMMON_FLAGS -DZSTD"
350 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lzstd"
351 JAVA_LDFLAGS
="$JAVA_LDFLAGS -lzstd"
355 if ! test $ROCKSDB_DISABLE_NUMA; then
356 # Test whether numa is available
357 $CXX $CFLAGS -x c
++ - -o /dev
/null
-lnuma 2>/dev
/null
<<EOF
362 if [ "$?" = 0 ]; then
363 COMMON_FLAGS
="$COMMON_FLAGS -DNUMA"
364 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lnuma"
365 JAVA_LDFLAGS
="$JAVA_LDFLAGS -lnuma"
369 if ! test $ROCKSDB_DISABLE_TBB; then
370 # Test whether tbb is available
371 $CXX $CFLAGS $LDFLAGS -x c
++ - -o /dev
/null
-ltbb 2>/dev
/null
<<EOF
375 if [ "$?" = 0 ]; then
376 COMMON_FLAGS
="$COMMON_FLAGS -DTBB"
377 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -ltbb"
378 JAVA_LDFLAGS
="$JAVA_LDFLAGS -ltbb"
382 if ! test $ROCKSDB_DISABLE_JEMALLOC; then
383 # Test whether jemalloc is available
384 if echo 'int main() {}' |
$CXX $CFLAGS -x c
++ - -o /dev
/null
-ljemalloc \
386 # This will enable some preprocessor identifiers in the Makefile
388 # JEMALLOC can be enabled either using the flag (like here) or by
389 # providing direct link to the jemalloc library
391 # check for JEMALLOC installed with HomeBrew
392 if [ "$PLATFORM" == "OS_MACOSX" ]; then
393 if hash brew
2>/dev
/null
&& brew
ls --versions jemalloc
> /dev
/null
; then
394 JEMALLOC_VER
=$
(brew
ls --versions jemalloc |
tail -n 1 | cut
-f 2 -d ' ')
395 JEMALLOC_INCLUDE
="-I/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/include"
396 JEMALLOC_LIB
="/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/lib/libjemalloc_pic.a"
397 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS $JEMALLOC_LIB"
398 JAVA_STATIC_LDFLAGS
="$JAVA_STATIC_LDFLAGS $JEMALLOC_LIB"
403 if ! test $JEMALLOC && ! test $ROCKSDB_DISABLE_TCMALLOC; then
404 # jemalloc is not available. Let's try tcmalloc
405 if echo 'int main() {}' |
$CXX $CFLAGS -x c
++ - -o /dev
/null \
406 -ltcmalloc 2>/dev
/null
; then
407 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -ltcmalloc"
408 JAVA_LDFLAGS
="$JAVA_LDFLAGS -ltcmalloc"
412 if ! test $ROCKSDB_DISABLE_MALLOC_USABLE_SIZE; then
413 # Test whether malloc_usable_size is available
414 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
417 size_t res = malloc_usable_size(0);
422 if [ "$?" = 0 ]; then
423 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_MALLOC_USABLE_SIZE"
427 if ! test $ROCKSDB_DISABLE_PTHREAD_MUTEX_ADAPTIVE_NP; then
428 # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available
429 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
432 int x = PTHREAD_MUTEX_ADAPTIVE_NP;
437 if [ "$?" = 0 ]; then
438 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_PTHREAD_ADAPTIVE_MUTEX"
442 if ! test $ROCKSDB_DISABLE_BACKTRACE; then
443 # Test whether backtrace is available
444 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
445 #include <execinfo.h>
448 backtrace_symbols(frames, backtrace(frames, 1));
452 if [ "$?" = 0 ]; then
453 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
455 # Test whether execinfo library is installed
456 $CXX $CFLAGS -lexecinfo -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
457 #include <execinfo.h>
460 backtrace_symbols(frames, backtrace(frames, 1));
463 if [ "$?" = 0 ]; then
464 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
465 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS -lexecinfo"
466 JAVA_LDFLAGS
="$JAVA_LDFLAGS -lexecinfo"
471 if ! test $ROCKSDB_DISABLE_PG; then
472 # Test if -pg is supported
473 $CXX $CFLAGS -pg -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
478 if [ "$?" = 0 ]; then
483 if ! test $ROCKSDB_DISABLE_SYNC_FILE_RANGE; then
484 # Test whether sync_file_range is supported for compatibility with an old glibc
485 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
488 int fd = open("/dev/null", 0);
489 sync_file_range(fd, 0, 1024, SYNC_FILE_RANGE_WRITE);
492 if [ "$?" = 0 ]; then
493 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_RANGESYNC_PRESENT"
497 if ! test $ROCKSDB_DISABLE_SCHED_GETCPU; then
498 # Test whether sched_getcpu is supported
499 $CXX $CFLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
502 int cpuid = sched_getcpu();
506 if [ "$?" = 0 ]; then
507 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_SCHED_GETCPU_PRESENT"
511 if ! test $ROCKSDB_DISABLE_ALIGNED_NEW; then
512 # Test whether c++17 aligned-new is supported
513 $CXX $PLATFORM_CXXFLAGS -faligned-new -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
514 struct alignas(1024) t {int a;};
517 if [ "$?" = 0 ]; then
518 PLATFORM_CXXFLAGS
="$PLATFORM_CXXFLAGS -faligned-new -DHAVE_ALIGNED_NEW"
523 # TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning.
524 # -Wshorten-64-to-32 breaks compilation on FreeBSD i386
525 if ! [ "$TARGET_OS" = FreeBSD
-a "$TARGET_ARCHITECTURE" = i386
]; then
526 # Test whether -Wshorten-64-to-32 is available
527 $CXX $CFLAGS -x c
++ - -o /dev
/null
-Wshorten-64-to-32 2>/dev
/null
<<EOF
530 if [ "$?" = 0 ]; then
531 COMMON_FLAGS
="$COMMON_FLAGS -Wshorten-64-to-32"
537 if test "$USE_HDFS"; then
538 if test -z "$JAVA_HOME"; then
539 echo "JAVA_HOME has to be set for HDFS usage." >&2
542 HDFS_CCFLAGS
="$HDFS_CCFLAGS -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -DUSE_HDFS -I$HADOOP_HOME/include"
543 HDFS_LDFLAGS
="$HDFS_LDFLAGS -lhdfs -L$JAVA_HOME/jre/lib/amd64 -L$HADOOP_HOME/lib/native"
544 HDFS_LDFLAGS
="$HDFS_LDFLAGS -L$JAVA_HOME/jre/lib/amd64/server -L$GLIBC_RUNTIME_PATH/lib"
545 HDFS_LDFLAGS
="$HDFS_LDFLAGS -ldl -lverify -ljava -ljvm"
546 COMMON_FLAGS
="$COMMON_FLAGS $HDFS_CCFLAGS"
547 PLATFORM_LDFLAGS
="$PLATFORM_LDFLAGS $HDFS_LDFLAGS"
548 JAVA_LDFLAGS
="$JAVA_LDFLAGS $HDFS_LDFLAGS"
551 if test "0$PORTABLE" -eq 0; then
552 if test -n "`echo $TARGET_ARCHITECTURE | grep ^ppc64`"; then
553 # Tune for this POWER processor, treating '+' models as base models
554 POWER
=`LD_SHOW_AUXV=1 /bin/true | grep AT_PLATFORM | grep -E -o power[0-9]+`
555 COMMON_FLAGS
="$COMMON_FLAGS -mcpu=$POWER -mtune=$POWER "
556 elif test -n "`echo $TARGET_ARCHITECTURE | grep ^s390x`"; then
557 COMMON_FLAGS
="$COMMON_FLAGS -march=z10 "
558 elif test -n "`echo $TARGET_ARCHITECTURE | grep -e^arm -e^aarch64`"; then
559 # TODO: Handle this with approprite options.
560 COMMON_FLAGS
="$COMMON_FLAGS"
561 elif test -n "`echo $TARGET_ARCHITECTURE | grep ^aarch64`"; then
562 COMMON_FLAGS
="$COMMON_FLAGS"
563 elif [ "$TARGET_OS" == "IOS" ]; then
564 COMMON_FLAGS
="$COMMON_FLAGS"
565 elif [ "$TARGET_OS" == "AIX" ] ||
[ "$TARGET_OS" == "SunOS" ]; then
566 # TODO: Not sure why we don't use -march=native on these OSes
567 if test "$USE_SSE"; then
571 COMMON_FLAGS
="$COMMON_FLAGS -march=native "
575 if test "$USE_SSE"; then
580 if test "$TRY_SSE_ETC"; then
581 # The USE_SSE flag now means "attempt to compile with widely-available
582 # Intel architecture extensions utilized by specific optimizations in the
583 # source code." It's a qualifier on PORTABLE=1 that means "mostly portable."
584 # It doesn't even really check that your current CPU is compatible.
586 # SSE4.2 available since nehalem, ca. 2008-2010
588 # PCLMUL available since westmere, ca. 2010-2011
589 TRY_PCLMUL
="-mpclmul"
590 # AVX2 available since haswell, ca. 2013-2015
594 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
596 #include <nmmintrin.h>
598 volatile uint32_t x = _mm_crc32_u32(0, 0);
602 if [ "$?" = 0 ]; then
603 COMMON_FLAGS
="$COMMON_FLAGS $TRY_SSE42 -DHAVE_SSE42"
604 elif test "$USE_SSE"; then
605 echo "warning: USE_SSE specified but compiler could not use SSE intrinsics, disabling" >&2
608 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
610 #include <wmmintrin.h>
612 const auto a = _mm_set_epi64x(0, 0);
613 const auto b = _mm_set_epi64x(0, 0);
614 const auto c = _mm_clmulepi64_si128(a, b, 0x00);
615 auto d = _mm_cvtsi128_si64(c);
619 if [ "$?" = 0 ]; then
620 COMMON_FLAGS
="$COMMON_FLAGS $TRY_PCLMUL -DHAVE_PCLMUL"
621 elif test "$USE_SSE"; then
622 echo "warning: USE_SSE specified but compiler could not use PCLMUL intrinsics, disabling" >&2
625 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_AVX2 -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
627 #include <immintrin.h>
629 const auto a = _mm256_setr_epi32(0, 1, 2, 3, 4, 7, 6, 5);
630 const auto b = _mm256_permutevar8x32_epi32(a, a);
634 if [ "$?" = 0 ]; then
635 COMMON_FLAGS
="$COMMON_FLAGS $TRY_AVX2 -DHAVE_AVX2"
636 elif test "$USE_SSE"; then
637 echo "warning: USE_SSE specified but compiler could not use AVX2 intrinsics, disabling" >&2
640 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
643 uint64_t a = 0xffffFFFFffffFFFF;
644 __uint128_t b = __uint128_t(a) * a;
645 a = static_cast<uint64_t>(b >> 64);
649 if [ "$?" = 0 ]; then
650 COMMON_FLAGS
="$COMMON_FLAGS -DHAVE_UINT128_EXTENSION"
653 # iOS doesn't support thread-local storage, but this check would erroneously
654 # succeed because the cross-compiler flags are added by the Makefile, not this
656 if [ "$PLATFORM" != IOS
]; then
657 $CXX $COMMON_FLAGS -x c
++ - -o /dev
/null
2>/dev
/null
<<EOF
658 #if defined(_MSC_VER) && !defined(__thread)
659 #define __thread __declspec(thread)
662 static __thread int tls;
666 if [ "$?" = 0 ]; then
667 COMMON_FLAGS
="$COMMON_FLAGS -DROCKSDB_SUPPORT_THREAD_LOCAL"
671 if [ "$FBCODE_BUILD" != "true" -a "$PLATFORM" = OS_LINUX
]; then
672 $CXX $COMMON_FLAGS $PLATFORM_SHARED_CFLAGS -x c
++ -c - -o test_dl.o
2>/dev
/null
<<EOF
675 if [ "$?" = 0 ]; then
676 $CXX $COMMON_FLAGS $PLATFORM_SHARED_LDFLAGS test_dl.o
-o /dev
/null
2>/dev
/null
677 if [ "$?" = 0 ]; then
684 PLATFORM_CCFLAGS
="$PLATFORM_CCFLAGS $COMMON_FLAGS"
685 PLATFORM_CXXFLAGS
="$PLATFORM_CXXFLAGS $COMMON_FLAGS"
687 VALGRIND_VER
="$VALGRIND_VER"
689 ROCKSDB_MAJOR
=`build_tools/version.sh major`
690 ROCKSDB_MINOR
=`build_tools/version.sh minor`
691 ROCKSDB_PATCH
=`build_tools/version.sh patch`
693 echo "CC=$CC" >> "$OUTPUT"
694 echo "CXX=$CXX" >> "$OUTPUT"
695 echo "PLATFORM=$PLATFORM" >> "$OUTPUT"
696 echo "PLATFORM_LDFLAGS=$PLATFORM_LDFLAGS" >> "$OUTPUT"
697 echo "JAVA_LDFLAGS=$JAVA_LDFLAGS" >> "$OUTPUT"
698 echo "JAVA_STATIC_LDFLAGS=$JAVA_STATIC_LDFLAGS" >> "$OUTPUT"
699 echo "VALGRIND_VER=$VALGRIND_VER" >> "$OUTPUT"
700 echo "PLATFORM_CCFLAGS=$PLATFORM_CCFLAGS" >> "$OUTPUT"
701 echo "PLATFORM_CXXFLAGS=$PLATFORM_CXXFLAGS" >> "$OUTPUT"
702 echo "PLATFORM_SHARED_CFLAGS=$PLATFORM_SHARED_CFLAGS" >> "$OUTPUT"
703 echo "PLATFORM_SHARED_EXT=$PLATFORM_SHARED_EXT" >> "$OUTPUT"
704 echo "PLATFORM_SHARED_LDFLAGS=$PLATFORM_SHARED_LDFLAGS" >> "$OUTPUT"
705 echo "PLATFORM_SHARED_VERSIONED=$PLATFORM_SHARED_VERSIONED" >> "$OUTPUT"
706 echo "EXEC_LDFLAGS=$EXEC_LDFLAGS" >> "$OUTPUT"
707 echo "JEMALLOC_INCLUDE=$JEMALLOC_INCLUDE" >> "$OUTPUT"
708 echo "JEMALLOC_LIB=$JEMALLOC_LIB" >> "$OUTPUT"
709 echo "ROCKSDB_MAJOR=$ROCKSDB_MAJOR" >> "$OUTPUT"
710 echo "ROCKSDB_MINOR=$ROCKSDB_MINOR" >> "$OUTPUT"
711 echo "ROCKSDB_PATCH=$ROCKSDB_PATCH" >> "$OUTPUT"
712 echo "CLANG_SCAN_BUILD=$CLANG_SCAN_BUILD" >> "$OUTPUT"
713 echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT"
714 echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
715 echo "FIND=$FIND" >> "$OUTPUT"
716 echo "WATCH=$WATCH" >> "$OUTPUT"
717 # This will enable some related identifiers for the preprocessor
718 if test -n "$JEMALLOC"; then
719 echo "JEMALLOC=1" >> "$OUTPUT"
721 # Indicates that jemalloc should be enabled using -ljemalloc flag
722 # The alternative is to porvide a direct link to the library via JEMALLOC_LIB
723 # and JEMALLOC_INCLUDE
724 if test -n "$WITH_JEMALLOC_FLAG"; then
725 echo "WITH_JEMALLOC_FLAG=$WITH_JEMALLOC_FLAG" >> "$OUTPUT"
727 echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT"
728 if test -n "$USE_FOLLY_DISTRIBUTED_MUTEX"; then
729 echo "USE_FOLLY_DISTRIBUTED_MUTEX=$USE_FOLLY_DISTRIBUTED_MUTEX" >> "$OUTPUT"