[CMake] Improve logic for enabling LTO on LLVM itself

[zturner]

Summary

With this patch, if you specify LLVM_ENABLE_LTO=Full or LLVM_ENABLE_LTO=On and you are using cl + link, we enable the /GL and /LTCG flags for the compiler and linker, respectively.

[inglorion]

llvm/cmake/modules/HandleLLVMOptions.cmake

780

Can you set ${style} to "OFF", "FULL", "MSVC", and "THIN" only? That way, dispatching on it won't have to worry about case and "ON" being an alias for "FULL". Also in the other passthrough case further down.

[zturner]

1. Updated with suggestions from inglorion. Specifically, decide_lto_style now either hard fails, or returns one of 4 values thin, full, msvc, none.
2. Deletes the codepath for treating -flto separately from -flto=full. Since they are both the same, we just always use -flto=full
3. Merge all the codepaths for the different styles into a single one. Instead of adding -flto=thin or -flto=full, we just add -flto=${LTO_STYLE}, collapsing some branches together.
4. Enables the ThinLTO cache when using lld-link.

[mehdi_amini]

llvm/cmake/modules/HandleLLVMOptions.cmake

771

What is "msvc"? (pointer to another doc accepted :))

[inglorion]

llvm/cmake/modules/HandleLLVMOptions.cmake

781

nit: the case here doesn't match what you actually return (THIN vs thin)

838

I think the old code supports gcc + gold, which require -flto instead of -flto=full. We still need to translate style full to -flto here, which will do the same thing as -flto=full in clang.

llvm/cmake/modules/HandleLLVMOptions.cmake

 # This CMake module is responsible for interpreting the user defined LLVM_
 # options and executing the appropriate CMake commands to realize the users'
 # selections.
 
 # This is commonly needed so make sure it's defined before we include anything
 # else.
 string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 
 include(CheckCompilerVersion)
 include(HandleLLVMStdlib)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 
-if(CMAKE_LINKER MATCHES "lld-link.exe" OR (WIN32 AND LLVM_USE_LINKER STREQUAL "lld"))
+get_filename_component(LINKER_FILENAME "${CMAKE_LINKER}" NAME)
+
+if(LINKER_FILENAME STREQUAL "lld-link.exe" OR (WIN32 AND LLVM_USE_LINKER STREQUAL "lld"))
   set(LINKER_IS_LLD_LINK TRUE)
 else()
   set(LINKER_IS_LLD_LINK FALSE)
 endif()
+if(LINKER_FILENAME STREQUAL "link.exe" OR (WIN32 AND LLVM_USE_LINKER STREQUAL "link"))
+  set(LINKER_IS_MSVC_LINK TRUE)
+else()
+  set(LINKER_IS_MSVC_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)
 
 # 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.")

 option(LLVM_BUILD_INSTRUMENTED_COVERAGE "Build LLVM and tools with Code Coverage instrumentation" Off)
 mark_as_advanced(LLVM_BUILD_INSTRUMENTED_COVERAGE)
 append_if(LLVM_BUILD_INSTRUMENTED_COVERAGE "-fprofile-instr-generate='${LLVM_PROFILE_FILE_PATTERN}' -fcoverage-mapping"
   CMAKE_CXX_FLAGS
   CMAKE_C_FLAGS
   CMAKE_EXE_LINKER_FLAGS
   CMAKE_SHARED_LINKER_FLAGS)
 
-if(LLVM_ENABLE_LTO AND LLVM_ON_WIN32 AND NOT LINKER_IS_LLD_LINK)
-  message(FATAL_ERROR "When compiling for Windows, LLVM_ENABLE_LTO requires using lld as the linker (point CMAKE_LINKER at lld-link.exe)")
+# Sets the output parameter style to one of the following values:
+#   thin, none, msvc, full
+# If the function returns (e.g. there is no fatal error), the output parameter
+# is guaranteed to contain one of these values.
+function(decide_lto_style style)
+  # Unset or set to OFF -> return NONE
+  if (NOT uppercase_LLVM_ENABLE_LTO OR uppercase_LLVM_ENABLE_LTO STREQUAL "OFF")
+    set(${style} none PARENT_SCOPE)
+    return()
   endif()
-if(uppercase_LLVM_ENABLE_LTO STREQUAL "THIN")
-  append("-flto=thin" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+
+  # Set to THIN -> error if Windows && !(clang-cl && lld-link), otherwise return THIN
+  if (uppercase_LLVM_ENABLE_LTO STREQUAL "THIN")
+    if (LLVM_ON_WIN32 AND NOT (CLANG_CL AND LINKER_IS_LLD_LINK))
+      message(FATAL_ERROR
+              "LLVM_ENABLE_LTO=Thin on Windows requires both clang-cl and lld."
+              "Point CMAKE_LINKER at lld-link.exe and CMAKE_C(XX)_COMPILER at clang-cl.exe")
+    endif()
+
+    set(${style} thin PARENT_SCOPE)
+    return()
+  endif()
+
+  # Set to FULL or ON -> return MSVC if (cl && msvc link)
+  #                      otherwise error if !(clang-cl && lld-link)
+  #                      otherwise return FULL
+  if ((uppercase_LLVM_ENABLE_LTO STREQUAL "FULL") OR (uppercase_LLVM_ENABLE_LTO STREQUAL "ON"))
+    if (MSVC)
+      # pure cl && msvc link, use MSVC style
+      if (NOT CLANG_CL AND LINKER_IS_MSVC_LINK)
+        set(${style} msvc PARENT_SCOPE)
+        return()
+      endif()
+
+      # clang-cl && lld-link
+      if (CLANG_CL AND LINKER_IS_LLD_LINK)
+        set(${style} full PARENT_SCOPE)
+        return()
+      endif()
+
+      # some other compiler & linker combination?
+      message(FATAL_ERROR
+             "LLVM_ENABLE_LTO=Full on Windows requires compiler and linker to"
+             " either be both MSVC or both LLVM.")
+      return()
+    endif()
+
+    set(${style} full PARENT_SCOPE)
+    return()
+  endif()
+
+  message(WARNING
+          "LLVM_ENABLE_LTO set to urecognized value ${LLVM_ENABLE_LTO}.  "
+          "Defaulting to OFF")
+  set(${style} none PARENT_SCOPE)
+endfunction()
+
+
+decide_lto_style(LTO_STYLE)
+
+if(LTO_STYLE STREQUAL "msvc")
+  append("/GL" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+  append("/LTCG" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS CMAKE_STATIC_LINKER_FLAGS)
+elseif(NOT LTO_STYLE STREQUAL "none")
+  # Since the set of values that can be in LTO_STYLE is limited and controlled
+  # entirely by us, it's safe to just pass -flto=${LTO_STYLE} instead of
+  # manually checking for whitelisted values.
+
+  append("-flto=${LTO_STYLE}" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
   if(NOT LINKER_IS_LLD_LINK)
-    append("-flto=thin" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+    append("-flto=${LTO_STYLE}" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
   endif()
+
+  if (LTO_STYLE STREQUAL "thin")
     # If the linker supports it, enable the lto cache. This improves initial build
     # time a little since we re-link a lot of the same objects, and significantly
     # improves incremental build time.
     # FIXME: We should move all this logic into the clang driver.
     if(APPLE)
       append("-Wl,-cache_path_lto,${PROJECT_BINARY_DIR}/lto.cache"
               CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
     elseif(UNIX AND LLVM_USE_LINKER STREQUAL "lld")
       append("-Wl,--thinlto-cache-dir=${PROJECT_BINARY_DIR}/lto.cache"
               CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
     elseif(LLVM_USE_LINKER STREQUAL "gold")
       append("-Wl,--plugin-opt,cache-dir=${PROJECT_BINARY_DIR}/lto.cache"
               CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+    elseif(LINKER_IS_LLD_LINK)
+      append("/lldltocache:${PROJECT_BINARY_DIR}/lto.cache"
+             CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
     endif()
-elseif(uppercase_LLVM_ENABLE_LTO STREQUAL "FULL")
-  append("-flto=full" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
-  if(NOT LINKER_IS_LLD_LINK)
-    append("-flto=full" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
-  endif()
-elseif(LLVM_ENABLE_LTO)
-  append("-flto" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
-  if(NOT LINKER_IS_LLD_LINK)
-    append("-flto" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
   endif()
 endif()
 
 # This option makes utils/extract_symbols.py be used to determine the list of
 # symbols to export from LLVM tools. This is necessary when using MSVC if you
 # want to allow plugins, though note that the plugin has to explicitly link
 # against (exactly one) tool so we can't unilaterally turn on
 # LLVM_ENABLE_PLUGINS when it's enabled.