CMake/HPHPFindLibs.cmake

   1 #
   2 #   +----------------------------------------------------------------------+
   3 #   | HipHop for PHP                                                       |
   4 #   +----------------------------------------------------------------------+
   5 #   | Copyright (c) 2010 Facebook, Inc. (http://www.facebook.com)          |
   6 #   | Copyright (c) 1997-2010 The PHP Group                                |
   7 #   +----------------------------------------------------------------------+
   8 #   | This source file is subject to version 3.01 of the PHP license,      |
   9 #   | that is bundled with this package in the file LICENSE, and is        |
  10 #   | available through the world-wide-web at the following url:           |
  11 #   | http://www.php.net/license/3_01.txt                                  |
  12 #   | If you did not receive a copy of the PHP license and are unable to   |
  13 #   | obtain it through the world-wide-web, please send a note to          |
  14 #   | license@php.net so we can mail you a copy immediately.               |
  15 #   +----------------------------------------------------------------------+
  16 #
  17
  18 include(CheckFunctionExists)
  19
  20 # libdl
  21 find_package(LibDL)
  22 if (LIBDL_INCLUDE_DIRS)
  23   add_definitions("-DHAVE_LIBDL")
  24   include_directories(${LIBDL_INCLUDE_DIRS})
  25   if (LIBDL_NEEDS_UNDERSCORE)
  26     add_definitions("-DLIBDL_NEEDS_UNDERSCORE")
  27   endif()
  28 endif()
  29
  30 # google-glog
  31 find_package(Glog REQUIRED)
  32 if (LIBGLOG_STATIC)
  33   add_definitions("-DGOOGLE_GLOG_DLL_DECL=")
  34 endif()
  35 include_directories(${LIBGLOG_INCLUDE_DIR})
  36
  37 # inotify checks
  38 find_package(Libinotify)
  39 if (LIBINOTIFY_INCLUDE_DIR)
  40   include_directories(${LIBINOTIFY_INCLUDE_DIR})
  41 endif()
  42
  43 # pcre checks
  44 find_package(PCRE)
  45 include_directories(${PCRE_INCLUDE_DIR})
  46
  47 # libevent checks
  48 find_package(LibEvent REQUIRED)
  49 include_directories(${LIBEVENT_INCLUDE_DIR})
  50
  51 set(CMAKE_REQUIRED_LIBRARIES "${LIBEVENT_LIB}")
  52 CHECK_FUNCTION_EXISTS("evhttp_bind_socket_with_fd" HAVE_CUSTOM_LIBEVENT)
  53 if(HAVE_CUSTOM_LIBEVENT)
  54         message("Using custom LIBEVENT")
  55         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAVE_CUSTOM_LIBEVENT")
  56 endif()
  57 set(CMAKE_REQUIRED_LIBRARIES)
  58
  59 # libXed
  60 if (ENABLE_XED)
  61   find_package(LibXed)
  62   if (LibXed_FOUND)
  63     include_directories(${LibXed_INCLUDE_DIR})
  64   endif()
  65   add_definitions("-DHAVE_LIBXED")
  66 else()
  67   message(STATUS "XED is disabled")
  68 endif()
  69
  70 # CURL checks
  71 find_package(CURL REQUIRED)
  72 include_directories(${CURL_INCLUDE_DIR})
  73 if (CURL_STATIC)
  74   add_definitions("-DCURL_STATICLIB")
  75 endif()
  76
  77 set(CMAKE_REQUIRED_LIBRARIES "${CURL_LIBRARIES}")
  78 CHECK_FUNCTION_EXISTS("curl_multi_select" HAVE_CURL_MULTI_SELECT)
  79 CHECK_FUNCTION_EXISTS("curl_multi_wait" HAVE_CURL_MULTI_WAIT)
  80 if (HAVE_CURL_MULTI_SELECT)
  81   add_definitions("-DHAVE_CURL_MULTI_SELECT")
  82 endif()
  83 if (HAVE_CURL_MULTI_WAIT)
  84   add_definitions("-DHAVE_CURL_MULTI_WAIT")
  85 endif()
  86 set(CMAKE_REQUIRED_LIBRARIES)
  87
  88 # LibXML2 checks
  89 find_package(LibXml2 REQUIRED)
  90 include_directories(${LIBXML2_INCLUDE_DIR})
  91 add_definitions(${LIBXML2_DEFINITIONS})
  92
  93 # libsqlite3
  94 find_package(LibSQLite)
  95 if (LIBSQLITE3_INCLUDE_DIR)
  96   include_directories(${LIBSQLITE3_INCLUDE_DIR})
  97 endif ()
  98
  99 # libdouble-conversion
 100 find_package(DoubleConversion)
 101 if (DOUBLE_CONVERSION_INCLUDE_DIR)
 102   include_directories(${DOUBLE_CONVERSION_INCLUDE_DIR})
 103 endif ()
 104
 105 # fastlz
 106 find_package(FastLZ)
 107 if (FASTLZ_INCLUDE_DIR)
 108   include_directories(${FASTLZ_INCLUDE_DIR})
 109 endif()
 110
 111 # ICU
 112 find_package(ICU REQUIRED)
 113 if (ICU_FOUND)
 114   if (ICU_VERSION VERSION_LESS "4.2")
 115     unset(ICU_FOUND CACHE)
 116     unset(ICU_INCLUDE_DIRS CACHE)
 117     unset(ICU_LIBRARIES CACHE)
 118     message(FATAL_ERROR "ICU is too old, found ${ICU_VERSION} and we need 4.2")
 119   endif ()
 120   include_directories(${ICU_INCLUDE_DIRS})
 121   if (ICU_STATIC)
 122     add_definitions("-DU_EXPORT=")
 123     add_definitions("-DU_IMPORT=")
 124   endif()
 125   # Everything is either in the `icu61` namespace or `icu` namespace, depending
 126   # on another definition. There's an implicit `using namespace WHATEVER;` in
 127   # ICU4c < 61.1, but now that's opt-in rather than opt-out.
 128   add_definitions("-DU_USING_ICU_NAMESPACE=1")
 129 endif (ICU_FOUND)
 130
 131 # jemalloc/tmalloc and profiler
 132 if (USE_GOOGLE_HEAP_PROFILER OR USE_GOOGLE_CPU_PROFILER)
 133   FIND_LIBRARY(GOOGLE_PROFILER_LIB profiler)
 134   FIND_PATH(GOOGLE_PROFILER_INCLUDE_DIR NAMES google/profiler.h)
 135   if (GOOGLE_PROFILER_INCLUDE_DIR)
 136     include_directories(${GOOGLE_PROFILER_INCLUDE_DIR})
 137   endif()
 138   if (GOOGLE_PROFILER_LIB)
 139     message(STATUS "Found Google profiler: ${GOOGLE_PROFILER_LIB}")
 140     if (USE_GOOGLE_CPU_PROFILER)
 141       set(GOOGLE_CPU_PROFILER_ENABLED 1)
 142     endif()
 143   else()
 144     message(STATUS "Can't find Google profiler")
 145   endif()
 146 endif()
 147
 148 if (USE_GOOGLE_HEAP_PROFILER AND GOOGLE_PROFILER_LIB)
 149   FIND_LIBRARY(GOOGLE_TCMALLOC_FULL_LIB tcmalloc)
 150   if (GOOGLE_TCMALLOC_FULL_LIB)
 151     message(STATUS "Found full tcmalloc: ${GOOGLE_TCMALLOC_FULL_LIB}")
 152     set(GOOGLE_HEAP_PROFILER_ENABLED 1)
 153     set(GOOGLE_TCMALLOC_ENABLED 1)
 154   else()
 155     message(STATUS "Can't find full tcmalloc - heap profiling is disabled")
 156   endif()
 157 endif()
 158
 159 if(USE_JEMALLOC AND NOT GOOGLE_TCMALLOC_ENABLED)
 160   add_definitions(-DUSE_JEMALLOC=1)
 161   set(JEMALLOC_ENABLED 1)
 162 else()
 163   add_definitions(-DNO_JEMALLOC=1)
 164 endif()
 165
 166 if (USE_TCMALLOC AND NOT JEMALLOC_ENABLED AND NOT GOOGLE_TCMALLOC_ENABLED)
 167   FIND_LIBRARY(GOOGLE_TCMALLOC_MIN_LIB tcmalloc_minimal)
 168   if (GOOGLE_TCMALLOC_MIN_LIB)
 169     message(STATUS "Found minimal tcmalloc: ${GOOGLE_TCMALLOC_MIN_LIB}")
 170     set(GOOGLE_TCMALLOC_ENABLED 1)
 171   else()
 172     message(STATUS "Can't find minimal tcmalloc")
 173   endif()
 174 endif()
 175
 176 if (GOOGLE_TCMALLOC_ENABLED)
 177   add_definitions(-DGOOGLE_TCMALLOC=1)
 178 else()
 179   add_definitions(-DNO_TCMALLOC=1)
 180 endif()
 181 if (GOOGLE_HEAP_PROFILER_ENABLED)
 182   add_definitions(-DGOOGLE_HEAP_PROFILER=1)
 183 endif()
 184 if (GOOGLE_CPU_PROFILER_ENABLED)
 185   add_definitions(-DGOOGLE_CPU_PROFILER=1)
 186 endif()
 187
 188 # HHProf
 189 if (JEMALLOC_ENABLED AND ENABLE_HHPROF)
 190   add_definitions(-DENABLE_HHPROF=1)
 191 endif()
 192
 193 # tbb libs
 194 find_package(TBB REQUIRED)
 195 if (${TBB_INTERFACE_VERSION} LESS 5005)
 196   unset(TBB_FOUND CACHE)
 197   unset(TBB_INCLUDE_DIRS CACHE)
 198   unset(TBB_LIBRARIES CACHE)
 199   message(FATAL_ERROR "TBB is too old, please install at least 3.0(5005), preferably 4.0(6000) or higher")
 200 endif()
 201 include_directories(${TBB_INCLUDE_DIRS})
 202 link_directories(${TBB_LIBRARY_DIRS})
 203
 204 # OpenSSL libs
 205 find_package(OpenSSL REQUIRED)
 206 include_directories(${OPENSSL_INCLUDE_DIR})
 207
 208 # LibreSSL explicitly refuses to support RAND_egd()
 209 SET(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
 210 SET(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_LIBRARIES})
 211 INCLUDE(CheckCXXSourceCompiles)
 212 CHECK_CXX_SOURCE_COMPILES("#include <openssl/rand.h>
 213 int main() {
 214   return RAND_egd(\"/dev/null\");
 215 }" OPENSSL_HAVE_RAND_EGD)
 216 if (NOT OPENSSL_HAVE_RAND_EGD)
 217   add_definitions("-DOPENSSL_NO_RAND_EGD")
 218 endif()
 219 CHECK_CXX_SOURCE_COMPILES("#include <openssl/ssl.h>
 220 int main() {
 221   return SSL_set_alpn_protos(nullptr, nullptr, 0);
 222 }" OPENSSL_HAVE_ALPN)
 223 SET(CMAKE_REQUIRED_INCLUDES)
 224 SET(CMAKE_REQUIRED_LIBRARIES)
 225
 226
 227 # ZLIB
 228 find_package(ZLIB REQUIRED)
 229 include_directories(${ZLIB_INCLUDE_DIR})
 230
 231 # libpthreads
 232 find_package(PThread REQUIRED)
 233 include_directories(${LIBPTHREAD_INCLUDE_DIRS})
 234 if (LIBPTHREAD_STATIC)
 235   add_definitions("-DPTW32_STATIC_LIB")
 236 endif()
 237
 238 OPTION(
 239   NON_DISTRIBUTABLE_BUILD
 240   "Use libraries which may result in a binary that can not be legally distributed"
 241   OFF
 242 )
 243
 244 # Either Readline or Editline (for hphpd)
 245 if(NON_DISTRIBUTABLE_BUILD)
 246   find_package(Readline)
 247 endif()
 248 if (NOT READLINE_INCLUDE_DIR)
 249   find_package(Editline)
 250 endif()
 251
 252 if (NON_DISTRIBUTABLE_BUILD AND READLINE_INCLUDE_DIR)
 253   if (READLINE_STATIC)
 254     add_definitions("-DREADLINE_STATIC")
 255   endif()
 256   include_directories(${READLINE_INCLUDE_DIR})
 257 elseif (EDITLINE_INCLUDE_DIRS)
 258   add_definitions("-DUSE_EDITLINE")
 259   include_directories(${EDITLINE_INCLUDE_DIRS})
 260 else()
 261   message(FATAL_ERROR "Could not find Readline or Editline")
 262 endif()
 263
 264 if (NOT WINDOWS)
 265   find_package(LibDwarf REQUIRED)
 266   include_directories(${LIBDWARF_INCLUDE_DIRS})
 267   if (LIBDWARF_CONST_NAME)
 268     add_definitions("-DLIBDWARF_CONST_NAME")
 269   endif()
 270   if (LIBDWARF_USE_INIT_C)
 271     add_definitions("-DLIBDWARF_USE_INIT_C")
 272   endif()
 273
 274   find_package(LibElf REQUIRED)
 275   include_directories(${LIBELF_INCLUDE_DIRS})
 276   if (ELF_GETSHDRSTRNDX)
 277     add_definitions("-DHAVE_ELF_GETSHDRSTRNDX")
 278   endif()
 279 endif()
 280
 281 FIND_LIBRARY(CRYPT_LIB NAMES xcrypt crypt crypto)
 282 if (LINUX OR FREEBSD)
 283   FIND_LIBRARY (RT_LIB rt)
 284 endif()
 285
 286 if (LINUX)
 287   FIND_LIBRARY (CAP_LIB cap)
 288
 289   if (NOT CAP_LIB)
 290     message(FATAL_ERROR "You need to install libcap")
 291   endif()
 292 endif()
 293
 294 if (LINUX OR APPLE)
 295   FIND_LIBRARY (DL_LIB dl)
 296   FIND_LIBRARY (RESOLV_LIB resolv)
 297 endif()
 298
 299 if (FREEBSD)
 300   FIND_LIBRARY (EXECINFO_LIB execinfo)
 301   if (NOT EXECINFO_LIB)
 302     message(FATAL_ERROR "You need to install libexecinfo")
 303   endif()
 304 endif()
 305
 306 if (APPLE)
 307   find_library(KERBEROS_LIB NAMES gssapi_krb5)
 308
 309   # This is required by Homebrew's libc. See
 310   # https://github.com/facebook/hhvm/pull/5728#issuecomment-124290712
 311   # for more info.
 312   find_package(Libpam)
 313   if (PAM_INCLUDE_PATH)
 314     include_directories(${PAM_INCLUDE_PATH})
 315   endif()
 316 endif()
 317
 318 #find_package(BISON REQUIRED)
 319 #find_package(FLEX REQUIRED)
 320
 321 #if (${FLEX_VERSION} VERSION_LESS 2.5.33)
 322 #  message(FATAL_ERROR "Flex is too old, found ${FLEX_VERSION} and we need 2.5.33")
 323 #endif()
 324
 325 include_directories(${HPHP_HOME}/hphp)
 326
 327 macro(hphp_link target)
 328   # oniguruma must be linked first for MacOS's linker to do the right thing -
 329   # that's handled in HPHPSetup.cmake
 330   #
 331   # That only handles linking - we still need to make sure that:
 332   # - oniguruma is built first, if needed (so we have the header files)
 333   # - we build with the header files in the include path
 334   if(APPLE)
 335     add_dependencies(${target} onig)
 336     target_include_directories(${target} PRIVATE $<TARGET_PROPERTY:onig,INTERFACE_INCLUDE_DIRECTORIES>)
 337   else()
 338     # Otherwise, the linker does the right thing, which sometimes means putting it after things that use it
 339     target_link_libraries(${target} onig)
 340   endif()
 341
 342   if (LIBDL_LIBRARIES)
 343     target_link_libraries(${target} ${LIBDL_LIBRARIES})
 344   endif ()
 345
 346   if (JEMALLOC_ENABLED)
 347     target_link_libraries(${target} jemalloc)
 348     add_dependencies(${target} jemalloc)
 349   endif ()
 350
 351   if (GOOGLE_HEAP_PROFILER_ENABLED OR GOOGLE_CPU_PROFILER_ENABLED)
 352     target_link_libraries(${target} ${GOOGLE_PROFILER_LIB})
 353   endif()
 354
 355   if (GOOGLE_HEAP_PROFILER_ENABLED)
 356     target_link_libraries(${target} ${GOOGLE_TCMALLOC_FULL_LIB})
 357   elseif (GOOGLE_TCMALLOC_ENABLED)
 358     target_link_libraries(${target} ${GOOGLE_TCMALLOC_MIN_LIB})
 359   endif()
 360
 361   add_dependencies(${target} boostMaybeBuild)
 362   target_link_libraries(${target} boost)
 363   add_dependencies(${target} libsodiumMaybeBuild)
 364   target_link_libraries(${target} libsodium)
 365
 366   target_link_libraries(${target} ${PCRE_LIBRARY})
 367   target_link_libraries(${target} ${ICU_DATA_LIBRARIES} ${ICU_I18N_LIBRARIES} ${ICU_LIBRARIES})
 368   target_link_libraries(${target} ${LIBEVENT_LIB})
 369   target_link_libraries(${target} ${CURL_LIBRARIES})
 370   target_link_libraries(${target} ${LIBGLOG_LIBRARY})
 371   if (LIBJSONC_LIBRARY)
 372     target_link_libraries(${target} ${LIBJSONC_LIBRARY})
 373   endif()
 374
 375   if (LIBINOTIFY_LIBRARY)
 376     target_link_libraries(${target} ${LIBINOTIFY_LIBRARY})
 377   endif()
 378
 379   if (LINUX)
 380     target_link_libraries(${target} ${CAP_LIB})
 381   endif()
 382
 383   if (LINUX OR APPLE)
 384     target_link_libraries(${target} ${RESOLV_LIB})
 385     target_link_libraries(${target} ${DL_LIB})
 386   endif()
 387
 388   if (FREEBSD)
 389     target_link_libraries(${target} ${EXECINFO_LIB})
 390   endif()
 391
 392   if (APPLE)
 393     target_link_libraries(${target} ${LIBINTL_LIBRARIES})
 394     target_link_libraries(${target} ${KERBEROS_LIB})
 395
 396     if (PAM_LIBRARY)
 397       target_link_libraries(${target} ${PAM_LIBRARY})
 398     endif()
 399   endif()
 400
 401   if (LIBPTHREAD_LIBRARIES)
 402     target_link_libraries(${target} ${LIBPTHREAD_LIBRARIES})
 403   endif()
 404
 405   target_link_libraries(${target} ${TBB_LIBRARIES})
 406   target_link_libraries(${target} ${OPENSSL_LIBRARIES})
 407   target_link_libraries(${target} ${ZLIB_LIBRARIES})
 408
 409   target_link_libraries(${target} ${LIBXML2_LIBRARIES})
 410
 411   target_link_libraries(${target} ${LBER_LIBRARIES})
 412
 413   if (CRYPT_LIB)
 414     target_link_libraries(${target} ${CRYPT_LIB})
 415   endif()
 416
 417   if (LINUX OR FREEBSD)
 418     target_link_libraries(${target} ${RT_LIB})
 419   endif()
 420
 421   if (LIBSQLITE3_FOUND AND LIBSQLITE3_LIBRARY)
 422     target_link_libraries(${target} ${LIBSQLITE3_LIBRARY})
 423   else()
 424     target_link_libraries(${target} sqlite3)
 425   endif()
 426
 427   if (DOUBLE_CONVERSION_FOUND)
 428     target_link_libraries(${target} ${DOUBLE_CONVERSION_LIBRARY})
 429   else()
 430     target_link_libraries(${target} double-conversion)
 431   endif()
 432
 433   target_link_libraries(${target} lz4)
 434   target_link_libraries(${target} libzip)
 435
 436   if (PCRE_LIBRARY)
 437     target_link_libraries(${target} ${PCRE_LIBRARY})
 438   else()
 439     target_link_libraries(${target} pcre)
 440   endif()
 441
 442   if (LIBFASTLZ_LIBRARY)
 443     target_link_libraries(${target} ${LIBFASTLZ_LIBRARY})
 444   else()
 445     target_link_libraries(${target} fastlz)
 446   endif()
 447
 448   target_link_libraries(${target} timelib)
 449   target_link_libraries(${target} folly)
 450   target_link_libraries(${target} wangle)
 451   target_link_libraries(${target} brotli)
 452
 453   if (ENABLE_MCROUTER)
 454     target_link_libraries(${target} mcrouter)
 455   endif()
 456
 457   if (NOT MSVC)
 458     target_link_libraries(${target} afdt)
 459   endif()
 460   target_link_libraries(${target} mbfl)
 461
 462   if (EDITLINE_LIBRARIES)
 463     target_link_libraries(${target} ${EDITLINE_LIBRARIES})
 464   elseif (READLINE_LIBRARY)
 465     target_link_libraries(${target} ${READLINE_LIBRARY})
 466   endif()
 467
 468   if (NOT WINDOWS)
 469     target_link_libraries(${target} ${LIBDWARF_LIBRARIES})
 470     target_link_libraries(${target} ${LIBELF_LIBRARIES})
 471   endif()
 472
 473   if (LINUX)
 474     target_link_libraries(${target})
 475   endif()
 476
 477   if (MSVC)
 478     target_link_libraries(${target} dbghelp.lib dnsapi.lib)
 479   endif()
 480
 481 # Check whether atomic operations require -latomic or not
 482 # See https://github.com/facebook/hhvm/issues/5217
 483   include(CheckCXXSourceCompiles)
 484   set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
 485   set(CMAKE_REQUIRED_FLAGS "-std=c++1y")
 486   CHECK_CXX_SOURCE_COMPILES("
 487 #include <atomic>
 488 #include <iostream>
 489 #include <stdint.h>
 490 int main() {
 491     struct Test { int64_t val1; int64_t val2; };
 492     std::atomic<Test> s;
 493     // Do this to stop modern compilers from optimizing away the libatomic
 494     // calls in release builds, making this test always pass in release builds,
 495     // and incorrectly think that HHVM doesn't need linking against libatomic.
 496     bool (std::atomic<Test>::* volatile x)(void) const =
 497       &std::atomic<Test>::is_lock_free;
 498     std::cout << (s.*x)() << std::endl;
 499 }
 500   " NOT_REQUIRE_ATOMIC_LINKER_FLAG)
 501
 502   if(NOT "${NOT_REQUIRE_ATOMIC_LINKER_FLAG}")
 503       message(STATUS "-latomic is required to link hhvm")
 504       find_library(ATOMIC_LIBRARY NAMES atomic libatomic.so.1)
 505       target_link_libraries(${target} ${ATOMIC_LIBRARY})
 506   endif()
 507   set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
 508
 509   if (ENABLE_XED)
 510     if (LibXed_FOUND)
 511         target_link_libraries(${target} ${LibXed_LIBRARY})
 512     else()
 513         target_link_libraries(${target} xed)
 514     endif()
 515   endif()
 516 endmacro()