]>
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 | ||
48 | # we depend on C++11 | |
49 | PLATFORM_CXXFLAGS="-std=c++11" | |
50 | # we currently depend on POSIX platform | |
51 | COMMON_FLAGS="-DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX" | |
52 | ||
53 | # Default to fbcode gcc on internal fb machines | |
54 | if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then | |
55 | FBCODE_BUILD="true" | |
56 | # If we're compiling with TSAN we need pic build | |
57 | PIC_BUILD=$COMPILE_WITH_TSAN | |
494da23a | 58 | if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then |
7c673cae FG |
59 | # we need this to build with MySQL. Don't use for other purposes. |
60 | source "$PWD/build_tools/fbcode_config4.8.1.sh" | |
f67539c2 | 61 | elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_5xx" ]; then |
494da23a | 62 | source "$PWD/build_tools/fbcode_config.sh" |
20effc67 TL |
63 | elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007" ]; then |
64 | source "$PWD/build_tools/fbcode_config_platform007.sh" | |
65 | elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM009" ]; then | |
66 | source "$PWD/build_tools/fbcode_config_platform009.sh" | |
67 | elif [ -z "$USE_CLANG" ]; then | |
68 | # Still use platform007 for gcc by default for build break on | |
69 | # some hosts. | |
f67539c2 | 70 | source "$PWD/build_tools/fbcode_config_platform007.sh" |
20effc67 TL |
71 | else |
72 | source "$PWD/build_tools/fbcode_config_platform009.sh" | |
7c673cae FG |
73 | fi |
74 | fi | |
75 | ||
76 | # Delete existing output, if it exists | |
77 | rm -f "$OUTPUT" | |
78 | touch "$OUTPUT" | |
79 | ||
80 | if test -z "$CC"; then | |
11fdf7f2 TL |
81 | if [ -x "$(command -v cc)" ]; then |
82 | CC=cc | |
83 | elif [ -x "$(command -v clang)" ]; then | |
84 | CC=clang | |
85 | else | |
86 | CC=cc | |
87 | fi | |
7c673cae FG |
88 | fi |
89 | ||
90 | if test -z "$CXX"; then | |
11fdf7f2 TL |
91 | if [ -x "$(command -v g++)" ]; then |
92 | CXX=g++ | |
93 | elif [ -x "$(command -v clang++)" ]; then | |
94 | CXX=clang++ | |
95 | else | |
96 | CXX=g++ | |
97 | fi | |
7c673cae FG |
98 | fi |
99 | ||
20effc67 TL |
100 | if test -z "$AR"; then |
101 | if [ -x "$(command -v gcc-ar)" ]; then | |
102 | AR=gcc-ar | |
103 | elif [ -x "$(command -v llvm-ar)" ]; then | |
104 | AR=llvm-ar | |
105 | else | |
106 | AR=ar | |
107 | fi | |
108 | fi | |
109 | ||
7c673cae FG |
110 | # Detect OS |
111 | if test -z "$TARGET_OS"; then | |
112 | TARGET_OS=`uname -s` | |
113 | fi | |
114 | ||
115 | if test -z "$TARGET_ARCHITECTURE"; then | |
116 | TARGET_ARCHITECTURE=`uname -m` | |
117 | fi | |
118 | ||
119 | if test -z "$CLANG_SCAN_BUILD"; then | |
120 | CLANG_SCAN_BUILD=scan-build | |
121 | fi | |
122 | ||
123 | if test -z "$CLANG_ANALYZER"; then | |
11fdf7f2 TL |
124 | CLANG_ANALYZER=$(command -v clang++ 2> /dev/null) |
125 | fi | |
126 | ||
127 | if test -z "$FIND"; then | |
128 | FIND=find | |
129 | fi | |
130 | ||
131 | if test -z "$WATCH"; then | |
132 | WATCH=watch | |
7c673cae FG |
133 | fi |
134 | ||
135 | COMMON_FLAGS="$COMMON_FLAGS ${CFLAGS}" | |
136 | CROSS_COMPILE= | |
137 | PLATFORM_CCFLAGS= | |
138 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS" | |
139 | PLATFORM_SHARED_EXT="so" | |
140 | PLATFORM_SHARED_LDFLAGS="-Wl,--no-as-needed -shared -Wl,-soname -Wl," | |
141 | PLATFORM_SHARED_CFLAGS="-fPIC" | |
142 | PLATFORM_SHARED_VERSIONED=true | |
143 | ||
144 | # generic port files (working on all platform by #ifdef) go directly in /port | |
145 | GENERIC_PORT_FILES=`cd "$ROCKSDB_ROOT"; find port -name '*.cc' | tr "\n" " "` | |
146 | ||
147 | # On GCC, we pick libc's memcmp over GCC's memcmp via -fno-builtin-memcmp | |
148 | case "$TARGET_OS" in | |
149 | Darwin) | |
150 | PLATFORM=OS_MACOSX | |
151 | COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX" | |
152 | PLATFORM_SHARED_EXT=dylib | |
153 | PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name " | |
154 | # PORT_FILES=port/darwin/darwin_specific.cc | |
155 | ;; | |
156 | IOS) | |
157 | PLATFORM=IOS | |
158 | COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX -DIOS_CROSS_COMPILE -DROCKSDB_LITE" | |
159 | PLATFORM_SHARED_EXT=dylib | |
160 | PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name " | |
161 | CROSS_COMPILE=true | |
162 | PLATFORM_SHARED_VERSIONED= | |
163 | ;; | |
164 | Linux) | |
165 | PLATFORM=OS_LINUX | |
166 | COMMON_FLAGS="$COMMON_FLAGS -DOS_LINUX" | |
167 | if [ -z "$USE_CLANG" ]; then | |
168 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp" | |
11fdf7f2 TL |
169 | else |
170 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic" | |
7c673cae | 171 | fi |
20effc67 | 172 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -ldl" |
f67539c2 TL |
173 | if test $ROCKSDB_USE_IO_URING; then |
174 | # check for liburing | |
175 | $CXX $CFLAGS -x c++ - -luring -o /dev/null 2>/dev/null <<EOF | |
176 | #include <liburing.h> | |
177 | int main() { | |
178 | struct io_uring ring; | |
179 | io_uring_queue_init(1, &ring, 0); | |
180 | return 0; | |
181 | } | |
182 | EOF | |
183 | if [ "$?" = 0 ]; then | |
184 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -luring" | |
185 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_IOURING_PRESENT" | |
186 | fi | |
187 | fi | |
188 | if test -z "$USE_FOLLY_DISTRIBUTED_MUTEX"; then | |
189 | USE_FOLLY_DISTRIBUTED_MUTEX=1 | |
190 | fi | |
7c673cae FG |
191 | # PORT_FILES=port/linux/linux_specific.cc |
192 | ;; | |
193 | SunOS) | |
194 | PLATFORM=OS_SOLARIS | |
195 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_SOLARIS -m64" | |
196 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -static-libstdc++ -static-libgcc -m64" | |
197 | # PORT_FILES=port/sunos/sunos_specific.cc | |
198 | ;; | |
199 | AIX) | |
200 | PLATFORM=OS_AIX | |
201 | CC=gcc | |
202 | COMMON_FLAGS="$COMMON_FLAGS -maix64 -pthread -fno-builtin-memcmp -D_REENTRANT -DOS_AIX -D__STDC_FORMAT_MACROS" | |
203 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread -lpthread -lrt -maix64 -static-libstdc++ -static-libgcc" | |
204 | # PORT_FILES=port/aix/aix_specific.cc | |
205 | ;; | |
206 | FreeBSD) | |
207 | PLATFORM=OS_FREEBSD | |
11fdf7f2 | 208 | CXX=clang++ |
7c673cae FG |
209 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_FREEBSD" |
210 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread" | |
211 | # PORT_FILES=port/freebsd/freebsd_specific.cc | |
212 | ;; | |
20effc67 TL |
213 | GNU/kFreeBSD) |
214 | PLATFORM=OS_GNU_KFREEBSD | |
215 | COMMON_FLAGS="$COMMON_FLAGS -DOS_GNU_KFREEBSD" | |
216 | if [ -z "$USE_CLANG" ]; then | |
217 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp" | |
218 | else | |
219 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic" | |
220 | fi | |
221 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt" | |
222 | # PORT_FILES=port/gnu_kfreebsd/gnu_kfreebsd_specific.cc | |
223 | ;; | |
7c673cae FG |
224 | NetBSD) |
225 | PLATFORM=OS_NETBSD | |
226 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_NETBSD" | |
227 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lgcc_s" | |
228 | # PORT_FILES=port/netbsd/netbsd_specific.cc | |
229 | ;; | |
230 | OpenBSD) | |
231 | PLATFORM=OS_OPENBSD | |
11fdf7f2 | 232 | CXX=clang++ |
7c673cae FG |
233 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_OPENBSD" |
234 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread" | |
235 | # PORT_FILES=port/openbsd/openbsd_specific.cc | |
11fdf7f2 TL |
236 | FIND=gfind |
237 | WATCH=gnuwatch | |
7c673cae FG |
238 | ;; |
239 | DragonFly) | |
240 | PLATFORM=OS_DRAGONFLYBSD | |
241 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_DRAGONFLYBSD" | |
242 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread" | |
243 | # PORT_FILES=port/dragonfly/dragonfly_specific.cc | |
244 | ;; | |
245 | Cygwin) | |
246 | PLATFORM=CYGWIN | |
247 | PLATFORM_SHARED_CFLAGS="" | |
248 | PLATFORM_CXXFLAGS="-std=gnu++11" | |
249 | COMMON_FLAGS="$COMMON_FLAGS -DCYGWIN" | |
250 | if [ -z "$USE_CLANG" ]; then | |
251 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp" | |
11fdf7f2 TL |
252 | else |
253 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic" | |
7c673cae FG |
254 | fi |
255 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt" | |
256 | # PORT_FILES=port/linux/linux_specific.cc | |
257 | ;; | |
258 | OS_ANDROID_CROSSCOMPILE) | |
259 | PLATFORM=OS_ANDROID | |
260 | COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_ANDROID -DROCKSDB_PLATFORM_POSIX" | |
261 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS " # All pthread features are in the Android C library | |
262 | # PORT_FILES=port/android/android.cc | |
263 | CROSS_COMPILE=true | |
264 | ;; | |
265 | *) | |
266 | echo "Unknown platform!" >&2 | |
267 | exit 1 | |
268 | esac | |
269 | ||
270 | PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS ${CXXFLAGS}" | |
271 | JAVA_LDFLAGS="$PLATFORM_LDFLAGS" | |
272 | JAVA_STATIC_LDFLAGS="$PLATFORM_LDFLAGS" | |
20effc67 | 273 | JAVAC_ARGS="-source 7" |
7c673cae FG |
274 | |
275 | if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then | |
276 | # Cross-compiling; do not try any compilation tests. | |
277 | # Also don't need any compilation tests if compiling on fbcode | |
20effc67 TL |
278 | if [ "$FBCODE_BUILD" = "true" ]; then |
279 | # Enable backtrace on fbcode since the necessary libraries are present | |
280 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE" | |
281 | fi | |
7c673cae FG |
282 | true |
283 | else | |
284 | if ! test $ROCKSDB_DISABLE_FALLOCATE; then | |
285 | # Test whether fallocate is available | |
286 | $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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/ | |
302 | $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
20effc67 | 317 | if $CXX $CFLAGS -x c++ - -o /dev/null 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 | |
326 | elif $CXX $CFLAGS -x c++ - -o /dev/null 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 $CFLAGS -x c++ - -o /dev/null 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 | |
348 | $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
361 | $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
374 | $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
388 | $CXX $CFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
401 | $CXX $CFLAGS -x c++ - -o /dev/null -lnuma 2>/dev/null <<EOF | |
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 | |
415 | $CXX $CFLAGS $LDFLAGS -x c++ - -o /dev/null -ltbb 2>/dev/null <<EOF | |
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 | |
428 | if echo 'int main() {}' | $CXX $CFLAGS -x c++ - -o /dev/null -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 | |
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 FG |
448 | # jemalloc is not available. Let's try tcmalloc |
449 | if echo 'int main() {}' | $CXX $CFLAGS -x c++ - -o /dev/null \ | |
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 | |
458 | $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
473 | $CXX $CFLAGS $COMMON_FLAGS -lmemkind -x c++ - -o /dev/null 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 | ||
11fdf7f2 TL |
487 | if ! test $ROCKSDB_DISABLE_PTHREAD_MUTEX_ADAPTIVE_NP; then |
488 | # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available | |
489 | $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
504 | $CXX $CFLAGS -x c++ - -o /dev/null 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 | |
516 | $CXX $CFLAGS -lexecinfo -x c++ - -o /dev/null 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 | |
7c673cae FG |
528 | fi |
529 | fi | |
530 | ||
11fdf7f2 TL |
531 | if ! test $ROCKSDB_DISABLE_PG; then |
532 | # Test if -pg is supported | |
533 | $CXX $CFLAGS -pg -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
545 | $CXX $CFLAGS -x c++ - -o /dev/null 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 $CFLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
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 | |
573 | $CXX $CFLAGS -x c++ - -o /dev/null 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 | ||
494da23a TL |
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 /dev/null 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 | |
7c673cae FG |
595 | fi |
596 | ||
597 | # TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning. | |
598 | # -Wshorten-64-to-32 breaks compilation on FreeBSD i386 | |
599 | if ! [ "$TARGET_OS" = FreeBSD -a "$TARGET_ARCHITECTURE" = i386 ]; then | |
600 | # Test whether -Wshorten-64-to-32 is available | |
601 | $CXX $CFLAGS -x c++ - -o /dev/null -Wshorten-64-to-32 2>/dev/null <<EOF | |
602 | int main() {} | |
603 | EOF | |
604 | if [ "$?" = 0 ]; then | |
605 | COMMON_FLAGS="$COMMON_FLAGS -Wshorten-64-to-32" | |
606 | fi | |
607 | fi | |
608 | ||
609 | # shall we use HDFS? | |
610 | ||
611 | if test "$USE_HDFS"; then | |
612 | if test -z "$JAVA_HOME"; then | |
f67539c2 | 613 | echo "JAVA_HOME has to be set for HDFS usage." >&2 |
7c673cae FG |
614 | exit 1 |
615 | fi | |
494da23a TL |
616 | HDFS_CCFLAGS="$HDFS_CCFLAGS -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -DUSE_HDFS -I$HADOOP_HOME/include" |
617 | HDFS_LDFLAGS="$HDFS_LDFLAGS -lhdfs -L$JAVA_HOME/jre/lib/amd64 -L$HADOOP_HOME/lib/native" | |
7c673cae FG |
618 | HDFS_LDFLAGS="$HDFS_LDFLAGS -L$JAVA_HOME/jre/lib/amd64/server -L$GLIBC_RUNTIME_PATH/lib" |
619 | HDFS_LDFLAGS="$HDFS_LDFLAGS -ldl -lverify -ljava -ljvm" | |
620 | COMMON_FLAGS="$COMMON_FLAGS $HDFS_CCFLAGS" | |
621 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS $HDFS_LDFLAGS" | |
622 | JAVA_LDFLAGS="$JAVA_LDFLAGS $HDFS_LDFLAGS" | |
623 | fi | |
624 | ||
f67539c2 | 625 | if test "0$PORTABLE" -eq 0; then |
7c673cae FG |
626 | if test -n "`echo $TARGET_ARCHITECTURE | grep ^ppc64`"; then |
627 | # Tune for this POWER processor, treating '+' models as base models | |
628 | POWER=`LD_SHOW_AUXV=1 /bin/true | grep AT_PLATFORM | grep -E -o power[0-9]+` | |
629 | COMMON_FLAGS="$COMMON_FLAGS -mcpu=$POWER -mtune=$POWER " | |
630 | elif test -n "`echo $TARGET_ARCHITECTURE | grep ^s390x`"; then | |
631 | COMMON_FLAGS="$COMMON_FLAGS -march=z10 " | |
f67539c2 | 632 | elif test -n "`echo $TARGET_ARCHITECTURE | grep -e^arm -e^aarch64`"; then |
11fdf7f2 TL |
633 | # TODO: Handle this with approprite options. |
634 | COMMON_FLAGS="$COMMON_FLAGS" | |
f67539c2 TL |
635 | elif test -n "`echo $TARGET_ARCHITECTURE | grep ^aarch64`"; then |
636 | COMMON_FLAGS="$COMMON_FLAGS" | |
11fdf7f2 TL |
637 | elif [ "$TARGET_OS" == "IOS" ]; then |
638 | COMMON_FLAGS="$COMMON_FLAGS" | |
f67539c2 TL |
639 | elif [ "$TARGET_OS" == "AIX" ] || [ "$TARGET_OS" == "SunOS" ]; then |
640 | # TODO: Not sure why we don't use -march=native on these OSes | |
641 | if test "$USE_SSE"; then | |
642 | TRY_SSE_ETC="1" | |
643 | fi | |
644 | else | |
7c673cae | 645 | COMMON_FLAGS="$COMMON_FLAGS -march=native " |
11fdf7f2 | 646 | fi |
f67539c2 TL |
647 | else |
648 | # PORTABLE=1 | |
649 | if test "$USE_SSE"; then | |
650 | TRY_SSE_ETC="1" | |
651 | fi | |
20effc67 TL |
652 | |
653 | if [[ "${PLATFORM}" == "OS_MACOSX" ]]; then | |
654 | # For portability compile for macOS 10.12 (2016) or newer | |
655 | COMMON_FLAGS="$COMMON_FLAGS -mmacosx-version-min=10.12" | |
656 | PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -mmacosx-version-min=10.12" | |
657 | PLATFORM_SHARED_LDFLAGS="$PLATFORM_SHARED_LDFLAGS -mmacosx-version-min=10.12" | |
658 | fi | |
11fdf7f2 TL |
659 | fi |
660 | ||
f67539c2 TL |
661 | if test "$TRY_SSE_ETC"; then |
662 | # The USE_SSE flag now means "attempt to compile with widely-available | |
663 | # Intel architecture extensions utilized by specific optimizations in the | |
664 | # source code." It's a qualifier on PORTABLE=1 that means "mostly portable." | |
665 | # It doesn't even really check that your current CPU is compatible. | |
666 | # | |
667 | # SSE4.2 available since nehalem, ca. 2008-2010 | |
20effc67 | 668 | # Includes POPCNT for BitsSetToOne, BitParity |
f67539c2 TL |
669 | TRY_SSE42="-msse4.2" |
670 | # PCLMUL available since westmere, ca. 2010-2011 | |
671 | TRY_PCLMUL="-mpclmul" | |
672 | # AVX2 available since haswell, ca. 2013-2015 | |
673 | TRY_AVX2="-mavx2" | |
20effc67 TL |
674 | # BMI available since haswell, ca. 2013-2015 |
675 | # Primarily for TZCNT for CountTrailingZeroBits | |
676 | TRY_BMI="-mbmi" | |
677 | # LZCNT available since haswell, ca. 2013-2015 | |
678 | # For FloorLog2 | |
679 | TRY_LZCNT="-mlzcnt" | |
f67539c2 TL |
680 | fi |
681 | ||
682 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o /dev/null 2>/dev/null <<EOF | |
11fdf7f2 TL |
683 | #include <cstdint> |
684 | #include <nmmintrin.h> | |
685 | int main() { | |
686 | volatile uint32_t x = _mm_crc32_u32(0, 0); | |
f67539c2 | 687 | (void)x; |
11fdf7f2 TL |
688 | } |
689 | EOF | |
690 | if [ "$?" = 0 ]; then | |
f67539c2 | 691 | COMMON_FLAGS="$COMMON_FLAGS $TRY_SSE42 -DHAVE_SSE42" |
11fdf7f2 | 692 | elif test "$USE_SSE"; then |
f67539c2 | 693 | echo "warning: USE_SSE specified but compiler could not use SSE intrinsics, disabling" >&2 |
11fdf7f2 TL |
694 | fi |
695 | ||
f67539c2 | 696 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c++ - -o /dev/null 2>/dev/null <<EOF |
11fdf7f2 TL |
697 | #include <cstdint> |
698 | #include <wmmintrin.h> | |
699 | int main() { | |
700 | const auto a = _mm_set_epi64x(0, 0); | |
701 | const auto b = _mm_set_epi64x(0, 0); | |
702 | const auto c = _mm_clmulepi64_si128(a, b, 0x00); | |
703 | auto d = _mm_cvtsi128_si64(c); | |
f67539c2 | 704 | (void)d; |
11fdf7f2 TL |
705 | } |
706 | EOF | |
707 | if [ "$?" = 0 ]; then | |
f67539c2 | 708 | COMMON_FLAGS="$COMMON_FLAGS $TRY_PCLMUL -DHAVE_PCLMUL" |
11fdf7f2 | 709 | elif test "$USE_SSE"; then |
f67539c2 TL |
710 | echo "warning: USE_SSE specified but compiler could not use PCLMUL intrinsics, disabling" >&2 |
711 | fi | |
712 | ||
713 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_AVX2 -x c++ - -o /dev/null 2>/dev/null <<EOF | |
714 | #include <cstdint> | |
715 | #include <immintrin.h> | |
716 | int main() { | |
717 | const auto a = _mm256_setr_epi32(0, 1, 2, 3, 4, 7, 6, 5); | |
718 | const auto b = _mm256_permutevar8x32_epi32(a, a); | |
719 | (void)b; | |
720 | } | |
721 | EOF | |
722 | if [ "$?" = 0 ]; then | |
723 | COMMON_FLAGS="$COMMON_FLAGS $TRY_AVX2 -DHAVE_AVX2" | |
724 | elif test "$USE_SSE"; then | |
725 | echo "warning: USE_SSE specified but compiler could not use AVX2 intrinsics, disabling" >&2 | |
726 | fi | |
727 | ||
20effc67 TL |
728 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_BMI -x c++ - -o /dev/null 2>/dev/null <<EOF |
729 | #include <cstdint> | |
730 | #include <immintrin.h> | |
731 | int main(int argc, char *argv[]) { | |
732 | (void)argv; | |
733 | return (int)_tzcnt_u64((uint64_t)argc); | |
734 | } | |
735 | EOF | |
736 | if [ "$?" = 0 ]; then | |
737 | COMMON_FLAGS="$COMMON_FLAGS $TRY_BMI -DHAVE_BMI" | |
738 | elif test "$USE_SSE"; then | |
739 | echo "warning: USE_SSE specified but compiler could not use BMI intrinsics, disabling" >&2 | |
740 | fi | |
741 | ||
742 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_LZCNT -x c++ - -o /dev/null 2>/dev/null <<EOF | |
743 | #include <cstdint> | |
744 | #include <immintrin.h> | |
745 | int main(int argc, char *argv[]) { | |
746 | (void)argv; | |
747 | return (int)_lzcnt_u64((uint64_t)argc); | |
748 | } | |
749 | EOF | |
750 | if [ "$?" = 0 ]; then | |
751 | COMMON_FLAGS="$COMMON_FLAGS $TRY_LZCNT -DHAVE_LZCNT" | |
752 | elif test "$USE_SSE"; then | |
753 | echo "warning: USE_SSE specified but compiler could not use LZCNT intrinsics, disabling" >&2 | |
754 | fi | |
755 | ||
f67539c2 TL |
756 | $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF |
757 | #include <cstdint> | |
758 | int main() { | |
759 | uint64_t a = 0xffffFFFFffffFFFF; | |
760 | __uint128_t b = __uint128_t(a) * a; | |
761 | a = static_cast<uint64_t>(b >> 64); | |
762 | (void)a; | |
763 | } | |
764 | EOF | |
765 | if [ "$?" = 0 ]; then | |
766 | COMMON_FLAGS="$COMMON_FLAGS -DHAVE_UINT128_EXTENSION" | |
11fdf7f2 TL |
767 | fi |
768 | ||
769 | # iOS doesn't support thread-local storage, but this check would erroneously | |
770 | # succeed because the cross-compiler flags are added by the Makefile, not this | |
771 | # script. | |
772 | if [ "$PLATFORM" != IOS ]; then | |
773 | $CXX $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF | |
774 | #if defined(_MSC_VER) && !defined(__thread) | |
775 | #define __thread __declspec(thread) | |
776 | #endif | |
777 | int main() { | |
778 | static __thread int tls; | |
f67539c2 | 779 | (void)tls; |
11fdf7f2 TL |
780 | } |
781 | EOF | |
782 | if [ "$?" = 0 ]; then | |
783 | COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_SUPPORT_THREAD_LOCAL" | |
7c673cae FG |
784 | fi |
785 | fi | |
786 | ||
20effc67 | 787 | |
f67539c2 TL |
788 | if [ "$FBCODE_BUILD" != "true" -a "$PLATFORM" = OS_LINUX ]; then |
789 | $CXX $COMMON_FLAGS $PLATFORM_SHARED_CFLAGS -x c++ -c - -o test_dl.o 2>/dev/null <<EOF | |
790 | void dummy_func() {} | |
791 | EOF | |
792 | if [ "$?" = 0 ]; then | |
793 | $CXX $COMMON_FLAGS $PLATFORM_SHARED_LDFLAGS test_dl.o -o /dev/null 2>/dev/null | |
794 | if [ "$?" = 0 ]; then | |
795 | EXEC_LDFLAGS+="-ldl" | |
796 | rm -f test_dl.o | |
797 | fi | |
798 | fi | |
799 | fi | |
800 | ||
7c673cae FG |
801 | PLATFORM_CCFLAGS="$PLATFORM_CCFLAGS $COMMON_FLAGS" |
802 | PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS $COMMON_FLAGS" | |
803 | ||
804 | VALGRIND_VER="$VALGRIND_VER" | |
805 | ||
806 | ROCKSDB_MAJOR=`build_tools/version.sh major` | |
807 | ROCKSDB_MINOR=`build_tools/version.sh minor` | |
808 | ROCKSDB_PATCH=`build_tools/version.sh patch` | |
809 | ||
810 | echo "CC=$CC" >> "$OUTPUT" | |
811 | echo "CXX=$CXX" >> "$OUTPUT" | |
20effc67 | 812 | echo "AR=$AR" >> "$OUTPUT" |
7c673cae FG |
813 | echo "PLATFORM=$PLATFORM" >> "$OUTPUT" |
814 | echo "PLATFORM_LDFLAGS=$PLATFORM_LDFLAGS" >> "$OUTPUT" | |
815 | echo "JAVA_LDFLAGS=$JAVA_LDFLAGS" >> "$OUTPUT" | |
816 | echo "JAVA_STATIC_LDFLAGS=$JAVA_STATIC_LDFLAGS" >> "$OUTPUT" | |
20effc67 | 817 | echo "JAVAC_ARGS=$JAVAC_ARGS" >> "$OUTPUT" |
7c673cae FG |
818 | echo "VALGRIND_VER=$VALGRIND_VER" >> "$OUTPUT" |
819 | echo "PLATFORM_CCFLAGS=$PLATFORM_CCFLAGS" >> "$OUTPUT" | |
820 | echo "PLATFORM_CXXFLAGS=$PLATFORM_CXXFLAGS" >> "$OUTPUT" | |
821 | echo "PLATFORM_SHARED_CFLAGS=$PLATFORM_SHARED_CFLAGS" >> "$OUTPUT" | |
822 | echo "PLATFORM_SHARED_EXT=$PLATFORM_SHARED_EXT" >> "$OUTPUT" | |
823 | echo "PLATFORM_SHARED_LDFLAGS=$PLATFORM_SHARED_LDFLAGS" >> "$OUTPUT" | |
824 | echo "PLATFORM_SHARED_VERSIONED=$PLATFORM_SHARED_VERSIONED" >> "$OUTPUT" | |
825 | echo "EXEC_LDFLAGS=$EXEC_LDFLAGS" >> "$OUTPUT" | |
826 | echo "JEMALLOC_INCLUDE=$JEMALLOC_INCLUDE" >> "$OUTPUT" | |
827 | echo "JEMALLOC_LIB=$JEMALLOC_LIB" >> "$OUTPUT" | |
828 | echo "ROCKSDB_MAJOR=$ROCKSDB_MAJOR" >> "$OUTPUT" | |
829 | echo "ROCKSDB_MINOR=$ROCKSDB_MINOR" >> "$OUTPUT" | |
830 | echo "ROCKSDB_PATCH=$ROCKSDB_PATCH" >> "$OUTPUT" | |
831 | echo "CLANG_SCAN_BUILD=$CLANG_SCAN_BUILD" >> "$OUTPUT" | |
832 | echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT" | |
833 | echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT" | |
11fdf7f2 TL |
834 | echo "FIND=$FIND" >> "$OUTPUT" |
835 | echo "WATCH=$WATCH" >> "$OUTPUT" | |
836 | # This will enable some related identifiers for the preprocessor | |
7c673cae FG |
837 | if test -n "$JEMALLOC"; then |
838 | echo "JEMALLOC=1" >> "$OUTPUT" | |
839 | fi | |
11fdf7f2 TL |
840 | # Indicates that jemalloc should be enabled using -ljemalloc flag |
841 | # The alternative is to porvide a direct link to the library via JEMALLOC_LIB | |
842 | # and JEMALLOC_INCLUDE | |
843 | if test -n "$WITH_JEMALLOC_FLAG"; then | |
844 | echo "WITH_JEMALLOC_FLAG=$WITH_JEMALLOC_FLAG" >> "$OUTPUT" | |
845 | fi | |
7c673cae | 846 | echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT" |
f67539c2 TL |
847 | if test -n "$USE_FOLLY_DISTRIBUTED_MUTEX"; then |
848 | echo "USE_FOLLY_DISTRIBUTED_MUTEX=$USE_FOLLY_DISTRIBUTED_MUTEX" >> "$OUTPUT" | |
849 | fi |