]>
Commit | Line | Data |
---|---|---|
11fdf7f2 | 1 | #!/usr/bin/env bash |
7c673cae FG |
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 | |
20effc67 | 12 | # JAVAC_ARGS Arguments for javac |
7c673cae FG |
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. | |
11fdf7f2 TL |
20 | # FIND Command for the find utility |
21 | # WATCH Command for the watch utility | |
7c673cae FG |
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 | |
20effc67 | 31 | # -DMEMKIND if the memkind library is present |
7c673cae FG |
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 | ||
1e59de90 TL |
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 | ||
7c673cae FG |
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" | |
1e59de90 | 61 | # If we're compiling with TSAN or shared lib, we need pic build |
7c673cae | 62 | PIC_BUILD=$COMPILE_WITH_TSAN |
1e59de90 TL |
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" | |
20effc67 TL |
68 | elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM009" ]; then |
69 | source "$PWD/build_tools/fbcode_config_platform009.sh" | |
20effc67 TL |
70 | else |
71 | source "$PWD/build_tools/fbcode_config_platform009.sh" | |
7c673cae FG |
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 | |
11fdf7f2 TL |
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 | |
7c673cae FG |
87 | fi |
88 | ||
89 | if test -z "$CXX"; then | |
11fdf7f2 TL |
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 | |
7c673cae FG |
97 | fi |
98 | ||
20effc67 TL |
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 | ||
7c673cae FG |
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 | |
11fdf7f2 TL |
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 | |
7c673cae FG |
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" | |
11fdf7f2 TL |
168 | else |
169 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic" | |
7c673cae | 170 | fi |
20effc67 | 171 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -ldl" |
1e59de90 TL |
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 | |
f67539c2 | 176 | # check for liburing |
1e59de90 | 177 | $CXX $PLATFORM_CXXFLAGS -x c++ - -luring -o test.o 2>/dev/null <<EOF |
f67539c2 TL |
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 | |
7c673cae FG |
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 | |
11fdf7f2 | 207 | CXX=clang++ |
7c673cae FG |
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 | ;; | |
20effc67 TL |
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 | ;; | |
7c673cae FG |
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 | |
11fdf7f2 | 231 | CXX=clang++ |
7c673cae FG |
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 | |
11fdf7f2 TL |
235 | FIND=gfind |
236 | WATCH=gnuwatch | |
7c673cae FG |
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" | |
11fdf7f2 TL |
251 | else |
252 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic" | |
7c673cae FG |
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" | |
1e59de90 | 272 | JAVAC_ARGS="-source 8" |
7c673cae FG |
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 | |
20effc67 TL |
277 | if [ "$FBCODE_BUILD" = "true" ]; then |
278 | # Enable backtrace on fbcode since the necessary libraries are present | |
279 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE" | |
1e59de90 | 280 | FOLLY_DIR="third-party/folly" |
20effc67 | 281 | fi |
7c673cae FG |
282 | true |
283 | else | |
284 | if ! test $ROCKSDB_DISABLE_FALLOCATE; then | |
285 | # Test whether fallocate is available | |
1e59de90 | 286 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
7c673cae FG |
287 | #include <fcntl.h> |
288 | #include <linux/falloc.h> | |
289 | int main() { | |
290 | int fd = open("/dev/null", 0); | |
494da23a | 291 | fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, 1024); |
7c673cae FG |
292 | } |
293 | EOF | |
294 | if [ "$?" = 0 ]; then | |
295 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_FALLOCATE_PRESENT" | |
296 | fi | |
297 | fi | |
298 | ||
11fdf7f2 TL |
299 | if ! test $ROCKSDB_DISABLE_SNAPPY; then |
300 | # Test whether Snappy library is installed | |
301 | # http://code.google.com/p/snappy/ | |
1e59de90 | 302 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
303 | #include <snappy.h> |
304 | int main() {} | |
7c673cae | 305 | EOF |
11fdf7f2 TL |
306 | if [ "$?" = 0 ]; then |
307 | COMMON_FLAGS="$COMMON_FLAGS -DSNAPPY" | |
308 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lsnappy" | |
309 | JAVA_LDFLAGS="$JAVA_LDFLAGS -lsnappy" | |
310 | fi | |
7c673cae FG |
311 | fi |
312 | ||
11fdf7f2 TL |
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 | |
1e59de90 | 317 | if $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF |
11fdf7f2 | 318 | #include <gflags/gflags.h> |
20effc67 | 319 | using namespace GFLAGS_NAMESPACE; |
11fdf7f2 | 320 | int main() {} |
7c673cae | 321 | EOF |
20effc67 TL |
322 | then |
323 | COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1" | |
324 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags" | |
325 | # check if namespace is gflags | |
1e59de90 | 326 | elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF |
20effc67 TL |
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 | |
1e59de90 | 335 | elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF |
11fdf7f2 TL |
336 | #include <gflags/gflags.h> |
337 | using namespace google; | |
338 | int main() {} | |
7c673cae | 339 | EOF |
20effc67 TL |
340 | then |
341 | COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1 -DGFLAGS_NAMESPACE=google" | |
342 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags" | |
11fdf7f2 | 343 | fi |
7c673cae FG |
344 | fi |
345 | ||
11fdf7f2 TL |
346 | if ! test $ROCKSDB_DISABLE_ZLIB; then |
347 | # Test whether zlib library is installed | |
1e59de90 | 348 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
349 | #include <zlib.h> |
350 | int main() {} | |
7c673cae | 351 | EOF |
11fdf7f2 TL |
352 | if [ "$?" = 0 ]; then |
353 | COMMON_FLAGS="$COMMON_FLAGS -DZLIB" | |
354 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lz" | |
355 | JAVA_LDFLAGS="$JAVA_LDFLAGS -lz" | |
356 | fi | |
7c673cae FG |
357 | fi |
358 | ||
11fdf7f2 TL |
359 | if ! test $ROCKSDB_DISABLE_BZIP; then |
360 | # Test whether bzip library is installed | |
1e59de90 | 361 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
362 | #include <bzlib.h> |
363 | int main() {} | |
7c673cae | 364 | EOF |
11fdf7f2 TL |
365 | if [ "$?" = 0 ]; then |
366 | COMMON_FLAGS="$COMMON_FLAGS -DBZIP2" | |
367 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbz2" | |
368 | JAVA_LDFLAGS="$JAVA_LDFLAGS -lbz2" | |
369 | fi | |
7c673cae FG |
370 | fi |
371 | ||
11fdf7f2 TL |
372 | if ! test $ROCKSDB_DISABLE_LZ4; then |
373 | # Test whether lz4 library is installed | |
1e59de90 | 374 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
375 | #include <lz4.h> |
376 | #include <lz4hc.h> | |
377 | int main() {} | |
7c673cae | 378 | EOF |
11fdf7f2 TL |
379 | if [ "$?" = 0 ]; then |
380 | COMMON_FLAGS="$COMMON_FLAGS -DLZ4" | |
381 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -llz4" | |
382 | JAVA_LDFLAGS="$JAVA_LDFLAGS -llz4" | |
383 | fi | |
7c673cae FG |
384 | fi |
385 | ||
11fdf7f2 TL |
386 | if ! test $ROCKSDB_DISABLE_ZSTD; then |
387 | # Test whether zstd library is installed | |
1e59de90 | 388 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF |
11fdf7f2 TL |
389 | #include <zstd.h> |
390 | int main() {} | |
7c673cae | 391 | EOF |
11fdf7f2 TL |
392 | if [ "$?" = 0 ]; then |
393 | COMMON_FLAGS="$COMMON_FLAGS -DZSTD" | |
394 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lzstd" | |
395 | JAVA_LDFLAGS="$JAVA_LDFLAGS -lzstd" | |
396 | fi | |
7c673cae FG |
397 | fi |
398 | ||
11fdf7f2 TL |
399 | if ! test $ROCKSDB_DISABLE_NUMA; then |
400 | # Test whether numa is available | |
1e59de90 | 401 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -lnuma 2>/dev/null <<EOF |
11fdf7f2 TL |
402 | #include <numa.h> |
403 | #include <numaif.h> | |
404 | int main() {} | |
7c673cae | 405 | EOF |
11fdf7f2 TL |
406 | if [ "$?" = 0 ]; then |
407 | COMMON_FLAGS="$COMMON_FLAGS -DNUMA" | |
408 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lnuma" | |
409 | JAVA_LDFLAGS="$JAVA_LDFLAGS -lnuma" | |
410 | fi | |
7c673cae FG |
411 | fi |
412 | ||
11fdf7f2 TL |
413 | if ! test $ROCKSDB_DISABLE_TBB; then |
414 | # Test whether tbb is available | |
1e59de90 | 415 | $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o test.o -ltbb 2>/dev/null <<EOF |
11fdf7f2 TL |
416 | #include <tbb/tbb.h> |
417 | int main() {} | |
7c673cae | 418 | EOF |
11fdf7f2 TL |
419 | if [ "$?" = 0 ]; then |
420 | COMMON_FLAGS="$COMMON_FLAGS -DTBB" | |
421 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltbb" | |
422 | JAVA_LDFLAGS="$JAVA_LDFLAGS -ltbb" | |
423 | fi | |
7c673cae FG |
424 | fi |
425 | ||
11fdf7f2 TL |
426 | if ! test $ROCKSDB_DISABLE_JEMALLOC; then |
427 | # Test whether jemalloc is available | |
1e59de90 | 428 | if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -ljemalloc \ |
11fdf7f2 TL |
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 | |
494da23a TL |
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 | |
11fdf7f2 TL |
445 | fi |
446 | fi | |
447 | if ! test $JEMALLOC && ! test $ROCKSDB_DISABLE_TCMALLOC; then | |
7c673cae | 448 | # jemalloc is not available. Let's try tcmalloc |
1e59de90 | 449 | if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o \ |
7c673cae FG |
450 | -ltcmalloc 2>/dev/null; then |
451 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltcmalloc" | |
452 | JAVA_LDFLAGS="$JAVA_LDFLAGS -ltcmalloc" | |
453 | fi | |
454 | fi | |
455 | ||
11fdf7f2 TL |
456 | if ! test $ROCKSDB_DISABLE_MALLOC_USABLE_SIZE; then |
457 | # Test whether malloc_usable_size is available | |
1e59de90 | 458 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
459 | #include <malloc.h> |
460 | int main() { | |
461 | size_t res = malloc_usable_size(0); | |
f67539c2 | 462 | (void)res; |
11fdf7f2 TL |
463 | return 0; |
464 | } | |
7c673cae | 465 | EOF |
11fdf7f2 TL |
466 | if [ "$?" = 0 ]; then |
467 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_MALLOC_USABLE_SIZE" | |
468 | fi | |
7c673cae FG |
469 | fi |
470 | ||
20effc67 TL |
471 | if ! test $ROCKSDB_DISABLE_MEMKIND; then |
472 | # Test whether memkind library is installed | |
1e59de90 | 473 | $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o test.o -lmemkind 2>/dev/null <<EOF |
20effc67 TL |
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 | ||
11fdf7f2 TL |
487 | if ! test $ROCKSDB_DISABLE_PTHREAD_MUTEX_ADAPTIVE_NP; then |
488 | # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available | |
1e59de90 | 489 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
490 | #include <pthread.h> |
491 | int main() { | |
492 | int x = PTHREAD_MUTEX_ADAPTIVE_NP; | |
f67539c2 | 493 | (void)x; |
11fdf7f2 TL |
494 | return 0; |
495 | } | |
7c673cae | 496 | EOF |
11fdf7f2 TL |
497 | if [ "$?" = 0 ]; then |
498 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_PTHREAD_ADAPTIVE_MUTEX" | |
499 | fi | |
7c673cae FG |
500 | fi |
501 | ||
11fdf7f2 TL |
502 | if ! test $ROCKSDB_DISABLE_BACKTRACE; then |
503 | # Test whether backtrace is available | |
1e59de90 | 504 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
f67539c2 | 505 | #include <execinfo.h> |
7c673cae FG |
506 | int main() { |
507 | void* frames[1]; | |
508 | backtrace_symbols(frames, backtrace(frames, 1)); | |
11fdf7f2 | 509 | return 0; |
7c673cae FG |
510 | } |
511 | EOF | |
512 | if [ "$?" = 0 ]; then | |
513 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE" | |
11fdf7f2 TL |
514 | else |
515 | # Test whether execinfo library is installed | |
1e59de90 | 516 | $CXX $PLATFORM_CXXFLAGS -lexecinfo -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
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 | |
7c673cae FG |
528 | fi |
529 | fi | |
530 | ||
11fdf7f2 TL |
531 | if ! test $ROCKSDB_DISABLE_PG; then |
532 | # Test if -pg is supported | |
1e59de90 | 533 | $CXX $PLATFORM_CXXFLAGS -pg -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
534 | int main() { |
535 | return 0; | |
536 | } | |
7c673cae | 537 | EOF |
11fdf7f2 TL |
538 | if [ "$?" = 0 ]; then |
539 | PROFILING_FLAGS=-pg | |
540 | fi | |
7c673cae FG |
541 | fi |
542 | ||
11fdf7f2 TL |
543 | if ! test $ROCKSDB_DISABLE_SYNC_FILE_RANGE; then |
544 | # Test whether sync_file_range is supported for compatibility with an old glibc | |
1e59de90 | 545 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
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 | |
1e59de90 | 559 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
560 | #include <sched.h> |
561 | int main() { | |
562 | int cpuid = sched_getcpu(); | |
f67539c2 | 563 | (void)cpuid; |
11fdf7f2 | 564 | } |
7c673cae | 565 | EOF |
11fdf7f2 TL |
566 | if [ "$?" = 0 ]; then |
567 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_SCHED_GETCPU_PRESENT" | |
568 | fi | |
7c673cae | 569 | fi |
494da23a | 570 | |
b3b6e05e TL |
571 | if ! test $ROCKSDB_DISABLE_AUXV_GETAUXVAL; then |
572 | # Test whether getauxval is supported | |
1e59de90 | 573 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
b3b6e05e TL |
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 | ||
494da23a TL |
585 | if ! test $ROCKSDB_DISABLE_ALIGNED_NEW; then |
586 | # Test whether c++17 aligned-new is supported | |
1e59de90 | 587 | $CXX $PLATFORM_CXXFLAGS -faligned-new -x c++ - -o test.o 2>/dev/null <<EOF |
494da23a TL |
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 | |
1e59de90 TL |
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 | ||
7c673cae FG |
616 | fi |
617 | ||
618 | # TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning. | |
1e59de90 TL |
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 | |
7c673cae | 621 | # Test whether -Wshorten-64-to-32 is available |
1e59de90 | 622 | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -Wshorten-64-to-32 2>/dev/null <<EOF |
7c673cae FG |
623 | int main() {} |
624 | EOF | |
625 | if [ "$?" = 0 ]; then | |
626 | COMMON_FLAGS="$COMMON_FLAGS -Wshorten-64-to-32" | |
627 | fi | |
628 | fi | |
629 | ||
f67539c2 | 630 | if test "0$PORTABLE" -eq 0; then |
7c673cae FG |
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 " | |
f67539c2 | 635 | elif test -n "`echo $TARGET_ARCHITECTURE | grep -e^arm -e^aarch64`"; then |
11fdf7f2 TL |
636 | # TODO: Handle this with approprite options. |
637 | COMMON_FLAGS="$COMMON_FLAGS" | |
f67539c2 TL |
638 | elif test -n "`echo $TARGET_ARCHITECTURE | grep ^aarch64`"; then |
639 | COMMON_FLAGS="$COMMON_FLAGS" | |
1e59de90 TL |
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}" | |
11fdf7f2 TL |
651 | elif [ "$TARGET_OS" == "IOS" ]; then |
652 | COMMON_FLAGS="$COMMON_FLAGS" | |
f67539c2 TL |
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 | |
7c673cae | 659 | COMMON_FLAGS="$COMMON_FLAGS -march=native " |
11fdf7f2 | 660 | fi |
f67539c2 TL |
661 | else |
662 | # PORTABLE=1 | |
663 | if test "$USE_SSE"; then | |
664 | TRY_SSE_ETC="1" | |
665 | fi | |
20effc67 | 666 | |
1e59de90 TL |
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 | ||
20effc67 | 676 | if [[ "${PLATFORM}" == "OS_MACOSX" ]]; then |
1e59de90 TL |
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 | |
20effc67 | 704 | fi |
11fdf7f2 TL |
705 | fi |
706 | ||
f67539c2 TL |
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 | |
20effc67 | 714 | # Includes POPCNT for BitsSetToOne, BitParity |
f67539c2 TL |
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" | |
20effc67 TL |
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" | |
f67539c2 TL |
726 | fi |
727 | ||
1e59de90 | 728 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
729 | #include <cstdint> |
730 | #include <nmmintrin.h> | |
731 | int main() { | |
732 | volatile uint32_t x = _mm_crc32_u32(0, 0); | |
f67539c2 | 733 | (void)x; |
11fdf7f2 TL |
734 | } |
735 | EOF | |
736 | if [ "$?" = 0 ]; then | |
f67539c2 | 737 | COMMON_FLAGS="$COMMON_FLAGS $TRY_SSE42 -DHAVE_SSE42" |
11fdf7f2 | 738 | elif test "$USE_SSE"; then |
f67539c2 | 739 | echo "warning: USE_SSE specified but compiler could not use SSE intrinsics, disabling" >&2 |
11fdf7f2 TL |
740 | fi |
741 | ||
1e59de90 | 742 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c++ - -o test.o 2>/dev/null <<EOF |
11fdf7f2 TL |
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); | |
f67539c2 | 750 | (void)d; |
11fdf7f2 TL |
751 | } |
752 | EOF | |
753 | if [ "$?" = 0 ]; then | |
f67539c2 | 754 | COMMON_FLAGS="$COMMON_FLAGS $TRY_PCLMUL -DHAVE_PCLMUL" |
11fdf7f2 | 755 | elif test "$USE_SSE"; then |
f67539c2 TL |
756 | echo "warning: USE_SSE specified but compiler could not use PCLMUL intrinsics, disabling" >&2 |
757 | fi | |
758 | ||
1e59de90 | 759 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_AVX2 -x c++ - -o test.o 2>/dev/null <<EOF |
f67539c2 TL |
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 | ||
1e59de90 | 774 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_BMI -x c++ - -o test.o 2>/dev/null <<EOF |
20effc67 TL |
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 | ||
1e59de90 | 788 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_LZCNT -x c++ - -o test.o 2>/dev/null <<EOF |
20effc67 TL |
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 | ||
1e59de90 | 802 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null <<EOF |
f67539c2 TL |
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" | |
11fdf7f2 TL |
813 | fi |
814 | ||
f67539c2 TL |
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 | |
1e59de90 | 820 | $CXX $COMMON_FLAGS $PLATFORM_SHARED_LDFLAGS test_dl.o -o test.o 2>/dev/null |
f67539c2 TL |
821 | if [ "$?" = 0 ]; then |
822 | EXEC_LDFLAGS+="-ldl" | |
823 | rm -f test_dl.o | |
824 | fi | |
825 | fi | |
826 | fi | |
827 | ||
1e59de90 TL |
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 | ||
7c673cae FG |
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" | |
20effc67 | 860 | echo "AR=$AR" >> "$OUTPUT" |
7c673cae FG |
861 | echo "PLATFORM=$PLATFORM" >> "$OUTPUT" |
862 | echo "PLATFORM_LDFLAGS=$PLATFORM_LDFLAGS" >> "$OUTPUT" | |
1e59de90 | 863 | echo "PLATFORM_CMAKE_FLAGS=$PLATFORM_CMAKE_FLAGS" >> "$OUTPUT" |
7c673cae FG |
864 | echo "JAVA_LDFLAGS=$JAVA_LDFLAGS" >> "$OUTPUT" |
865 | echo "JAVA_STATIC_LDFLAGS=$JAVA_STATIC_LDFLAGS" >> "$OUTPUT" | |
1e59de90 TL |
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" | |
20effc67 | 869 | echo "JAVAC_ARGS=$JAVAC_ARGS" >> "$OUTPUT" |
7c673cae FG |
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" | |
11fdf7f2 TL |
886 | echo "FIND=$FIND" >> "$OUTPUT" |
887 | echo "WATCH=$WATCH" >> "$OUTPUT" | |
1e59de90 TL |
888 | echo "FOLLY_PATH=$FOLLY_PATH" >> "$OUTPUT" |
889 | ||
11fdf7f2 | 890 | # This will enable some related identifiers for the preprocessor |
7c673cae FG |
891 | if test -n "$JEMALLOC"; then |
892 | echo "JEMALLOC=1" >> "$OUTPUT" | |
893 | fi | |
11fdf7f2 TL |
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 | |
7c673cae | 900 | echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT" |
1e59de90 TL |
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" | |
f67539c2 | 906 | fi |