cmake_modules/SetupCxxFlags.cmake - paimon-cpp - Git at Google


            
            # 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()
	# 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()