ceph/src/rocksdb/build_tools/build_detect_platform

   1 #!/usr/bin/env bash
   2 #
   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.
   5 #
   6 # The output will set the following variables:
   7 #   CC                          C Compiler path
   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 #   JAVAC_ARGS                  Arguments for javac
  13 #   PLATFORM_SHARED_EXT         Extension for shared libraries
  14 #   PLATFORM_SHARED_LDFLAGS     Flags for building shared library
  15 #   PLATFORM_SHARED_CFLAGS      Flags for compiling objects for shared library
  16 #   PLATFORM_CCFLAGS            C compiler flags
  17 #   PLATFORM_CXXFLAGS           C++ compiler flags.  Will contain:
  18 #   PLATFORM_SHARED_VERSIONED   Set to 'true' if platform supports versioned
  19 #                               shared libraries, empty otherwise.
  20 #   FIND                        Command for the find utility
  21 #   WATCH                       Command for the watch utility
  22 #
  23 # The PLATFORM_CCFLAGS and PLATFORM_CXXFLAGS might include the following:
  24 #
  25 #       -DROCKSDB_PLATFORM_POSIX    if posix-platform based
  26 #       -DSNAPPY                    if the Snappy library is present
  27 #       -DLZ4                       if the LZ4 library is present
  28 #       -DZSTD                      if the ZSTD library is present
  29 #       -DNUMA                      if the NUMA library is present
  30 #       -DTBB                       if the TBB library is present
  31 #       -DMEMKIND                   if the memkind library is present
  32 #
  33 # Using gflags in rocksdb:
  34 # Our project depends on gflags, which requires users to take some extra steps
  35 # before they can compile the whole repository:
  36 #   1. Install gflags. You may download it from here:
  37 #      https://gflags.github.io/gflags/ (Mac users can `brew install gflags`)
  38 #   2. Once installed, add the include path for gflags to your CPATH env var and
  39 #      the lib path to LIBRARY_PATH. If installed with default settings, the lib
  40 #      will be /usr/local/lib and the include path will be /usr/local/include
  41
  42 OUTPUT=$1
  43 if test -z "$OUTPUT"; then
  44   echo "usage: $0 <output-filename>" >&2
  45   exit 1
  46 fi
  47
  48 # we depend on C++17, but should be compatible with newer standards
  49 if [ "$ROCKSDB_CXX_STANDARD" ]; then
  50   PLATFORM_CXXFLAGS="-std=$ROCKSDB_CXX_STANDARD"
  51 else
  52   PLATFORM_CXXFLAGS="-std=c++17"
  53 fi
  54
  55 # we currently depend on POSIX platform
  56 COMMON_FLAGS="-DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX"
  57
  58 # Default to fbcode gcc on internal fb machines
  59 if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then
  60     FBCODE_BUILD="true"
  61     # If we're compiling with TSAN or shared lib, we need pic build
  62     PIC_BUILD=$COMPILE_WITH_TSAN
  63     if [ "$LIB_MODE" == "shared" ]; then
  64       PIC_BUILD=1
  65     fi
  66     if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM010" ]; then
  67       source "$PWD/build_tools/fbcode_config_platform010.sh"
  68     elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM009" ]; then
  69       source "$PWD/build_tools/fbcode_config_platform009.sh"
  70     else
  71       source "$PWD/build_tools/fbcode_config_platform009.sh"
  72     fi
  73 fi
  74
  75 # Delete existing output, if it exists
  76 rm -f "$OUTPUT"
  77 touch "$OUTPUT"
  78
  79 if test -z "$CC"; then
  80     if [ -x "$(command -v cc)" ]; then
  81         CC=cc
  82     elif [ -x "$(command -v clang)" ]; then
  83         CC=clang
  84     else
  85         CC=cc
  86     fi
  87 fi
  88
  89 if test -z "$CXX"; then
  90     if [ -x "$(command -v g++)" ]; then
  91         CXX=g++
  92     elif [ -x "$(command -v clang++)" ]; then
  93         CXX=clang++
  94     else
  95         CXX=g++
  96     fi
  97 fi
  98
  99 if test -z "$AR"; then
 100     if [ -x "$(command -v gcc-ar)" ]; then
 101         AR=gcc-ar
 102     elif [ -x "$(command -v llvm-ar)" ]; then
 103         AR=llvm-ar
 104     else
 105         AR=ar
 106     fi
 107 fi
 108
 109 # Detect OS
 110 if test -z "$TARGET_OS"; then
 111     TARGET_OS=`uname -s`
 112 fi
 113
 114 if test -z "$TARGET_ARCHITECTURE"; then
 115     TARGET_ARCHITECTURE=`uname -m`
 116 fi
 117
 118 if test -z "$CLANG_SCAN_BUILD"; then
 119     CLANG_SCAN_BUILD=scan-build
 120 fi
 121
 122 if test -z "$CLANG_ANALYZER"; then
 123     CLANG_ANALYZER=$(command -v clang++ 2> /dev/null)
 124 fi
 125
 126 if test -z "$FIND"; then
 127     FIND=find
 128 fi
 129
 130 if test -z "$WATCH"; then
 131     WATCH=watch
 132 fi
 133
 134 COMMON_FLAGS="$COMMON_FLAGS ${CFLAGS}"
 135 CROSS_COMPILE=
 136 PLATFORM_CCFLAGS=
 137 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS"
 138 PLATFORM_SHARED_EXT="so"
 139 PLATFORM_SHARED_LDFLAGS="-Wl,--no-as-needed -shared -Wl,-soname -Wl,"
 140 PLATFORM_SHARED_CFLAGS="-fPIC"
 141 PLATFORM_SHARED_VERSIONED=true
 142
 143 # generic port files (working on all platform by #ifdef) go directly in /port
 144 GENERIC_PORT_FILES=`cd "$ROCKSDB_ROOT"; find port -name '*.cc' | tr "\n" " "`
 145
 146 # On GCC, we pick libc's memcmp over GCC's memcmp via -fno-builtin-memcmp
 147 case "$TARGET_OS" in
 148     Darwin)
 149         PLATFORM=OS_MACOSX
 150         COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX"
 151         PLATFORM_SHARED_EXT=dylib
 152         PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name "
 153         # PORT_FILES=port/darwin/darwin_specific.cc
 154         ;;
 155     IOS)
 156         PLATFORM=IOS
 157         COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX -DIOS_CROSS_COMPILE -DROCKSDB_LITE"
 158         PLATFORM_SHARED_EXT=dylib
 159         PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name "
 160         CROSS_COMPILE=true
 161         PLATFORM_SHARED_VERSIONED=
 162         ;;
 163     Linux)
 164         PLATFORM=OS_LINUX
 165         COMMON_FLAGS="$COMMON_FLAGS -DOS_LINUX"
 166         if [ -z "$USE_CLANG" ]; then
 167             COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp"
 168         else
 169             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic"
 170         fi
 171         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -ldl"
 172         if test -z "$ROCKSDB_USE_IO_URING"; then
 173             ROCKSDB_USE_IO_URING=1
 174         fi
 175         if test "$ROCKSDB_USE_IO_URING" -ne 0; then
 176             # check for liburing
 177             $CXX $PLATFORM_CXXFLAGS -x c++ - -luring -o test.o 2>/dev/null  <<EOF
 178               #include <liburing.h>
 179               int main() {
 180                 struct io_uring ring;
 181                 io_uring_queue_init(1, &ring, 0);
 182                 return 0;
 183               }
 184 EOF
 185             if [ "$?" = 0 ]; then
 186                 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -luring"
 187                 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_IOURING_PRESENT"
 188             fi
 189         fi
 190         # PORT_FILES=port/linux/linux_specific.cc
 191         ;;
 192     SunOS)
 193         PLATFORM=OS_SOLARIS
 194         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_SOLARIS -m64"
 195         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -static-libstdc++ -static-libgcc -m64"
 196         # PORT_FILES=port/sunos/sunos_specific.cc
 197         ;;
 198     AIX)
 199         PLATFORM=OS_AIX
 200         CC=gcc
 201         COMMON_FLAGS="$COMMON_FLAGS -maix64 -pthread -fno-builtin-memcmp -D_REENTRANT -DOS_AIX -D__STDC_FORMAT_MACROS"
 202         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread -lpthread -lrt -maix64 -static-libstdc++ -static-libgcc"
 203         # PORT_FILES=port/aix/aix_specific.cc
 204         ;;
 205     FreeBSD)
 206         PLATFORM=OS_FREEBSD
 207         CXX=clang++
 208         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_FREEBSD"
 209         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread"
 210         # PORT_FILES=port/freebsd/freebsd_specific.cc
 211         ;;
 212     GNU/kFreeBSD)
 213         PLATFORM=OS_GNU_KFREEBSD
 214         COMMON_FLAGS="$COMMON_FLAGS -DOS_GNU_KFREEBSD"
 215         if [ -z "$USE_CLANG" ]; then
 216             COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp"
 217         else
 218             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic"
 219         fi
 220         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt"
 221         # PORT_FILES=port/gnu_kfreebsd/gnu_kfreebsd_specific.cc
 222         ;;
 223     NetBSD)
 224         PLATFORM=OS_NETBSD
 225         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_NETBSD"
 226         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lgcc_s"
 227         # PORT_FILES=port/netbsd/netbsd_specific.cc
 228         ;;
 229     OpenBSD)
 230         PLATFORM=OS_OPENBSD
 231         CXX=clang++
 232         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_OPENBSD"
 233         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread"
 234         # PORT_FILES=port/openbsd/openbsd_specific.cc
 235         FIND=gfind
 236         WATCH=gnuwatch
 237         ;;
 238     DragonFly)
 239         PLATFORM=OS_DRAGONFLYBSD
 240         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_DRAGONFLYBSD"
 241         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread"
 242         # PORT_FILES=port/dragonfly/dragonfly_specific.cc
 243         ;;
 244     Cygwin)
 245         PLATFORM=CYGWIN
 246         PLATFORM_SHARED_CFLAGS=""
 247         PLATFORM_CXXFLAGS="-std=gnu++11"
 248         COMMON_FLAGS="$COMMON_FLAGS -DCYGWIN"
 249         if [ -z "$USE_CLANG" ]; then
 250             COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp"
 251         else
 252             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic"
 253         fi
 254         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt"
 255         # PORT_FILES=port/linux/linux_specific.cc
 256         ;;
 257     OS_ANDROID_CROSSCOMPILE)
 258         PLATFORM=OS_ANDROID
 259         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_ANDROID -DROCKSDB_PLATFORM_POSIX"
 260         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS "  # All pthread features are in the Android C library
 261         # PORT_FILES=port/android/android.cc
 262         CROSS_COMPILE=true
 263         ;;
 264     *)
 265         echo "Unknown platform!" >&2
 266         exit 1
 267 esac
 268
 269 PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS ${CXXFLAGS}"
 270 JAVA_LDFLAGS="$PLATFORM_LDFLAGS"
 271 JAVA_STATIC_LDFLAGS="$PLATFORM_LDFLAGS"
 272 JAVAC_ARGS="-source 8"
 273
 274 if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then
 275     # Cross-compiling; do not try any compilation tests.
 276     # Also don't need any compilation tests if compiling on fbcode
 277     if [ "$FBCODE_BUILD" = "true" ]; then
 278       # Enable backtrace on fbcode since the necessary libraries are present
 279       COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
 280       FOLLY_DIR="third-party/folly"
 281     fi
 282     true
 283 else
 284     if ! test $ROCKSDB_DISABLE_FALLOCATE; then
 285         # Test whether fallocate is available
 286         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 287           #include <fcntl.h>
 288           #include <linux/falloc.h>
 289           int main() {
 290       int fd = open("/dev/null", 0);
 291       fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, 1024);
 292           }
 293 EOF
 294         if [ "$?" = 0 ]; then
 295             COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_FALLOCATE_PRESENT"
 296         fi
 297     fi
 298
 299     if ! test $ROCKSDB_DISABLE_SNAPPY; then
 300         # Test whether Snappy library is installed
 301         # http://code.google.com/p/snappy/
 302         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 303           #include <snappy.h>
 304           int main() {}
 305 EOF
 306         if [ "$?" = 0 ]; then
 307             COMMON_FLAGS="$COMMON_FLAGS -DSNAPPY"
 308             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lsnappy"
 309             JAVA_LDFLAGS="$JAVA_LDFLAGS -lsnappy"
 310         fi
 311     fi
 312
 313     if ! test $ROCKSDB_DISABLE_GFLAGS; then
 314         # Test whether gflags library is installed
 315         # http://gflags.github.io/gflags/
 316         # check if the namespace is gflags
 317         if $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF
 318           #include <gflags/gflags.h>
 319           using namespace GFLAGS_NAMESPACE;
 320           int main() {}
 321 EOF
 322         then
 323           COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1"
 324           PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
 325         # check if namespace is gflags
 326         elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF
 327             #include <gflags/gflags.h>
 328             using namespace gflags;
 329             int main() {}
 330 EOF
 331         then
 332           COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1 -DGFLAGS_NAMESPACE=gflags"
 333           PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
 334         # check if namespace is google
 335         elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF
 336             #include <gflags/gflags.h>
 337             using namespace google;
 338             int main() {}
 339 EOF
 340         then
 341           COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1 -DGFLAGS_NAMESPACE=google"
 342           PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
 343         fi
 344     fi
 345
 346     if ! test $ROCKSDB_DISABLE_ZLIB; then
 347         # Test whether zlib library is installed
 348         $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 349           #include <zlib.h>
 350           int main() {}
 351 EOF
 352         if [ "$?" = 0 ]; then
 353             COMMON_FLAGS="$COMMON_FLAGS -DZLIB"
 354             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lz"
 355             JAVA_LDFLAGS="$JAVA_LDFLAGS -lz"
 356         fi
 357     fi
 358
 359     if ! test $ROCKSDB_DISABLE_BZIP; then
 360         # Test whether bzip library is installed
 361         $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 362           #include <bzlib.h>
 363           int main() {}
 364 EOF
 365         if [ "$?" = 0 ]; then
 366             COMMON_FLAGS="$COMMON_FLAGS -DBZIP2"
 367             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbz2"
 368             JAVA_LDFLAGS="$JAVA_LDFLAGS -lbz2"
 369         fi
 370     fi
 371
 372     if ! test $ROCKSDB_DISABLE_LZ4; then
 373         # Test whether lz4 library is installed
 374         $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 375           #include <lz4.h>
 376           #include <lz4hc.h>
 377           int main() {}
 378 EOF
 379         if [ "$?" = 0 ]; then
 380             COMMON_FLAGS="$COMMON_FLAGS -DLZ4"
 381             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -llz4"
 382             JAVA_LDFLAGS="$JAVA_LDFLAGS -llz4"
 383         fi
 384     fi
 385
 386     if ! test $ROCKSDB_DISABLE_ZSTD; then
 387         # Test whether zstd library is installed
 388         $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
 389           #include <zstd.h>
 390           int main() {}
 391 EOF
 392         if [ "$?" = 0 ]; then
 393             COMMON_FLAGS="$COMMON_FLAGS -DZSTD"
 394             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lzstd"
 395             JAVA_LDFLAGS="$JAVA_LDFLAGS -lzstd"
 396         fi
 397     fi
 398
 399     if ! test $ROCKSDB_DISABLE_NUMA; then
 400         # Test whether numa is available
 401         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -lnuma 2>/dev/null  <<EOF
 402           #include <numa.h>
 403           #include <numaif.h>
 404           int main() {}
 405 EOF
 406         if [ "$?" = 0 ]; then
 407             COMMON_FLAGS="$COMMON_FLAGS -DNUMA"
 408             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lnuma"
 409             JAVA_LDFLAGS="$JAVA_LDFLAGS -lnuma"
 410         fi
 411     fi
 412
 413     if ! test $ROCKSDB_DISABLE_TBB; then
 414         # Test whether tbb is available
 415         $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o test.o -ltbb 2>/dev/null  <<EOF
 416           #include <tbb/tbb.h>
 417           int main() {}
 418 EOF
 419         if [ "$?" = 0 ]; then
 420             COMMON_FLAGS="$COMMON_FLAGS -DTBB"
 421             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltbb"
 422             JAVA_LDFLAGS="$JAVA_LDFLAGS -ltbb"
 423         fi
 424     fi
 425
 426     if ! test $ROCKSDB_DISABLE_JEMALLOC; then
 427         # Test whether jemalloc is available
 428         if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -ljemalloc \
 429           2>/dev/null; then
 430             # This will enable some preprocessor identifiers in the Makefile
 431             JEMALLOC=1
 432             # JEMALLOC can be enabled either using the flag (like here) or by
 433             # providing direct link to the jemalloc library
 434             WITH_JEMALLOC_FLAG=1
 435             # check for JEMALLOC installed with HomeBrew
 436             if [ "$PLATFORM" == "OS_MACOSX" ]; then
 437                 if hash brew 2>/dev/null && brew ls --versions jemalloc > /dev/null; then
 438                     JEMALLOC_VER=$(brew ls --versions jemalloc | tail -n 1 | cut -f 2 -d ' ')
 439                     JEMALLOC_INCLUDE="-I/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/include"
 440                     JEMALLOC_LIB="/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/lib/libjemalloc_pic.a"
 441                     PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS $JEMALLOC_LIB"
 442                     JAVA_STATIC_LDFLAGS="$JAVA_STATIC_LDFLAGS $JEMALLOC_LIB"
 443                 fi
 444             fi
 445         fi
 446     fi
 447     if ! test $JEMALLOC && ! test $ROCKSDB_DISABLE_TCMALLOC; then
 448         # jemalloc is not available. Let's try tcmalloc
 449         if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o \
 450           -ltcmalloc 2>/dev/null; then
 451             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltcmalloc"
 452             JAVA_LDFLAGS="$JAVA_LDFLAGS -ltcmalloc"
 453         fi
 454     fi
 455
 456     if ! test $ROCKSDB_DISABLE_MALLOC_USABLE_SIZE; then
 457         # Test whether malloc_usable_size is available
 458         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 459           #include <malloc.h>
 460           int main() {
 461             size_t res = malloc_usable_size(0);
 462             (void)res;
 463             return 0;
 464           }
 465 EOF
 466         if [ "$?" = 0 ]; then
 467             COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_MALLOC_USABLE_SIZE"
 468         fi
 469     fi
 470
 471     if ! test $ROCKSDB_DISABLE_MEMKIND; then
 472         # Test whether memkind library is installed
 473         $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o test.o -lmemkind 2>/dev/null  <<EOF
 474           #include <memkind.h>
 475           int main() {
 476             memkind_malloc(MEMKIND_DAX_KMEM, 1024);
 477             return 0;
 478           }
 479 EOF
 480         if [ "$?" = 0 ]; then
 481             COMMON_FLAGS="$COMMON_FLAGS -DMEMKIND"
 482             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lmemkind"
 483             JAVA_LDFLAGS="$JAVA_LDFLAGS -lmemkind"
 484         fi
 485     fi
 486
 487     if ! test $ROCKSDB_DISABLE_PTHREAD_MUTEX_ADAPTIVE_NP; then
 488         # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available
 489         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 490           #include <pthread.h>
 491           int main() {
 492             int x = PTHREAD_MUTEX_ADAPTIVE_NP;
 493             (void)x;
 494             return 0;
 495           }
 496 EOF
 497         if [ "$?" = 0 ]; then
 498             COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_PTHREAD_ADAPTIVE_MUTEX"
 499         fi
 500     fi
 501
 502     if ! test $ROCKSDB_DISABLE_BACKTRACE; then
 503         # Test whether backtrace is available
 504         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 505           #include <execinfo.h>
 506           int main() {
 507             void* frames[1];
 508             backtrace_symbols(frames, backtrace(frames, 1));
 509             return 0;
 510           }
 511 EOF
 512         if [ "$?" = 0 ]; then
 513             COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
 514         else
 515             # Test whether execinfo library is installed
 516             $CXX $PLATFORM_CXXFLAGS -lexecinfo -x c++ - -o test.o 2>/dev/null  <<EOF
 517               #include <execinfo.h>
 518               int main() {
 519                 void* frames[1];
 520                 backtrace_symbols(frames, backtrace(frames, 1));
 521               }
 522 EOF
 523             if [ "$?" = 0 ]; then
 524                 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
 525                 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lexecinfo"
 526                 JAVA_LDFLAGS="$JAVA_LDFLAGS -lexecinfo"
 527             fi
 528         fi
 529     fi
 530
 531     if ! test $ROCKSDB_DISABLE_PG; then
 532         # Test if -pg is supported
 533         $CXX $PLATFORM_CXXFLAGS -pg -x c++ - -o test.o 2>/dev/null  <<EOF
 534           int main() {
 535             return 0;
 536           }
 537 EOF
 538         if [ "$?" = 0 ]; then
 539             PROFILING_FLAGS=-pg
 540         fi
 541     fi
 542
 543     if ! test $ROCKSDB_DISABLE_SYNC_FILE_RANGE; then
 544         # Test whether sync_file_range is supported for compatibility with an old glibc
 545         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 546           #include <fcntl.h>
 547           int main() {
 548             int fd = open("/dev/null", 0);
 549             sync_file_range(fd, 0, 1024, SYNC_FILE_RANGE_WRITE);
 550           }
 551 EOF
 552         if [ "$?" = 0 ]; then
 553             COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_RANGESYNC_PRESENT"
 554         fi
 555     fi
 556
 557     if ! test $ROCKSDB_DISABLE_SCHED_GETCPU; then
 558         # Test whether sched_getcpu is supported
 559         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 560           #include <sched.h>
 561           int main() {
 562             int cpuid = sched_getcpu();
 563             (void)cpuid;
 564           }
 565 EOF
 566         if [ "$?" = 0 ]; then
 567             COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_SCHED_GETCPU_PRESENT"
 568         fi
 569     fi
 570
 571     if ! test $ROCKSDB_DISABLE_AUXV_GETAUXVAL; then
 572         # Test whether getauxval is supported
 573         $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
 574           #include <sys/auxv.h>
 575           int main() {
 576             uint64_t auxv = getauxval(AT_HWCAP);
 577             (void)auxv;
 578           }
 579 EOF
 580         if [ "$?" = 0 ]; then
 581             COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_AUXV_GETAUXVAL_PRESENT"
 582         fi
 583     fi
 584
 585     if ! test $ROCKSDB_DISABLE_ALIGNED_NEW; then
 586         # Test whether c++17 aligned-new is supported
 587         $CXX $PLATFORM_CXXFLAGS -faligned-new -x c++ - -o test.o 2>/dev/null <<EOF
 588             struct alignas(1024) t {int a;};
 589             int main() {}
 590 EOF
 591         if [ "$?" = 0 ]; then
 592             PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS -faligned-new -DHAVE_ALIGNED_NEW"
 593         fi
 594     fi
 595     if ! test $ROCKSDB_DISABLE_BENCHMARK; then
 596         # Test whether google benchmark is available
 597         $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -lbenchmark -lpthread 2>/dev/null  <<EOF
 598           #include <benchmark/benchmark.h>
 599           int main() {}
 600 EOF
 601         if [ "$?" = 0 ]; then
 602             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbenchmark"
 603         fi
 604     fi
 605     if test $USE_FOLLY; then
 606         # Test whether libfolly library is installed
 607         $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
 608           #include <folly/synchronization/DistributedMutex.h>
 609           int main() {}
 610 EOF
 611         if [ "$?" != 0 ]; then
 612           FOLLY_DIR="./third-party/folly"
 613         fi
 614     fi
 615
 616 fi
 617
 618 # TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning.
 619 # -Wshorten-64-to-32 breaks compilation on FreeBSD aarch64 and i386
 620 if ! { [ "$TARGET_OS" = FreeBSD ] && [ "$TARGET_ARCHITECTURE" = arm64 -o "$TARGET_ARCHITECTURE" = i386 ]; }; then
 621   # Test whether -Wshorten-64-to-32 is available
 622   $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -Wshorten-64-to-32 2>/dev/null  <<EOF
 623     int main() {}
 624 EOF
 625   if [ "$?" = 0 ]; then
 626     COMMON_FLAGS="$COMMON_FLAGS -Wshorten-64-to-32"
 627   fi
 628 fi
 629
 630 if test "0$PORTABLE" -eq 0; then
 631   if test -n "`echo $TARGET_ARCHITECTURE | grep ^ppc64`"; then
 632     # Tune for this POWER processor, treating '+' models as base models
 633     POWER=`LD_SHOW_AUXV=1 /bin/true | grep AT_PLATFORM | grep -E -o power[0-9]+`
 634     COMMON_FLAGS="$COMMON_FLAGS -mcpu=$POWER -mtune=$POWER "
 635   elif test -n "`echo $TARGET_ARCHITECTURE | grep -e^arm -e^aarch64`"; then
 636     # TODO: Handle this with approprite options.
 637     COMMON_FLAGS="$COMMON_FLAGS"
 638   elif test -n "`echo $TARGET_ARCHITECTURE | grep ^aarch64`"; then
 639     COMMON_FLAGS="$COMMON_FLAGS"
 640   elif test -n "`echo $TARGET_ARCHITECTURE | grep ^s390x`"; then
 641     if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ \
 642       -march=native - -o /dev/null 2>/dev/null; then
 643       COMMON_FLAGS="$COMMON_FLAGS -march=native "
 644     else
 645       COMMON_FLAGS="$COMMON_FLAGS -march=z196 "
 646     fi
 647     COMMON_FLAGS="$COMMON_FLAGS"
 648   elif test -n "`echo $TARGET_ARCHITECTURE | grep ^riscv64`"; then
 649     RISC_ISA=$(cat /proc/cpuinfo | grep isa | head -1 | cut --delimiter=: -f 2 | cut -b 2-)
 650     COMMON_FLAGS="$COMMON_FLAGS -march=${RISC_ISA}"
 651   elif [ "$TARGET_OS" == "IOS" ]; then
 652     COMMON_FLAGS="$COMMON_FLAGS"
 653   elif [ "$TARGET_OS" == "AIX" ] || [ "$TARGET_OS" == "SunOS" ]; then
 654     # TODO: Not sure why we don't use -march=native on these OSes
 655     if test "$USE_SSE"; then
 656       TRY_SSE_ETC="1"
 657     fi
 658   else
 659     COMMON_FLAGS="$COMMON_FLAGS -march=native "
 660   fi
 661 else
 662   # PORTABLE=1
 663   if test "$USE_SSE"; then
 664     TRY_SSE_ETC="1"
 665   fi
 666
 667   if test -n "`echo $TARGET_ARCHITECTURE | grep ^s390x`"; then
 668     COMMON_FLAGS="$COMMON_FLAGS -march=z196 "
 669   fi
 670
 671   if test -n "`echo $TARGET_ARCHITECTURE | grep ^riscv64`"; then
 672     RISC_ISA=$(cat /proc/cpuinfo | grep isa | head -1 | cut --delimiter=: -f 2 | cut -b 2-)
 673     COMMON_FLAGS="$COMMON_FLAGS -march=${RISC_ISA}"
 674   fi
 675
 676   if [[ "${PLATFORM}" == "OS_MACOSX" ]]; then
 677     # For portability compile for macOS 10.13 (2017) or newer
 678     COMMON_FLAGS="$COMMON_FLAGS -mmacosx-version-min=10.13"
 679     PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -mmacosx-version-min=10.13"
 680     # -mmacosx-version-min must come first here.
 681     PLATFORM_SHARED_LDFLAGS="-mmacosx-version-min=10.13 $PLATFORM_SHARED_LDFLAGS"
 682     PLATFORM_CMAKE_FLAGS="-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13"
 683     JAVA_STATIC_DEPS_COMMON_FLAGS="-mmacosx-version-min=10.13"
 684     JAVA_STATIC_DEPS_LDFLAGS="$JAVA_STATIC_DEPS_COMMON_FLAGS"
 685     JAVA_STATIC_DEPS_CCFLAGS="$JAVA_STATIC_DEPS_COMMON_FLAGS"
 686     JAVA_STATIC_DEPS_CXXFLAGS="$JAVA_STATIC_DEPS_COMMON_FLAGS"
 687   fi
 688 fi
 689
 690 if test -n "`echo $TARGET_ARCHITECTURE | grep ^ppc64`"; then
 691   # check for GNU libc on ppc64
 692   $CXX -x c++ - -o /dev/null 2>/dev/null <<EOF
 693     #include <stdio.h>
 694     #include <stdlib.h>
 695     #include <gnu/libc-version.h>
 696
 697     int main(int argc, char *argv[]) {
 698       printf("GNU libc version: %s\n", gnu_get_libc_version());
 699       return 0;
 700     }
 701 EOF
 702   if [ "$?" != 0 ]; then
 703       PPC_LIBC_IS_GNU=0
 704   fi
 705 fi
 706
 707 if test "$TRY_SSE_ETC"; then
 708   # The USE_SSE flag now means "attempt to compile with widely-available
 709   # Intel architecture extensions utilized by specific optimizations in the
 710   # source code." It's a qualifier on PORTABLE=1 that means "mostly portable."
 711   # It doesn't even really check that your current CPU is compatible.
 712   #
 713   # SSE4.2 available since nehalem, ca. 2008-2010
 714   # Includes POPCNT for BitsSetToOne, BitParity
 715   TRY_SSE42="-msse4.2"
 716   # PCLMUL available since westmere, ca. 2010-2011
 717   TRY_PCLMUL="-mpclmul"
 718   # AVX2 available since haswell, ca. 2013-2015
 719   TRY_AVX2="-mavx2"
 720   # BMI available since haswell, ca. 2013-2015
 721   # Primarily for TZCNT for CountTrailingZeroBits
 722   TRY_BMI="-mbmi"
 723   # LZCNT available since haswell, ca. 2013-2015
 724   # For FloorLog2
 725   TRY_LZCNT="-mlzcnt"
 726 fi
 727
 728 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o test.o 2>/dev/null <<EOF
 729   #include <cstdint>
 730   #include <nmmintrin.h>
 731   int main() {
 732     volatile uint32_t x = _mm_crc32_u32(0, 0);
 733     (void)x;
 734   }
 735 EOF
 736 if [ "$?" = 0 ]; then
 737   COMMON_FLAGS="$COMMON_FLAGS $TRY_SSE42 -DHAVE_SSE42"
 738 elif test "$USE_SSE"; then
 739   echo "warning: USE_SSE specified but compiler could not use SSE intrinsics, disabling" >&2
 740 fi
 741
 742 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c++ - -o test.o 2>/dev/null <<EOF
 743   #include <cstdint>
 744   #include <wmmintrin.h>
 745   int main() {
 746     const auto a = _mm_set_epi64x(0, 0);
 747     const auto b = _mm_set_epi64x(0, 0);
 748     const auto c = _mm_clmulepi64_si128(a, b, 0x00);
 749     auto d = _mm_cvtsi128_si64(c);
 750     (void)d;
 751   }
 752 EOF
 753 if [ "$?" = 0 ]; then
 754   COMMON_FLAGS="$COMMON_FLAGS $TRY_PCLMUL -DHAVE_PCLMUL"
 755 elif test "$USE_SSE"; then
 756   echo "warning: USE_SSE specified but compiler could not use PCLMUL intrinsics, disabling" >&2
 757 fi
 758
 759 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_AVX2 -x c++ - -o test.o 2>/dev/null <<EOF
 760   #include <cstdint>
 761   #include <immintrin.h>
 762   int main() {
 763     const auto a = _mm256_setr_epi32(0, 1, 2, 3, 4, 7, 6, 5);
 764     const auto b = _mm256_permutevar8x32_epi32(a, a);
 765     (void)b;
 766   }
 767 EOF
 768 if [ "$?" = 0 ]; then
 769   COMMON_FLAGS="$COMMON_FLAGS $TRY_AVX2 -DHAVE_AVX2"
 770 elif test "$USE_SSE"; then
 771   echo "warning: USE_SSE specified but compiler could not use AVX2 intrinsics, disabling" >&2
 772 fi
 773
 774 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_BMI -x c++ - -o test.o 2>/dev/null <<EOF
 775   #include <cstdint>
 776   #include <immintrin.h>
 777   int main(int argc, char *argv[]) {
 778     (void)argv;
 779     return (int)_tzcnt_u64((uint64_t)argc);
 780   }
 781 EOF
 782 if [ "$?" = 0 ]; then
 783   COMMON_FLAGS="$COMMON_FLAGS $TRY_BMI -DHAVE_BMI"
 784 elif test "$USE_SSE"; then
 785   echo "warning: USE_SSE specified but compiler could not use BMI intrinsics, disabling" >&2
 786 fi
 787
 788 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_LZCNT -x c++ - -o test.o 2>/dev/null <<EOF
 789   #include <cstdint>
 790   #include <immintrin.h>
 791   int main(int argc, char *argv[]) {
 792     (void)argv;
 793     return (int)_lzcnt_u64((uint64_t)argc);
 794   }
 795 EOF
 796 if [ "$?" = 0 ]; then
 797   COMMON_FLAGS="$COMMON_FLAGS $TRY_LZCNT -DHAVE_LZCNT"
 798 elif test "$USE_SSE"; then
 799   echo "warning: USE_SSE specified but compiler could not use LZCNT intrinsics, disabling" >&2
 800 fi
 801
 802 $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null <<EOF
 803   #include <cstdint>
 804   int main() {
 805     uint64_t a = 0xffffFFFFffffFFFF;
 806     __uint128_t b = __uint128_t(a) * a;
 807     a = static_cast<uint64_t>(b >> 64);
 808     (void)a;
 809   }
 810 EOF
 811 if [ "$?" = 0 ]; then
 812   COMMON_FLAGS="$COMMON_FLAGS -DHAVE_UINT128_EXTENSION"
 813 fi
 814
 815 if [ "$FBCODE_BUILD" != "true" -a "$PLATFORM" = OS_LINUX ]; then
 816   $CXX $COMMON_FLAGS $PLATFORM_SHARED_CFLAGS -x c++ -c - -o test_dl.o 2>/dev/null <<EOF
 817   void dummy_func() {}
 818 EOF
 819   if [ "$?" = 0 ]; then
 820     $CXX $COMMON_FLAGS $PLATFORM_SHARED_LDFLAGS test_dl.o -o test.o 2>/dev/null
 821     if [ "$?" = 0 ]; then
 822       EXEC_LDFLAGS+="-ldl"
 823       rm -f test_dl.o
 824     fi
 825   fi
 826 fi
 827
 828 # check for F_FULLFSYNC
 829 $CXX $PLATFORM_CXXFALGS -x c++ - -o test.o 2>/dev/null  <<EOF
 830   #include <fcntl.h>
 831   int main() {
 832     fcntl(0, F_FULLFSYNC);
 833     return 0;
 834   }
 835 EOF
 836 if [ "$?" = 0 ]; then
 837   COMMON_FLAGS="$COMMON_FLAGS -DHAVE_FULLFSYNC"
 838 fi
 839
 840 rm -f test.o test_dl.o
 841
 842 # Get the path for the folly installation dir
 843 if [ "$USE_FOLLY" ]; then
 844   if [ "$FOLLY_DIR" ]; then
 845     FOLLY_PATH=`cd $FOLLY_DIR && $PYTHON build/fbcode_builder/getdeps.py show-inst-dir folly`
 846   fi
 847 fi
 848
 849 PLATFORM_CCFLAGS="$PLATFORM_CCFLAGS $COMMON_FLAGS"
 850 PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS $COMMON_FLAGS"
 851
 852 VALGRIND_VER="$VALGRIND_VER"
 853
 854 ROCKSDB_MAJOR=`build_tools/version.sh major`
 855 ROCKSDB_MINOR=`build_tools/version.sh minor`
 856 ROCKSDB_PATCH=`build_tools/version.sh patch`
 857
 858 echo "CC=$CC" >> "$OUTPUT"
 859 echo "CXX=$CXX" >> "$OUTPUT"
 860 echo "AR=$AR" >> "$OUTPUT"
 861 echo "PLATFORM=$PLATFORM" >> "$OUTPUT"
 862 echo "PLATFORM_LDFLAGS=$PLATFORM_LDFLAGS" >> "$OUTPUT"
 863 echo "PLATFORM_CMAKE_FLAGS=$PLATFORM_CMAKE_FLAGS" >> "$OUTPUT"
 864 echo "JAVA_LDFLAGS=$JAVA_LDFLAGS" >> "$OUTPUT"
 865 echo "JAVA_STATIC_LDFLAGS=$JAVA_STATIC_LDFLAGS" >> "$OUTPUT"
 866 echo "JAVA_STATIC_DEPS_CCFLAGS=$JAVA_STATIC_DEPS_CCFLAGS" >> "$OUTPUT"
 867 echo "JAVA_STATIC_DEPS_CXXFLAGS=$JAVA_STATIC_DEPS_CXXFLAGS" >> "$OUTPUT"
 868 echo "JAVA_STATIC_DEPS_LDFLAGS=$JAVA_STATIC_DEPS_LDFLAGS" >> "$OUTPUT"
 869 echo "JAVAC_ARGS=$JAVAC_ARGS" >> "$OUTPUT"
 870 echo "VALGRIND_VER=$VALGRIND_VER" >> "$OUTPUT"
 871 echo "PLATFORM_CCFLAGS=$PLATFORM_CCFLAGS" >> "$OUTPUT"
 872 echo "PLATFORM_CXXFLAGS=$PLATFORM_CXXFLAGS" >> "$OUTPUT"
 873 echo "PLATFORM_SHARED_CFLAGS=$PLATFORM_SHARED_CFLAGS" >> "$OUTPUT"
 874 echo "PLATFORM_SHARED_EXT=$PLATFORM_SHARED_EXT" >> "$OUTPUT"
 875 echo "PLATFORM_SHARED_LDFLAGS=$PLATFORM_SHARED_LDFLAGS" >> "$OUTPUT"
 876 echo "PLATFORM_SHARED_VERSIONED=$PLATFORM_SHARED_VERSIONED" >> "$OUTPUT"
 877 echo "EXEC_LDFLAGS=$EXEC_LDFLAGS" >> "$OUTPUT"
 878 echo "JEMALLOC_INCLUDE=$JEMALLOC_INCLUDE" >> "$OUTPUT"
 879 echo "JEMALLOC_LIB=$JEMALLOC_LIB" >> "$OUTPUT"
 880 echo "ROCKSDB_MAJOR=$ROCKSDB_MAJOR" >> "$OUTPUT"
 881 echo "ROCKSDB_MINOR=$ROCKSDB_MINOR" >> "$OUTPUT"
 882 echo "ROCKSDB_PATCH=$ROCKSDB_PATCH" >> "$OUTPUT"
 883 echo "CLANG_SCAN_BUILD=$CLANG_SCAN_BUILD" >> "$OUTPUT"
 884 echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT"
 885 echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
 886 echo "FIND=$FIND" >> "$OUTPUT"
 887 echo "WATCH=$WATCH" >> "$OUTPUT"
 888 echo "FOLLY_PATH=$FOLLY_PATH" >> "$OUTPUT"
 889
 890 # This will enable some related identifiers for the preprocessor
 891 if test -n "$JEMALLOC"; then
 892   echo "JEMALLOC=1" >> "$OUTPUT"
 893 fi
 894 # Indicates that jemalloc should be enabled using -ljemalloc flag
 895 # The alternative is to porvide a direct link to the library via JEMALLOC_LIB
 896 # and JEMALLOC_INCLUDE
 897 if test -n "$WITH_JEMALLOC_FLAG"; then
 898   echo "WITH_JEMALLOC_FLAG=$WITH_JEMALLOC_FLAG" >> "$OUTPUT"
 899 fi
 900 echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT"
 901 if test -n "$USE_FOLLY"; then
 902   echo "USE_FOLLY=$USE_FOLLY" >> "$OUTPUT"
 903 fi
 904 if test -n "$PPC_LIBC_IS_GNU"; then
 905   echo "PPC_LIBC_IS_GNU=$PPC_LIBC_IS_GNU" >> "$OUTPUT"
 906 fi