[cmake] Create versioned symlinks on versioned tools

[mgorny]

Summary

Create versioned symlink structure when symlinking a tool that has
the VERSION property set (e.g. clang).

Currently, if symlink target had version set, CMake created symlink from
non-versioned name to the versioned name implicitly and we created
additional symlinks to the non-versioned name. For example:

clang -> clang-4.0
clang++ -> clang
...

With this patch, a versioned symlink that points to the versioned (real)
executable is created first, and a non-versioned symlink to
the versioned symlink is created afterwards. The resulting structure
becomes:

clang++-4.0 -> clang-4.0
clang -> clang-4.0
clang++ -> clang++-4.0
...

As a result, this improves consistency between the symlinks and makes it
easier to maintain multiple versions of clang installed on the same
system. In particular, after installing a new version the 'bare'
symlinks are clobbered but the versioned symlinks continue to work.

[mgorny]

Rebasing is not worth the effort.

cmake/modules/AddLLVM.cmake

function(llvm_install_symlink name dest)
   cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
   foreach(path ${CMAKE_MODULE_PATH})
     if(EXISTS ${path}/LLVMInstallSymlink.cmake)
       set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
       break()
     endif()
   endforeach()
 
+  # If target is a versioned executable, reconstruct the version symlink
+  # on the target symlink as well.
+  set(symlink_version)
+  if(TARGET ${dest})
+    get_property(symlink_version TARGET ${dest} PROPERTY VERSION)
+  endif()
+
   if(ARG_ALWAYS_GENERATE)
     set(component ${dest})
   else()
     set(component ${name})
   endif()
 
+  if(NOT DEFINED symlink_version)
     set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
     set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
+  else()
+    set(full_name ${name}-${symlink_version}${CMAKE_EXECUTABLE_SUFFIX})
+    set(full_dest ${dest}-${symlink_version}${CMAKE_EXECUTABLE_SUFFIX})
+    set(nonver_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
+  endif()
 
+  # sym[-X.Y] -> dest[-X.Y]
   install(SCRIPT ${INSTALL_SYMLINK}
           CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
           COMPONENT ${component})
+  if(DEFINED symlink_version)
+    # sym -> sym-X.Y
+    install(SCRIPT ${INSTALL_SYMLINK}
+            CODE "install_symlink(${nonver_name} ${full_name} ${LLVM_TOOLS_INSTALL_DIR})"
+            COMPONENT ${component})
+  endif()
 
   if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
     add_custom_target(install-${name}
                       DEPENDS ${name} ${dest} install-${dest}
                       COMMAND "${CMAKE_COMMAND}"
                               -DCMAKE_INSTALL_COMPONENT=${name}
                               -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
   endif()
 endfunction()
 
 function(add_llvm_tool_symlink name dest)
   cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
+
+  # If target is a versioned executable, reconstruct the version symlink
+  # on the target symlink as well.
+  set(symlink_version)
+  if(TARGET ${dest})
+    get_property(symlink_version TARGET ${dest} PROPERTY VERSION)
+  endif()
+
+  set(output_path "${LLVM_RUNTIME_OUTPUT_INTDIR}/${name}${CMAKE_EXECUTABLE_SUFFIX}")
+  if(DEFINED symlink_version)
+    set(output_ver_path "${LLVM_RUNTIME_OUTPUT_INTDIR}/${name}-${symlink_version}${CMAKE_EXECUTABLE_SUFFIX}")
+  endif()
+
   if(UNIX)
     set(LLVM_LINK_OR_COPY create_symlink)
+    if(NOT DEFINED symlink_version)
       set(dest_binary "${dest}${CMAKE_EXECUTABLE_SUFFIX}")
     else()
+      set(dest_ver_binary "${dest}-${symlink_version}${CMAKE_EXECUTABLE_SUFFIX}")
+      set(dest_ver_output "${name}-${symlink_version}${CMAKE_EXECUTABLE_SUFFIX}")
+    endif()
+  else()
     set(LLVM_LINK_OR_COPY copy)
+    if(NOT DEFINED symlink_version)
       set(dest_binary "${LLVM_RUNTIME_OUTPUT_INTDIR}/${dest}${CMAKE_EXECUTABLE_SUFFIX}")
+    else()
+      set(dest_ver_binary "${LLVM_RUNTIME_OUTPUT_INTDIR}/${dest}-${symlink_version}${CMAKE_EXECUTABLE_SUFFIX}")
+      set(dest_ver_output "${output_ver_path}")
+    endif()
   endif()
-
-  set(output_path "${LLVM_RUNTIME_OUTPUT_INTDIR}/${name}${CMAKE_EXECUTABLE_SUFFIX}")
 
   set(target_name ${name})
   if(TARGET ${name})
     set(target_name ${name}-link)
   endif()
 
 
   if(ARG_ALWAYS_GENERATE)
     set_property(DIRECTORY APPEND PROPERTY
       ADDITIONAL_MAKE_CLEAN_FILES ${dest_binary})
+    if(NOT DEFINED symlink_version)
+      # sym -> dest
       add_custom_command(TARGET ${dest} POST_BUILD
         COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}")
     else()
+      # sym -> sym-X.Y -> dest-X.Y
+      add_custom_command(TARGET ${dest} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_ver_binary}" "${output_ver_path}"
+        COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_ver_output}" "${output_path}")
+    endif()
+  else()
+    if(NOT DEFINED symlink_version)
+      # sym -> dest
       add_custom_command(OUTPUT ${output_path}
-                     COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}"
-                     DEPENDS ${dest})
-    add_custom_target(${target_name} ALL DEPENDS ${output_path})
+    else()
+      # sym -> sym-X.Y -> dest-X.Y
+      add_custom_command(OUTPUT ${output_ver_path}
+        COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_ver_binary}" "${output_ver_path}"
+        DEPENDS ${dest})
+      add_custom_command(OUTPUT ${output_path}
+        COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_ver_output}" "${output_path}"
+        DEPENDS ${output_ver_path})
+    endif()
+    add_custom_target(${target_name} ALL DEPENDS ${output_path} ${output_ver_path})
     set_target_properties(${target_name} PROPERTIES FOLDER Tools)
 
     # Make sure both the link and target are toolchain tools
     if (${name} IN_LIST LLVM_TOOLCHAIN_TOOLS AND ${dest} IN_LIST LLVM_TOOLCHAIN_TOOLS)
       set(TOOL_IS_TOOLCHAIN ON)
     endif()
 
     if ((TOOL_IS_TOOLCHAIN OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY) AND LLVM_BUILD_TOOLS)