libmdbx: merge with 0.7 final version

2 files changed, 105 insertions, 48 deletions

diff --git a/libs/libmdbx/src/cmake/compiler.cmake b/libs/libmdbx/src/cmake/compiler.cmake
index 93c2c9f18b..a3bca1ac29 100644
--- a/libs/libmdbx/src/cmake/compiler.cmake
+++ b/libs/libmdbx/src/cmake/compiler.cmake
@@ -17,17 +17,15 @@ cmake_minimum_required(VERSION 3.8.2)
 cmake_policy(PUSH)
 cmake_policy(VERSION 3.8.2)
 
-if (CMAKE_VERSION MATCHES ".*MSVC.*")
+if(CMAKE_VERSION MATCHES ".*MSVC.*" AND CMAKE_VERSION VERSION_LESS 3.16)
   message(FATAL_ERROR "CMake from MSVC kit is unfit! "
-    "Please use the original CMake from https://cmake.org/download/")
+    "Please use MSVC2019 with modern CMake the original CMake from https://cmake.org/download/")
 endif()
 
-if (NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED))
+if(NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED))
   message(FATAL_ERROR "This module required C or C++ to be enabled")
 endif()
 
-include(CMakeDependentOption)
-
 if(CMAKE_CXX_COMPILER_LOADED)
   include(CheckCXXSourceRuns)
   include(CheckCXXSourceCompiles)
@@ -38,6 +36,9 @@ if(CMAKE_C_COMPILER_LOADED)
   include(CheckCSourceCompiles)
   include(CheckCCompilerFlag)
 endif()
+include(CMakeDependentOption)
+include(CheckLibraryExists)
+include(CheckIncludeFiles)
 
 # Check if the same compile family is used for both C and CXX
 if(CMAKE_C_COMPILER_LOADED AND CMAKE_CXX_COMPILER_LOADED AND
@@ -150,6 +151,16 @@ if(WIN32 AND CMAKE_COMPILER_IS_GNU${CMAKE_PRIMARY_LANG})
   unset(__GCC_TARGET_MACHINE)
 endif()
 
+if(NOT DEFINED IOS)
+  if(APPLE AND (CMAKE_SYSTEM_NAME STREQUAL "iOS"
+      OR DEFINED CMAKE_IOS_DEVELOPER_ROOT
+      OR DEFINED IOS_PLATFORM OR DEFINED IOS_ARCH))
+    set(IOS TRUE)
+  else()
+    set(IOS FALSE)
+  endif()
+endif()
+
 if(CMAKE_COMPILER_IS_ELBRUSC OR CMAKE_SYSTEM_PROCESSOR MATCHES "e2k.*|E2K.*|elbrus.*|ELBRUS.*")
   set(E2K TRUE)
   set(CMAKE_SYSTEM_ARCH "Elbrus")
@@ -214,6 +225,15 @@ else()
   check_compiler_flag("-Ominimal" CC_HAS_OMINIMAL)
   check_compiler_flag("-ffunction-sections -fdata-sections" CC_HAS_SECTIONS)
   check_compiler_flag("-ffast-math" CC_HAS_FASTMATH)
+  check_compiler_flag("-Wno-attributes" CC_HAS_WNO_ATTRIBUTES)
+
+  # Check for an omp support
+  set(CMAKE_REQUIRED_FLAGS "-fopenmp -Werror")
+  check_cxx_source_compiles("int main(void) {
+    #pragma omp parallel
+    return 0;
+    }" HAVE_OPENMP)
+  set(CMAKE_REQUIRED_FLAGS "")
 endif()
 
 # Check for LTO support by GCC
@@ -276,7 +296,7 @@ if(CMAKE_COMPILER_IS_GNU${CMAKE_PRIMARY_LANG})
 endif()
 
 # check for LTO by MSVC
-if(MSVC)
+if(MSVC AND NOT CMAKE_COMPILER_IS_CLANG)
   if(NOT MSVC_VERSION LESS 1600)
     set(MSVC_LTO_AVAILABLE TRUE)
     message(STATUS "Link-Time Optimization by MSVC is available")
@@ -290,25 +310,37 @@ endif()
 if(CMAKE_COMPILER_IS_CLANG)
   if(NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 3.5)
     execute_process(COMMAND ${CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER} -print-search-dirs
-      OUTPUT_VARIABLE clang_search_dirs)
+      OUTPUT_VARIABLE clang_search_dirs RESULT_VARIABLE clang_probe_result ERROR_QUIET)
 
     unset(clang_bindir)
     unset(clang_libdir)
-    string(REGEX MATCH "^(.*programs: =)([^:]*:)*([^:]+/llvm[-.0-9]+/bin[^:]*)(:[^:]*)*(\n.+)$" clang_bindir_valid ${clang_search_dirs})
-    if(clang_bindir_valid)
-      string(REGEX REPLACE "^(.*programs: =)([^:]*:)*([^:]+/llvm[-.0-9]+/bin[^:]*)(:[^:]*)*(\n.+)$" "\\3" clang_bindir ${clang_search_dirs})
-      get_filename_component(clang_libdir "${clang_bindir}/../lib" REALPATH)
-      if(clang_libdir)
-        message(STATUS "Found CLANG/LLVM directories: ${clang_bindir}, ${clang_libdir}")
+    if(clang_probe_result EQUAL 0)
+        string(REGEX MATCH "^(.*programs: =)([^:]*:)*([^:]+/llvm[-.0-9]+/bin[^:]*)(:[^:]*)*(\n.+)$" clang_bindir_valid ${clang_search_dirs})
+        if(clang_bindir_valid)
+          string(REGEX REPLACE "^(.*programs: =)([^:]*:)*([^:]+/llvm[-.0-9]+/bin[^:]*)(:[^:]*)*(\n.+)$" "\\3" clang_bindir ${clang_search_dirs})
+          if(CMAKE_SYSTEM_NAME STREQUAL "WINDOWS")
+            set(clang_libdir ${clang_bindir})
+          else()
+            get_filename_component(clang_libdir "${clang_bindir}/../lib" REALPATH)
+          endif()
+        endif()
+    else()
+      get_filename_component(clang_bindir ${CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER} DIRECTORY)
+      if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+        set(clang_libdir ${clang_bindir})
+      else()
+        get_filename_component(clang_libdir "${clang_bindir}/../lib" REALPATH)
       endif()
     endif()
 
-    if(NOT (clang_bindir AND clang_libdir))
+    if(clang_bindir AND clang_libdir)
+      message(STATUS "Found CLANG/LLVM directories: ${clang_bindir}, ${clang_libdir}")
+    else()
       message(STATUS "Could NOT find CLANG/LLVM directories (bin and/or lib).")
     endif()
 
     if(NOT CMAKE_CLANG_LD AND clang_bindir)
-      find_program(CMAKE_CLANG_LD NAMES llvm-link link llvm-ld ld PATHS ${clang_bindir} NO_DEFAULT_PATH)
+      find_program(CMAKE_CLANG_LD NAMES lld-link ld.lld ld64.lld lld-link llvm-link link llvm-ld ld PATHS ${clang_bindir} NO_DEFAULT_PATH)
     endif()
     if(NOT CMAKE_CLANG_AR AND clang_bindir)
       find_program(CMAKE_CLANG_AR NAMES llvm-ar ar PATHS ${clang_bindir} NO_DEFAULT_PATH)
@@ -346,19 +378,19 @@ if(CMAKE_COMPILER_IS_CLANG)
     unset(clang_search_dirs)
   endif()
 
-  if((CLANG_LTO_PLUGIN AND CMAKE_LD_GOLD) AND
+  if((CLANG_LTO_PLUGIN AND CMAKE_LD_GOLD) OR
       (CMAKE_CLANG_LD AND CMAKE_CLANG_AR AND CMAKE_CLANG_NM AND CMAKE_CLANG_RANLIB))
     set(CLANG_LTO_AVAILABLE TRUE)
     message(STATUS "Link-Time Optimization by CLANG/LLVM is available")
   elseif(CMAKE_TOOLCHAIN_FILE AND NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 7.0)
     set(CLANG_LTO_AVAILABLE TRUE)
-    if (NOT CMAKE_CLANG_AR)
+    if(NOT CMAKE_CLANG_AR)
       set(CMAKE_CLANG_AR ${CMAKE_AR})
     endif()
-    if (NOT CMAKE_CLANG_NM)
+    if(NOT CMAKE_CLANG_NM)
       set(CMAKE_CLANG_NM ${CMAKE_NM})
     endif()
-    if (NOT CMAKE_CLANG_RANLIB)
+    if(NOT CMAKE_CLANG_RANLIB)
       set(CMAKE_CLANG_RANLIB ${CMAKE_RANLIB})
     endif()
     message(STATUS "Assume Link-Time Optimization by CLANG/LLVM is available via ${CMAKE_TOOLCHAIN_FILE}")
@@ -408,7 +440,7 @@ if(ENABLE_BACKTRACE)
 endif()
 
 macro(setup_compile_flags)
-  # LY: save initial C/CXX flags
+  # save initial C/CXX flags
   if(NOT INITIAL_CMAKE_FLAGS_SAVED)
     if(MSVC)
       string(REGEX REPLACE "^(.*)(/EHsc)( *)(.*)$" "\\1/EHs\\3\\4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
@@ -422,7 +454,7 @@ macro(setup_compile_flags)
     set(INITIAL_CMAKE_FLAGS_SAVED TRUE CACHE INTERNAL "State of initial CMake's flags" FORCE)
   endif()
 
-  # LY: reset C/CXX flags
+  # reset C/CXX flags
   set(CXX_FLAGS ${INITIAL_CMAKE_CXX_FLAGS})
   set(C_FLAGS ${INITIAL_CMAKE_C_FLAGS})
   set(EXE_LINKER_FLAGS ${INITIAL_CMAKE_EXE_LINKER_FLAGS})
@@ -437,6 +469,12 @@ macro(setup_compile_flags)
     add_compile_flags("CXX" "-fcxx-exceptions -frtti")
   endif()
 
+  if(CC_HAS_WNO_ATTRIBUTES AND CMAKE_COMPILER_IS_GNU${CMAKE_PRIMARY_LANG}
+      AND CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 9)
+    # GCC < 9.x generates false-positive warnings for optimization attributes
+    add_compile_flags("C;CXX" "-Wno-attributes")
+  endif()
+
   # In C a global variable without a storage specifier (static/extern) and
   # without an initialiser is called a ’tentative definition’. The
   # language permits multiple tentative definitions in the single
@@ -482,7 +520,7 @@ macro(setup_compile_flags)
   endif()
 
   if(MSVC)
-    if (MSVC_VERSION LESS 1900)
+    if(MSVC_VERSION LESS 1900)
       message(FATAL_ERROR "At least \"Microsoft C/C++ Compiler\" version 19.0.24234.1 (Visual Studio 2015 Update 3) is required.")
     endif()
     add_compile_flags("CXX" "/Zc:__cplusplus")
@@ -514,11 +552,11 @@ macro(setup_compile_flags)
     if(MSVC)
       add_compile_flags("C;CXX" "/WX")
     elseif(CMAKE_COMPILER_IS_CLANG)
-      if (NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 6)
+      if(NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 6)
         add_compile_flags("C;CXX" "-Werror")
       endif()
     elseif(CMAKE_COMPILER_IS_GNUCC)
-      if (NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 6)
+      if(NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 6)
         add_compile_flags("C;CXX" "-Werror")
       endif()
     else()
@@ -526,7 +564,7 @@ macro(setup_compile_flags)
     endif()
   endif()
 
-  if (ENABLE_ASAN)
+  if(ENABLE_ASAN)
     add_compile_flags("C;CXX" -fsanitize=address)
   endif()
 
@@ -564,7 +602,7 @@ macro(setup_compile_flags)
     endif()
   endif()
 
-  if(MSVC AND LTO_ENABLED)
+  if(MSVC AND NOT CMAKE_COMPILER_IS_CLANG AND LTO_ENABLED)
     add_compile_flags("C;CXX" "/GL")
     foreach(linkmode IN ITEMS EXE SHARED STATIC MODULE)
       set(${linkmode}_LINKER_FLAGS "${${linkmode}_LINKER_FLAGS} /LTCG")
@@ -617,12 +655,14 @@ macro(setup_compile_flags)
       set(CLANG_LTO_FLAG "-flto=thin")
     endif()
     add_compile_flags("C;CXX" ${CLANG_LTO_FLAG})
-    set(EXE_LINKER_FLAGS "${EXE_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm -fwhole-program")
-    set(SHARED_LINKER_FLAGS "${SHARED_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm")
-    set(MODULE_LINKER_FLAGS "${MODULE_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm")
+    if(NOT MSVC)
+      set(EXE_LINKER_FLAGS "${EXE_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm -fwhole-program")
+      set(SHARED_LINKER_FLAGS "${SHARED_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm")
+      set(MODULE_LINKER_FLAGS "${MODULE_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm")
+    endif()
   endif()
 
-  # LY: push C/CXX flags into the cache
+  # push C/CXX flags into the cache
   set(CMAKE_CXX_FLAGS ${CXX_FLAGS} CACHE STRING "Flags used by the C++ compiler during all build types" FORCE)
   set(CMAKE_C_FLAGS ${C_FLAGS} CACHE STRING "Flags used by the C compiler during all build types" FORCE)
   set(CMAKE_EXE_LINKER_FLAGS ${EXE_LINKER_FLAGS} CACHE STRING "Flags used by the linker" FORCE)
@@ -640,11 +680,11 @@ endmacro(setup_compile_flags)
 # determine library for for std::filesystem
 set(LIBCXX_FILESYSTEM "")
 if(CMAKE_COMPILER_IS_GNUCXX)
-  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
     set(LIBCXX_FILESYSTEM "stdc++fs")
   endif()
-elseif (CMAKE_COMPILER_IS_CLANG)
-  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+elseif(CMAKE_COMPILER_IS_CLANG)
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
     set(LIBCXX_FILESYSTEM "c++experimental")
   else()
     set(LIBCXX_FILESYSTEM "stdc++fs")
diff --git a/libs/libmdbx/src/cmake/utils.cmake b/libs/libmdbx/src/cmake/utils.cmake
index 22e0d72f57..13add097dc 100644
--- a/libs/libmdbx/src/cmake/utils.cmake
+++ b/libs/libmdbx/src/cmake/utils.cmake
@@ -61,7 +61,7 @@ macro(set_source_files_compile_flags)
   unset(_lang)
 endmacro(set_source_files_compile_flags)
 
-macro(fetch_version name version_file)
+macro(fetch_version name version_file parent_scope)
   set(${name}_VERSION "")
   set(${name}_GIT_DESCRIBE "")
   set(${name}_GIT_TIMESTAMP "")
@@ -69,7 +69,7 @@ macro(fetch_version name version_file)
   set(${name}_GIT_COMMIT "")
   set(${name}_GIT_REVISION 0)
   set(${name}_GIT_VERSION "")
-  if(GIT)
+  if(GIT AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git")
     execute_process(COMMAND ${GIT} describe --tags --long --dirty=-dirty
       OUTPUT_VARIABLE ${name}_GIT_DESCRIBE
       OUTPUT_STRIP_TRAILING_WHITESPACE
@@ -137,7 +137,9 @@ macro(fetch_version name version_file)
   endif()
 
   if(NOT ${name}_GIT_VERSION OR NOT ${name}_GIT_TIMESTAMP OR NOT ${name}_GIT_REVISION)
-    message(WARNING "Unable to retrive ${name} version from git.")
+    if(GIT AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git")
+      message(WARNING "Unable to retrive ${name} version from git.")
+    endif()
     set(${name}_GIT_VERSION "0;0;0;0")
     set(${name}_GIT_TIMESTAMP "")
     set(${name}_GIT_REVISION 0)
@@ -166,18 +168,33 @@ macro(fetch_version name version_file)
   list(GET ${name}_VERSION_LIST 2 "${name}_VERSION_RELEASE")
   list(GET ${name}_VERSION_LIST 3 "${name}_VERSION_REVISION")
 
-  set(${name}_VERSION_MAJOR ${${name}_VERSION_MAJOR} PARENT_SCOPE)
-  set(${name}_VERSION_MINOR ${${name}_VERSION_MINOR} PARENT_SCOPE)
-  set(${name}_VERSION_RELEASE ${${name}_VERSION_RELEASE} PARENT_SCOPE)
-  set(${name}_VERSION_REVISION ${${name}_VERSION_REVISION} PARENT_SCOPE)
-  set(${name}_VERSION ${${name}_VERSION} PARENT_SCOPE)
-
-  set(${name}_GIT_DESCRIBE ${${name}_GIT_DESCRIBE} PARENT_SCOPE)
-  set(${name}_GIT_TIMESTAMP ${${name}_GIT_TIMESTAMP} PARENT_SCOPE)
-  set(${name}_GIT_TREE ${${name}_GIT_TREE} PARENT_SCOPE)
-  set(${name}_GIT_COMMIT ${${name}_GIT_COMMIT} PARENT_SCOPE)
-  set(${name}_GIT_REVISION ${${name}_GIT_REVISION} PARENT_SCOPE)
-  set(${name}_GIT_VERSION ${${name}_GIT_VERSION} PARENT_SCOPE)
+  if(parent_scope)
+    set(${name}_VERSION_MAJOR ${${name}_VERSION_MAJOR} PARENT_SCOPE)
+    set(${name}_VERSION_MINOR ${${name}_VERSION_MINOR} PARENT_SCOPE)
+    set(${name}_VERSION_RELEASE ${${name}_VERSION_RELEASE} PARENT_SCOPE)
+    set(${name}_VERSION_REVISION ${${name}_VERSION_REVISION} PARENT_SCOPE)
+    set(${name}_VERSION ${${name}_VERSION} PARENT_SCOPE)
+
+    set(${name}_GIT_DESCRIBE ${${name}_GIT_DESCRIBE} PARENT_SCOPE)
+    set(${name}_GIT_TIMESTAMP ${${name}_GIT_TIMESTAMP} PARENT_SCOPE)
+    set(${name}_GIT_TREE ${${name}_GIT_TREE} PARENT_SCOPE)
+    set(${name}_GIT_COMMIT ${${name}_GIT_COMMIT} PARENT_SCOPE)
+    set(${name}_GIT_REVISION ${${name}_GIT_REVISION} PARENT_SCOPE)
+    set(${name}_GIT_VERSION ${${name}_GIT_VERSION} PARENT_SCOPE)
+  else()
+    set(${name}_VERSION_MAJOR ${${name}_VERSION_MAJOR})
+    set(${name}_VERSION_MINOR ${${name}_VERSION_MINOR})
+    set(${name}_VERSION_RELEASE ${${name}_VERSION_RELEASE})
+    set(${name}_VERSION_REVISION ${${name}_VERSION_REVISION})
+    set(${name}_VERSION ${${name}_VERSION})
+
+    set(${name}_GIT_DESCRIBE ${${name}_GIT_DESCRIBE})
+    set(${name}_GIT_TIMESTAMP ${${name}_GIT_TIMESTAMP})
+    set(${name}_GIT_TREE ${${name}_GIT_TREE})
+    set(${name}_GIT_COMMIT ${${name}_GIT_COMMIT})
+    set(${name}_GIT_REVISION ${${name}_GIT_REVISION})
+    set(${name}_GIT_VERSION ${${name}_GIT_VERSION})
+  endif()
 endmacro(fetch_version)
 
 cmake_policy(POP)