[llvm][cmake] Use more generator expressions

[sebastian-ne]

Summary

Multi-config builds don’t have CMAKE_BUILD_TYPE set, instead, we should
use generator expressions to switch flags depending on the build type.

Do that for a couple of places that were relatively easy to convert.

llvm/cmake/modules/AddLLVM.cmake

if (LLVM_ENABLE_LTO)
         set_property(TARGET ${target_name} APPEND_STRING PROPERTY
                       LINK_FLAGS " -Wl,-mllvm,-O0")
       endif()
     endif()
   endif()
 
   # Don't use linker optimizations in debug builds since it slows down the
   # linker in a context where the optimizations are not important.
-  if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
-    if(NOT LLVM_NO_DEAD_STRIP)
-      if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-        # ld64's implementation of -dead_strip breaks tools that use plugins.
-        set_property(TARGET ${target_name} APPEND_STRING PROPERTY
-                     LINK_FLAGS " -Wl,-dead_strip")
-      elseif(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-        # Support for ld -z discard-unused=sections was only added in
-        # Solaris 11.4.
-        include(LLVMCheckLinkerFlag)
-        llvm_check_linker_flag(CXX "-Wl,-z,discard-unused=sections" LINKER_SUPPORTS_Z_DISCARD_UNUSED)
-        if (LINKER_SUPPORTS_Z_DISCARD_UNUSED)
-          set_property(TARGET ${target_name} APPEND_STRING PROPERTY
-                       LINK_FLAGS " -Wl,-z,discard-unused=sections")
-        endif()
-      elseif(NOT MSVC AND NOT CMAKE_SYSTEM_NAME MATCHES "AIX|OS390")
-        # TODO Revisit this later on z/OS.
-        set_property(TARGET ${target_name} APPEND_STRING PROPERTY
-                     LINK_FLAGS " -Wl,--gc-sections")
-      endif()
-    else() #LLVM_NO_DEAD_STRIP
-      if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
-        set_property(TARGET ${target_name} APPEND_STRING PROPERTY
-                     LINK_FLAGS " -Wl,-bnogc")
-      endif()
+      target_link_options(${target_name} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-Wl,-dead_strip>")
+        target_link_options(${target_name} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-Wl,-z,discard-unused=sections>")
+      target_link_options(${target_name} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-Wl,--gc-sections>")
+      target_link_options(${target_name} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-Wl,-bnogc>")
     endif()
   endif()
 
   if(ARG_SUPPORT_PLUGINS AND ${CMAKE_SYSTEM_NAME} MATCHES "AIX")
     set_property(TARGET ${target_name} APPEND_STRING PROPERTY
                  LINK_FLAGS " -Wl,-brtl")
   endif()
 endfunction(add_link_opts)

llvm/cmake/modules/HandleLLVMOptions.cmake

if(CMAKE_LINKER MATCHES "lld-link" OR (MSVC AND (LLVM_USE_LINKER STREQUAL "lld" OR LLVM_ENABLE_LLD)))
   set(LINKER_IS_LLD_LINK TRUE)
 else()
   set(LINKER_IS_LLD_LINK FALSE)
 endif()
 
 set(LLVM_ENABLE_LTO OFF CACHE STRING "Build LLVM with LTO. May be specified as Thin or Full to use a particular kind of LTO")
 string(TOUPPER "${LLVM_ENABLE_LTO}" uppercase_LLVM_ENABLE_LTO)
 
+set(is_c_or_cxx "$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>")
+set(is_not_debug "$<NOT:$<CONFIG:Debug>>")
+
 # Ninja Job Pool support
 # The following only works with the Ninja generator in CMake >= 3.0.
 set(LLVM_PARALLEL_COMPILE_JOBS "" CACHE STRING
   "Define the maximum number of concurrent compilation jobs (Ninja only).")
 if(LLVM_PARALLEL_COMPILE_JOBS)
   if(NOT CMAKE_GENERATOR MATCHES "Ninja")
     message(WARNING "Job pooling is only available with Ninja generators.")
   else()

 
 if( LLVM_ENABLE_ASSERTIONS )
   # MSVC doesn't like _DEBUG on release builds. See PR 4379.
   if( NOT MSVC )
     add_definitions( -D_DEBUG )
   endif()
   # On non-Debug builds cmake automatically defines NDEBUG, so we
   # explicitly undefine it:
-  if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
-    # NOTE: use `add_compile_options` rather than `add_definitions` since
-    # `add_definitions` does not support generator expressions.
-    add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-UNDEBUG>)
-    if (MSVC)
-      # Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines.
-      foreach (flags_var_to_scrub
-          CMAKE_CXX_FLAGS_RELEASE
-          CMAKE_CXX_FLAGS_RELWITHDEBINFO
-          CMAKE_CXX_FLAGS_MINSIZEREL
-          CMAKE_C_FLAGS_RELEASE
-          CMAKE_C_FLAGS_RELWITHDEBINFO
-          CMAKE_C_FLAGS_MINSIZEREL)
-        string (REGEX REPLACE "(^| )[/-]D *NDEBUG($| )" " "
-          "${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
-      endforeach()
-     endif()
-  endif()
-endif()
+  add_compile_options("$<$<AND:${is_not_debug},${is_c_or_cxx}>:-UNDEBUG>")
 
 if(LLVM_ENABLE_EXPENSIVE_CHECKS)
   add_definitions(-DEXPENSIVE_CHECKS)
 
   # In some libstdc++ versions, std::min_element is not constexpr when
   # _GLIBCXX_DEBUG is enabled.
   CHECK_CXX_SOURCE_COMPILES("
     #define _GLIBCXX_DEBUG
function(append_if condition value)
   if (${condition})
     foreach(variable ${ARGN})
       set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
     endforeach(variable)
   endif()
 endfunction()
 
 macro(add_flag_if_supported flag name)
-  check_c_compiler_flag("-Werror ${flag}" "C_SUPPORTS_${name}")
-  append_if("C_SUPPORTS_${name}" "${flag}" CMAKE_C_FLAGS)
-  check_cxx_compiler_flag("-Werror ${flag}" "CXX_SUPPORTS_${name}")
-  append_if("CXX_SUPPORTS_${name}" "${flag}" CMAKE_CXX_FLAGS)
+  string(GENEX_STRIP "${flag}" bare_flag)
+  check_c_compiler_flag("-Werror ${bare_flag}" "C_SUPPORTS_${name}")
+  if (${C_SUPPORTS_${name}})
+    add_compile_options($<$<COMPILE_LANGUAGE:C>:${flag}>)
+  endif()
+  check_cxx_compiler_flag("-Werror ${bare_flag}" "CXX_SUPPORTS_${name}")
+  if (${CXX_SUPPORTS_${name}})
+    add_compile_options($<$<COMPILE_LANGUAGE:CXX>:${flag}>)
+  endif()
 endmacro()
 
 function(add_flag_or_print_warning flag name)
-  check_c_compiler_flag("-Werror ${flag}" "C_SUPPORTS_${name}")
-  check_cxx_compiler_flag("-Werror ${flag}" "CXX_SUPPORTS_${name}")
+  string(GENEX_STRIP "${flag}" bare_flag)
+  check_c_compiler_flag("-Werror ${bare_flag}" "C_SUPPORTS_${name}")
+  check_cxx_compiler_flag("-Werror ${bare_flag}" "CXX_SUPPORTS_${name}")
   if (C_SUPPORTS_${name} AND CXX_SUPPORTS_${name})
-    message(STATUS "Building with ${flag}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
-    set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${flag}" PARENT_SCOPE)
+    message(STATUS "Building with ${bare_flag}")
+    add_compile_options("$<$<OR:$<COMPILE_LANGUAGE:ASM>,$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:${flag}>")
   else()
-    message(WARNING "${flag} is not supported.")
+    message(WARNING "${bare_flag} is not supported.")
   endif()
 endfunction()
 
 function(has_msvc_incremental_no_flag flags incr_no_flag_on)
   set(${incr_no_flag_on} OFF PARENT_SCOPE)
   string(FIND "${flags}" "/INCREMENTAL" idx REVERSE)
   if (${idx} GREATER -1)
     string(SUBSTRING "${flags}" ${idx} 15 no_flag)
else()
     # -fno-semantic-interposition (https://reviews.llvm.org/D117183).
     if ((CMAKE_COMPILER_IS_GNUCXX AND
          NOT (LLVM_NATIVE_ARCH STREQUAL "SystemZ" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.3))
        OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 14))
       add_flag_if_supported("-fno-semantic-interposition" FNO_SEMANTIC_INTERPOSITION)
     endif()
   endif()
   # 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)
+  if(CMAKE_COMPILER_IS_GNUCXX AND LLVM_NATIVE_ARCH STREQUAL "Mips")
+    add_flag_or_print_warning("$<${is_not_debug}>:-fno-shrink-wrap>" FNO_SHRINK_WRAP)
   endif()
   # gcc with -O3 -fPIC generates TLS sequences that violate the spec on
   # Solaris/sparcv9, causing executables created with the system linker
   # to SEGV (GCC PR target/96607).
   # clang with -O3 -fPIC generates code that SEGVs.
   # Both can be worked around by compiling with -O instead.
   if(${CMAKE_SYSTEM_NAME} STREQUAL "SunOS" AND LLVM_NATIVE_ARCH STREQUAL "Sparc")
     llvm_replace_compiler_option(CMAKE_CXX_FLAGS_RELEASE "-O[23]" "-O")
if( MSVC )
   # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
   append("/Zc:__cplusplus" CMAKE_CXX_FLAGS)
 
   # Allow users to request PDBs in release mode. CMake offeres the
   # RelWithDebInfo configuration, but it uses different optimization settings
   # (/Ob1 vs /Ob2 or -O2 vs -O3). LLVM provides this flag so that users can get
   # PDBs without changing codegen.
   option(LLVM_ENABLE_PDB OFF)
-  if (LLVM_ENABLE_PDB AND uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
-    append("/Zi" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+  if (LLVM_ENABLE_PDB)
+    add_compile_options("$<$<AND:$<CONFIG:Release>,${is_c_or_cxx}>:/ZI>")
     # /DEBUG disables linker GC and ICF, but we want those in Release mode.
-    append("/DEBUG /OPT:REF /OPT:ICF"
-          CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS
-          CMAKE_SHARED_LINKER_FLAGS)
+    add_link_options($<$<CONFIG:Release>:/DEBUG /OPT:REF /OPT:ICF>)
   endif()
 
   # Get all linker flags in upper case form so we can search them.
   string(CONCAT all_linker_flags_uppercase
      ${CMAKE_EXE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} " "
      ${CMAKE_EXE_LINKER_FLAGS} " "
      ${CMAKE_MODULE_LINKER_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} " "
      ${CMAKE_MODULE_LINKER_FLAGS} " "
if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT LLVM_ENABLE_WARNINGS)
   append("-w" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 endif()
 
 macro(append_common_sanitizer_flags)
   if (NOT MSVC)
     # 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)
-    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)
-    endif()
+    add_flag_if_supported("$<$<AND:$<NOT:$<CONFIG:Debug>>,$<NOT:$<CONFIG:RelWithDebInfo>>>:-gline-tables-only>" GLINE_TABLES_ONLY)
     # 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)
+    if (LLVM_OPTIMIZE_SANITIZED_BUILDS)
+      add_flag_if_supported("$<$<CONFIG:Debug>:-O1>" O1)
     endif()
   else()
     # Always ask the linker to produce symbols with asan.
     append("/Z7" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     append("/debug" CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
     # Not compatible with /INCREMENTAL link.
     foreach (flags_opt_to_scrub
         CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
if (EXISTS "${IGNORELIST_FILE}")
       # accepted with clang 13.0 or newer.
       append("-fsanitize-blacklist=${IGNORELIST_FILE}"
              CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     endif()
   endif()
 endif()
 
 # Turn on -gsplit-dwarf if requested in debug builds.
-if (LLVM_USE_SPLIT_DWARF AND
-    ((uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") OR
-     (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")))
+if (LLVM_USE_SPLIT_DWARF)
   # Limit to clang and gcc so far. Add compilers supporting this option.
   if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR
       CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    add_compile_options(-gsplit-dwarf)
+    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:-gsplit-dwarf>)
     include(LLVMCheckLinkerFlag)
     llvm_check_linker_flag(CXX "-Wl,--gdb-index" LINKER_SUPPORTS_GDB_INDEX)
-  append_if(LINKER_SUPPORTS_GDB_INDEX "-Wl,--gdb-index"
-    CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+    if (${LINKER_SUPPORTS_GDB_INDEX})
+      add_link_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:LINKER:--gdb-index>)
+    endif()
   endif()
 endif()
 
 add_definitions( -D__STDC_CONSTANT_MACROS )
 add_definitions( -D__STDC_FORMAT_MACROS )
 add_definitions( -D__STDC_LIMIT_MACROS )
 
 # clang and gcc don't default-print colored diagnostics when invoked from Ninja.
append_if(LINKER_SUPPORTS_COLOR_DIAGNOSTICS "-Wl,--color-diagnostics"
     CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
 endif()
 
 # Add flags for add_dead_strip().
 # FIXME: With MSVS, consider compiling with /Gy and linking with /OPT:REF?
 # But MinSizeRel seems to add that automatically, so maybe disable these
 # flags instead if LLVM_NO_DEAD_STRIP is set.
 if(NOT CYGWIN AND NOT MSVC)
-  if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND
-     NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+  if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     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)
+      add_flag_if_supported("$<${is_not_debug}:-ffunction-sections>" FFUNCTION_SECTIONS)
     elseif (CMAKE_CXX_COMPILER_ID MATCHES "XL")
-      append("-qfuncsect" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+      add_compile_options("$<$<AND:${is_not_debug},${is_c_or_cxx}>:-qfuncsect>")
     endif()
-    add_flag_if_supported("-fdata-sections" FDATA_SECTIONS)
+    add_flag_if_supported("$<${is_not_debug}:-fdata-sections>" FDATA_SECTIONS)
   endif()
 elseif(MSVC)
-  if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
-    append("/Gw" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
-  endif()
+  add_compile_options("$<$<AND:${is_not_debug},${is_c_or_cxx}>:/Gw>")
 endif()
 
 if(MSVC)
   # Remove flags here, for exceptions and RTTI.
   # Each target property or source property should be responsible to control
   # them.
   # CL.EXE complains to override flags like "/GR /GR-".
   string(REGEX REPLACE "(^| ) */EH[-cs]+ *( |$)" "\\1 \\2" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")