[lto] Only build host libraries using LTO.

gottesmm · gottesmm · commit 95d926abb0e2 · 2016-06-10T13:33:54.000-07:00
At some point in the future, we may consider using LTO on the runtime/standard
library, but right now is not that time. We are just trying to use LTO to
improve the compile time performance of the compiler itself.

rdar://24717107
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -140,8 +140,10 @@ set(SWIFT_NATIVE_CLANG_TOOLS_PATH "" CACHE STRING
 set(SWIFT_NATIVE_SWIFT_TOOLS_PATH "" CACHE STRING
     "Path to the directory that contains Swift tools that are executable on the build machine")
 
-option(SWIFT_TOOLS_ENABLE_LTO
-  "If set to true, build the swift compiler with link time optimization enabled" FALSE)
+set(SWIFT_TOOLS_ENABLE_LTO OFF CACHE STRING "Build Swift tools with LTO. One
+    must specify the form of LTO by setting this to one of: 'full', 'thin'. This
+    option only affects the tools that run on the host (the compiler), and has
+    no effect on the target libraries (the standard library and the runtime).")
 
 # The following only works with the Ninja generator in CMake >= 3.0.
 set(SWIFT_PARALLEL_LINK_JOBS "" CACHE STRING
diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
@@ -53,6 +53,15 @@ function(compute_library_subdir result_var_name sdk arch)
   set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${arch}" PARENT_SCOPE)
 endfunction()
 
+function(_compute_lto_flag option out_var)
+  string(TOLOWER "${option}" lowercase_option)
+  if (lowercase_option STREQUAL "full")
+    set(${out_var} "-flto=full" PARENT_SCOPE)
+  elseif (lowercase_option STREQUAL "thin")
+    set(${out_var} "-flto=thin" PARENT_SCOPE)
+  endif()
+endfunction()
+
 # Usage:
 # _add_variant_c_compile_link_flags(
 #   SDK sdk
@@ -110,7 +119,8 @@ function(_add_variant_c_compile_link_flags)
   endif()
 
   if(CFLAGS_ENABLE_LTO)
-    list(APPEND result "-flto")
+    _compute_lto_flag(${CFLAGS_ENABLE_LTO} _lto_flag_out)
+    list(APPEND result "${_lto_flag_out}")
   endif()
 
   set("${CFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
@@ -150,7 +160,8 @@ function(_add_variant_c_compile_flags)
 
   is_build_type_with_debuginfo("${CFLAGS_BUILD_TYPE}" debuginfo)
   if(debuginfo)
-    if(SWIFT_TOOLS_ENABLE_LTO)
+    _compute_lto_flag("${CFLAGS_ENABLE_LTO}" _lto_flag_out)
+    if(_lto_flag_out)
       list(APPEND result "-gline-tables-only")
     else()
       list(APPEND result "-g")
@@ -797,13 +808,18 @@ function(_add_swift_library_single target name)
     set(enable_assertions "${LLVM_ENABLE_ASSERTIONS}")
     set(analyze_code_coverage "${SWIFT_ANALYZE_CODE_COVERAGE}")
   endif()
+
+  if (NOT SWIFTLIB_SINGLE_TARGET_LIBRARY)
+    set(lto_type "${SWIFT_TOOLS_ENABLE_LTO}")
+  endif()
+
   _add_variant_c_compile_flags(
     SDK "${SWIFTLIB_SINGLE_SDK}"
     ARCH "${SWIFTLIB_SINGLE_ARCHITECTURE}"
     BUILD_TYPE "${build_type}"
     ENABLE_ASSERTIONS "${enable_assertions}"
     ANALYZE_CODE_COVERAGE "${analyze_code_coverage}"
-    ENABLE_LTO "${SWIFT_TOOLS_ENABLE_LTO}"
+    ENABLE_LTO "${lto_type}"
     DEPLOYMENT_VERSION_IOS "${SWIFTLIB_DEPLOYMENT_VERSION_IOS}"
     RESULT_VAR_NAME c_compile_flags
     )
@@ -813,7 +829,7 @@ function(_add_swift_library_single target name)
     BUILD_TYPE "${build_type}"
     ENABLE_ASSERTIONS "${enable_assertions}"
     ANALYZE_CODE_COVERAGE "${analyze_code_coverage}"
-    ENABLE_LTO "${SWIFT_TOOLS_ENABLE_LTO}"
+    ENABLE_LTO "${lto_type}"
     DEPLOYMENT_VERSION_IOS "${SWIFTLIB_DEPLOYMENT_VERSION_IOS}"
     RESULT_VAR_NAME link_flags
       )
diff --git a/test/lit.cfg b/test/lit.cfg
@@ -191,7 +191,7 @@ if platform.system() == 'Darwin':
 config.test_format = SwiftTest(coverage_mode=config.coverage_mode)
 
 # suffixes: A list of file extensions to treat as test files.
-config.suffixes = ['.swift', '.ll', '.sil', '.gyb', '.m']
+config.suffixes = ['.swift', '.ll', '.sil', '.gyb', '.m', '.test-sh']
 
 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
 # subdirectories contain auxiliary inputs for various tests in their parent
@@ -333,6 +333,7 @@ completion_cache_path = tempfile.mkdtemp(prefix="swift-testsuite-completion-cach
 ccp_opt = "-completion-cache-path %r" % completion_cache_path
 lit_config.note("Using code completion cache: " + completion_cache_path)
 
+config.substitutions.append( ('%swift_obj_root', config.swift_obj_root) )
 config.substitutions.append( ('%{python}', sys.executable) )
 config.substitutions.append( ('%mcp_opt', mcp_opt) )
 config.substitutions.append( ('%swift_driver_plain', "%r" % config.swift) )
diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
@@ -26,7 +26,7 @@ if "@SWIFT_ASAN_BUILD@" == "TRUE":
 else:
     config.available_features.add('no_asan')
 
-if '@SWIFT_TOOLS_ENABLE_LTO@' == 'TRUE':
+if '@SWIFT_TOOLS_ENABLE_LTO@'.lower() in ['full', 'thin']:
     config.available_features.add('lto')
 else:
     config.available_features.add('no_lto')
diff --git a/utils/build-script b/utils/build-script
@@ -709,10 +709,10 @@ class BuildScriptInvocation(object):
                     pipes.quote(opt) for opt in args.extra_cmake_options)
             ]
 
-        if args.lto:
+        if args.lto_type is not None:
             impl_args += [
-                "--llvm-enable-lto",
-                "--swift-tools-enable-lto"
+                "--llvm-enable-lto=%s" % args.lto_type,
+                "--swift-tools-enable-lto=%s" % args.lto_type
             ]
             if args.llvm_max_parallel_lto_link_jobs is not None:
                 impl_args += [
@@ -1707,12 +1707,15 @@ details of the setups of other systems or automated environments.""")
     parser.add_argument(
         "--lto",
         help="use lto optimization on llvm/swift tools. This does not "
-             "imply using lto on the swift standard library or runtime",
-        metavar="BOOL",
+             "imply using lto on the swift standard library or runtime. "
+             "Options: thin, full. If no optional arg is provided, full is "
+             "chosen by default",
+        metavar="LTO_TYPE",
         nargs='?',
-        type=arguments.type.bool,
-        default=False,
-        const=True)
+        choices=['thin', 'full'],
+        default=None,
+        const='full',
+        dest='lto_type')
 
     default_max_lto_link_job_counts = host.max_lto_link_job_counts()
     parser.add_argument(
diff --git a/utils/build-script-impl b/utils/build-script-impl
@@ -74,8 +74,8 @@ KNOWN_SETTINGS=(
     swift-build-type            "Debug"          "the CMake build variant for Swift"
     swift-enable-assertions     "1"              "enable assertions in Swift"
     swift-analyze-code-coverage "not-merged"     "Code coverage analysis mode for Swift (false, not-merged, merged). Defaults to false if the argument is not present, and not-merged if the argument is present without a modifier."
-    swift-tools-enable-lto      "0"              "enable LTO compilation of Swift tools. *NOTE* This does not include the swift standard library and runtime."
-    llvm-enable-lto             "0"              "enable LTO compilation of LLVM/Clang."
+    swift-tools-enable-lto      ""               "enable LTO compilation of Swift tools. *NOTE* This does not include the swift standard library and runtime. Must be set to one of 'thin' or 'full'"
+    llvm-enable-lto             ""               "Must be set to one of 'thin' or 'full'"
     swift-tools-num-parallel-lto-link-jobs ""    "The number of parallel link jobs to use when compiling swift tools"
     llvm-num-parallel-lto-link-jobs ""           "The number of parallel link jobs to use when compiling llvm"
     swift-stdlib-build-type     "Debug"          "the CMake build variant for Swift"
@@ -289,6 +289,24 @@ function set_lldb_build_mode() {
     LLDB_BUILD_MODE="CustomSwift-${LLDB_BUILD_TYPE}"
 }
 
+function is_llvm_lto_enabled() {
+    if [[ "${LLVM_ENABLE_LTO}" == "thin" ]] ||
+       [[ "${LLVM_ENABLE_LTO}" == "full" ]]; then
+        echo "TRUE"
+    else
+        echo "FALSE"
+    fi
+}
+
+function is_swift_lto_enabled() {
+    if [[ "${SWIFT_TOOLS_ENABLE_LTO}" == "thin" ]] ||
+       [[ "${SWIFT_TOOLS_ENABLE_LTO}" == "full" ]]; then
+        echo "TRUE"
+    else
+        echo "FALSE"
+    fi
+}
+
 # Support for performing isolated actions.
 #
 # This is part of refactoring more work to be done or controllable via
@@ -567,8 +585,8 @@ function set_build_options_for_host() {
                 -DCOMPILER_RT_ENABLE_TVOS:BOOL=FALSE
                 -DSANITIZER_MIN_OSX_VERSION="${cmake_osx_deployment_target}"
             )
-            if [[ $(true_false "${LLVM_ENABLE_LTO}") = "TRUE" ]]; then
-                if [[ $(cmake_needs_to_specify_standard_computed_defaults) = "TRUE" ]]; then
+            if [[ $(is_llvm_lto_enabled) == "TRUE" ]]; then
+                if [[ $(cmake_needs_to_specify_standard_computed_defaults) == "TRUE" ]]; then
                     llvm_cmake_options+=(
                         "-DCMAKE_C_STANDARD_COMPUTED_DEFAULT=AppleClang"
                         "-DCMAKE_CXX_STANDARD_COMPUTED_DEFAULT=AppleClang"
@@ -580,7 +598,7 @@ function set_build_options_for_host() {
                 )
             fi
 
-            if [[ $(true_false "${SWIFT_TOOLS_ENABLE_LTO}") = "TRUE" ]]; then
+            if [[ $(is_swift_lto_enabled) == "TRUE" ]]; then
                 if [[ $(cmake_needs_to_specify_standard_computed_defaults) = "TRUE" ]]; then
                     swift_cmake_options+=(
                         "-DCMAKE_C_STANDARD_COMPUTED_DEFAULT=AppleClang"
@@ -1442,7 +1460,7 @@ function llvm_c_flags() {
     if [[ $(is_cmake_release_build_type "${LLVM_BUILD_TYPE}") ]] ; then
         echo -n " -fno-stack-protector"
     fi
-    if [[ $(true_false "${LLVM_ENABLE_LTO}") = "TRUE" ]] ; then
+    if [[ $(is_llvm_lto_enabled) == "TRUE" ]] ; then
         echo -n " -gline-tables-only"
     fi
 }
@@ -1761,7 +1779,7 @@ for host in "${ALL_HOSTS[@]}"; do
                     -DLLVM_TARGETS_TO_BUILD="${LLVM_TARGETS_TO_BUILD}"
                     -DLLVM_INCLUDE_TESTS:BOOL=$(true_false "${SOURCE_TREE_INCLUDES_TESTS}")
                     -DLLVM_INCLUDE_DOCS:BOOL=TRUE
-                    -DLLVM_ENABLE_LTO=$(true_false "${LLVM_ENABLE_LTO}")
+                    -DLLVM_ENABLE_LTO:STRING="${LLVM_ENABLE_LTO}"
                     "${llvm_cmake_options[@]}"
                 )
                 if [[ $(is_cross_tools_host ${host}) ]] ; then
@@ -1876,7 +1894,7 @@ for host in "${ALL_HOSTS[@]}"; do
                     -DSWIFT_INCLUDE_TESTS:BOOL=$(true_false "${build_tests_this_time}")
                     -DSWIFT_INSTALL_COMPONENTS:STRING="${SWIFT_INSTALL_COMPONENTS}"
                     -DSWIFT_EMBED_BITCODE_SECTION:BOOL=$(true_false "${EMBED_BITCODE_SECTION}")
-                    -DSWIFT_TOOLS_ENABLE_LTO:BOOL=$(true_false "${SWIFT_TOOLS_ENABLE_LTO}")
+                    -DSWIFT_TOOLS_ENABLE_LTO:STRING="${SWIFT_TOOLS_ENABLE_LTO}"
                     -DSWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER:BOOL=$(true_false "${BUILD_RUNTIME_WITH_HOST_COMPILER}")
                     "${swift_cmake_options[@]}"
                 )
diff --git a/validation-test/LTO/host-libraries-do-have-bitcode.test-sh b/validation-test/LTO/host-libraries-do-have-bitcode.test-sh
@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+
+# This test makes sure that if lto is enabled and that all host libraries
+# contain only bitcode.
+#
+# *NOTE* This will not trigger for embedded bitcode sections since to file those
+# are still mach-o files and come up as such.
+
+set -e
+set -u
+
+# REQUIRES: lto
+# REQUIRES: macosx
+# RUN: %s %swift_obj_root %t
+
+function check_thin_archive_for_bitcode() {
+    set -e
+    set -u
+    set -o pipefail
+
+    pushd . 1>/dev/null
+
+    local BASE_TEMPDIR=$1
+    local ARCHIVE=$2
+
+    local LIB_NAME=$(basename ${ARCHIVE})
+    local LIB_ARCH=$(basename $(dirname ${ARCHIVE}))
+    local LIB_PLATFORM=$(basename $(dirname $(dirname ${ARCHIVE})))
+
+    LIB_TEMP_DIR="${BASE_TEMPDIR}/${LIB_PLATFORM}-${LIB_ARCH}-${LIB_NAME}"
+    mkdir -p "${LIB_TEMP_DIR}"
+    cd "${LIB_TEMP_DIR}"
+    ar -x ${ARCHIVE}
+    if [[ -n "$(find ./ -iname '*.o' -exec file {} \; | grep bit-code)" ]]; then
+        echo "Found bitcode file in thin archive: ${ARCHIVE}"
+    else
+        echo "No bitcode in thin archive: ${ARCHIVE}"
+        exit 1
+    fi
+    popd 1>/dev/null
+
+    set +o pipefail
+    set +u
+    set +e
+}
+export -f check_thin_archive_for_bitcode
+
+function check_thick_archive_for_bitcode() {
+    set -e
+    set -u
+    set -o pipefail
+
+    pushd . 1>/dev/null
+
+    local BASE_TEMPDIR=$1
+    local ARCHIVE=$2
+
+    local LIB_NAME=$(basename ${ARCHIVE})
+    local LIB_PLATFORM=$(basename $(dirname ${ARCHIVE}))
+
+    LIB_TEMP_DIR="${BASE_TEMPDIR}/${LIB_PLATFORM}-thick-${LIB_NAME}"
+    LIB_ARCHIVE_DIR="${LIB_TEMP_DIR}/archive"
+    LIB_OBJECT_DIR="${LIB_TEMP_DIR}/object"
+
+    mkdir -p "${LIB_TEMP_DIR}"
+    mkdir -p "${LIB_ARCHIVE_DIR}"
+    mkdir -p "${LIB_OBJECT_DIR}"
+
+    ARCHS=( $(lipo -info ${ARCHIVE} | cut -f 3 -d ":" ) )
+    cd ${LIB_OBJECT_DIR}
+    for arch in "${ARCHS[@]}"; do
+        pushd . 1>/dev/null
+        local THIN_ARCHIVE="${LIB_NAME}.${arch}"
+        lipo -thin "${arch}" -output "${LIB_ARCHIVE_DIR}/${THIN_ARCHIVE}" "${ARCHIVE}"
+        mkdir ${arch}
+        cd ${arch}
+        ar -x "${LIB_ARCHIVE_DIR}/${THIN_ARCHIVE}"
+
+        if [[ -n "$(find ./ -iname '*.o' -exec file {} \; | grep bit-code)" ]]; then
+            echo "Found bitcode file in thin archive: ${THIN_ARCHIVE}. Taken from thick archive: ${ARCHIVE}"
+        else
+            echo "No bitcode in thin archive: ${THIN_ARCHIVE}. Taken from thick archive: ${ARCHIVE}"
+            exit 1
+        fi
+
+        popd 1>/dev/null
+    done
+    popd 1>/dev/null
+
+    set +o pipefail
+    set +u
+    set +e
+}
+export -f check_thick_archive_for_bitcode
+
+OBJROOT=$(cd ${1} && pwd)
+TEMPDIR=${2}
+
+rm -rf $TEMPDIR
+mkdir -p $TEMPDIR
+
+THIN_ARCHIVES=( \
+    $(find ${OBJROOT}/lib -depth 1 -iname '*.a' -exec lipo -info {} \; | grep "Non-fat file" | cut -f 3 -d " ") \
+)
+
+if [[ ${#THIN_ARCHIVES[@]} -gt 0 ]]; then
+    echo "${THIN_ARCHIVES[@]}" | xargs -n 1 -P 8 bash -c "check_thin_archive_for_bitcode \"${TEMPDIR}\" \${1}" --
+fi
+
+THICK_ARCHIVES=( \
+   $(find ${OBJROOT}/lib -depth 1 -iname '*.a' -exec lipo -info {} \; | grep "Architectures in the fat file" | cut -f 6 -d " ") \
+)
+
+if [[ ${#THICK_ARCHIVES[@]} -gt 0 ]]; then
+    echo "${THICK_ARCHIVES[@]}" | xargs -n 1 -P 8 bash -c "check_thick_archive_for_bitcode \"${TEMPDIR}\" \${1}" --
+fi
+
+set +o pipefail
+set +u
+set +e
diff --git a/validation-test/LTO/object-files-do-have-bitcode.test-sh b/validation-test/LTO/object-files-do-have-bitcode.test-sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+# This test makes sure that if lto is enabled and that all host libraries
+# contain only bitcode.
+#
+# *NOTE* This will not trigger for embedded bitcode sections since to file those
+# are still mach-o files and come up as such.
+
+set -e
+set -u
+
+# REQUIRES: lto
+# RUN: %s %swift_obj_root
+
+if [[ -n "$(find $1/lib -iname '*.cpp.o' -type f -exec file {} \; | grep -v bit-code)" ]]; then
+    echo "Found a ./lib non-bitcode object file!"
+    exit 1
+else
+    echo "All ./lib object files are bit-code files!"
+fi
+
+if [[ -n "$(find $1/unittests -iname '*.cpp.o' -type f -exec file {} \; | grep -v bit-code)" ]]; then
+    echo "Found a ./unittests non-bitcode object file!"
+    exit 1
+else
+    echo "All ./unittests object files are bit-code files!"
+fi
+
+set +u
+set +e
diff --git a/validation-test/LTO/target-libraries-do-not-have-bitcode.test-sh b/validation-test/LTO/target-libraries-do-not-have-bitcode.test-sh
diff --git a/validation-test/lit.site.cfg.in b/validation-test/lit.site.cfg.in
