CMakeLists.txt

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

cmake_minimum_required(VERSION 3.20)

set(STARROCKS_PRECONFIG_MODE "AUTO" CACHE STRING "Preconfigure bootstrap mode: AUTO, ON, or OFF")
set_property(CACHE STARROCKS_PRECONFIG_MODE PROPERTY STRINGS AUTO ON OFF)
set(STARROCKS_PRECONFIG_MODE_NORMALIZED "${STARROCKS_PRECONFIG_MODE}")
string(TOUPPER "${STARROCKS_PRECONFIG_MODE_NORMALIZED}" STARROCKS_PRECONFIG_MODE_NORMALIZED)

set(STARROCKS_HAS_CMAKE_COMPILER_OVERRIDE OFF)
if ((DEFINED CMAKE_C_COMPILER AND NOT "${CMAKE_C_COMPILER}" STREQUAL "") OR
    (DEFINED CMAKE_CXX_COMPILER AND NOT "${CMAKE_CXX_COMPILER}" STREQUAL ""))
    set(STARROCKS_HAS_CMAKE_COMPILER_OVERRIDE ON)
endif()

set(STARROCKS_USE_PRECONFIG OFF)
if (STARROCKS_PRECONFIG_MODE_NORMALIZED STREQUAL "ON")
    set(STARROCKS_USE_PRECONFIG ON)
elseif (STARROCKS_PRECONFIG_MODE_NORMALIZED STREQUAL "AUTO")
    if (NOT DEFINED ENV{STARROCKS_HOME} OR "$ENV{STARROCKS_HOME}" STREQUAL "" OR
        NOT DEFINED ENV{STARROCKS_THIRDPARTY} OR "$ENV{STARROCKS_THIRDPARTY}" STREQUAL "" OR
        ((NOT STARROCKS_HAS_CMAKE_COMPILER_OVERRIDE) AND
         (((NOT DEFINED ENV{CC} OR "$ENV{CC}" STREQUAL "") OR
          (NOT DEFINED ENV{CXX} OR "$ENV{CXX}" STREQUAL "")) AND
         (NOT DEFINED ENV{STARROCKS_GCC_HOME} OR "$ENV{STARROCKS_GCC_HOME}" STREQUAL "") AND
         (NOT DEFINED ENV{STARROCKS_LLVM_HOME} OR "$ENV{STARROCKS_LLVM_HOME}" STREQUAL ""))))
        set(STARROCKS_USE_PRECONFIG ON)
    endif()
elseif (NOT STARROCKS_PRECONFIG_MODE_NORMALIZED STREQUAL "OFF")
    message(FATAL_ERROR
            "Invalid STARROCKS_PRECONFIG_MODE='${STARROCKS_PRECONFIG_MODE}'. Expected AUTO, ON, or OFF.")
endif()

if (STARROCKS_USE_PRECONFIG)
    include("${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/BootstrapEnv.cmake")
endif()

# set CMAKE_C_COMPILER, this must set before project command
if (STARROCKS_HAS_CMAKE_COMPILER_OVERRIDE)
elseif (DEFINED ENV{CC} AND NOT "$ENV{CC}" STREQUAL "" AND DEFINED ENV{CXX} AND NOT "$ENV{CXX}" STREQUAL "")
    set(CMAKE_C_COMPILER "$ENV{CC}")
    set(CMAKE_CXX_COMPILER "$ENV{CXX}")
elseif (DEFINED ENV{STARROCKS_GCC_HOME} AND NOT "$ENV{STARROCKS_GCC_HOME}" STREQUAL "")
    # prefer GCC
    set(CMAKE_C_COMPILER "$ENV{STARROCKS_GCC_HOME}/bin/gcc")
    set(CMAKE_CXX_COMPILER "$ENV{STARROCKS_GCC_HOME}/bin/g++")
elseif (DEFINED ENV{STARROCKS_LLVM_HOME} AND NOT "$ENV{STARROCKS_LLVM_HOME}" STREQUAL "")
    set(CMAKE_C_COMPILER "$ENV{STARROCKS_LLVM_HOME}/bin/clang")
    set(CMAKE_CXX_COMPILER "$ENV{STARROCKS_LLVM_HOME}/bin/clang++")
else()
    message(FATAL_ERROR "Neither STARROCKS_GCC_HOME nor STARROCKS_LLVM_HOME environment variable is set")
endif()

# disable pkgconfig searching libraries, all libraries are static imported
set(CMAKE_DISABLE_FIND_PACKAGE_PkgConfig ON)
# Workaround error of `Unknown CMake command "pkg_check_modules".'`
# refer to: https://gitlab.kitware.com/cmake/cmake/-/issues/17043
macro( pkg_check_modules )
endmacro()

project(starrocks CXX C)

include(CheckSymbolExists)

# set CMAKE_BUILD_TYPE
if (NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE RELEASE)
endif()

string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE)
message(STATUS "Build type is ${CMAKE_BUILD_TYPE}")

# set CMAKE_BUILD_TARGET_ARCH
# use `lscpu | grep 'Architecture' | awk '{print $2}'` only support system which language is en_US.UTF-8
execute_process(COMMAND bash "-c" "uname -m"
                OUTPUT_VARIABLE
                CMAKE_BUILD_TARGET_ARCH
                OUTPUT_STRIP_TRAILING_WHITESPACE)
if (APPLE AND CMAKE_BUILD_TARGET_ARCH STREQUAL "arm64")
    set(CMAKE_BUILD_TARGET_ARCH "aarch64")
endif()
message(STATUS "Build target arch is ${CMAKE_BUILD_TARGET_ARCH}")

# Set dirs
set(BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
# CMAKE_BINARY_DIR is set to be $BASE_DIR/be/build_${buildType}
set(FILE_PREFIX_MAP_FLAG "-ffile-prefix-map=${CMAKE_BINARY_DIR}=. -ffile-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=be")
set(BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}")
set(THIRDPARTY_DIR "$ENV{STARROCKS_THIRDPARTY}/installed/")
set(STARROCKS_THIRDPARTY "$ENV{STARROCKS_THIRDPARTY}")
set(SRC_DIR "${BASE_DIR}/src")
set(GENSRC_DIR "${SRC_DIR}/gen_cpp/build")
set(BE_PROTO_THRIFT_GENSRC_DIR "${CMAKE_BINARY_DIR}/gensrc")
set(BE_PROTO_THRIFT_GEN_CPP_DIR "${BE_PROTO_THRIFT_GENSRC_DIR}/gen_cpp")
set(BE_PROTO_THRIFT_CODEGEN_DIR "${BE_PROTO_THRIFT_GENSRC_DIR}/codegen")
set(TEST_DIR "${CMAKE_SOURCE_DIR}/test/")
set(OUTPUT_DIR "${BASE_DIR}/output")
set(CONTRIB_DIR "${BASE_DIR}/../contrib/")
set(CMAKE_EXPORT_COMPILECOMMANDS ON)

# Keep the active Thrift package version in the compile command so cached
# objects built against an older Thrift header ABI cannot be reused after
# a runtime upgrade.
set(STARROCKS_THRIFT_CONFIG_H "${THIRDPARTY_DIR}/include/thrift/config.h")
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${STARROCKS_THRIFT_CONFIG_H}")
if (EXISTS "${STARROCKS_THRIFT_CONFIG_H}")
    file(STRINGS "${STARROCKS_THRIFT_CONFIG_H}" STARROCKS_THRIFT_VERSION_LINE
         REGEX "^#define PACKAGE_VERSION \"[^\"]+\"$")
    if (STARROCKS_THRIFT_VERSION_LINE)
        string(REGEX REPLACE "^#define PACKAGE_VERSION \"([^\"]+)\"$" "\\1"
               STARROCKS_THRIFT_PACKAGE_VERSION "${STARROCKS_THRIFT_VERSION_LINE}")
        add_compile_definitions(STARROCKS_THRIFT_PACKAGE_VERSION="${STARROCKS_THRIFT_PACKAGE_VERSION}")
        message(STATUS "Thrift package version is ${STARROCKS_THRIFT_PACKAGE_VERSION}")
    endif()
endif()

if (APPLE)
    find_library(STARROCKS_LIBEVENT_LIBRARY NAMES libevent.dylib event PATHS ${THIRDPARTY_DIR}/lib
                 ${THIRDPARTY_DIR}/lib64 NO_DEFAULT_PATH)
    find_library(STARROCKS_LIBEVENT_CORE_LIBRARY NAMES libevent_core.dylib event_core PATHS ${THIRDPARTY_DIR}/lib
                 ${THIRDPARTY_DIR}/lib64 NO_DEFAULT_PATH)
    find_library(STARROCKS_LIBEVENT_EXTRA_LIBRARY NAMES libevent_extra.dylib event_extra PATHS ${THIRDPARTY_DIR}/lib
                 ${THIRDPARTY_DIR}/lib64 NO_DEFAULT_PATH)

    set(_STARROCKS_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}")
    set(_STARROCKS_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
    set(_STARROCKS_REQUIRED_QUIET "${CMAKE_REQUIRED_QUIET}")
    list(APPEND CMAKE_REQUIRED_INCLUDES "${THIRDPARTY_DIR}/include" "${THIRDPARTY_DIR}/include/event")
    list(APPEND CMAKE_REQUIRED_LIBRARIES ${STARROCKS_LIBEVENT_EXTRA_LIBRARY} ${STARROCKS_LIBEVENT_CORE_LIBRARY}
         ${STARROCKS_LIBEVENT_LIBRARY})
    set(CMAKE_REQUIRED_QUIET TRUE)

    check_symbol_exists(evhttp_request_get_user_data "event2/http.h" STARROCKS_HAVE_EVHTTP_REQUEST_GET_USER_DATA)
    check_symbol_exists(evhttp_request_set_user_data "event2/http.h" STARROCKS_HAVE_EVHTTP_REQUEST_SET_USER_DATA)
    check_symbol_exists(evhttp_set_newreqcb "event2/http.h" STARROCKS_HAVE_EVHTTP_SET_NEWREQCB)
    check_symbol_exists(evhttp_request_set_on_free_cb "event2/http.h"
                        STARROCKS_HAVE_EVHTTP_REQUEST_SET_ON_FREE_CB)

    set(CMAKE_REQUIRED_INCLUDES "${_STARROCKS_REQUIRED_INCLUDES}")
    set(CMAKE_REQUIRED_LIBRARIES "${_STARROCKS_REQUIRED_LIBRARIES}")
    set(CMAKE_REQUIRED_QUIET "${_STARROCKS_REQUIRED_QUIET}")
    unset(_STARROCKS_REQUIRED_INCLUDES)
    unset(_STARROCKS_REQUIRED_LIBRARIES)
    unset(_STARROCKS_REQUIRED_QUIET)
    unset(STARROCKS_LIBEVENT_LIBRARY CACHE)
    unset(STARROCKS_LIBEVENT_CORE_LIBRARY CACHE)
    unset(STARROCKS_LIBEVENT_EXTRA_LIBRARY CACHE)

    if (STARROCKS_HAVE_EVHTTP_REQUEST_GET_USER_DATA)
        add_compile_definitions(STARROCKS_HAVE_EVHTTP_REQUEST_GET_USER_DATA=1)
    endif()
    if (STARROCKS_HAVE_EVHTTP_REQUEST_SET_USER_DATA)
        add_compile_definitions(STARROCKS_HAVE_EVHTTP_REQUEST_SET_USER_DATA=1)
    endif()
    if (STARROCKS_HAVE_EVHTTP_SET_NEWREQCB)
        add_compile_definitions(STARROCKS_HAVE_EVHTTP_SET_NEWREQCB=1)
    endif()
    if (STARROCKS_HAVE_EVHTTP_REQUEST_SET_ON_FREE_CB)
        add_compile_definitions(STARROCKS_HAVE_EVHTTP_REQUEST_SET_ON_FREE_CB=1)
    endif()
endif()

option(MAKE_TEST "ON for make unit test or OFF for not" OFF)
message(STATUS "make test: ${MAKE_TEST}")

option(WITH_GCOV "Build binary with gcov to get code coverage" OFF)

option(WITH_COMPRESS "Build binary with compresss debug section" ON)

option(THIN_ARCHIVE "Build binary with thin archive" OFF)

set(WITH_STARCACHE_DEFAULT ON)
if (APPLE)
    set(WITH_STARCACHE_DEFAULT OFF)
endif()
option(WITH_STARCACHE "Build binary with starcache library" ${WITH_STARCACHE_DEFAULT})
option(WITH_BRCP_KEEPALIVE "Build binary with brpc_socket_keepalive (requires brpc 1.8)" OFF)

option(WITH_BENCH "Build binary with bench" OFF)
option(WITH_CONNECTOR_BENCHMARK "Build the benchgen-backed benchmark connector" ON)
option(WITH_CONNECTOR_ELASTICSEARCH "Build the Elasticsearch connector" ON)
option(WITH_CONNECTOR_JDBC "Build the JDBC connector" ON)
option(WITH_CONNECTOR_MYSQL "Build the MySQL connector" ON)

option(USE_STAROS "Use StarOS to manager tablet info" OFF)

option(USE_SSE4_2 "Build with SSE4.2 instruction" ON)

option(USE_BMI_2 "Build with BMI2 instruction" ON)

option(USE_AVX2 "Build with AVX2 instruction" ON)

option(USE_AVX512 "Build with AVX512f/AVX512BW instruction" OFF)

option(WITH_TENANN "Build with TENANN" OFF)

option(WITH_RELATIVE_SRC_PATH "Build source file with relative path" ON)

if (${WITH_TENANN} STREQUAL "ON")
    add_definitions(-DWITH_TENANN)
endif()

# The StarRocks module enables dynamic linking. This is a developer option.
# If only certain modules are modified without altering the ABI,
# subsequent linking stages may be skipped.
option(ENABLE_MULTI_DYNAMIC_LIBS "Enable dynamic linking of individual StarRocks modules (developer option)" OFF)

message(STATUS "WITH TENANN is: ${WITH_TENANN}")
if (APPLE AND WITH_STARCACHE)
    message(STATUS "Disable starcache on macOS")
    set(WITH_STARCACHE OFF CACHE BOOL "Build binary with starcache library" FORCE)
endif()

# Check gcc
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.8.2")
        message(FATAL_ERROR "Need GCC version at least 4.8.2")
    endif()
elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
elseif (NOT APPLE)
    message(FATAL_ERROR "Compiler should be GNU")
endif()

set(CMAKE_SKIP_RPATH TRUE)

set(ALL_BE_LIBS "" CACHE INTERNAL "All BE libraries")

FUNCTION(FINALIZE_BE_LIBS)
    LIST(SORT ALL_BE_LIBS)
    MESSAGE(STATUS "ALL BE LIBS (SORTED): ${ALL_BE_LIBS}") 
ENDFUNCTION()

include(cmake_modules/ThirdParty.cmake)

include(cmake_modules/PreBuildModule.cmake)

# LLVM
include(cmake_modules/FindLLVM.cmake)

# install runtime libraries if needed
include(cmake_modules/InstallSysRuntime.cmake)

# Check Clang-Tidy
include(cmake_modules/FindClangTidy.cmake)

if (CLANG_TIDY_PATH)
    # enable clang-tidy check for all source code files
    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
endif()

# Check if functions are supported in this platform. All flags will generated
# in gensrc/build/common/env_config.h.
# You can check funcion here which depends on platform. Don't forget add this
# to be/src/common/env_config.h.in
include(CheckFunctionExists)
check_function_exists(sched_getcpu HAVE_SCHED_GETCPU)

# support to pass cxx flags from environment.
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} $ENV{STARROCKS_CXX_COMMON_FLAGS}")

# -no-pie: Disable Position Independent Executables (PIE) as certain libraries cannot be linked against PIE executables.
if (NOT APPLE)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -no-pie")
endif()
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} $ENV{STARROCKS_CXX_LINKER_FLAGS}")

# compiler flags that are common across debug/release builds
#  -Wall: Enable all warnings.
#  -Wno-sign-compare: suppress warnings for comparison between signed and unsigned
#    integers
#   -fno-strict-aliasing: disable optimizations that assume strict aliasing. This
#       is unsafe to do if the code uses casts (which we obviously do).
#  -Wno-unknown-pragmas: suppress warnings for unknown (compiler specific) pragmas
#  -Wno-deprecated: gutil contains deprecated headers
#  -Wno-vla: we use C99-style variable-length arrays
#  -pthread: enable multithreaded malloc
#  -DBOOST_DATE_TIME_POSIX_TIME_STD_CONFIG: enable nanosecond precision for boost
#  -fno-omit-frame-pointers: Keep frame pointer for functions in register
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall -Wno-sign-compare -Wno-unknown-pragmas -pthread -Wno-register")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-strict-aliasing -fno-omit-frame-pointer")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -std=gnu++23 -D__STDC_FORMAT_MACROS")
if (APPLE)
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -D_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -D_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS")
endif()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated -Wno-vla -Wno-comment")
if("${WITH_RELATIVE_SRC_PATH}" STREQUAL "ON")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} ${FILE_PREFIX_MAP_FLAG}")
endif()
# disable link delete(void*, long)
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -fno-sized-deallocation")

if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    if (NOT ${MAKE_TEST} STREQUAL "ON")
        # there are too many warnings reported by clang in be/test and it will take some time to fix.
        # temporarily disable Werror in the unit test so that clang can compile.
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Werror")
    endif()
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unused-parameter -Wno-documentation -Wno-weak-vtables")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unknown-warning-option")
    # GCC 15's libstdc++ annotates __find_if (used by std::find_if/any_of/all_of/remove_if) with
    # "#pragma GCC unroll 4". clang treats that as an explicit unroll request and emits
    # -Wpass-failed=transform-warning when the predicate is not trivially unrollable, which -Werror
    # turns into a build failure. These are missed-optimization diagnostics, not correctness issues,
    # so keep the warning but do not let it fail the build.
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-error=pass-failed")
    # Turn on following warning as error explicitly
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Werror=string-plus-int")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Werror=pessimizing-move")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Werror=delete-non-virtual-dtor")
    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "11.0.0")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-reserved-identifier -Wno-suggest-destructor-override")
    endif()
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-documentation-unknown-command -Wno-old-style-cast")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-c++20-designator -Wno-mismatched-tags")
    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0.0")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-bitwise-instead-of-logical -Wno-inconsistent-missing-override -Wno-ambiguous-reversed-operator")
    endif()
    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "16.0.0")
        # ignore warning from apache-orc
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unsafe-buffer-usage")
    endif ()
    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "18.0.0")
        # ignore warning from apache-orc
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-switch-default")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-error=nrvo")
    endif ()
    # Add -rtlib=compiler-rt for ARM architecture to fix LLVM bug: https://bugs.llvm.org/show_bug.cgi?id=16404
    if ("${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "aarch64")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -rtlib=compiler-rt")
    endif()
else ()
    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0.0")
        # ignore error from apache-orc
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-error=dangling-reference")
    endif ()
    set(CXX_GCC_FLAGS "${CXX_GCC_FLAGS} -fcoroutines")
endif()

set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DBOOST_DATE_TIME_POSIX_TIME_STD_CONFIG")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DBOOST_SYSTEM_NO_DEPRECATED -DBOOST_UUID_RANDOM_PROVIDER_FORCE_POSIX")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Werror=return-type -Werror=switch")
if (${USE_STAROS} STREQUAL "ON")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DUSE_STAROS")
endif()
if (${WITH_STARCACHE} STREQUAL "ON")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DWITH_STARCACHE")
endif()

# When LLVM is used, should give GCC_HOME to get c++11 header to use new string and list
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    if (DEFINED ENV{STARROCKS_GCC_HOME})
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} --gcc-toolchain=$ENV{STARROCKS_GCC_HOME}")
    elseif (NOT APPLE)
        message(WARNING "STARROCKS_GCC_HOME evnironment variable is not set, ")
    endif()
endif()

if ("${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "x86" OR "${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "x86_64")
    if (${USE_SSE4_2})
        # the compiler will define __SSE4_2__
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -msse4.2 -mpclmul")
    endif()
    if (${USE_AVX2})
        # the compiler will define __AVX2__
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -mavx2")
    endif()
    if (${USE_BMI_2})
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -mbmi2")
    endif()
    if (${USE_AVX512})
        # the compiler will define __AVX512F__ __AVX512BW__ __AVX512DQ__ __AVX512CD__ __AVX512VL__
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -mavx512f -mavx512bw -mavx512dq -mavx512cd -mavx512vl")
    endif()
elseif ("${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "aarch64")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -march=armv8-a+crc")
endif()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS}  -Wno-attributes -DS2_USE_GFLAGS -DS2_USE_GLOG")

if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0)
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -faligned-new")
endif()

if (APPLE AND STARROCKS_JIT_ENABLE)
    message(STATUS "Disable JIT on macOS")
    set(STARROCKS_JIT_ENABLE OFF CACHE BOOL "Enable LLVM JIT support" FORCE)
endif()

if (STARROCKS_JIT_ENABLE)
    message(STATUS "Enable JIT")
    set(CXX_GCC_FLAGS "${CXX_GCC_FLAGS} -DSTARROCKS_JIT_ENABLE")
endif()

# For any gcc builds:
#   -g: Enable symbols for profiler tools
#   -Wno-unused-local-typedefs: Do not warn for local typedefs that are unused.
set(CXX_GCC_FLAGS "${CXX_GCC_FLAGS} -g -Wno-unused-local-typedefs")

if (WITH_GCOV)
    # To generate flags to code coverage
    set(CXX_GCC_FLAGS "${CXX_GCC_FLAGS} -fprofile-arcs -ftest-coverage")
endif()

if (WITH_COMPRESS)
    # to compresss debug section. https://gcc.gnu.org/onlinedocs/gcc/Debugging-Options.html
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -gz=zlib")
endif()

if (ENABLE_FAULT_INJECTION)
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DFIU_ENABLE")
    message(STATUS "enable fault injection")
endif()

option(ASSERT_STATUS_CHECKED "build with assert status checked" OFF)
if (ASSERT_STATUS_CHECKED)
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DSTARROCKS_ASSERT_STATUS_CHECKED")
endif()

if (BUILD_FORMAT_LIB)
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -fPIC -DBUILD_FORMAT_LIB")
    message(STATUS "enable build format library")
endif()

# For CMAKE_BUILD_TYPE=Debug
#   -ggdb: Enable gdb debugging
#   -Werror: compile warnings should be errors when using the toolchain compiler.
# Only enable for debug builds because this is what we test in pre-commit tests.
set(CXX_FLAGS_DEBUG "${CXX_GCC_FLAGS} -ggdb -O0 -gdwarf-5 -DDEBUG")

# For CMAKE_BUILD_TYPE=Release
#   -O3: Enable all compiler optimizations
#   -DNDEBUG: Turn off dchecks/asserts/debug only code.
set(CXX_FLAGS_RELEASE "${CXX_GCC_FLAGS} -O3 -gdwarf-4 -DNDEBUG")

SET(CXX_FLAGS_ASAN "${CXX_GCC_FLAGS} -ggdb3 -O0 -gdwarf-5 -fsanitize=address -DADDRESS_SANITIZER")
SET(CXX_FLAGS_LSAN "${CXX_GCC_FLAGS} -ggdb3 -O0 -gdwarf-5 -fsanitize=leak -DLEAK_SANITIZER")

# Set the flags to the undefined behavior sanitizer, also known as "ubsan"
# Turn on sanitizer and debug symbols to get stack traces:
SET(CXX_FLAGS_UBSAN "${CXX_FLAGS_RELEASE} -fsanitize=undefined")
# Ignore a number of noisy errors with too many false positives:
# TODO(zc):
# SET(CXX_FLAGS_UBSAN "${CXX_FLAGS_UBSAN} -fno-sanitize=alignment,function,vptr,float-divide-by-zero,float-cast-overflow")
# Don't enforce wrapped signed integer arithmetic so that the sanitizer actually sees

# Set the flags to the thread sanitizer, also known as "tsan"
# Turn on sanitizer and debug symbols to get stack traces:
SET(CXX_FLAGS_TSAN "${CXX_GCC_FLAGS} -O0 -ggdb3 -fsanitize=thread -DTHREAD_SANITIZER")

# Set compile flags based on the build type.
if ("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
    SET(CMAKE_CXX_FLAGS ${CXX_FLAGS_DEBUG})
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
    SET(CMAKE_CXX_FLAGS ${CXX_FLAGS_RELEASE})
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "ASAN")
    SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_ASAN}")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "LSAN")
    SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_LSAN}")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN")
    SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_UBSAN}")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "TSAN")
    SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_TSAN}")
else()
    message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}")
endif()

# Add flags that are common across build types
SET(CMAKE_CXX_FLAGS "${CXX_COMMON_FLAGS} ${CMAKE_CXX_FLAGS}")
if("${WITH_RELATIVE_SRC_PATH}" STREQUAL "ON")
    # apply -ffile-prefix-map option to .c source files as well
    SET(CMAKE_C_FLAGS "${FILE_PREFIX_MAP_FLAG} ${CMAKE_C_FLAGS}")
endif()

message(STATUS "Compiler Flags: ${CMAKE_CXX_FLAGS}")

# Thrift requires these two definitions for some types that we use
add_definitions(-DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H)

# Set include dirs
if (APPLE)
    include_directories(
        BEFORE
        ${SRC_DIR}/macos_compat
    )
endif()
include_directories(
    BEFORE
    ${SRC_DIR}/formats/orc/apache-orc/c++/include/
)
include_directories(
    BEFORE
    ${SRC_DIR}/
    ${TEST_DIR}/
    ${BE_PROTO_THRIFT_GENSRC_DIR}/
    ${GENSRC_DIR}/
    SYSTEM ${THIRDPARTY_DIR}/include
    SYSTEM ${GPERFTOOLS_HOME}/include
    SYSTEM ${JEMALLOC_HOME}/include
    SYSTEM ${THIRDPARTY_DIR}/include/thrift/
    SYSTEM ${THIRDPARTY_DIR}/include/event/
    SYSTEM ${THIRDPARTY_DIR}/llvm/include/
)

if ("${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "x86" OR "${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "x86_64")
    include_directories(${THIRDPARTY_DIR}/include/breakpad/)
endif()

if (APPLE)
    set(WL_START_GROUP "")
    set(WL_END_GROUP "")
    set(WL_LINK_STATIC "")
    set(WL_LINK_DYNAMIC "")
    # Darwin has no GNU whole-archive/group flags. Force-load the static
    # registrar libraries on executable targets via STARROCKS_FORCE_LOAD_LIBS().
    set(WL_WHOLE_ARCHIVE_PREFIX "")
    set(WL_WHOLE_ARCHIVE_SUFFIX "")
else()
    set(WL_START_GROUP "-Wl,--start-group")
    set(WL_END_GROUP "-Wl,--end-group")
    set(WL_LINK_STATIC "-Wl,-Bstatic")
    set(WL_LINK_DYNAMIC "-Wl,-Bdynamic")
    set(WL_WHOLE_ARCHIVE_PREFIX "-Wl,--whole-archive")
    set(WL_WHOLE_ARCHIVE_SUFFIX "-Wl,--no-whole-archive")
endif()

include(${SRC_DIR}/exprs_ext/extension_targets.cmake)

# Concrete connectors reach the BE binary only as transitive PRIVATE deps of
# ModuleBootstrap/Exec, which CMake places after the thirdparty group. List every
# connector ModuleBootstrap pulls (guarded by the same options) ahead of it.
set (DIRECT_CONNECTOR_LINK_LIBS
    Connector
    ConnectorLake
    ConnectorFile
    ConnectorHive
    ConnectorIceberg
    ConnectorCacheStats
)
if (WITH_CONNECTOR_BENCHMARK)
    list(APPEND DIRECT_CONNECTOR_LINK_LIBS ConnectorBenchmark)
endif()
if (WITH_CONNECTOR_ELASTICSEARCH)
    list(APPEND DIRECT_CONNECTOR_LINK_LIBS ConnectorElasticsearch)
endif()
if (WITH_CONNECTOR_JDBC)
    list(APPEND DIRECT_CONNECTOR_LINK_LIBS ConnectorJDBC)
endif()
if (WITH_CONNECTOR_MYSQL)
    list(APPEND DIRECT_CONNECTOR_LINK_LIBS ConnectorMySQL)
endif()

# Set starrocks libraries
set(STARROCKS_LINK_LIBS
    HttpService
    Tools
    AgentServer
    Script
    ModuleBootstrap
    Orchestration
    DataWorkflows
    ${WL_START_GROUP}
    Exec
    ${WL_WHOLE_ARCHIVE_PREFIX} ${EXPR_EXTENSION_LIBS} ${WL_WHOLE_ARCHIVE_SUFFIX}
    ${WL_END_GROUP}
    Storage
    # Connectors depend on the format libs and thirdparty archives below; keep ahead.
    ${WL_START_GROUP}
    ${DIRECT_CONNECTOR_LINK_LIBS}
    ${WL_END_GROUP}
    # The concrete format libraries must be linked ahead of the thirdparty
    # dependency group below (which owns avro/avrocpp/arrow/orc). Linking only
    # the Formats aggregate lets CMake append its concrete members after that
    # group as transitive deps, which leaves FormatAvro's avro/avrocpp
    # references unresolved. List the members explicitly, with FormatCore last,
    # to keep them ahead of their thirdparty archives.
    Formats
    FormatParquet
    FormatOrc
    FormatAvro
    FormatJson
    FormatCsv
    FormatCore
    ExecRuntime
    ComputeEnv
    ExecPrimitive
    StoragePrimitive
    ${WL_WHOLE_ARCHIVE_PREFIX} $<TARGET_FILE:Expr> ${WL_WHOLE_ARCHIVE_SUFFIX}
    $<TARGET_FILE:Cache>
    $<TARGET_FILE:HdfsFileSystem>
    Runtime
    Platform
    $<TARGET_FILE:ChunkCore>
    $<TARGET_FILE:ColumnCore>
    $<TARGET_FILE:Types>
    $<TARGET_FILE:FileSystem>
    $<TARGET_FILE:IO>
    Geo
    $<TARGET_FILE:Common>
    $<TARGET_FILE:Base>
    $<TARGET_FILE:Gutil>
    $<TARGET_FILE:StarRocksGen>
)

set(STARROCKS_DEPENDENCIES ${STARROCKS_DEPENDENCIES}
    mysql
)

set(STARROCKS_DEPENDENCIES ${STARROCKS_DEPENDENCIES}
    ${AWSSDK_LINK_LIBRARIES}
)
set_target_properties(aws-cpp-sdk-core PROPERTIES INTERFACE_LINK_LIBRARIES AWS::aws-crt-cpp)

if (STARROCKS_JIT_ENABLE)
    set(STARROCKS_DEPENDENCIES
        ${STARROCKS_DEPENDENCIES}
        ${WL_START_GROUP}
        ${LLVM_LIBRARIES}
        ${WL_END_GROUP}
    )
endif()

# Set thirdparty libraries
set(STARROCKS_DEPENDENCIES
    ${STARROCKS_DEPENDENCIES}
    build_version
    ${WL_START_GROUP}
    clucene-core
    clucene-shared
    clucene-contribs-lib
    rocksdb
    libs2
    snappy
    ${Boost_LIBRARIES}
    thrift
    thriftnb
    glog
    re2
    pprof
    # Put lz4 in front of librdkafka to make sure that segment use the native lz4 library to compress/decompress page
    # Otherwise, he will use the lz4 Library in librdkafka
    lz4
    libevent
    curl
    ${Poco_LIBRARIES}
    libz
    libbz2
    gflags
    brpc
    protobuf
    openssl
    crypto
    leveldb
    bitshuffle
    roaring
    brotlicommon
    brotlidec
    brotlienc
    zstd
    streamvbyte
    arrow
    arrow_testing
    arrow_flight
    arrow_flight_sql
    gRPC::grpc
    gRPC::grpc++
    parquet
    cctz
    fmt
    ryu
    hyperscan
    simdjson
    simdutf
    sasl
    gssapi_krb5
    krb5
    krb5support
    k5crypto
    com_err
    librdkafka_cpp
    librdkafka
    libpulsar
    velocypack
    opentelemetry_trace
    http_client_curl
    opentelemetry_resources
    opentelemetry_common
    opentelemetry_exporter_jaeger_trace
    libxml2
    azure-core
    azure-identity
    azure-storage-common
    azure-storage-blobs
    azure-storage-files-datalake
    jansson
    avro
    avrocpp
    serdes
    fiu
    icuuc
    icui18n
    icudata
    blake3
    ${WL_END_GROUP}
)

if (APPLE)
    list(REMOVE_ITEM STARROCKS_DEPENDENCIES
        opentelemetry_trace
        http_client_curl
        opentelemetry_resources
        opentelemetry_common
        opentelemetry_exporter_jaeger_trace)
endif()

if (NOT BUILD_FORMAT_LIB)
    set(STARROCKS_DEPENDENCIES
            ${STARROCKS_DEPENDENCIES}
            jemalloc # required by arrow
    )
endif()

if (${WITH_STARCACHE} STREQUAL "ON")
    set(STARROCKS_DEPENDENCIES
        ${STARROCKS_DEPENDENCIES}
        ${WL_START_GROUP}
        brpc
        starcache
        ${WL_END_GROUP}
    )
endif()

if ("${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "x86" OR "${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "x86_64")
    set(STARROCKS_DEPENDENCIES
        ${STARROCKS_DEPENDENCIES}
        breakpad
        libdeflate
    )
endif()

if (${WITH_TENANN} STREQUAL "ON")
    set(STARROCKS_DEPENDENCIES
        ${STARROCKS_DEPENDENCIES}
        tenann
    )
endif()

# enable global pch compiling
option(WITH_PCH "Enable precompiled headers for BE targets" ON)
if (WITH_PCH)
    add_library(StarRocksPCH INTERFACE)
    target_precompile_headers(StarRocksPCH INTERFACE ${SRC_DIR}/pch/starrocks_pch.h)
    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
        target_compile_options(StarRocksPCH INTERFACE "$<$<COMPILE_LANGUAGE:CXX>:SHELL:-Xclang -fno-pch-timestamp>")
    endif()
endif()

if (APPLE)
    if (CMAKE_CXX_COMPILER_AR)
        set(CMAKE_AR "${CMAKE_CXX_COMPILER_AR}" CACHE FILEPATH "Archiver" FORCE)
    endif()
    if (CMAKE_CXX_COMPILER_RANLIB)
        set(CMAKE_RANLIB "${CMAKE_CXX_COMPILER_RANLIB}" CACHE FILEPATH "Ranlib" FORCE)
    endif()
endif()

if (THIN_ARCHIVE)
    set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> qcsT <TARGET> <OBJECTS>")
    set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qcsT <TARGET> <OBJECTS>")
    set(CMAKE_C_ARCHIVE_APPEND   "<CMAKE_AR> qsT  <TARGET> <OBJECTS>")
    set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qsT  <TARGET> <OBJECTS>")

    set(CMAKE_C_ARCHIVE_FINISH   "true")
    set(CMAKE_CXX_ARCHIVE_FINISH "true")
endif()


# Add all external dependencies. They should come after the starrocks libs.

set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} ${STARROCKS_DEPENDENCIES} hdfs jvm)

set(BUILD_FOR_SANITIZE "OFF")
set(DEP_SANITIZE_LIBS "")

# Add sanitize static link flags or jemalloc
if ("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG" OR "${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
    message("use jemalloc")
    set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} jemalloc)
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "ASAN")
    if (APPLE)
        # Darwin only supports the dynamic ASan runtime selected by -fsanitize=address.
    elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
        set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libsan)
        set(DEP_SANITIZE_LIBS -static-libsan)
    else()
        set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libasan)
        set(DEP_SANITIZE_LIBS -static-libasan)
    endif()
    set(BUILD_FOR_SANITIZE "ON")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "LSAN")
    set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-liblsan)
    set(DEP_SANITIZE_LIBS -static-liblsan)
    set(BUILD_FOR_SANITIZE "ON")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN")
    message("use jemalloc")
    set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libubsan jemalloc)
    set(DEP_SANITIZE_LIBS -static-libubsan)
    set(BUILD_FOR_SANITIZE "ON")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "TSAN")
    set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} -static-libtsan)
    set(DEP_SANITIZE_LIBS -static-libtsan)
    set(BUILD_FOR_SANITIZE "ON")
else()
    message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}")
endif()

if (APPLE)
    set(WRAP_LINKER_FLAGS "")
else()
    set(WRAP_LINKER_FLAGS "-Wl,-wrap,__cxa_throw -Wl,-wrap,__floattidf")
endif()

FUNCTION(ADD_BE_LIB LIB_NAME)
    IF(ENABLE_MULTI_DYNAMIC_LIBS)
        # support build and install component 
        # ${CMAKE_CMD} -DCOMPONENT=$LIB_NAME -P cmake_install.cmake
        ADD_LIBRARY(${LIB_NAME} SHARED ${ARGN})
        target_link_libraries(${LIB_NAME} PRIVATE ${WRAP_LINKER_FLAGS} ${DEP_SANITIZE_LIBS})
        install(TARGETS ${LIB_NAME}
            LIBRARY DESTINATION ${OUTPUT_DIR}/lib COMPONENT ${LIB_NAME} 
            ARCHIVE DESTINATION ${OUTPUT_DIR}/lib COMPONENT ${LIB_NAME} 
        )
    ELSE()
        ADD_LIBRARY(${LIB_NAME} STATIC ${ARGN})
        if (WITH_PCH)
            target_link_libraries(${LIB_NAME} PRIVATE StarRocksPCH)
        endif()
    ENDIF()
    set(ALL_BE_LIBS "${ALL_BE_LIBS};${LIB_NAME}" CACHE INTERNAL "All BE libraries")
ENDFUNCTION()

function(STARROCKS_FORCE_LOAD_LIBS TARGET_NAME)
    if (APPLE)
        foreach(FORCE_LOAD_TARGET IN LISTS ARGN)
            target_link_options(${TARGET_NAME} PRIVATE "LINKER:-force_load,$<TARGET_FILE:${FORCE_LOAD_TARGET}>")
        endforeach()
    endif()
endfunction()


set(STARROCKS_STATIC_LINK_LIBS ${WL_LINK_STATIC})
if (NOT APPLE)
    set(STARROCKS_STATIC_LINK_LIBS ${STARROCKS_STATIC_LINK_LIBS} -lgomp)
endif()

if (NOT APPLE AND NOT ${ENABLE_MULTI_DYNAMIC_LIBS} AND NOT ("${MAKE_TEST}" STREQUAL "ON" AND "${BUILD_FOR_SANITIZE}" STREQUAL "ON"))
    # In other words, turn to dynamic link when ENABLE_MULTI_DYNAMIC_LIBS or MAKE_TEST and BUILD_TYPE == *SAN
    # otherwise do static link gcc's lib
    set(STARROCKS_STATIC_LINK_LIBS ${STARROCKS_STATIC_LINK_LIBS} -static-libstdc++ -static-libgcc)
endif()

if (APPLE)
    set(STARROCKS_SYSTEM_LINK_LIBS
        -lresolv
        -lm
        -pthread
        "-framework Foundation"
        "-framework CoreText"
        "-framework ApplicationServices"
        "-framework SystemConfiguration"
    )
    find_library(MIMALLOC_LIB
        NAMES mimalloc
        HINTS ${THIRDPARTY_DIR}/lib ${THIRDPARTY_DIR}/lib64 /opt/homebrew/lib /usr/local/lib
    )
    if (MIMALLOC_LIB AND NOT "${BUILD_FOR_SANITIZE}" STREQUAL "ON")
        list(APPEND STARROCKS_SYSTEM_LINK_LIBS ${MIMALLOC_LIB})
    endif()
else()
    set(STARROCKS_SYSTEM_LINK_LIBS -lresolv -lc -lm -ldl -rdynamic -pthread)
endif()

set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS}
    ${STARROCKS_STATIC_LINK_LIBS}
    ${WL_LINK_DYNAMIC} ${STARROCKS_SYSTEM_LINK_LIBS} ${WRAP_LINKER_FLAGS}
)

# link gcov if WITH_GCOV is on
if (WITH_GCOV)
    set(STARROCKS_LINK_LIBS ${STARROCKS_LINK_LIBS} --coverage)
endif()

# Set libraries for test. TestUtil is UT-only and intentionally stays out of
# STARROCKS_LINK_LIBS so normal BE, format-lib, and benchmark builds do not
# compile or link test helper code.
set (TEST_LINK_LIBS
    Orchestration
    ${STARROCKS_LINK_LIBS}
    TestUtil
    ${WL_START_GROUP}
    ${DIRECT_CONNECTOR_LINK_LIBS}
    gmock
    gtest
    ${WL_END_GROUP}
)

set (BENCH_LINK_LIBS
    ${STARROCKS_LINK_LIBS}
    ${WL_START_GROUP}
    ${DIRECT_CONNECTOR_LINK_LIBS}
    ${WL_END_GROUP}
)

# Only build static libs
set(BUILD_SHARED_LIBS OFF)

set (STARROCKS_LINKER "$ENV{STARROCKS_LINKER}")
include(cmake_modules/FindGlibcVersion.cmake)

if (NOT APPLE AND GLIBC_VERSION VERSION_LESS "2.29" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 14.0.0)
    if ("${STARROCKS_LINKER}" STREQUAL "" AND NOT "${CMAKE_BUILD_TARGET_ARCH}" STREQUAL "aarch64")
        set(STARROCKS_LINKER "gold")
        message(STATUS "forcibly switch linker to: ${STARROCKS_LINKER}")
    endif()
endif()
message(STATUS "using linker: ${STARROCKS_LINKER}")

if (NOT STARROCKS_LINKER STREQUAL "")
    add_link_options("-fuse-ld=${STARROCKS_LINKER}")
endif ()

if (${MAKE_TEST} STREQUAL "ON")
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGTEST_USE_OWN_TR1_TUPLE=0")
    add_definitions(-DBE_TEST)
    add_definitions(-DFIU_ENABLE)
else()
    if (BUILD_FORMAT_LIB)
        set(THIN_ARCHIVE OFF)
        # output *.a, *.so, *.dylib to output/format-lib-tmp
        set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_DIR}/format-lib-tmp/${CMAKE_BUILD_TYPE})
        set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_DIR}/format-lib-tmp/${CMAKE_BUILD_TYPE})
    else()
        # output *.a, *.so, *.dylib to output/tmp
        set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/tmp/${CMAKE_BUILD_TYPE})
        set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_DIR}/tmp/${CMAKE_BUILD_TYPE})
    endif ()
    # output *.exe to output/lib
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_DIR}/lib)
endif ()

# Utility CMake function to make specifying tests and benchmarks less verbose
FUNCTION(ADD_BE_TEST TEST_NAME)
    set(BUILD_OUTPUT_ROOT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/")
    # This gets the directory where the test is from (e.g. 'exprs' or 'runtime')
    get_filename_component(DIR_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
    get_filename_component(TEST_DIR_NAME ${TEST_NAME} PATH)
    get_filename_component(TEST_FILE_NAME ${TEST_NAME} NAME)

    ADD_EXECUTABLE(${TEST_FILE_NAME} ${TEST_NAME}.cpp)
    TARGET_LINK_LIBRARIES(${TEST_FILE_NAME} ${TEST_LINK_LIBS} gtest_main)
    STARROCKS_FORCE_LOAD_LIBS(${TEST_FILE_NAME} ${EXPR_FORCE_LOAD_LIBS})
    SET_TARGET_PROPERTIES(${TEST_FILE_NAME} PROPERTIES COMPILE_FLAGS "-fno-access-control")
    if (NOT "${TEST_DIR_NAME}" STREQUAL "")
        SET_TARGET_PROPERTIES(${TEST_FILE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${BUILD_OUTPUT_ROOT_DIRECTORY}/${TEST_DIR_NAME}")
    endif()
    ADD_TEST(${TEST_FILE_NAME} "${BUILD_OUTPUT_ROOT_DIRECTORY}/${TEST_NAME}")
ENDFUNCTION()

# Add a benchmark to BE
FUNCTION(ADD_BE_BENCH BENCH_NAME)
    message(STATUS "Add Be Bench")
    set(BUILD_OUTPUT_ROOT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/")
    # This gets the directory where the test is from (e.g. 'exprs' or 'runtime')
    get_filename_component(DIR_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
    get_filename_component(BENCH_DIR_NAME ${BENCH_NAME} PATH)
    set(BENCH_OUTPUT_DIR_NAME "output")
    get_filename_component(BENCH_FILE_NAME ${BENCH_NAME} NAME)

    find_package(benchmark REQUIRED)
    ADD_EXECUTABLE(${BENCH_FILE_NAME} ${BENCH_NAME}.cpp)
    TARGET_LINK_LIBRARIES(${BENCH_FILE_NAME} benchmark benchmark_main ${BENCH_LINK_LIBS})
    STARROCKS_FORCE_LOAD_LIBS(${BENCH_FILE_NAME} ${EXPR_FORCE_LOAD_LIBS})

    SET_TARGET_PROPERTIES(${BENCH_FILE_NAME} PROPERTIES COMPILE_FLAGS "-fno-access-control ${CXX_FLAGS_RELEASE}")
    if (NOT "${BENCH_OUTPUT_DIR_NAME}" STREQUAL "")
        SET_TARGET_PROPERTIES(${BENCH_FILE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${BUILD_OUTPUT_ROOT_DIRECTORY}/${BENCH_OUTPUT_DIR_NAME}")
    endif()
    ADD_TEST(${BENCH_FILE_NAME} "${BUILD_OUTPUT_ROOT_DIRECTORY}/${BENCH_NAME}")
ENDFUNCTION()

add_subdirectory(${SRC_DIR}/agent)
add_subdirectory(${SRC_DIR}/base)
add_subdirectory(${SRC_DIR}/common)
add_subdirectory(${SRC_DIR}/column)
add_subdirectory(${SRC_DIR}/formats)
add_subdirectory(${SRC_DIR}/fs)
add_subdirectory(${SRC_DIR}/fs_ext)
add_subdirectory(${SRC_DIR}/exec_primitive)
add_subdirectory(${SRC_DIR}/connector_primitive)
add_subdirectory(${SRC_DIR}/connector)
add_subdirectory(${SRC_DIR}/module)
add_subdirectory(${SRC_DIR}/exec)
add_subdirectory(${SRC_DIR}/exprs)
add_subdirectory(${SRC_DIR}/gen_cpp)
add_subdirectory(${SRC_DIR}/geo)
add_subdirectory(${SRC_DIR}/gutil)
add_subdirectory(${SRC_DIR}/http)
add_subdirectory(${SRC_DIR}/io)
add_subdirectory(${SRC_DIR}/platform)
add_subdirectory(${SRC_DIR}/storage_primitive)
add_subdirectory(${SRC_DIR}/storage)
add_subdirectory(${SRC_DIR}/data_workflows)
add_subdirectory(${SRC_DIR}/retrieval)
add_subdirectory(${SRC_DIR}/runtime)
add_subdirectory(${SRC_DIR}/cache)
add_subdirectory(${SRC_DIR}/compute_env)
add_subdirectory(${SRC_DIR}/exprs_ext)
add_subdirectory(${SRC_DIR}/orchestration)
add_subdirectory(${SRC_DIR}/service)
add_subdirectory(${SRC_DIR}/types)

add_subdirectory(${SRC_DIR}/tools)
add_subdirectory(${SRC_DIR}/script)

if (BUILD_FORMAT_LIB)
    message(STATUS "Build starrocks format lib")
    add_subdirectory(${SRC_DIR}/starrocks_format)
endif()

if (WITH_BENCH STREQUAL "ON")
    message(STATUS "Build binary with bench")
    add_subdirectory(${SRC_DIR}/bench)
endif()

if (${MAKE_TEST} STREQUAL "ON")
    add_subdirectory(test)
endif ()

# Install be
install(DIRECTORY DESTINATION ${OUTPUT_DIR})
install(DIRECTORY DESTINATION ${OUTPUT_DIR}/bin)
install(DIRECTORY DESTINATION ${OUTPUT_DIR}/conf)
install(DIRECTORY DESTINATION ${OUTPUT_DIR}/lib)

install(FILES
    ${BASE_DIR}/../bin/common.sh
    ${BASE_DIR}/../bin/start_backend.sh
    ${BASE_DIR}/../bin/start_be.sh
    ${BASE_DIR}/../bin/start_cn.sh
    ${BASE_DIR}/../bin/stop_be.sh
    ${BASE_DIR}/../bin/stop_cn.sh
    ${BASE_DIR}/../bin/show_be_version.sh
    ${BASE_DIR}/../bin/meta_tool.sh
    ${BASE_DIR}/../bin/collect_be_profile.sh
    PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
    GROUP_READ GROUP_WRITE GROUP_EXECUTE
    WORLD_READ WORLD_EXECUTE
    DESTINATION ${OUTPUT_DIR}/bin)

install(FILES
    ${BASE_DIR}/../conf/be.conf
    ${BASE_DIR}/../conf/be_test.conf
    ${BASE_DIR}/../conf/cn.conf
    ${BASE_DIR}/../conf/hadoop_env.sh
    ${BASE_DIR}/../conf/log4j2.properties
    ${BASE_DIR}/../conf/udf_security.policy
    ${BASE_DIR}/../conf/core-site.xml
    ${BASE_DIR}/../conf/asan_suppressions.conf
    DESTINATION ${OUTPUT_DIR}/conf)

install(FILES
    ${BASE_DIR}/../conf/type_checker_config.xml
    DESTINATION ${OUTPUT_DIR}/lib)

install(DIRECTORY
    ${BASE_DIR}/../webroot/be/
    DESTINATION ${OUTPUT_DIR}/www)

FINALIZE_BE_LIBS()