[llvm] Add stripped installation targets

[smeenai]

Summary

CMake's generated installation scripts support CMAKE_INSTALL_DO_STRIP
to enable stripping the installed binaries. LLVM's build system doesn't
expose this option to the install- targets, but it's useful in
conjunction with install-distribution.

Add a new function to create the install targets, which creates both the
regular install target and a second install target that strips during
installation. Change the creation of all installation targets to use
this new function. Stripping doesn't make a whole lot of sense for some
installation targets (e.g. the LLVM headers), but consistency doesn't
hurt.

I'll make other repositories (e.g. clang, compiler-rt) use this in a
follow-up, and then add an install-distribution-stripped target to
actually accomplish the end goal of creating a stripped distribution. I
don't want to do that step yet because the creation of that target would
depend on the presence of the install-*-stripped target for each
distribution component, and the distribution components from other
repositories will be missing that target right now.

[beanz]

Is there a reason to add a new option instead of just adding -DCMAKE_INSTALL_DO_STRIP=${CMAKE_INSTALL_DO_STRIP} to the install commands?

[smeenai]

In D40620#939765, @beanz wrote:

Is there a reason to add a new option instead of just adding -DCMAKE_INSTALL_DO_STRIP=${CMAKE_INSTALL_DO_STRIP} to the install commands?

My reasoning for not going with that approach was that, in the usual CMake setup, CMAKE_INSTALL_DO_STRIP is only applicable when running installation scripts, and it doesn't have any effect at configuration time. If we're adding special behavior to LLVM's build system to make the stripping flag sticky during configuration, it seemed better to make it clear that this behavior was specific to LLVM's build system and not a general CMake thing.

I guess the install- targets themselves are an LLVM build system thing anyway though, so their behavior is already custom. I'm happy to change it according to your suggestion.

[beanz]

So, I wasn't actually familiar with how CMAKE_INSTALL_DO_STRIP worked, so I went and researched it. I think we actually should mimic how that works. So instead of having an option that enables stripping on the install targets, we should create two targets, one that strips and one that doesn't. Then the user can select whether or not they want their install contents stripped by choosing which target they run.

Also because of how many places we create these install targets we probably should abstract it into a function in AddLLVM.cmake (something like add_llvm_install_targets), which would take a target name and optional component and install prefix, and dependencies. That function would look something like:

function(add_llvm_install_targets target)
  cmake_parse_arguments(ARG "" "COMPONENT;PREFIX" "DEPENDS" ${ARGN})
  if(ARG_COMPONENT)
    set(component_option -DCMAKE_INSTALL_COMPONENT=${ARG_COMPONENT})
  endif()
  if(ARG_PREFIX)
    set(prefix_option -DCMAKE_INSTALL_PREFIX=${ARG_PREFIX})
  endif()
  add_custom_target(${target}
                    DEPENDS ${ARG_DEPENDS}
                    COMMAND "${CMAKE_COMMAND}"
                            ${component_option}
                            ${prefix_option}
                            -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
                    USES_TERMINAL)

  add_custom_target(${target}/strip
                    DEPENDS ${ARG_DEPENDS}
                    COMMAND "${CMAKE_COMMAND}"
                            ${component_option}
                            ${prefix_option}
                            -DCMAKE_INSTALL_DO_STRIP=1
                            -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
                    USES_TERMINAL)
endfunction()

Then you just change the places we create install targets to be calls like:

add_llvm_install_targets(install-${name}
                      DEPENDS ${name}
                      COMPONENT ${name})

or

add_llvm_install_targets(install-distribution-${target}
                DEPENDS ${target}
                COMPONENT ${target}
                PREFIX ${LLVMToolchainDir}/usr/)

[smeenai]

@beanz suggestions. / isn't valid in a target so I went with a -stripped suffix

[beanz]

LGTM. It is a little strange that CMake generates the install/strip target automatically, but won't let you put / in a target name, but there really isn't anything to be done about it.

llvm/trunk/CMakeLists.txt

install(DIRECTORY ${LLVM_INCLUDE_DIR}/llvm
     )
 
   # Installing the headers needs to depend on generating any public
   # tablegen'd headers.
   add_custom_target(llvm-headers DEPENDS intrinsics_gen)
   set_target_properties(llvm-headers PROPERTIES FOLDER "Misc")
 
   if (NOT CMAKE_CONFIGURATION_TYPES)
-    add_custom_target(install-llvm-headers
-                      DEPENDS llvm-headers
-                      COMMAND "${CMAKE_COMMAND}"
-                              -DCMAKE_INSTALL_COMPONENT=llvm-headers
-                              -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+    add_llvm_install_targets(install-llvm-headers
+                             COMPONENT llvm-headers)
   endif()
 endif()
 
 # This must be at the end of the LLVM root CMakeLists file because it must run
 # after all targets are created.
 if(LLVM_DISTRIBUTION_COMPONENTS)
   if(CMAKE_CONFIGURATION_TYPES)
     message(FATAL_ERROR "LLVM_DISTRIBUTION_COMPONENTS cannot be specified with multi-configuration generators (i.e. Xcode or Visual Studio)")

llvm/trunk/cmake/modules/AddLLVM.cmake

if(LLVM_COMMON_DEPENDS)
     endforeach()
   endif()
 
   if(ARG_SHARED OR ARG_MODULE)
     llvm_externalize_debuginfo(${name})
   endif()
 endfunction()
 
+function(add_llvm_install_targets target)
+  cmake_parse_arguments(ARG "" "COMPONENT;PREFIX" "DEPENDS" ${ARGN})
+  if(ARG_COMPONENT)
+    set(component_option -DCMAKE_INSTALL_COMPONENT="${ARG_COMPONENT}")
+  endif()
+  if(ARG_PREFIX)
+    set(prefix_option -DCMAKE_INSTALL_PREFIX="${ARG_PREFIX}")
+  endif()
+
+  add_custom_target(${target}
+                    DEPENDS ${ARG_DEPENDS}
+                    COMMAND "${CMAKE_COMMAND}"
+                            ${component_option}
+                            ${prefix_option}
+                            -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
+                    USES_TERMINAL)
+  add_custom_target(${target}-stripped
+                    DEPENDS ${ARG_DEPENDS}
+                    COMMAND "${CMAKE_COMMAND}"
+                            ${component_option}
+                            ${prefix_option}
+                            -DCMAKE_INSTALL_DO_STRIP=1
+                            -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
+                    USES_TERMINAL)
+endfunction()
+
 macro(add_llvm_library name)
   cmake_parse_arguments(ARG
     "SHARED;BUILDTREE_ONLY"
     ""
     ""
     ${ARGN})
   if( BUILD_SHARED_LIBS OR ARG_SHARED )
     llvm_add_library(${name} SHARED ${ARG_UNPARSED_ARGUMENTS})
if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LTO" OR
       endif()
 
       install(TARGETS ${name}
               ${export_to_llvmexports}
               ${install_type} DESTINATION ${install_dir}
               COMPONENT ${name})
 
       if (NOT CMAKE_CONFIGURATION_TYPES)
-        add_custom_target(install-${name}
+        add_llvm_install_targets(install-${name}
                                  DEPENDS ${name}
-                          COMMAND "${CMAKE_COMMAND}"
-                                  -DCMAKE_INSTALL_COMPONENT=${name}
-                                  -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+                                 COMPONENT ${name})
       endif()
     endif()
     set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
   endif()
   set_target_properties(${name} PROPERTIES FOLDER "Libraries")
 endmacro(add_llvm_library name)
 
 macro(add_llvm_loadable_module name)
if( LLVM_BUILD_TOOLS )
       endif()
 
       install(TARGETS ${name}
               ${export_to_llvmexports}
               RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
               COMPONENT ${name})
 
       if (NOT CMAKE_CONFIGURATION_TYPES)
-        add_custom_target(install-${name}
+        add_llvm_install_targets(install-${name}
                                  DEPENDS ${name}
-                          COMMAND "${CMAKE_COMMAND}"
-                                  -DCMAKE_INSTALL_COMPONENT=${name}
-                                  -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+                                 COMPONENT ${name})
       endif()
     endif()
   endif()
   if( LLVM_BUILD_TOOLS )
     set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
   endif()
   set_target_properties(${name} PROPERTIES FOLDER "Tools")
 endmacro(add_llvm_tool name)
macro(add_llvm_utility name)
 
   add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN})
   set_target_properties(${name} PROPERTIES FOLDER "Utils")
   if( LLVM_INSTALL_UTILS AND LLVM_BUILD_UTILS )
     install (TARGETS ${name}
       RUNTIME DESTINATION ${LLVM_UTILS_INSTALL_DIR}
       COMPONENT ${name})
     if (NOT CMAKE_CONFIGURATION_TYPES)
-      add_custom_target(install-${name}
+      add_llvm_install_targets(install-${name}
                                DEPENDS ${name}
-                        COMMAND "${CMAKE_COMMAND}"
-                                -DCMAKE_INSTALL_COMPONENT=${name}
-                                -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+                               COMPONENT ${name})
     endif()
   endif()
 endmacro(add_llvm_utility name)
 
 macro(add_llvm_fuzzer name)
   cmake_parse_arguments(ARG "" "DUMMY_MAIN" "" ${ARGN})
   if( LLVM_LIB_FUZZING_ENGINE )
     set(LLVM_OPTIONAL_SOURCES ${ARG_DUMMY_MAIN})
if(WIN32 AND "${type}" STREQUAL "SHARED")
     set(output_dir bin)
   endif()
 
   install(SCRIPT ${INSTALL_SYMLINK}
           CODE "install_symlink(${full_name} ${full_dest} ${output_dir})"
           COMPONENT ${component})
 
   if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
-    add_custom_target(install-${name}
+    add_llvm_install_targets(install-${name}
                              DEPENDS ${name} ${dest} install-${dest}
-                      COMMAND "${CMAKE_COMMAND}"
-                              -DCMAKE_INSTALL_COMPONENT=${name}
-                              -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+                             COMPONENT ${name})
   endif()
 endfunction()
 
 function(llvm_install_symlink name dest)
   cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN})
   foreach(path ${CMAKE_MODULE_PATH})
     if(EXISTS ${path}/LLVMInstallSymlink.cmake)
       set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
function(llvm_install_symlink name dest)
   set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
   set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
 
   install(SCRIPT ${INSTALL_SYMLINK}
           CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
           COMPONENT ${component})
 
   if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
-    add_custom_target(install-${name}
+    add_llvm_install_targets(install-${name}
                              DEPENDS ${name} ${dest} install-${dest}
-                      COMMAND "${CMAKE_COMMAND}"
-                              -DCMAKE_INSTALL_COMPONENT=${name}
-                              -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+                             COMPONENT ${name})
   endif()
 endfunction()
 
 function(add_llvm_tool_symlink link_name target)
   cmake_parse_arguments(ARG "ALWAYS_GENERATE" "OUTPUT_DIR" "" ${ARGN})
   set(dest_binary "$<TARGET_FILE:${target}>")
 
   # This got a bit gross... For multi-configuration generators the target

llvm/trunk/cmake/modules/CMakeLists.txt

install(DIRECTORY .
     PATTERN LLVMConfig.cmake EXCLUDE
     PATTERN LLVMConfigVersion.cmake EXCLUDE
     PATTERN LLVM-Config.cmake EXCLUDE
     PATTERN GetHostTriple.cmake EXCLUDE)
 
   if (NOT CMAKE_CONFIGURATION_TYPES)
     # Add a dummy target so this can be used with LLVM_DISTRIBUTION_COMPONENTS
     add_custom_target(cmake-exports)
-    add_custom_target(install-cmake-exports
-                      COMMAND "${CMAKE_COMMAND}"
-                                  -DCMAKE_INSTALL_COMPONENT=cmake-exports
-                                  -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+    add_llvm_install_targets(install-cmake-exports
+                             COMPONENT cmake-exports)
   endif()
 endif()

llvm/trunk/cmake/modules/LLVMExternalProjectUtils.cmake

if(ARG_USE_TOOLCHAIN)
     set_target_properties(${name}-clean PROPERTIES
       SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp)
   endif()
 
   if(NOT ARG_NO_INSTALL)
     install(CODE "execute_process\(COMMAND \${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=\${CMAKE_INSTALL_PREFIX} -P ${BINARY_DIR}/cmake_install.cmake \)"
       COMPONENT ${name})
 
-    add_custom_target(install-${name}
+    add_llvm_install_targets(install-${name}
                              DEPENDS ${name}
-                      COMMAND "${CMAKE_COMMAND}"
-                               -DCMAKE_INSTALL_COMPONENT=${name}
-                               -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
-                      USES_TERMINAL)
+                             COMPONENT ${name})
   endif()
 
   # Add top-level targets
   foreach(target ${ARG_EXTRA_TARGETS})
     string(REPLACE ":" ";" target_list ${target})
     list(GET target_list 0 target)
     list(LENGTH target_list target_list_len)
     if(${target_list_len} GREATER 1)

llvm/trunk/tools/xcode-toolchain/CMakeLists.txt

 
 add_custom_command(OUTPUT ${LLVMToolchainDir}/Info.plist
                   DEPENDS ${LLVMToolchainDir}
                   COMMAND ${CMAKE_COMMAND} -E remove ${LLVMToolchainDir}/Info.plist
                   COMMAND /usr/libexec/PlistBuddy -c "Add:CFBundleIdentifier string org.llvm.${PACKAGE_VERSION}" "${LLVMToolchainDir}/Info.plist"
                   COMMAND /usr/libexec/PlistBuddy -c "Add:CompatibilityVersion integer ${COMPAT_VERSION}" "${LLVMToolchainDir}/Info.plist"
                   )
 
-add_custom_target(install-xcode-toolchain
-                  DEPENDS ${LLVMToolchainDir}/Info.plist
-                  COMMAND "${CMAKE_COMMAND}" --build ${CMAKE_BINARY_DIR} --target all
-                  COMMAND "${CMAKE_COMMAND}"
-                          -DCMAKE_INSTALL_PREFIX=${LLVMToolchainDir}/usr/
-                          -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
-                  USES_TERMINAL)
+add_custom_target(build-xcode-toolchain
+                  COMMAND "${CMAKE_COMMAND}" --build ${CMAKE_BINARY_DIR} --target all)
+add_llvm_install_targets(install-xcode-toolchain
+                         DEPENDS ${LLVMToolchainDir}/Info.plist build-xcode-toolchain
+                         PREFIX ${LLVMToolchainDir}/usr/)
 
 if(LLVM_DISTRIBUTION_COMPONENTS)
   if(CMAKE_CONFIGURATION_TYPES)
     message(FATAL_ERROR "LLVM_DISTRIBUTION_COMPONENTS cannot be specified with multi-configuration generators (i.e. Xcode or Visual Studio)")
   endif()
 
   add_custom_target(install-distribution-toolchain
                   DEPENDS ${LLVMToolchainDir}/Info.plist distribution)
 
   foreach(target ${LLVM_DISTRIBUTION_COMPONENTS})
-    add_custom_target(install-distribution-${target}
+    add_llvm_install_targets(install-distribution-${target}
                              DEPENDS ${target}
-                COMMAND "${CMAKE_COMMAND}"
-                        -DCMAKE_INSTALL_COMPONENT=${target}
-                        -DCMAKE_INSTALL_PREFIX=${LLVMToolchainDir}/usr/
-                        -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
-                USES_TERMINAL)
+                             COMPONENT ${target}
+                             PREFIX ${LLVMToolchainDir}/usr/)
     add_dependencies(install-distribution-toolchain install-distribution-${target})
   endforeach()
 endif()