Merge pull request #37222 from ClickHouse/cmake-cleanup-pt2

Cmake cleanup pt2
2024-11-26 09:32:01 +00:00 · 2022-05-16 09:28:37 +02:00 · 2022-05-16 09:28:37 +02:00 · f7de28ce4a
commit f7de28ce4a
parent c430fa3a7c 95d28973aa
5 changed files with 53 additions and 74 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -16,6 +16,7 @@ endif()
 include (cmake/arch.cmake)
 include (cmake/target.cmake)
 include (cmake/tools.cmake)
+include (cmake/ccache.cmake)
 include (cmake/clang_tidy.cmake)
 include (cmake/git_status.cmake)

@ -38,8 +39,6 @@ if (NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/sysroot/README.md")
    message (FATAL_ERROR "Submodules are not initialized. Run\n\tgit submodule update --init --recursive")
 endif ()

-include (cmake/ccache.cmake)
-
 # Take care to add prlimit in command line before ccache, or else ccache thinks that
 # prlimit is compiler, and clang++ is its input file, and refuses to work  with
 # multiple inputs, e.g in ccache log:
@ -472,8 +471,7 @@ endif ()
 message (STATUS
    "Building for: ${CMAKE_SYSTEM} ${CMAKE_SYSTEM_PROCESSOR} ${CMAKE_LIBRARY_ARCHITECTURE} ;
    USE_STATIC_LIBRARIES=${USE_STATIC_LIBRARIES}
-    SPLIT_SHARED=${SPLIT_SHARED_LIBRARIES}
-    CCACHE=${CCACHE_FOUND} ${CCACHE_VERSION}")
+    SPLIT_SHARED=${SPLIT_SHARED_LIBRARIES}")

 include (GNUInstallDirs)

--- a/cmake/ccache.cmake
+++ b/cmake/ccache.cmake
@ -30,7 +30,7 @@ if (CCACHE_FOUND AND NOT COMPILER_MATCHES_CCACHE)
   string(REGEX REPLACE "ccache version ([0-9\\.]+).*" "\\1" CCACHE_VERSION ${CCACHE_VERSION})

   if (CCACHE_VERSION VERSION_GREATER "3.2.0" OR NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-      message(STATUS "Using ${CCACHE_FOUND} ${CCACHE_VERSION}")
+      message(STATUS "Using ccache: ${CCACHE_FOUND} (version ${CCACHE_VERSION})")
      set(LAUNCHER ${CCACHE_FOUND})

      # debian (debhelpers) set SOURCE_DATE_EPOCH environment variable, that is
@ -49,8 +49,8 @@ if (CCACHE_FOUND AND NOT COMPILER_MATCHES_CCACHE)
      set (CMAKE_CXX_COMPILER_LAUNCHER ${LAUNCHER} ${CMAKE_CXX_COMPILER_LAUNCHER})
      set (CMAKE_C_COMPILER_LAUNCHER ${LAUNCHER} ${CMAKE_C_COMPILER_LAUNCHER})
   else ()
-      message(${RECONFIGURE_MESSAGE_LEVEL} "Not using ${CCACHE_FOUND} ${CCACHE_VERSION} bug: https://bugzilla.samba.org/show_bug.cgi?id=8118")
+       message(${RECONFIGURE_MESSAGE_LEVEL} "Using ccache: No. Found ${CCACHE_FOUND} (version ${CCACHE_VERSION}) but disabled because of bug: https://bugzilla.samba.org/show_bug.cgi?id=8118")
   endif ()
 elseif (NOT CCACHE_FOUND AND NOT COMPILER_MATCHES_CCACHE)
-    message (${RECONFIGURE_MESSAGE_LEVEL} "Cannot use ccache")
+    message (${RECONFIGURE_MESSAGE_LEVEL} "Using ccache: No")
 endif ()
--- a/cmake/git_status.cmake
+++ b/cmake/git_status.cmake
@ -11,7 +11,7 @@ if (Git_FOUND)
  message(STATUS "HEAD's commit hash ${GIT_COMMIT_ID}")
  execute_process(
    COMMAND ${GIT_EXECUTABLE} status
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} OUTPUT_STRIP_TRAILING_WHITESPACE)
 else()
  message(STATUS "The git program could not be found.")
 endif()
--- a/cmake/tools.cmake
+++ b/cmake/tools.cmake
@ -6,67 +6,65 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
    set (COMPILER_CLANG 1) # Safe to treat AppleClang as a regular Clang, in general.
 elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    set (COMPILER_CLANG 1)
+else ()
+    message (FATAL_ERROR "Compiler ${CMAKE_CXX_COMPILER_ID} is not supported")
 endif ()

-execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version)
+# Print details to output
+execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version OUTPUT_VARIABLE COMPILER_SELF_IDENTIFICATION OUTPUT_STRIP_TRAILING_WHITESPACE)
+message (STATUS "Using compiler:\n${COMPILER_SELF_IDENTIFICATION}")
+
+# Require minimum compiler versions
+set (CLANG_MINIMUM_VERSION 12)
+set (XCODE_MINIMUM_VERSION 12.0)
+set (APPLE_CLANG_MINIMUM_VERSION 12.0.0)
+set (GCC_MINIMUM_VERSION 11)

 if (COMPILER_GCC)
-    # Require minimum version of gcc
-    set (GCC_MINIMUM_VERSION 11)
    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${GCC_MINIMUM_VERSION})
-        message (FATAL_ERROR "GCC version must be at least ${GCC_MINIMUM_VERSION}. For example, if GCC ${GCC_MINIMUM_VERSION} is available under gcc-${GCC_MINIMUM_VERSION}, g++-${GCC_MINIMUM_VERSION} names, do the following: export CC=gcc-${GCC_MINIMUM_VERSION} CXX=g++-${GCC_MINIMUM_VERSION}; rm -rf CMakeCache.txt CMakeFiles; and re run cmake or ./release.")
+        message (FATAL_ERROR "Compilation with GCC version ${CMAKE_CXX_COMPILER_VERSION} is unsupported, the minimum required version is ${GCC_MINIMUM_VERSION}.")
    endif ()

-    message (WARNING "GCC compiler is not officially supported for ClickHouse. You should migrate to clang.")
+    message (WARNING "Compilation with GCC is unsupported. Please use Clang instead.")

 elseif (COMPILER_CLANG)
-    # Require minimum version of clang/apple-clang
    if (CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
        # (Experimental!) Specify "-DALLOW_APPLECLANG=ON" when running CMake configuration step, if you want to experiment with using it.
        if (NOT ALLOW_APPLECLANG AND NOT DEFINED ENV{ALLOW_APPLECLANG})
-            message (FATAL_ERROR "AppleClang is not supported, you should install clang from brew. See the instruction: https://clickhouse.com/docs/en/development/build-osx/")
+            message (FATAL_ERROR "Compilation with AppleClang is unsupported. Please use vanilla Clang, e.g. from Homebrew.")
        endif ()

-        # AppleClang 10.0.1 (Xcode 10.2) corresponds to LLVM/Clang upstream version 7.0.0
-        # AppleClang 11.0.0 (Xcode 11.0) corresponds to LLVM/Clang upstream version 8.0.0
-        set (XCODE_MINIMUM_VERSION 10.2)
-        set (APPLE_CLANG_MINIMUM_VERSION 10.0.1)
+        # For a mapping between XCode / AppleClang / vanilla Clang versions, see https://en.wikipedia.org/wiki/Xcode
        if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${APPLE_CLANG_MINIMUM_VERSION})
-            message (FATAL_ERROR "AppleClang compiler version must be at least ${APPLE_CLANG_MINIMUM_VERSION} (Xcode ${XCODE_MINIMUM_VERSION}).")
-        elseif (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11.0.0)
-            # char8_t is available starting (upstream vanilla) Clang 7, but prior to Clang 8,
-            # it is not enabled by -std=c++20 and can be enabled with an explicit -fchar8_t.
-            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fchar8_t")
-            set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fchar8_t")
+            message (FATAL_ERROR "Compilation with AppleClang version ${CMAKE_CXX_COMPILER_VERSION} is unsupported, the minimum required version is ${APPLE_CLANG_MINIMUM_VERSION} (Xcode ${XCODE_MINIMUM_VERSION}).")
        endif ()
    else ()
-        set (CLANG_MINIMUM_VERSION 12)
        if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${CLANG_MINIMUM_VERSION})
-            message (FATAL_ERROR "Clang version must be at least ${CLANG_MINIMUM_VERSION}.")
+            message (FATAL_ERROR "Compilation with Clang version ${CMAKE_CXX_COMPILER_VERSION} is unsupported, the minimum required version is ${CLANG_MINIMUM_VERSION}.")
        endif ()
    endif ()
-else ()
-    message (WARNING "You are using an unsupported compiler. Compilation has only been tested with Clang and GCC.")
 endif ()

+# Linker
+
 string (REGEX MATCHALL "[0-9]+" COMPILER_VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION})
 list (GET COMPILER_VERSION_LIST 0 COMPILER_VERSION_MAJOR)

-# Linker
-
 # Example values: `lld-10`, `gold`.
 option (LINKER_NAME "Linker name or full path")

-if (COMPILER_GCC AND NOT LINKER_NAME)
-    find_program (LLD_PATH NAMES "ld.lld")
-    find_program (GOLD_PATH NAMES "ld.gold")
-elseif (NOT LINKER_NAME)
-    find_program (LLD_PATH NAMES "ld.lld-${COMPILER_VERSION_MAJOR}" "lld-${COMPILER_VERSION_MAJOR}" "ld.lld" "lld")
-    find_program (GOLD_PATH NAMES "ld.gold" "gold")
-endif ()
+if (NOT LINKER_NAME)
+    if (COMPILER_GCC)
+        find_program (LLD_PATH NAMES "ld.lld")
+        find_program (GOLD_PATH NAMES "ld.gold")
+    elseif (COMPILER_CLANG)
+        find_program (LLD_PATH NAMES "ld.lld-${COMPILER_VERSION_MAJOR}" "lld-${COMPILER_VERSION_MAJOR}" "ld.lld" "lld")
+        find_program (GOLD_PATH NAMES "ld.gold" "gold")
+    endif ()
+endif()

 if (OS_LINUX AND NOT LINKER_NAME)
-    # We prefer LLD linker over Gold or BFD on Linux.
+    # prefer lld linker over gold or ld on linux
    if (LLD_PATH)
        if (COMPILER_GCC)
            # GCC driver requires one of supported linker names like "lld".
@ -87,9 +85,10 @@ if (OS_LINUX AND NOT LINKER_NAME)
        endif ()
    endif ()
 endif ()
+# TODO: allow different linker on != OS_LINUX

 if (LINKER_NAME)
-    if (COMPILER_CLANG AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 12.0.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 12.0.0))
+    if (COMPILER_CLANG)
        find_program (LLD_PATH NAMES ${LINKER_NAME})
        if (NOT LLD_PATH)
            message (FATAL_ERROR "Using linker ${LINKER_NAME} but can't find its path.")
@ -101,9 +100,14 @@ if (LINKER_NAME)
        set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fuse-ld=${LINKER_NAME}")
    endif ()

-    message(STATUS "Using custom linker by name: ${LINKER_NAME}")
 endif ()

+if (LINKER_NAME)
+    message(STATUS "Using linker: ${LINKER_NAME}")
+else()
+    message(STATUS "Using linker: <default>")
+endif()
+
 # Archiver

 if (COMPILER_GCC)
@ -116,6 +120,8 @@ if (LLVM_AR_PATH)
    set (CMAKE_AR "${LLVM_AR_PATH}")
 endif ()

+message(STATUS "Using archiver: ${CMAKE_AR}")
+
 # Ranlib

 if (COMPILER_GCC)
@ -128,6 +134,8 @@ if (LLVM_RANLIB_PATH)
    set (CMAKE_RANLIB "${LLVM_RANLIB_PATH}")
 endif ()

+message(STATUS "Using ranlib: ${CMAKE_RANLIB}")
+
 # Install Name Tool

 if (COMPILER_GCC)
@ -140,6 +148,8 @@ if (LLVM_INSTALL_NAME_TOOL_PATH)
    set (CMAKE_INSTALL_NAME_TOOL "${LLVM_INSTALL_NAME_TOOL_PATH}")
 endif ()

+message(STATUS "Using install-name-tool: ${CMAKE_INSTALL_NAME_TOOL}")
+
 # Objcopy

 if (COMPILER_GCC)
@ -148,29 +158,13 @@ else ()
    find_program (OBJCOPY_PATH NAMES "llvm-objcopy-${COMPILER_VERSION_MAJOR}" "llvm-objcopy" "objcopy")
 endif ()

-if (NOT OBJCOPY_PATH AND OS_DARWIN)
-    find_program (BREW_PATH NAMES "brew")
-    if (BREW_PATH)
-        execute_process (COMMAND ${BREW_PATH} --prefix llvm ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE LLVM_PREFIX)
-        if (LLVM_PREFIX)
-            find_program (OBJCOPY_PATH NAMES "llvm-objcopy" PATHS "${LLVM_PREFIX}/bin" NO_DEFAULT_PATH)
-        endif ()
-        if (NOT OBJCOPY_PATH)
-            execute_process (COMMAND ${BREW_PATH} --prefix binutils ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE BINUTILS_PREFIX)
-            if (BINUTILS_PREFIX)
-                find_program (OBJCOPY_PATH NAMES "objcopy" PATHS "${BINUTILS_PREFIX}/bin" NO_DEFAULT_PATH)
-            endif ()
-        endif ()
-    endif ()
-endif ()
-
 if (OBJCOPY_PATH)
    message (STATUS "Using objcopy: ${OBJCOPY_PATH}")
 else ()
    message (FATAL_ERROR "Cannot find objcopy.")
 endif ()

-# Strip (FIXME copypaste)
+# Strip

 if (COMPILER_GCC)
    find_program (STRIP_PATH NAMES "llvm-strip" "llvm-strip-13" "llvm-strip-12" "llvm-strip-11" "strip")
@ -178,22 +172,6 @@ else ()
    find_program (STRIP_PATH NAMES "llvm-strip-${COMPILER_VERSION_MAJOR}" "llvm-strip" "strip")
 endif ()

-if (NOT STRIP_PATH AND OS_DARWIN)
-    find_program (BREW_PATH NAMES "brew")
-    if (BREW_PATH)
-        execute_process (COMMAND ${BREW_PATH} --prefix llvm ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE LLVM_PREFIX)
-        if (LLVM_PREFIX)
-            find_program (STRIP_PATH NAMES "llvm-strip" PATHS "${LLVM_PREFIX}/bin" NO_DEFAULT_PATH)
-        endif ()
-        if (NOT STRIP_PATH)
-            execute_process (COMMAND ${BREW_PATH} --prefix binutils ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE BINUTILS_PREFIX)
-            if (BINUTILS_PREFIX)
-                find_program (STRIP_PATH NAMES "strip" PATHS "${BINUTILS_PREFIX}/bin" NO_DEFAULT_PATH)
-            endif ()
-        endif ()
-    endif ()
-endif ()
-
 if (STRIP_PATH)
    message (STATUS "Using strip: ${STRIP_PATH}")
 else ()
--- a/docs/en/development/build-osx.md
+++ b/docs/en/development/build-osx.md
@ -54,6 +54,7 @@ To build using Homebrew's vanilla Clang compiler (the only **recommended** way):
 ``` bash
 cd ClickHouse
 mkdir build
+export PATH=$(brew --prefix llvm)/bin:$PATH
 export CC=$(brew --prefix llvm)/bin/clang
 export CXX=$(brew --prefix llvm)/bin/clang++
 cmake -G Ninja -DCMAKE_BUILD_TYPE=RelWithDebInfo -S . -B build
@ -79,6 +80,8 @@ To build using Homebrew's vanilla GCC compiler (this option is only for developm
 ``` bash
 cd ClickHouse
 mkdir build
+export PATH=$(brew --prefix binutils)/bin:$PATH
+export PATH=$(brew --prefix gcc)/bin:$PATH
 export CC=$(brew --prefix gcc)/bin/gcc-11
 export CXX=$(brew --prefix gcc)/bin/g++-11
 cmake -G Ninja -DCMAKE_BUILD_TYPE=RelWithDebInfo -S . -B build