[CMake] Only detect the linker once in AddLLVM.cmake

[ldionne]

Summary

Otherwise, the build output contains a bunch of "Linker detection: <xxx>"
lines that are really redundant. We also make redundant calls to the
linker, although that's a smaller concern.

[smeenai]

This only works because of a specific detail of LLVM's build system. The variable will get set in the directory scope, so different directories including this module will still duplicate the check. Here's a simple test I did, using cmake version 3.12.1 (run this as a script):

mkdir /tmp/cmaketest
cd /tmp/cmaketest
cat > CMakeLists.txt <<'EOF'
cmake_minimum_required(VERSION 3.4.3)
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/modules)
add_subdirectory(dir1)
add_subdirectory(dir2)
EOF

mkdir modules
cat > modules/detect.cmake <<'EOF'
if(NOT DEFINED DETECTED)
  message(STATUS Detected)
  set(DETECTED YES)
endif()
EOF

mkdir dir1
cat > dir1/CMakeLists.txt <<'EOF'
include(detect)
add_subdirectory(subdir)
EOF

mkdir dir1/subdir
echo 'include(detect)' > dir1/subdir/CMakeLists.txt

mkdir dir2
echo 'include(detect)' > dir2/CMakeLists.txt

mkdir build
cd build
cmake -G Ninja ..

For me, the "Detected" message is still printed twice, for dir1 and dir2. It doesn't print for subdir, since that inherits the variable for dir1, but independent directories still duplicate the message.

In LLVM, we include(AddLLVM) in the top-level CMakeLists.txt, so any variable created in that directory scope is essentially global. Nevertheless, it'd be nicer to explicitly use a global property for this, but I'm also okay with this going in as-is if you prefer.

[ldionne]

Use a global variable to store the variables, per @smeenai's comment.

[ldionne]

@smeenai I'm now using CACHE variables, which should mean the detection is performed exactly once per build.

[smeenai]

Works for me!

[smeenai]

(my previous accept still stands)

[ldionne]

Thanks!

llvm/cmake/modules/AddLLVM.cmake

function(add_llvm_symbol_exports target_name export_file)
 
   add_dependencies(${target_name} ${target_name}_exports)
 
   # Add dependency to *_exports later -- CMake issue 14747
   list(APPEND LLVM_COMMON_DEPENDS ${target_name}_exports)
   set(LLVM_COMMON_DEPENDS ${LLVM_COMMON_DEPENDS} PARENT_SCOPE)
 endfunction(add_llvm_symbol_exports)
 
+if (NOT DEFINED LLVM_LINKER_DETECTED)
   if(APPLE)
     execute_process(
       COMMAND "${CMAKE_LINKER}" -v
       ERROR_VARIABLE stderr
       )
     set(LLVM_LINKER_DETECTED YES)
     if("${stderr}" MATCHES "PROJECT:ld64")
       set(LLVM_LINKER_IS_LD64 YES)
       message(STATUS "Linker detection: ld64")
     else()
       set(LLVM_LINKER_DETECTED NO)
       message(STATUS "Linker detection: unknown")
     endif()
   elseif(NOT WIN32)
     # Detect what linker we have here
     if( LLVM_USE_LINKER )
       set(command ${CMAKE_C_COMPILER} -fuse-ld=${LLVM_USE_LINKER} -Wl,--version)
     else()
       separate_arguments(flags UNIX_COMMAND "${CMAKE_EXE_LINKER_FLAGS}")
       set(command ${CMAKE_C_COMPILER} ${flags} -Wl,--version)
     endif()
     execute_process(
       COMMAND ${command}
       OUTPUT_VARIABLE stdout
       ERROR_VARIABLE stderr
       )
     set(LLVM_LINKER_DETECTED YES)
     if("${stdout}" MATCHES "GNU gold")
       set(LLVM_LINKER_IS_GOLD YES)
       message(STATUS "Linker detection: GNU Gold")
     elseif("${stdout}" MATCHES "^LLD")
       set(LLVM_LINKER_IS_LLD YES)
       message(STATUS "Linker detection: LLD")
     elseif("${stdout}" MATCHES "GNU ld")
       set(LLVM_LINKER_IS_GNULD YES)
       message(STATUS "Linker detection: GNU ld")
     elseif("${stderr}" MATCHES "Solaris Link Editors" OR
            "${stdout}" MATCHES "Solaris Link Editors")
       set(LLVM_LINKER_IS_SOLARISLD YES)
       message(STATUS "Linker detection: Solaris ld")
     else()
       set(LLVM_LINKER_DETECTED NO)
       message(STATUS "Linker detection: unknown")
     endif()
   endif()
+endif()
 
 function(add_link_opts target_name)
   # 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")
 
     # Pass -O3 to the linker. This enabled different optimizations on different
     # linkers.