[cmake] Use symlinks for Windows-hosted toolchains built on Unix

[smeenai]

Summary

When cross-compiling for Windows on Unix, the built toolchain will need
to be transferred to Windows to actually run. My opinion is that the
Unix build should use symlinks, and the transfer to Windows should take
care of making those symlinks usable. E.g., I envision tarballs to be a
common form of transfer from Unix to Windows, in which case the tarball
can be created using --dereference to follow the symlinks.

The motivation here is that, when cross-compiling for Windows on Unix,
the installation will *already* create symlinks. The reason is that the
installation script will be invoked without knowing the host system, so
the if(UNIX) check in the installation symlink creation script will
reflect the build system rather than the host system. We could either
make the build and install trees both contain copies or both contain
symlinks, and using symlinks is a significant space saving without (in
my opinion) having any detrimental effect on the usage of the cross-
compiled toolchain on Windows.

A secondary motivation is that Windows 10 version 1703 and later finally
lift the administrator rights requirement for creating symbolic links
(if the system is in Developer Mode), which makes symlinks a lot more
practical even on Windows. Of course Unix and Windows symlinks aren't
interoperable, but symlinks for Windows toolchains is a reasonable
future direction to be going in anyway.

[smeenai]

Ping.

We should either go in this direction or change the installation to also create a copy rather than a symlink (but I've outlined why I prefer symlinks personally in the summary). The current situation, where the build tree has copies but the install tree has symlinks (while attempting to create copies but failing because of a CMake subtlety) is really confusing.

[compnerd]

Yeah, we should be using symlinks on the unix hosts. This fixes an issue in cross-compiling, LGTM.

llvm/trunk/cmake/modules/AddLLVM.cmake

function(add_llvm_tool_symlink link_name target)
   # expression. To reconstruct the platform-agnostic path we have to do some
   # magic. First we grab one of the types, and a type-specific path. Then from
   # the type-specific path we find the last occurrence of the type in the path,
   # and replace it with CMAKE_CFG_INTDIR. This allows the build step to be type
   # agnostic again.
   if(NOT ARG_OUTPUT_DIR)
     # If you're not overriding the OUTPUT_DIR, we can make the link relative in
     # the same directory.
-    if(UNIX)
+    if(CMAKE_HOST_UNIX)
       set(dest_binary "$<TARGET_FILE_NAME:${target}>")
     endif()
     if(CMAKE_CONFIGURATION_TYPES)
       list(GET CMAKE_CONFIGURATION_TYPES 0 first_type)
       string(TOUPPER ${first_type} first_type_upper)
       set(first_type_suffix _${first_type_upper})
     endif()
     get_target_property(target_type ${target} TYPE)
if(CMAKE_CONFIGURATION_TYPES)
       string(SUBSTRING "${ARG_OUTPUT_DIR}" 0 ${type_start} path_prefix)
       string(SUBSTRING "${ARG_OUTPUT_DIR}" ${type_start} -1 path_suffix)
       string(REPLACE "/${first_type}/" "/${CMAKE_CFG_INTDIR}/"
              path_suffix ${path_suffix})
       set(ARG_OUTPUT_DIR ${path_prefix}${path_suffix})
     endif()
   endif()
 
-  if(UNIX)
+  if(CMAKE_HOST_UNIX)
     set(LLVM_LINK_OR_COPY create_symlink)
   else()
     set(LLVM_LINK_OR_COPY copy)
   endif()
 
   set(output_path "${ARG_OUTPUT_DIR}/${link_name}${CMAKE_EXECUTABLE_SUFFIX}")
 
   set(target_name ${link_name})

llvm/trunk/cmake/modules/LLVMInstallSymlink.cmake

 # We need to execute this script at installation time because the
 # DESTDIR environment variable may be unset at configuration time.
 # See PR8397.
 
 function(install_symlink name target outdir)
-  if(UNIX)
+  if(CMAKE_HOST_UNIX)
     set(LINK_OR_COPY create_symlink)
     set(DESTDIR $ENV{DESTDIR})
   else()
     set(LINK_OR_COPY copy)
   endif()
 
   set(bindir "${DESTDIR}${CMAKE_INSTALL_PREFIX}/${outdir}/")
 
   message("Creating ${name}")
 
   execute_process(
     COMMAND "${CMAKE_COMMAND}" -E ${LINK_OR_COPY} "${target}" "${name}"
     WORKING_DIRECTORY "${bindir}")
 
 endfunction()