diff --git a/clang/CMakeLists.txt b/clang/CMakeLists.txt index c20ce47a12abb..a6bcb853a464c 100644 --- a/clang/CMakeLists.txt +++ b/clang/CMakeLists.txt @@ -349,10 +349,7 @@ if (LLVM_COMPILER_IS_GCC_COMPATIBLE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wno-long-long") endif () - check_cxx_compiler_flag("-Werror -Wnested-anon-types" CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG) - if( CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG ) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types" ) - endif() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types" ) endif () # Determine HOST_LINK_VERSION on Darwin. diff --git a/clang/tools/scan-build-py/tests/functional/exec/CMakeLists.txt b/clang/tools/scan-build-py/tests/functional/exec/CMakeLists.txt index 95c6fdb610e0f..cb6ebda183725 100644 --- a/clang/tools/scan-build-py/tests/functional/exec/CMakeLists.txt +++ b/clang/tools/scan-build-py/tests/functional/exec/CMakeLists.txt @@ -2,11 +2,7 @@ project(exec C) cmake_minimum_required(VERSION 3.20.0) -include(CheckCCompilerFlag) -check_c_compiler_flag("-std=c99" C99_SUPPORTED) -if (C99_SUPPORTED) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99") -endif() +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99") include(CheckFunctionExists) include(CheckSymbolExists) diff --git a/lldb/cmake/modules/LLDBConfig.cmake b/lldb/cmake/modules/LLDBConfig.cmake index 3c6223b015bb1..6458f2e174643 100644 --- a/lldb/cmake/modules/LLDBConfig.cmake +++ b/lldb/cmake/modules/LLDBConfig.cmake @@ -187,24 +187,18 @@ include_directories("${CMAKE_CURRENT_BINARY_DIR}/../clang/include") # form -W, and if supported, add the corresponding -Wno- option. # Disable GCC warnings -check_cxx_compiler_flag("-Wdeprecated-declarations" CXX_SUPPORTS_DEPRECATED_DECLARATIONS) -append_if(CXX_SUPPORTS_DEPRECATED_DECLARATIONS "-Wno-deprecated-declarations" CMAKE_CXX_FLAGS) - -check_cxx_compiler_flag("-Wunknown-pragmas" CXX_SUPPORTS_UNKNOWN_PRAGMAS) -append_if(CXX_SUPPORTS_UNKNOWN_PRAGMAS "-Wno-unknown-pragmas" CMAKE_CXX_FLAGS) - -check_cxx_compiler_flag("-Wstrict-aliasing" CXX_SUPPORTS_STRICT_ALIASING) -append_if(CXX_SUPPORTS_STRICT_ALIASING "-Wno-strict-aliasing" CMAKE_CXX_FLAGS) +append("-Wno-deprecated-declarations" CMAKE_CXX_FLAGS) +append("-Wno-unknown-pragmas" CMAKE_CXX_FLAGS) +append("-Wno-strict-aliasing" CMAKE_CXX_FLAGS) check_cxx_compiler_flag("-Wstringop-truncation" CXX_SUPPORTS_STRINGOP_TRUNCATION) append_if(CXX_SUPPORTS_STRINGOP_TRUNCATION "-Wno-stringop-truncation" CMAKE_CXX_FLAGS) # Disable Clang warnings -check_cxx_compiler_flag("-Wdeprecated-register" CXX_SUPPORTS_DEPRECATED_REGISTER) -append_if(CXX_SUPPORTS_DEPRECATED_REGISTER "-Wno-deprecated-register" CMAKE_CXX_FLAGS) - -check_cxx_compiler_flag("-Wvla-extension" CXX_SUPPORTS_VLA_EXTENSION) -append_if(CXX_SUPPORTS_VLA_EXTENSION "-Wno-vla-extension" CMAKE_CXX_FLAGS) +if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + append("-Wno-deprecated-register" CMAKE_CXX_FLAGS) + append("-Wno-vla-extension" CMAKE_CXX_FLAGS) +endif() # Disable MSVC warnings if( MSVC ) diff --git a/llvm/cmake/config-ix.cmake b/llvm/cmake/config-ix.cmake index bf1b110245bb2..5a884a5b0a0c0 100644 --- a/llvm/cmake/config-ix.cmake +++ b/llvm/cmake/config-ix.cmake @@ -415,15 +415,18 @@ if( LLVM_ENABLE_PIC ) set(ENABLE_PIC 1) else() set(ENABLE_PIC 0) - check_cxx_compiler_flag("-fno-pie" SUPPORTS_NO_PIE_FLAG) - if(SUPPORTS_NO_PIE_FLAG) - set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-pie") - endif() + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-pie") endif() -check_cxx_compiler_flag("-Wvariadic-macros" SUPPORTS_VARIADIC_MACROS_FLAG) -check_cxx_compiler_flag("-Wgnu-zero-variadic-macro-arguments" - SUPPORTS_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS_FLAG) +set(SUPPORTS_VARIADIC_MACROS_FLAG 0) +if (LLVM_COMPILER_IS_GCC_COMPATIBLE) + set(SUPPORTS_VARIADIC_MACROS_FLAG 1) +endif() +if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set(SUPPORTS_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS_FLAG 1) +else() + set(SUPPORTS_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS_FLAG 0) +endif() set(USE_NO_MAYBE_UNINITIALIZED 0) set(USE_NO_UNINITIALIZED 0) @@ -433,11 +436,9 @@ set(USE_NO_UNINITIALIZED 0) if (CMAKE_COMPILER_IS_GNUCXX) # Disable all -Wuninitialized warning for old GCC versions. if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0) - check_cxx_compiler_flag("-Wuninitialized" HAS_UNINITIALIZED) - set(USE_NO_UNINITIALIZED ${HAS_UNINITIALIZED}) + set(USE_NO_UNINITIALIZED 1) else() - check_cxx_compiler_flag("-Wmaybe-uninitialized" HAS_MAYBE_UNINITIALIZED) - set(USE_NO_MAYBE_UNINITIALIZED ${HAS_MAYBE_UNINITIALIZED}) + set(USE_NO_MAYBE_UNINITIALIZED 1) endif() endif() diff --git a/llvm/cmake/modules/AddLLVM.cmake b/llvm/cmake/modules/AddLLVM.cmake index 693fd5669f63f..e600b8ff7c0f0 100644 --- a/llvm/cmake/modules/AddLLVM.cmake +++ b/llvm/cmake/modules/AddLLVM.cmake @@ -260,11 +260,11 @@ if (NOT DEFINED LLVM_LINKER_DETECTED AND NOT WIN32) if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") include(CheckLinkerFlag) - # Linkers that support Darwin allow a setting to internalize all symbol exports, + # Linkers that support Darwin allow a setting to internalize all symbol exports, # aiding in reducing binary size and often is applicable for executables. check_linker_flag(C "-Wl,-no_exported_symbols" LLVM_LINKER_SUPPORTS_NO_EXPORTED_SYMBOLS) - - if (NOT LLVM_USE_LINKER) + + if (NOT LLVM_USE_LINKER) # Apple's linker complains about duplicate libraries, which CMake likes to do # to support ELF platforms. To silence that warning, we can use # -no_warn_duplicate_libraries, but only in versions of the linker that @@ -273,8 +273,8 @@ if (NOT DEFINED LLVM_LINKER_DETECTED AND NOT WIN32) else() set(LLVM_LINKER_SUPPORTS_NO_WARN_DUPLICATE_LIBRARIES OFF CACHE INTERNAL "") endif() - - else() + + else() set(LLVM_LINKER_SUPPORTS_NO_EXPORTED_SYMBOLS OFF CACHE INTERNAL "") endif() endif() @@ -1038,7 +1038,7 @@ macro(add_llvm_executable name) add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} ) endif(LLVM_EXPORTED_SYMBOL_FILE) - if (DEFINED LLVM_ENABLE_EXPORTED_SYMBOLS_IN_EXECUTABLES AND + if (DEFINED LLVM_ENABLE_EXPORTED_SYMBOLS_IN_EXECUTABLES AND NOT LLVM_ENABLE_EXPORTED_SYMBOLS_IN_EXECUTABLES) if(LLVM_LINKER_SUPPORTS_NO_EXPORTED_SYMBOLS) set_property(TARGET ${name} APPEND_STRING PROPERTY @@ -1641,7 +1641,7 @@ function(add_unittest test_suite test_name) if (SUPPORTS_VARIADIC_MACROS_FLAG) list(APPEND LLVM_COMPILE_FLAGS "-Wno-variadic-macros") - endif () + endif() # Some parts of gtest rely on this GNU extension, don't warn on it. if(SUPPORTS_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS_FLAG) list(APPEND LLVM_COMPILE_FLAGS "-Wno-gnu-zero-variadic-macro-arguments") diff --git a/llvm/cmake/modules/HandleLLVMOptions.cmake b/llvm/cmake/modules/HandleLLVMOptions.cmake index d16641d831900..46b17711b9df2 100644 --- a/llvm/cmake/modules/HandleLLVMOptions.cmake +++ b/llvm/cmake/modules/HandleLLVMOptions.cmake @@ -425,7 +425,7 @@ if( LLVM_ENABLE_PIC ) # GCC for MIPS can miscompile LLVM due to PR37701. if(CMAKE_COMPILER_IS_GNUCXX AND LLVM_NATIVE_ARCH STREQUAL "Mips" AND NOT Uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") - add_flag_or_print_warning("-fno-shrink-wrap" FNO_SHRINK_WRAP) + append("-fno-shrink-wrap" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif() # gcc with -O3 -fPIC generates TLS sequences that violate the spec on # Solaris/sparcv9, causing executables created with the system linker @@ -635,18 +635,16 @@ if( MSVC ) # This checks CMAKE_CXX_COMPILER_ID in addition to check_cxx_compiler_flag() # because cl.exe does not emit an error on flags it doesn't understand, # letting check_cxx_compiler_flag() claim it understands all flags. - check_cxx_compiler_flag("/Brepro" SUPPORTS_BREPRO) - if (SUPPORTS_BREPRO) - # Check if /INCREMENTAL is passed to the linker and complain that it - # won't work with /Brepro. - has_msvc_incremental_no_flag("${CMAKE_EXE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_EXE_LINKER_FLAGS}" NO_INCR_EXE) - has_msvc_incremental_no_flag("${CMAKE_MODULE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_MODULE_LINKER_FLAGS}" NO_INCR_MODULE) - has_msvc_incremental_no_flag("${CMAKE_SHARED_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_SHARED_LINKER_FLAGS}" NO_INCR_SHARED) - if (NO_INCR_EXE AND NO_INCR_MODULE AND NO_INCR_SHARED) - append("/Brepro" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) - else() - message(WARNING "/Brepro not compatible with /INCREMENTAL linking - builds will be non-deterministic") - endif() + + # Check if /INCREMENTAL is passed to the linker and complain that it + # won't work with /Brepro. + has_msvc_incremental_no_flag("${CMAKE_EXE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_EXE_LINKER_FLAGS}" NO_INCR_EXE) + has_msvc_incremental_no_flag("${CMAKE_MODULE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_MODULE_LINKER_FLAGS}" NO_INCR_MODULE) + has_msvc_incremental_no_flag("${CMAKE_SHARED_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_SHARED_LINKER_FLAGS}" NO_INCR_SHARED) + if (NO_INCR_EXE AND NO_INCR_MODULE AND NO_INCR_SHARED) + append("/Brepro" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + else() + message(WARNING "/Brepro not compatible with /INCREMENTAL linking - builds will be non-deterministic") endif() endif() # By default MSVC has a 2^16 limit on the number of sections in an object file, @@ -667,19 +665,22 @@ endif( LLVM_COMPILER_IS_GCC_COMPATIBLE ) # Specific default warnings-as-errors for compilers accepting GCC-compatible warning flags: if ( LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL" ) - add_flag_if_supported("-Werror=date-time" WERROR_DATE_TIME) - add_flag_if_supported("-Werror=unguarded-availability-new" WERROR_UNGUARDED_AVAILABILITY_NEW) + append("-Werror=date-time" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif( LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL" ) -if ( LLVM_COMPILER_IS_GCC_COMPATIBLE ) +if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + append("-Werror=unguarded-availability-new" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) +endif() + +if (CMAKE_CXX_COMPILER_ID STREQUAL "GCC") # LLVM data structures like llvm::User and llvm::MDNode rely on # the value of object storage persisting beyond the lifetime of the # object (#24952). This is not standard compliant and causes a runtime # crash if LLVM is built with GCC and LTO enabled (#57740). Until # these bugs are fixed, we need to disable dead store eliminations # based on object lifetime. - add_flag_if_supported("-fno-lifetime-dse" CMAKE_CXX_FLAGS) -endif ( LLVM_COMPILER_IS_GCC_COMPATIBLE ) + append("-fno-lifetime-dse" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) +endif () # Modules enablement for GCC-compatible compilers: if ( LLVM_COMPILER_IS_GCC_COMPATIBLE AND LLVM_ENABLE_MODULES ) @@ -697,22 +698,7 @@ if ( LLVM_COMPILER_IS_GCC_COMPATIBLE AND LLVM_ENABLE_MODULES ) (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO"))) set(module_flags "${module_flags} -gmodules") endif() - set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${module_flags}") - - # Check that we can build code with modules enabled, and that repeatedly - # including still manages to respect NDEBUG properly. - CHECK_CXX_SOURCE_COMPILES("#undef NDEBUG - #include - #define NDEBUG - #include - int main() { assert(this code is not compiled); }" - CXX_SUPPORTS_MODULES) - set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS}) - if (CXX_SUPPORTS_MODULES) - append("${module_flags}" CMAKE_CXX_FLAGS) - else() - message(FATAL_ERROR "LLVM_ENABLE_MODULES is not supported by this compiler") - endif() + append("${module_flags}" CMAKE_CXX_FLAGS) endif( LLVM_COMPILER_IS_GCC_COMPATIBLE AND LLVM_ENABLE_MODULES ) if (MSVC) @@ -814,13 +800,10 @@ if (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL)) # Turn off missing field initializer warnings for gcc to avoid noise from # false positives with empty {}. Turn them on otherwise (they're off by # default for clang). - check_cxx_compiler_flag("-Wmissing-field-initializers" CXX_SUPPORTS_MISSING_FIELD_INITIALIZERS_FLAG) - if (CXX_SUPPORTS_MISSING_FIELD_INITIALIZERS_FLAG) - if (CMAKE_COMPILER_IS_GNUCXX) - append("-Wno-missing-field-initializers" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) - else() - append("-Wmissing-field-initializers" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) - endif() + if (CMAKE_COMPILER_IS_GNUCXX) + append("-Wno-missing-field-initializers" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + else() + append("-Wmissing-field-initializers" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif() if (LLVM_ENABLE_PEDANTIC AND LLVM_COMPILER_IS_GCC_COMPATIBLE) @@ -833,8 +816,10 @@ if (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL)) add_flag_if_supported("-Wc++98-compat-extra-semi" CXX98_COMPAT_EXTRA_SEMI_FLAG) endif() - add_flag_if_supported("-Wimplicit-fallthrough" IMPLICIT_FALLTHROUGH_FLAG) - add_flag_if_supported("-Wcovered-switch-default" COVERED_SWITCH_DEFAULT_FLAG) + append("-Wimplicit-fallthrough" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + append("-Wcovered-switch-default" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + endif() append_if(USE_NO_UNINITIALIZED "-Wno-uninitialized" CMAKE_CXX_FLAGS) append_if(USE_NO_MAYBE_UNINITIALIZED "-Wno-maybe-uninitialized" CMAKE_CXX_FLAGS) @@ -845,38 +830,30 @@ if (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL)) # Disable -Wclass-memaccess, a C++-only warning from GCC 8 that fires on # LLVM's ADT classes. - check_cxx_compiler_flag("-Wclass-memaccess" CXX_SUPPORTS_CLASS_MEMACCESS_FLAG) - append_if(CXX_SUPPORTS_CLASS_MEMACCESS_FLAG "-Wno-class-memaccess" CMAKE_CXX_FLAGS) + if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1) + append("-Wno-class-memaccess" CMAKE_CXX_FLAGS) + endif() + endif() # Disable -Wredundant-move and -Wpessimizing-move on GCC>=9. GCC wants to - # remove std::move in code like "A foo(ConvertibleToA a) { - # return std::move(a); }", but this code does not compile (or uses the copy + # remove std::move in code like + # "A foo(ConvertibleToA a) { return std::move(a); }", + # but this code does not compile (or uses the copy # constructor instead) on clang<=3.8. Clang also has a -Wredundant-move and # -Wpessimizing-move, but they only fire when the types match exactly, so we # can keep them here. if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") - check_cxx_compiler_flag("-Wredundant-move" CXX_SUPPORTS_REDUNDANT_MOVE_FLAG) - append_if(CXX_SUPPORTS_REDUNDANT_MOVE_FLAG "-Wno-redundant-move" CMAKE_CXX_FLAGS) - check_cxx_compiler_flag("-Wpessimizing-move" CXX_SUPPORTS_PESSIMIZING_MOVE_FLAG) - append_if(CXX_SUPPORTS_PESSIMIZING_MOVE_FLAG "-Wno-pessimizing-move" CMAKE_CXX_FLAGS) + if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 9.1) + append("-Wno-redundant-move" CMAKE_CXX_FLAGS) + append("-Wno-pessimizing-move" CMAKE_CXX_FLAGS) + endif() endif() # The LLVM libraries have no stable C++ API, so -Wnoexcept-type is not useful. - check_cxx_compiler_flag("-Wnoexcept-type" CXX_SUPPORTS_NOEXCEPT_TYPE_FLAG) - append_if(CXX_SUPPORTS_NOEXCEPT_TYPE_FLAG "-Wno-noexcept-type" CMAKE_CXX_FLAGS) - - # Check if -Wnon-virtual-dtor warns for a class marked final, when it has a - # friend declaration. If it does, don't add -Wnon-virtual-dtor. The case is - # considered unhelpful (https://gcc.gnu.org/PR102168). - set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS}) - set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror=non-virtual-dtor") - CHECK_CXX_SOURCE_COMPILES("class f {}; - class base {friend f; public: virtual void anchor();protected: ~base();}; - int main() { return 0; }" - CXX_WONT_WARN_ON_FINAL_NONVIRTUALDTOR) - set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS}) - append_if(CXX_WONT_WARN_ON_FINAL_NONVIRTUALDTOR "-Wnon-virtual-dtor" CMAKE_CXX_FLAGS) + append("-Wno-noexcept-type" CMAKE_CXX_FLAGS) + append("-Wnon-virtual-dtor" CMAKE_CXX_FLAGS) append("-Wdelete-non-virtual-dtor" CMAKE_CXX_FLAGS) # Enable -Wsuggest-override if it's available, and only if it doesn't @@ -906,14 +883,15 @@ if (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL)) endif() # Enable -Wstring-conversion to catch misuse of string literals. - add_flag_if_supported("-Wstring-conversion" STRING_CONVERSION_FLAG) + if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + append("-Wstring-conversion" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + endif() if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") # Disable the misleading indentation warning with GCC; GCC can # produce noisy notes about this getting disabled in large files. # See e.g. https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89549 - check_cxx_compiler_flag("-Wmisleading-indentation" CXX_SUPPORTS_MISLEADING_INDENTATION_FLAG) - append_if(CXX_SUPPORTS_MISLEADING_INDENTATION_FLAG "-Wno-misleading-indentation" CMAKE_CXX_FLAGS) + append("-Wno-misleading-indentation" CMAKE_CXX_FLAGS) else() # Prevent bugs that can happen with llvm's brace style. add_flag_if_supported("-Wmisleading-indentation" MISLEADING_INDENTATION_FLAG) @@ -931,14 +909,15 @@ macro(append_common_sanitizer_flags) if (NOT MSVC OR CLANG_CL) # Append -fno-omit-frame-pointer and turn on debug info to get better # stack traces. - add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER) + append("-fno-omit-frame-pointer" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND - NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO") - add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY) + NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO" AND + CMAKE_CXX_COMPILER_ID MATCHES "Clang") + append("-gline-tables-only" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif() # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large. if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND LLVM_OPTIMIZE_SANITIZED_BUILDS) - add_flag_if_supported("-O1" O1) + append("-O1" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif() else() # Always ask the linker to produce symbols with asan. @@ -1112,15 +1091,12 @@ endif() if(NOT CYGWIN AND NOT MSVC) if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") - check_c_compiler_flag("-Werror -fno-function-sections" C_SUPPORTS_FNO_FUNCTION_SECTIONS) - if (C_SUPPORTS_FNO_FUNCTION_SECTIONS) - # Don't add -ffunction-sections if it can't be disabled with -fno-function-sections. - # Doing so will break sanitizers. - add_flag_if_supported("-ffunction-sections" FFUNCTION_SECTIONS) - elseif (CMAKE_CXX_COMPILER_ID MATCHES "XL") + if (CMAKE_CXX_COMPILER_ID MATCHES "XL") append("-qfuncsect" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + else() + append("-ffunction-sections" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif() - add_flag_if_supported("-fdata-sections" FDATA_SECTIONS) + append("-fdata-sections" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif() elseif(MSVC) if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" ) @@ -1385,7 +1361,9 @@ if(LLVM_USE_RELATIVE_PATHS_IN_DEBUG_INFO) file(RELATIVE_PATH relative_root "${CMAKE_BINARY_DIR}" "${source_root}") append_if(SUPPORTS_FDEBUG_PREFIX_MAP "-fdebug-prefix-map=${CMAKE_BINARY_DIR}=${relative_root}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) append_if(SUPPORTS_FDEBUG_PREFIX_MAP "-fdebug-prefix-map=${source_root}/=${LLVM_SOURCE_PREFIX}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) - add_flag_if_supported("-no-canonical-prefixes" NO_CANONICAL_PREFIXES) + if (LLVM_COMPILER_IS_GCC_COMPATIBLE) + append("-no-canonical-prefixes" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + endif() endif() option(LLVM_USE_RELATIVE_PATHS_IN_FILES "Use relative paths in sources and debug info" OFF) @@ -1400,7 +1378,9 @@ if(LLVM_USE_RELATIVE_PATHS_IN_FILES) file(RELATIVE_PATH relative_root "${CMAKE_BINARY_DIR}" "${source_root}") append_if(SUPPORTS_FFILE_PREFIX_MAP "-ffile-prefix-map=${CMAKE_BINARY_DIR}=${relative_root}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) append_if(SUPPORTS_FFILE_PREFIX_MAP "-ffile-prefix-map=${source_root}/=${LLVM_SOURCE_PREFIX}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) - add_flag_if_supported("-no-canonical-prefixes" NO_CANONICAL_PREFIXES) + if (LLVM_COMPILER_IS_GCC_COMPATIBLE) + append("-no-canonical-prefixes" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + endif() endif() set(LLVM_THIRD_PARTY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../third-party CACHE STRING