llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-lldb @llvm/pr-subscribers-clang Author: Vlad Serebrennikov (Endilll) <details> <summary>Changes</summary> This patch remove 36 checks for compiler flags that are done via invoking the compiler across LLVM, Clang, and LLDB. It's was made possible by raising the bar for supported compilers that has been happening over the years since the checks were added. This is going to improve CMake configuration times. This topic was highlighted in https://discourse.llvm.org/t/cmake-compiler-flag-checks-are-really-slow-ideas-to-speed-them-up/78882. --- Full diff: https://github.com/llvm/llvm-project/pull/92953.diff 7 Files Affected: - (modified) clang/CMakeLists.txt (+1-4) - (modified) clang/tools/scan-build-py/tests/functional/exec/CMakeLists.txt (+1-5) - (modified) lldb/cmake/modules/LLDBConfig.cmake (+7-13) - (modified) llvm/cmake/config-ix.cmake (+8-11) - (modified) llvm/cmake/modules/AddLLVM.cmake (+1-3) - (modified) llvm/cmake/modules/HandleLLVMOptions.cmake (+61-81) - (modified) third-party/unittest/CMakeLists.txt (+1-3) ``````````diff 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<foo>, and if supported, add the corresponding -Wno-<foo> 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..0900e1107076e 100644 --- a/llvm/cmake/config-ix.cmake +++ b/llvm/cmake/config-ix.cmake @@ -415,15 +415,14 @@ 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) +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 +432,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..91f371e1ad621 100644 --- a/llvm/cmake/modules/AddLLVM.cmake +++ b/llvm/cmake/modules/AddLLVM.cmake @@ -1639,9 +1639,7 @@ function(add_unittest test_suite test_name) set(EXCLUDE_FROM_ALL ON) endif() - if (SUPPORTS_VARIADIC_MACROS_FLAG) - list(APPEND LLVM_COMPILE_FLAGS "-Wno-variadic-macros") - endif () + list(APPEND LLVM_COMPILE_FLAGS "-Wno-variadic-macros") # 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 <cassert> still manages to respect NDEBUG properly. - CHECK_CXX_SOURCE_COMPILES("#undef NDEBUG - #include <cassert> - #define NDEBUG - #include <cassert> - 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 diff --git a/third-party/unittest/CMakeLists.txt b/third-party/unittest/CMakeLists.txt index bf6ef54555144..e85fe045a60bb 100644 --- a/third-party/unittest/CMakeLists.txt +++ b/third-party/unittest/CMakeLists.txt @@ -21,9 +21,7 @@ if (UNIX AND ${CMAKE_SYSTEM_NAME} MATCHES "AIX") add_definitions("-D_ALL_SOURCE") endif() -if(SUPPORTS_VARIADIC_MACROS_FLAG) - add_definitions("-Wno-variadic-macros") -endif() +add_definitions("-Wno-variadic-macros") if(SUPPORTS_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS_FLAG) add_definitions("-Wno-gnu-zero-variadic-macro-arguments") endif() `````````` </details> https://github.com/llvm/llvm-project/pull/92953 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
