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