# 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.

# Check if the target architecture and compiler supports some special
# instruction sets that would boost performance.
include(CheckCXXCompilerFlag)
# Get cpu architecture

message(STATUS "System processor: ${CMAKE_SYSTEM_PROCESSOR}")

include("${CMAKE_CURRENT_LIST_DIR}/TargetArchitecture.cmake")
message(STATUS "Target processor: ${PAIMON_TARGET_PROCESSOR} "
               "(CPU family: ${PAIMON_TARGET_CPU_FAMILY})")

# Probe the architecture specific tuning flags. x86 deliberately gets none of its
# own, so there is nothing to probe there: the baseline stays whatever the
# toolchain defaults to, and no persisted value depends on it; see
# src/paimon/common/utils/crc32c.h.
if(PAIMON_TARGET_CPU_FAMILY STREQUAL "aarch64" AND NOT "${PAIMON_AARCH64_MARCH}" STREQUAL
                                                   "")
    set(PAIMON_AARCH64_MARCH_FLAG "-march=${PAIMON_AARCH64_MARCH}")
    # check_cxx_compiler_flag() caches under a fixed name, so a reconfigure in the
    # same build directory would otherwise reuse the old PAIMON_AARCH64_MARCH verdict.
    if(NOT "${PAIMON_AARCH64_MARCH_FLAG}" STREQUAL "${PAIMON_PROBED_AARCH64_MARCH_FLAG}")
        unset(CXX_SUPPORTS_AARCH64_MARCH CACHE)
        set(PAIMON_PROBED_AARCH64_MARCH_FLAG
            "${PAIMON_AARCH64_MARCH_FLAG}"
            CACHE INTERNAL "Arm64 arch flag that CXX_SUPPORTS_AARCH64_MARCH refers to")
    endif()
    check_cxx_compiler_flag("${PAIMON_AARCH64_MARCH_FLAG}" CXX_SUPPORTS_AARCH64_MARCH)
endif()

# Support C11
if(NOT DEFINED CMAKE_C_STANDARD)
    set(CMAKE_C_STANDARD 11)
endif()

# This ensures that things like c++11 get passed correctly
if(NOT DEFINED CMAKE_CXX_STANDARD)
    set(CMAKE_CXX_STANDARD 17)
endif()

# We require a C++11 compliant compiler
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(CMAKE_CXX_EXTENSIONS OFF)

# Build with -fPIC so that can static link our libraries into other people's
# shared libraries
set(CMAKE_POSITION_INDEPENDENT_CODE ON)

string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE)

set(UNKNOWN_COMPILER_MESSAGE
    "Unknown compiler: ${CMAKE_CXX_COMPILER_VERSION} ${CMAKE_CXX_COMPILER_VERSION}")

# Defaults BUILD_WARNING_LEVEL to `CHECKIN`, unless CMAKE_BUILD_TYPE is
# `RELEASE`, then it will default to `PRODUCTION`. The goal of defaulting to
# `CHECKIN` is to avoid friction with long response time from CI.
if(NOT BUILD_WARNING_LEVEL)
    if("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
        set(BUILD_WARNING_LEVEL PRODUCTION)
    else()
        set(BUILD_WARNING_LEVEL CHECKIN)
    endif()
endif(NOT BUILD_WARNING_LEVEL)
string(TOUPPER ${BUILD_WARNING_LEVEL} BUILD_WARNING_LEVEL)

message(STATUS "Paimon build warning level: ${BUILD_WARNING_LEVEL}")

set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Werror")

if("${BUILD_WARNING_LEVEL}" STREQUAL "CHECKIN")
    # Pre-checkin builds
    if(MSVC)
        # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warnings-by-compiler-version
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /W3")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4365")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4267")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4838")
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL
                                                          "Clang")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wextra")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wdocumentation")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wglobal-constructors")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-missing-braces")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unused-parameter")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unknown-warning-option")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-constant-logical-operand")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated-declarations")
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-conversion")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated-declarations")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-sign-conversion")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unused-variable")
    else()
        message(FATAL_ERROR "${UNKNOWN_COMPILER_MESSAGE}")
    endif()

elseif("${BUILD_WARNING_LEVEL}" STREQUAL "EVERYTHING")
    # Pedantic builds for fixing warnings
    if(MSVC)
        string(REPLACE "/W3" "" CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS}")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wall")
        # https://docs.microsoft.com/en-us/cpp/build/reference/compiler-option-warning-level
        # /wdnnnn disables a warning where "nnnn" is a warning number
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL
                                                          "Clang")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Weverything")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-c++98-compat")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-c++98-compat-pedantic")
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wpedantic")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wextra")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unused-parameter")
    else()
        message(FATAL_ERROR "${UNKNOWN_COMPILER_MESSAGE}")
    endif()

else()
    # Production builds (warning are not treated as errors)
    if(MSVC)
        # https://docs.microsoft.com/en-us/cpp/build/reference/compiler-option-warning-level
        # TODO: Enable /Wall and disable individual warnings until build compiles without errors
        # /wdnnnn disables a warning where "nnnn" is a warning number
        string(REPLACE "/W3" "" CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS}")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /W3")
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang"
           OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
           OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
    else()
        message(FATAL_ERROR "${UNKNOWN_COMPILER_MESSAGE}")
    endif()

endif()

if(MSVC)
    # Disable annoying "performance warning" about int-to-bool conversion
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4800")

    # Disable unchecked iterator warnings, equivalent to /D_SCL_SECURE_NO_WARNINGS
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4996")

    # Disable "switch statement contains 'default' but no 'case' labels" warning
    # (required for protobuf, see https://github.com/protocolbuffers/protobuf/issues/6885)
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4065")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    if(CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "7.0" OR CMAKE_CXX_COMPILER_VERSION
                                                         VERSION_GREATER "7.0")
        # Without this, gcc >= 7 warns related to changes in C++17
        set(CXX_ONLY_FLAGS
            "${CXX_ONLY_FLAGS} -Wno-noexcept-type -Wno-stringop-overflow -Wno-free-nonheap-object"
        )
    endif()

    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "4.9")
        # Add colors when paired with ninja
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=always")
    endif()

    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0")
        # Work around https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43407
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-attributes")
    endif()

    if(CMAKE_UNITY_BUILD)
        # Work around issue similar to https://bugs.webkit.org/show_bug.cgi?id=176869
        set(CXX_ONLY_FLAGS "${CXX_ONLY_FLAGS} -Wno-subobject-linkage")
    endif()

    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "8.0"
       AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "9.0")
        # When using the C++17 filesystem library (<filesystem>) with GCC 8, you do need to explicitly link stdc++fs.
        link_libraries(stdc++fs)
    endif()

elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL
                                                      "Clang")
    # Clang options for all builds

    # Using Clang with ccache causes a bunch of spurious warnings that are
    # purportedly fixed in the next version of ccache. See the following for details:
    #
    #   http://petereisentraut.blogspot.com/2011/05/ccache-and-clang.html
    #   http://petereisentraut.blogspot.com/2011/09/ccache-and-clang-part-2.html
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Qunused-arguments")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qunused-arguments")

    # Avoid clang error when an unknown warning flag is passed
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unknown-warning-option")
    # Add colors when paired with ninja
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")

    # Don't complain about optimization passes that were not possible
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-pass-failed")
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated-declarations")

    if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
        # Depending on the default OSX_DEPLOYMENT_TARGET (< 10.9), libstdc++ may be
        # the default standard library which does not support C++11. libc++ is the
        # default from 10.9 onward.
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -stdlib=libc++")
    elseif(APPLE AND PAIMON_USE_APPLE_LIBCXX_WITH_CLANG)
        execute_process(COMMAND xcrun --show-sdk-path
                        OUTPUT_VARIABLE PAIMON_MACOS_SDK_PATH
                        OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
        if(NOT PAIMON_MACOS_SDK_PATH)
            message(FATAL_ERROR "PAIMON_USE_APPLE_LIBCXX_WITH_CLANG is enabled, but xcrun could not find the macOS SDK"
            )
        endif()
        set(PAIMON_MACOS_LIBCXX_INCLUDE_DIR "${PAIMON_MACOS_SDK_PATH}/usr/include/c++/v1")
        if(NOT EXISTS "${PAIMON_MACOS_LIBCXX_INCLUDE_DIR}/cstdlib")
            message(FATAL_ERROR "PAIMON_USE_APPLE_LIBCXX_WITH_CLANG is enabled, but libc++ headers were not found at ${PAIMON_MACOS_LIBCXX_INCLUDE_DIR}"
            )
        endif()
        message(STATUS "Using Apple libc++ headers with Clang: ${PAIMON_MACOS_LIBCXX_INCLUDE_DIR}"
        )
        set(CMAKE_CXX_FLAGS
            "${CMAKE_CXX_FLAGS} -nostdinc++ -isystem ${PAIMON_MACOS_LIBCXX_INCLUDE_DIR} -include cstdlib"
        )
    endif()
endif()

# if build warning flags is set, add to CXX_COMMON_FLAGS
if(BUILD_WARNING_FLAGS)
    # Use BUILD_WARNING_FLAGS with BUILD_WARNING_LEVEL=everything to disable
    # warnings (use with Clang's -Weverything flag to find potential errors)
    set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} ${BUILD_WARNING_FLAGS}")
endif(BUILD_WARNING_FLAGS)

# Only enable additional instruction sets if they are supported
if(PAIMON_TARGET_CPU_FAMILY STREQUAL "aarch64")
    if("${PAIMON_AARCH64_MARCH}" STREQUAL "")
        # An explicitly empty PAIMON_AARCH64_MARCH opts out of -march entirely, for
        # toolchains that reject the flag, such as AppleClang targeting arm64.
        message(STATUS "PAIMON_AARCH64_MARCH is empty: passing no -march flag")
    else()
        if(NOT CXX_SUPPORTS_AARCH64_MARCH)
            message(FATAL_ERROR "The compiler does not accept ${PAIMON_AARCH64_MARCH_FLAG}. "
                                "Set -DPAIMON_AARCH64_MARCH to a value it accepts, or to an "
                                "empty string to pass no -march flag.")
        endif()
        if(PAIMON_AARCH64_MARCH_FLAG MATCHES "native")
            message(FATAL_ERROR "native arch not allowed, please specify arch explicitly."
            )
        endif()
        set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} ${PAIMON_AARCH64_MARCH_FLAG}")
    endif()
endif()

# ----------------------------------------------------------------------
# Setup Gold linker, if available. Code originally from Apache Kudu

# Interrogates the linker version via the C++ compiler to determine whether
# we're using the gold linker, and if so, extracts its version.
#
# If the gold linker is being used, sets GOLD_VERSION in the parent scope with
# the extracted version.
#
# Any additional arguments are passed verbatim into the C++ compiler invocation.
function(GET_GOLD_VERSION)
    # The gold linker is only for ELF binaries, which macOS doesn't use.
    execute_process(COMMAND ${CMAKE_CXX_COMPILER} "-Wl,--version" ${ARGN}
                    ERROR_QUIET
                    OUTPUT_VARIABLE LINKER_OUTPUT)
    # We're expecting LINKER_OUTPUT to look like one of these:
    #   GNU gold (version 2.24) 1.11
    #   GNU gold (GNU Binutils for Ubuntu 2.30) 1.15
    if(LINKER_OUTPUT MATCHES "GNU gold")
        string(REGEX MATCH "GNU gold \\([^\\)]*\\) (([0-9]+\\.?)+)" _ "${LINKER_OUTPUT}")
        if(NOT CMAKE_MATCH_1)
            message(SEND_ERROR "Could not extract GNU gold version. "
                               "Linker version output: ${LINKER_OUTPUT}")
        endif()
        set(GOLD_VERSION
            "${CMAKE_MATCH_1}"
            PARENT_SCOPE)
    endif()
endfunction()

# Is the compiler hard-wired to use the gold linker?
if(NOT WIN32 AND NOT APPLE)
    get_gold_version()
    if(GOLD_VERSION)
        set(MUST_USE_GOLD 1)
    elseif(PAIMON_USE_LD_GOLD)
        # Can the compiler optionally enable the gold linker?
        get_gold_version("-fuse-ld=gold")

        # We can't use the gold linker if it's inside devtoolset because the compiler
        # won't find it when invoked directly from make/ninja (which is typically
        # done outside devtoolset).
        execute_process(COMMAND which ld.gold
                        OUTPUT_VARIABLE GOLD_LOCATION
                        OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
        if("${GOLD_LOCATION}" MATCHES "^/opt/rh/devtoolset")
            message("Skipping optional gold linker (version ${GOLD_VERSION}) because "
                    "it's in devtoolset")
            set(GOLD_VERSION)
        endif()
    endif()

    if(GOLD_VERSION)
        # Older versions of the gold linker are vulnerable to a bug [1] which
        # prevents weak symbols from being overridden properly. This leads to
        # omitting of dependencies like tcmalloc (used in Kudu, where this
        # workaround was written originally)
        #
        # How we handle this situation depends on other factors:
        # - If gold is optional, we won't use it.
        # - If gold is required, we'll either:
        #   - Raise an error in RELEASE builds (we shouldn't release such a product), or
        #   - Drop tcmalloc in all other builds.
        #
        # 1. https://sourceware.org/bugzilla/show_bug.cgi?id=16979.
        if("${GOLD_VERSION}" VERSION_LESS "1.12")
            set(PAIMON_BUGGY_GOLD 1)
        endif()
        if(MUST_USE_GOLD)
            message("Using hard-wired gold linker (version ${GOLD_VERSION})")
            if(PAIMON_BUGGY_GOLD)
                if("${PAIMON_LINK}" STREQUAL "d" AND "${CMAKE_BUILD_TYPE}" STREQUAL
                                                     "RELEASE")
                    message(SEND_ERROR "Configured to use buggy gold with dynamic linking "
                                       "in a RELEASE build")
                endif()
            endif()
        elseif(NOT PAIMON_BUGGY_GOLD)
            # The Gold linker must be manually enabled.
            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fuse-ld=gold")
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fuse-ld=gold")
            message("Using optional gold linker (version ${GOLD_VERSION})")
        else()
            message("Optional gold linker is buggy, using ld linker instead")
        endif()
    else()
        message("Using ld linker")
    endif()
endif()

# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .')
# For all builds:
# For CMAKE_BUILD_TYPE=Debug
#   -ggdb: Enable gdb debugging
# For CMAKE_BUILD_TYPE=FastDebug
#   Same as DEBUG, except with some optimizations on.
# For CMAKE_BUILD_TYPE=Release
#   -O3: Enable all compiler optimizations
#   Debug symbols are stripped for reduced binary size. Add
#   -DPAIMON_CXXFLAGS="-g" to add them
if(NOT MSVC)
    if(PAIMON_GGDB_DEBUG)
        set(PAIMON_DEBUG_SYMBOL_TYPE "gdb")
        set(C_FLAGS_DEBUG "-g${PAIMON_DEBUG_SYMBOL_TYPE} -O0")
        set(C_FLAGS_FASTDEBUG "-g${PAIMON_DEBUG_SYMBOL_TYPE} -O1")
        set(CXX_FLAGS_DEBUG "-g${PAIMON_DEBUG_SYMBOL_TYPE} -O0")
        set(CXX_FLAGS_FASTDEBUG "-g${PAIMON_DEBUG_SYMBOL_TYPE} -O1")
    else()
        set(C_FLAGS_DEBUG "-g -O0")
        set(C_FLAGS_FASTDEBUG "-g -O1")
        set(CXX_FLAGS_DEBUG "-g -O0")
        set(CXX_FLAGS_FASTDEBUG "-g -O1")
    endif()

    set(C_FLAGS_RELEASE "-O3 -DNDEBUG")
    set(CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
endif()

set(C_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate")
set(C_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use")
set(CXX_FLAGS_PROFILE_GEN "${CXX_FLAGS_RELEASE} -fprofile-generate")
set(CXX_FLAGS_PROFILE_BUILD "${CXX_FLAGS_RELEASE} -fprofile-use")

# Set compile flags based on the build type.
message("Configured for ${CMAKE_BUILD_TYPE} build (set with cmake -DCMAKE_BUILD_TYPE={release,debug,...})"
)
if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_DEBUG}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_DEBUG}")
elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO")

elseif("${CMAKE_BUILD_TYPE}" STREQUAL "FASTDEBUG")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_FASTDEBUG}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_FASTDEBUG}")
elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_RELEASE}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_RELEASE}")
elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_GEN")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_GEN}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_GEN}")
elseif("${CMAKE_BUILD_TYPE}" STREQUAL "PROFILE_BUILD")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${C_FLAGS_PROFILE_BUILD}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAGS_PROFILE_BUILD}")
else()
    message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}")
endif()

if("${CMAKE_CXX_FLAGS}" MATCHES "-DNDEBUG")
    set(PAIMON_DEFINITION_FLAGS "-DNDEBUG")
else()
    set(PAIMON_DEFINITION_FLAGS "")
endif()

message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}")

# ----------------------------------------------------------------------
# MSVC-specific linker options

if(MSVC)
    set(MSVC_LINKER_FLAGS)
    if(MSVC_LINK_VERBOSE)
        set(MSVC_LINKER_FLAGS "${MSVC_LINKER_FLAGS} /VERBOSE:LIB")
    endif()
    if(NOT PAIMON_USE_STATIC_CRT)
        set(MSVC_LINKER_FLAGS "${MSVC_LINKER_FLAGS} /NODEFAULTLIB:LIBCMT")
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LINKER_FLAGS}")
        set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MSVC_LINKER_FLAGS}")
        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MSVC_LINKER_FLAGS}")
    endif()
endif()