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# 32# Using gflags in rocksdb: 33# Our project depends on gflags, which requires users to take some extra steps 34# before they can compile the whole repository: 35# 1. Install gflags. You may download it from here: 36# https://gflags.github.io/gflags/ (Mac users can `brew install gflags`) 37# 2. Once installed, add the include path for gflags to your CPATH env var and 38# the lib path to LIBRARY_PATH. If installed with default settings, the lib 39# will be /usr/local/lib and the include path will be /usr/local/include 40 41OUTPUT=$1 42if test -z "$OUTPUT"; then 43 echo "usage: $0 <output-filename>" >&2 44 exit 1 45fi 46 47# we depend on C++11 48PLATFORM_CXXFLAGS="-std=c++11" 49# we currently depend on POSIX platform 50COMMON_FLAGS="-DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX" 51 52# Default to fbcode gcc on internal fb machines 53if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then 54 FBCODE_BUILD="true" 55 # If we're compiling with TSAN we need pic build 56 PIC_BUILD=$COMPILE_WITH_TSAN 57 if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then 58 # we need this to build with MySQL. Don't use for other purposes. 59 source "$PWD/build_tools/fbcode_config4.8.1.sh" 60 elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_5xx" ]; then 61 source "$PWD/build_tools/fbcode_config.sh" 62 else 63 source "$PWD/build_tools/fbcode_config_platform007.sh" 64 fi 65fi 66 67# Delete existing output, if it exists 68rm -f "$OUTPUT" 69touch "$OUTPUT" 70 71if test -z "$CC"; then 72 if [ -x "$(command -v cc)" ]; then 73 CC=cc 74 elif [ -x "$(command -v clang)" ]; then 75 CC=clang 76 else 77 CC=cc 78 fi 79fi 80 81if test -z "$CXX"; then 82 if [ -x "$(command -v g++)" ]; then 83 CXX=g++ 84 elif [ -x "$(command -v clang++)" ]; then 85 CXX=clang++ 86 else 87 CXX=g++ 88 fi 89fi 90 91# Detect OS 92if test -z "$TARGET_OS"; then 93 TARGET_OS=`uname -s` 94fi 95 96if test -z "$TARGET_ARCHITECTURE"; then 97 TARGET_ARCHITECTURE=`uname -m` 98fi 99 100if test -z "$CLANG_SCAN_BUILD"; then 101 CLANG_SCAN_BUILD=scan-build 102fi 103 104if test -z "$CLANG_ANALYZER"; then 105 CLANG_ANALYZER=$(command -v clang++ 2> /dev/null) 106fi 107 108if test -z "$FIND"; then 109 FIND=find 110fi 111 112if test -z "$WATCH"; then 113 WATCH=watch 114fi 115 116COMMON_FLAGS="$COMMON_FLAGS ${CFLAGS}" 117CROSS_COMPILE= 118PLATFORM_CCFLAGS= 119PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS" 120PLATFORM_SHARED_EXT="so" 121PLATFORM_SHARED_LDFLAGS="-Wl,--no-as-needed -shared -Wl,-soname -Wl," 122PLATFORM_SHARED_CFLAGS="-fPIC" 123PLATFORM_SHARED_VERSIONED=true 124 125# generic port files (working on all platform by #ifdef) go directly in /port 126GENERIC_PORT_FILES=`cd "$ROCKSDB_ROOT"; find port -name '*.cc' | tr "\n" " "` 127 128# On GCC, we pick libc's memcmp over GCC's memcmp via -fno-builtin-memcmp 129case "$TARGET_OS" in 130 Darwin) 131 PLATFORM=OS_MACOSX 132 COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX" 133 PLATFORM_SHARED_EXT=dylib 134 PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name " 135 # PORT_FILES=port/darwin/darwin_specific.cc 136 ;; 137 IOS) 138 PLATFORM=IOS 139 COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX -DIOS_CROSS_COMPILE -DROCKSDB_LITE" 140 PLATFORM_SHARED_EXT=dylib 141 PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name " 142 CROSS_COMPILE=true 143 PLATFORM_SHARED_VERSIONED= 144 ;; 145 Linux) 146 PLATFORM=OS_LINUX 147 COMMON_FLAGS="$COMMON_FLAGS -DOS_LINUX" 148 if [ -z "$USE_CLANG" ]; then 149 COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp" 150 else 151 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic" 152 fi 153 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt" 154 if test $ROCKSDB_USE_IO_URING; then 155 # check for liburing 156 $CXX $CFLAGS -x c++ - -luring -o /dev/null 2>/dev/null <<EOF 157 #include <liburing.h> 158 int main() { 159 struct io_uring ring; 160 io_uring_queue_init(1, &ring, 0); 161 return 0; 162 } 163EOF 164 if [ "$?" = 0 ]; then 165 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -luring" 166 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_IOURING_PRESENT" 167 fi 168 fi 169 if test -z "$USE_FOLLY_DISTRIBUTED_MUTEX"; then 170 USE_FOLLY_DISTRIBUTED_MUTEX=1 171 fi 172 # PORT_FILES=port/linux/linux_specific.cc 173 ;; 174 SunOS) 175 PLATFORM=OS_SOLARIS 176 COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_SOLARIS -m64" 177 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -static-libstdc++ -static-libgcc -m64" 178 # PORT_FILES=port/sunos/sunos_specific.cc 179 ;; 180 AIX) 181 PLATFORM=OS_AIX 182 CC=gcc 183 COMMON_FLAGS="$COMMON_FLAGS -maix64 -pthread -fno-builtin-memcmp -D_REENTRANT -DOS_AIX -D__STDC_FORMAT_MACROS" 184 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread -lpthread -lrt -maix64 -static-libstdc++ -static-libgcc" 185 # PORT_FILES=port/aix/aix_specific.cc 186 ;; 187 FreeBSD) 188 PLATFORM=OS_FREEBSD 189 CXX=clang++ 190 COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_FREEBSD" 191 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread" 192 # PORT_FILES=port/freebsd/freebsd_specific.cc 193 ;; 194 NetBSD) 195 PLATFORM=OS_NETBSD 196 COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_NETBSD" 197 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lgcc_s" 198 # PORT_FILES=port/netbsd/netbsd_specific.cc 199 ;; 200 OpenBSD) 201 PLATFORM=OS_OPENBSD 202 CXX=clang++ 203 COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_OPENBSD" 204 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread" 205 # PORT_FILES=port/openbsd/openbsd_specific.cc 206 FIND=gfind 207 WATCH=gnuwatch 208 ;; 209 DragonFly) 210 PLATFORM=OS_DRAGONFLYBSD 211 COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_DRAGONFLYBSD" 212 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread" 213 # PORT_FILES=port/dragonfly/dragonfly_specific.cc 214 ;; 215 Cygwin) 216 PLATFORM=CYGWIN 217 PLATFORM_SHARED_CFLAGS="" 218 PLATFORM_CXXFLAGS="-std=gnu++11" 219 COMMON_FLAGS="$COMMON_FLAGS -DCYGWIN" 220 if [ -z "$USE_CLANG" ]; then 221 COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp" 222 else 223 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic" 224 fi 225 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt" 226 # PORT_FILES=port/linux/linux_specific.cc 227 ;; 228 OS_ANDROID_CROSSCOMPILE) 229 PLATFORM=OS_ANDROID 230 COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_ANDROID -DROCKSDB_PLATFORM_POSIX" 231 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS " # All pthread features are in the Android C library 232 # PORT_FILES=port/android/android.cc 233 CROSS_COMPILE=true 234 ;; 235 *) 236 echo "Unknown platform!" >&2 237 exit 1 238esac 239 240PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS ${CXXFLAGS}" 241JAVA_LDFLAGS="$PLATFORM_LDFLAGS" 242JAVA_STATIC_LDFLAGS="$PLATFORM_LDFLAGS" 243JAVAC_ARGS="-source 7" 244 245if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then 246 # Cross-compiling; do not try any compilation tests. 247 # Also don't need any compilation tests if compiling on fbcode 248 true 249else 250 if ! test $ROCKSDB_DISABLE_FALLOCATE; then 251 # Test whether fallocate is available 252 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 253 #include <fcntl.h> 254 #include <linux/falloc.h> 255 int main() { 256 int fd = open("/dev/null", 0); 257 fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, 1024); 258 } 259EOF 260 if [ "$?" = 0 ]; then 261 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_FALLOCATE_PRESENT" 262 fi 263 fi 264 265 if ! test $ROCKSDB_DISABLE_SNAPPY; then 266 # Test whether Snappy library is installed 267 # http://code.google.com/p/snappy/ 268 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 269 #include <snappy.h> 270 int main() {} 271EOF 272 if [ "$?" = 0 ]; then 273 COMMON_FLAGS="$COMMON_FLAGS -DSNAPPY" 274 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lsnappy" 275 JAVA_LDFLAGS="$JAVA_LDFLAGS -lsnappy" 276 fi 277 fi 278 279 if ! test $ROCKSDB_DISABLE_GFLAGS; then 280 # Test whether gflags library is installed 281 # http://gflags.github.io/gflags/ 282 # check if the namespace is gflags 283 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF 284 #include <gflags/gflags.h> 285 int main() {} 286EOF 287 if [ "$?" = 0 ]; then 288 COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1" 289 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags" 290 else 291 # check if namespace is google 292 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF 293 #include <gflags/gflags.h> 294 using namespace google; 295 int main() {} 296EOF 297 if [ "$?" = 0 ]; then 298 COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=google" 299 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags" 300 fi 301 fi 302 fi 303 304 if ! test $ROCKSDB_DISABLE_ZLIB; then 305 # Test whether zlib library is installed 306 $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 307 #include <zlib.h> 308 int main() {} 309EOF 310 if [ "$?" = 0 ]; then 311 COMMON_FLAGS="$COMMON_FLAGS -DZLIB" 312 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lz" 313 JAVA_LDFLAGS="$JAVA_LDFLAGS -lz" 314 fi 315 fi 316 317 if ! test $ROCKSDB_DISABLE_BZIP; then 318 # Test whether bzip library is installed 319 $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 320 #include <bzlib.h> 321 int main() {} 322EOF 323 if [ "$?" = 0 ]; then 324 COMMON_FLAGS="$COMMON_FLAGS -DBZIP2" 325 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbz2" 326 JAVA_LDFLAGS="$JAVA_LDFLAGS -lbz2" 327 fi 328 fi 329 330 if ! test $ROCKSDB_DISABLE_LZ4; then 331 # Test whether lz4 library is installed 332 $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 333 #include <lz4.h> 334 #include <lz4hc.h> 335 int main() {} 336EOF 337 if [ "$?" = 0 ]; then 338 COMMON_FLAGS="$COMMON_FLAGS -DLZ4" 339 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -llz4" 340 JAVA_LDFLAGS="$JAVA_LDFLAGS -llz4" 341 fi 342 fi 343 344 if ! test $ROCKSDB_DISABLE_ZSTD; then 345 # Test whether zstd library is installed 346 $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 347 #include <zstd.h> 348 int main() {} 349EOF 350 if [ "$?" = 0 ]; then 351 COMMON_FLAGS="$COMMON_FLAGS -DZSTD" 352 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lzstd" 353 JAVA_LDFLAGS="$JAVA_LDFLAGS -lzstd" 354 fi 355 fi 356 357 if ! test $ROCKSDB_DISABLE_NUMA; then 358 # Test whether numa is available 359 $CXX $CFLAGS -x c++ - -o /dev/null -lnuma 2>/dev/null <<EOF 360 #include <numa.h> 361 #include <numaif.h> 362 int main() {} 363EOF 364 if [ "$?" = 0 ]; then 365 COMMON_FLAGS="$COMMON_FLAGS -DNUMA" 366 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lnuma" 367 JAVA_LDFLAGS="$JAVA_LDFLAGS -lnuma" 368 fi 369 fi 370 371 if ! test $ROCKSDB_DISABLE_TBB; then 372 # Test whether tbb is available 373 $CXX $CFLAGS $LDFLAGS -x c++ - -o /dev/null -ltbb 2>/dev/null <<EOF 374 #include <tbb/tbb.h> 375 int main() {} 376EOF 377 if [ "$?" = 0 ]; then 378 COMMON_FLAGS="$COMMON_FLAGS -DTBB" 379 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltbb" 380 JAVA_LDFLAGS="$JAVA_LDFLAGS -ltbb" 381 fi 382 fi 383 384 if ! test $ROCKSDB_DISABLE_JEMALLOC; then 385 # Test whether jemalloc is available 386 if echo 'int main() {}' | $CXX $CFLAGS -x c++ - -o /dev/null -ljemalloc \ 387 2>/dev/null; then 388 # This will enable some preprocessor identifiers in the Makefile 389 JEMALLOC=1 390 # JEMALLOC can be enabled either using the flag (like here) or by 391 # providing direct link to the jemalloc library 392 WITH_JEMALLOC_FLAG=1 393 # check for JEMALLOC installed with HomeBrew 394 if [ "$PLATFORM" == "OS_MACOSX" ]; then 395 if hash brew 2>/dev/null && brew ls --versions jemalloc > /dev/null; then 396 JEMALLOC_VER=$(brew ls --versions jemalloc | tail -n 1 | cut -f 2 -d ' ') 397 JEMALLOC_INCLUDE="-I/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/include" 398 JEMALLOC_LIB="/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/lib/libjemalloc_pic.a" 399 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS $JEMALLOC_LIB" 400 JAVA_STATIC_LDFLAGS="$JAVA_STATIC_LDFLAGS $JEMALLOC_LIB" 401 fi 402 fi 403 fi 404 fi 405 if ! test $JEMALLOC && ! test $ROCKSDB_DISABLE_TCMALLOC; then 406 # jemalloc is not available. Let's try tcmalloc 407 if echo 'int main() {}' | $CXX $CFLAGS -x c++ - -o /dev/null \ 408 -ltcmalloc 2>/dev/null; then 409 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltcmalloc" 410 JAVA_LDFLAGS="$JAVA_LDFLAGS -ltcmalloc" 411 fi 412 fi 413 414 if ! test $ROCKSDB_DISABLE_MALLOC_USABLE_SIZE; then 415 # Test whether malloc_usable_size is available 416 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 417 #include <malloc.h> 418 int main() { 419 size_t res = malloc_usable_size(0); 420 (void)res; 421 return 0; 422 } 423EOF 424 if [ "$?" = 0 ]; then 425 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_MALLOC_USABLE_SIZE" 426 fi 427 fi 428 429 if ! test $ROCKSDB_DISABLE_PTHREAD_MUTEX_ADAPTIVE_NP; then 430 # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available 431 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 432 #include <pthread.h> 433 int main() { 434 int x = PTHREAD_MUTEX_ADAPTIVE_NP; 435 (void)x; 436 return 0; 437 } 438EOF 439 if [ "$?" = 0 ]; then 440 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_PTHREAD_ADAPTIVE_MUTEX" 441 fi 442 fi 443 444 if ! test $ROCKSDB_DISABLE_BACKTRACE; then 445 # Test whether backtrace is available 446 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 447 #include <execinfo.h> 448 int main() { 449 void* frames[1]; 450 backtrace_symbols(frames, backtrace(frames, 1)); 451 return 0; 452 } 453EOF 454 if [ "$?" = 0 ]; then 455 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE" 456 else 457 # Test whether execinfo library is installed 458 $CXX $CFLAGS -lexecinfo -x c++ - -o /dev/null 2>/dev/null <<EOF 459 #include <execinfo.h> 460 int main() { 461 void* frames[1]; 462 backtrace_symbols(frames, backtrace(frames, 1)); 463 } 464EOF 465 if [ "$?" = 0 ]; then 466 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE" 467 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lexecinfo" 468 JAVA_LDFLAGS="$JAVA_LDFLAGS -lexecinfo" 469 fi 470 fi 471 fi 472 473 if ! test $ROCKSDB_DISABLE_PG; then 474 # Test if -pg is supported 475 $CXX $CFLAGS -pg -x c++ - -o /dev/null 2>/dev/null <<EOF 476 int main() { 477 return 0; 478 } 479EOF 480 if [ "$?" = 0 ]; then 481 PROFILING_FLAGS=-pg 482 fi 483 fi 484 485 if ! test $ROCKSDB_DISABLE_SYNC_FILE_RANGE; then 486 # Test whether sync_file_range is supported for compatibility with an old glibc 487 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 488 #include <fcntl.h> 489 int main() { 490 int fd = open("/dev/null", 0); 491 sync_file_range(fd, 0, 1024, SYNC_FILE_RANGE_WRITE); 492 } 493EOF 494 if [ "$?" = 0 ]; then 495 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_RANGESYNC_PRESENT" 496 fi 497 fi 498 499 if ! test $ROCKSDB_DISABLE_SCHED_GETCPU; then 500 # Test whether sched_getcpu is supported 501 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 502 #include <sched.h> 503 int main() { 504 int cpuid = sched_getcpu(); 505 (void)cpuid; 506 } 507EOF 508 if [ "$?" = 0 ]; then 509 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_SCHED_GETCPU_PRESENT" 510 fi 511 fi 512 513 if ! test $ROCKSDB_DISABLE_AUXV_GETAUXVAL; then 514 # Test whether getauxval is supported 515 $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 516 #include <sys/auxv.h> 517 int main() { 518 uint64_t auxv = getauxval(AT_HWCAP); 519 (void)auxv; 520 } 521EOF 522 if [ "$?" = 0 ]; then 523 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_AUXV_GETAUXVAL_PRESENT" 524 fi 525 fi 526 527 if ! test $ROCKSDB_DISABLE_ALIGNED_NEW; then 528 # Test whether c++17 aligned-new is supported 529 $CXX $PLATFORM_CXXFLAGS -faligned-new -x c++ - -o /dev/null 2>/dev/null <<EOF 530 struct alignas(1024) t {int a;}; 531 int main() {} 532EOF 533 if [ "$?" = 0 ]; then 534 PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS -faligned-new -DHAVE_ALIGNED_NEW" 535 fi 536 fi 537fi 538 539# TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning. 540# -Wshorten-64-to-32 breaks compilation on FreeBSD i386 541if ! [ "$TARGET_OS" = FreeBSD -a "$TARGET_ARCHITECTURE" = i386 ]; then 542 # Test whether -Wshorten-64-to-32 is available 543 $CXX $CFLAGS -x c++ - -o /dev/null -Wshorten-64-to-32 2>/dev/null <<EOF 544 int main() {} 545EOF 546 if [ "$?" = 0 ]; then 547 COMMON_FLAGS="$COMMON_FLAGS -Wshorten-64-to-32" 548 fi 549fi 550 551# shall we use HDFS? 552 553if test "$USE_HDFS"; then 554 if test -z "$JAVA_HOME"; then 555 echo "JAVA_HOME has to be set for HDFS usage." >&2 556 exit 1 557 fi 558 HDFS_CCFLAGS="$HDFS_CCFLAGS -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -DUSE_HDFS -I$HADOOP_HOME/include" 559 HDFS_LDFLAGS="$HDFS_LDFLAGS -lhdfs -L$JAVA_HOME/jre/lib/amd64 -L$HADOOP_HOME/lib/native" 560 HDFS_LDFLAGS="$HDFS_LDFLAGS -L$JAVA_HOME/jre/lib/amd64/server -L$GLIBC_RUNTIME_PATH/lib" 561 HDFS_LDFLAGS="$HDFS_LDFLAGS -ldl -lverify -ljava -ljvm" 562 COMMON_FLAGS="$COMMON_FLAGS $HDFS_CCFLAGS" 563 PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS $HDFS_LDFLAGS" 564 JAVA_LDFLAGS="$JAVA_LDFLAGS $HDFS_LDFLAGS" 565fi 566 567if test "0$PORTABLE" -eq 0; then 568 if test -n "`echo $TARGET_ARCHITECTURE | grep ^ppc64`"; then 569 # Tune for this POWER processor, treating '+' models as base models 570 POWER=`LD_SHOW_AUXV=1 /bin/true | grep AT_PLATFORM | grep -E -o power[0-9]+` 571 COMMON_FLAGS="$COMMON_FLAGS -mcpu=$POWER -mtune=$POWER " 572 elif test -n "`echo $TARGET_ARCHITECTURE | grep ^s390x`"; then 573 COMMON_FLAGS="$COMMON_FLAGS -march=z10 " 574 elif test -n "`echo $TARGET_ARCHITECTURE | grep -e^arm -e^aarch64`"; then 575 # TODO: Handle this with approprite options. 576 COMMON_FLAGS="$COMMON_FLAGS" 577 elif test -n "`echo $TARGET_ARCHITECTURE | grep ^aarch64`"; then 578 COMMON_FLAGS="$COMMON_FLAGS" 579 elif [ "$TARGET_OS" == "IOS" ]; then 580 COMMON_FLAGS="$COMMON_FLAGS" 581 elif [ "$TARGET_OS" == "AIX" ] || [ "$TARGET_OS" == "SunOS" ]; then 582 # TODO: Not sure why we don't use -march=native on these OSes 583 if test "$USE_SSE"; then 584 TRY_SSE_ETC="1" 585 fi 586 else 587 COMMON_FLAGS="$COMMON_FLAGS -march=native " 588 fi 589else 590 # PORTABLE=1 591 if test "$USE_SSE"; then 592 TRY_SSE_ETC="1" 593 fi 594fi 595 596if test "$TRY_SSE_ETC"; then 597 # The USE_SSE flag now means "attempt to compile with widely-available 598 # Intel architecture extensions utilized by specific optimizations in the 599 # source code." It's a qualifier on PORTABLE=1 that means "mostly portable." 600 # It doesn't even really check that your current CPU is compatible. 601 # 602 # SSE4.2 available since nehalem, ca. 2008-2010 603 TRY_SSE42="-msse4.2" 604 # PCLMUL available since westmere, ca. 2010-2011 605 TRY_PCLMUL="-mpclmul" 606 # AVX2 available since haswell, ca. 2013-2015 607 TRY_AVX2="-mavx2" 608fi 609 610$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o /dev/null 2>/dev/null <<EOF 611 #include <cstdint> 612 #include <nmmintrin.h> 613 int main() { 614 volatile uint32_t x = _mm_crc32_u32(0, 0); 615 (void)x; 616 } 617EOF 618if [ "$?" = 0 ]; then 619 COMMON_FLAGS="$COMMON_FLAGS $TRY_SSE42 -DHAVE_SSE42" 620elif test "$USE_SSE"; then 621 echo "warning: USE_SSE specified but compiler could not use SSE intrinsics, disabling" >&2 622fi 623 624$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c++ - -o /dev/null 2>/dev/null <<EOF 625 #include <cstdint> 626 #include <wmmintrin.h> 627 int main() { 628 const auto a = _mm_set_epi64x(0, 0); 629 const auto b = _mm_set_epi64x(0, 0); 630 const auto c = _mm_clmulepi64_si128(a, b, 0x00); 631 auto d = _mm_cvtsi128_si64(c); 632 (void)d; 633 } 634EOF 635if [ "$?" = 0 ]; then 636 COMMON_FLAGS="$COMMON_FLAGS $TRY_PCLMUL -DHAVE_PCLMUL" 637elif test "$USE_SSE"; then 638 echo "warning: USE_SSE specified but compiler could not use PCLMUL intrinsics, disabling" >&2 639fi 640 641$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_AVX2 -x c++ - -o /dev/null 2>/dev/null <<EOF 642 #include <cstdint> 643 #include <immintrin.h> 644 int main() { 645 const auto a = _mm256_setr_epi32(0, 1, 2, 3, 4, 7, 6, 5); 646 const auto b = _mm256_permutevar8x32_epi32(a, a); 647 (void)b; 648 } 649EOF 650if [ "$?" = 0 ]; then 651 COMMON_FLAGS="$COMMON_FLAGS $TRY_AVX2 -DHAVE_AVX2" 652elif test "$USE_SSE"; then 653 echo "warning: USE_SSE specified but compiler could not use AVX2 intrinsics, disabling" >&2 654fi 655 656$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 657 #include <cstdint> 658 int main() { 659 uint64_t a = 0xffffFFFFffffFFFF; 660 __uint128_t b = __uint128_t(a) * a; 661 a = static_cast<uint64_t>(b >> 64); 662 (void)a; 663 } 664EOF 665if [ "$?" = 0 ]; then 666 COMMON_FLAGS="$COMMON_FLAGS -DHAVE_UINT128_EXTENSION" 667fi 668 669# iOS doesn't support thread-local storage, but this check would erroneously 670# succeed because the cross-compiler flags are added by the Makefile, not this 671# script. 672if [ "$PLATFORM" != IOS ]; then 673 $CXX $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF 674 #if defined(_MSC_VER) && !defined(__thread) 675 #define __thread __declspec(thread) 676 #endif 677 int main() { 678 static __thread int tls; 679 (void)tls; 680 } 681EOF 682 if [ "$?" = 0 ]; then 683 COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_SUPPORT_THREAD_LOCAL" 684 fi 685fi 686 687if [ "$FBCODE_BUILD" != "true" -a "$PLATFORM" = OS_LINUX ]; then 688 $CXX $COMMON_FLAGS $PLATFORM_SHARED_CFLAGS -x c++ -c - -o test_dl.o 2>/dev/null <<EOF 689 void dummy_func() {} 690EOF 691 if [ "$?" = 0 ]; then 692 $CXX $COMMON_FLAGS $PLATFORM_SHARED_LDFLAGS test_dl.o -o /dev/null 2>/dev/null 693 if [ "$?" = 0 ]; then 694 EXEC_LDFLAGS+="-ldl" 695 rm -f test_dl.o 696 fi 697 fi 698fi 699 700PLATFORM_CCFLAGS="$PLATFORM_CCFLAGS $COMMON_FLAGS" 701PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS $COMMON_FLAGS" 702 703VALGRIND_VER="$VALGRIND_VER" 704 705ROCKSDB_MAJOR=`build_tools/version.sh major` 706ROCKSDB_MINOR=`build_tools/version.sh minor` 707ROCKSDB_PATCH=`build_tools/version.sh patch` 708 709echo "CC=$CC" >> "$OUTPUT" 710echo "CXX=$CXX" >> "$OUTPUT" 711echo "PLATFORM=$PLATFORM" >> "$OUTPUT" 712echo "PLATFORM_LDFLAGS=$PLATFORM_LDFLAGS" >> "$OUTPUT" 713echo "JAVA_LDFLAGS=$JAVA_LDFLAGS" >> "$OUTPUT" 714echo "JAVA_STATIC_LDFLAGS=$JAVA_STATIC_LDFLAGS" >> "$OUTPUT" 715echo "JAVAC_ARGS=$JAVAC_ARGS" >> "$OUTPUT" 716echo "VALGRIND_VER=$VALGRIND_VER" >> "$OUTPUT" 717echo "PLATFORM_CCFLAGS=$PLATFORM_CCFLAGS" >> "$OUTPUT" 718echo "PLATFORM_CXXFLAGS=$PLATFORM_CXXFLAGS" >> "$OUTPUT" 719echo "PLATFORM_SHARED_CFLAGS=$PLATFORM_SHARED_CFLAGS" >> "$OUTPUT" 720echo "PLATFORM_SHARED_EXT=$PLATFORM_SHARED_EXT" >> "$OUTPUT" 721echo "PLATFORM_SHARED_LDFLAGS=$PLATFORM_SHARED_LDFLAGS" >> "$OUTPUT" 722echo "PLATFORM_SHARED_VERSIONED=$PLATFORM_SHARED_VERSIONED" >> "$OUTPUT" 723echo "EXEC_LDFLAGS=$EXEC_LDFLAGS" >> "$OUTPUT" 724echo "JEMALLOC_INCLUDE=$JEMALLOC_INCLUDE" >> "$OUTPUT" 725echo "JEMALLOC_LIB=$JEMALLOC_LIB" >> "$OUTPUT" 726echo "ROCKSDB_MAJOR=$ROCKSDB_MAJOR" >> "$OUTPUT" 727echo "ROCKSDB_MINOR=$ROCKSDB_MINOR" >> "$OUTPUT" 728echo "ROCKSDB_PATCH=$ROCKSDB_PATCH" >> "$OUTPUT" 729echo "CLANG_SCAN_BUILD=$CLANG_SCAN_BUILD" >> "$OUTPUT" 730echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT" 731echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT" 732echo "FIND=$FIND" >> "$OUTPUT" 733echo "WATCH=$WATCH" >> "$OUTPUT" 734# This will enable some related identifiers for the preprocessor 735if test -n "$JEMALLOC"; then 736 echo "JEMALLOC=1" >> "$OUTPUT" 737fi 738# Indicates that jemalloc should be enabled using -ljemalloc flag 739# The alternative is to porvide a direct link to the library via JEMALLOC_LIB 740# and JEMALLOC_INCLUDE 741if test -n "$WITH_JEMALLOC_FLAG"; then 742 echo "WITH_JEMALLOC_FLAG=$WITH_JEMALLOC_FLAG" >> "$OUTPUT" 743fi 744echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT" 745if test -n "$USE_FOLLY_DISTRIBUTED_MUTEX"; then 746 echo "USE_FOLLY_DISTRIBUTED_MUTEX=$USE_FOLLY_DISTRIBUTED_MUTEX" >> "$OUTPUT" 747fi 748