Merge pull request #37058 from eeckstein/libswift

libswift: Start implementing SIL optimizations in Swift

Author: eeckstein

CMakeLists.txt

@@ -191,6 +191,10 @@ set(SWIFT_TOOLS_ENABLE_LTO OFF CACHE STRING "Build Swift tools with LTO. One
     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).")
 
+option(SWIFT_TOOLS_ENABLE_LIBSWIFT
+  "Enable building libswift and linking libswift into the compiler itself."
+  FALSE)
+
 # The following only works with the Ninja generator in CMake >= 3.0.
 set(SWIFT_PARALLEL_LINK_JOBS "" CACHE STRING
   "Define the maximum number of linker jobs for swift.")
@@ -891,6 +895,7 @@ if(SWIFT_INCLUDE_TOOLS)
   message(STATUS "  Build type:     ${CMAKE_BUILD_TYPE}")
   message(STATUS "  Assertions:     ${LLVM_ENABLE_ASSERTIONS}")
   message(STATUS "  LTO:            ${SWIFT_TOOLS_ENABLE_LTO}")
+  message(STATUS "  libswift:       ${SWIFT_TOOLS_ENABLE_LIBSWIFT}")
   message(STATUS "")
 else()
   message(STATUS "Not building host Swift tools")
@@ -1034,6 +1039,11 @@ add_subdirectory(include)
 if(SWIFT_INCLUDE_TOOLS)
   add_subdirectory(lib)
 
+  # "libswift" must come before "tools".
+  # It adds libswift module names to the global property "libswift_modules"
+  # which is used in add_swift_host_tool for the lldb workaround.
+  add_subdirectory(libswift)
+
   # Always include this after including stdlib/!
   # Refer to the large comment above the add_subdirectory(stdlib) call.
   # https://bugs.swift.org/browse/SR-5975

cmake/modules/AddSwift.cmake

@@ -607,6 +607,121 @@ function(add_swift_host_library name)
   endif()
 endfunction()
 
+# Add a module of libswift
+#
+# Creates a target to compile a module which is part of libswift.
+# Adds the module name to the global property "libswift_modules".
+#
+# This is a temporary workaround until it's possible to compile libswift with
+# cmake's builtin swift support.
+function(add_libswift_module module)
+  cmake_parse_arguments(ALSM
+                        ""
+                        "DEPENDS"
+                        ""
+                        ${ARGN})
+  set(sources ${ALSM_UNPARSED_ARGUMENTS})
+  list(TRANSFORM sources PREPEND "${CMAKE_CURRENT_SOURCE_DIR}/")
+
+  set(target_name "LibSwift${module}")
+
+  # Add a target which depends on the actual compilation target, which
+  # will be created in add_libswift.
+  # This target is mainly used to add properties, like the list of source files.
+  add_custom_target(
+      ${target_name}
+      SOURCES ${sources}
+      COMMENT "libswift module ${module}")
+
+  set_property(TARGET ${target_name} PROPERTY "module_name" ${module})
+  set_property(TARGET ${target_name} PROPERTY "module_depends" ${ALSM_DEPENDS})
+
+  get_property(modules GLOBAL PROPERTY "libswift_modules")
+  set_property(GLOBAL PROPERTY "libswift_modules" ${modules} ${module})
+endfunction()
+ 
+# Add source files to a libswift module.
+#
+# This is a temporary workaround until it's possible to compile libswift with
+# cmake's builtin swift support.
+function(libswift_sources module)
+  cmake_parse_arguments(LSS
+                        ""
+                        ""
+                        ""
+                        ${ARGN})
+  set(sources ${LSS_UNPARSED_ARGUMENTS})
+  list(TRANSFORM sources PREPEND "${CMAKE_CURRENT_SOURCE_DIR}/")
+
+  set(target_name "LibSwift${module}")
+  set_property(TARGET "LibSwift${module}" APPEND PROPERTY SOURCES ${sources})
+endfunction()
+ 
+# Add the libswift library.
+#
+# Adds targets to compile all modules of libswift and a target for the
+# libswift library itself.
+#
+# This is a temporary workaround until it's possible to compile libswift with
+# cmake's builtin swift support.
+function(add_libswift name)
+  if(CMAKE_BUILD_TYPE STREQUAL Debug)
+    set(libswift_compile_options "-g")
+  else()
+    set(libswift_compile_options "-O" "-cross-module-optimization")
+  endif()
+
+  set(build_dir ${CMAKE_CURRENT_BINARY_DIR})
+
+  if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
+    set(deployment_version "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
+  endif()
+  get_versioned_target_triple(target ${SWIFT_HOST_VARIANT_SDK}
+      ${SWIFT_HOST_VARIANT_ARCH} "${deployment_version}")
+
+  get_property(modules GLOBAL PROPERTY "libswift_modules")
+  foreach(module ${modules})
+
+    set(module_target "LibSwift${module}")
+    get_target_property(module ${module_target} "module_name")
+    get_target_property(sources ${module_target} SOURCES)
+    get_target_property(dependencies ${module_target} "module_depends")
+    if(dependencies)
+      list(TRANSFORM dependencies PREPEND "LibSwift")
+    else()
+      set(dependencies "")
+    endif()
+
+    set(module_obj_file "${build_dir}/${module}.o")
+    set(module_file "${build_dir}/${module}.swiftmodule")
+    set_property(TARGET ${module_target} PROPERTY "module_file" "${module_file}")
+
+    set(all_obj_files ${all_obj_files} ${module_obj_file})
+
+    # Compile the libswift module into an object file
+    add_custom_command_target(dep_target OUTPUT ${module_obj_file}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      DEPENDS ${sources} ${dependencies}
+      COMMAND ${CMAKE_Swift_COMPILER} "-c" "-o" ${module_obj_file}
+              "-sdk" "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}"
+              "-target" ${target}
+              "-module-name" ${module} "-emit-module"
+              "-emit-module-path" "${build_dir}/${module}.swiftmodule"
+              "-parse-as-library" ${sources}
+              "-wmo" ${libswift_compile_options}
+              "-I" "${CMAKE_SOURCE_DIR}/include/swift"
+              "-I" "${build_dir}"
+      COMMENT "Building libswift module ${module}")
+
+    add_dependencies(${module_target} ${dep_target})
+
+  endforeach()
+
+  # Create a static libswift library containing all module object files.
+  add_library(${name} STATIC ${all_obj_files})
+  set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
+endfunction()
+
 macro(add_swift_tool_subdirectory name)
   add_llvm_subdirectory(SWIFT TOOL ${name})
 endmacro()
@@ -616,7 +731,7 @@ macro(add_swift_lib_subdirectory name)
 endmacro()
 
 function(add_swift_host_tool executable)
-  set(options)
+  set(options HAS_LIBSWIFT)
   set(single_parameter_options SWIFT_COMPONENT)
   set(multiple_parameter_options LLVM_LINK_COMPONENTS)
 
@@ -668,6 +783,24 @@ function(add_swift_host_tool executable)
       get_filename_component(TOOLCHAIN_BIN_DIR ${CMAKE_Swift_COMPILER} DIRECTORY)
       get_filename_component(TOOLCHAIN_LIB_DIR "${TOOLCHAIN_BIN_DIR}/../lib/swift/macosx" ABSOLUTE)
       target_link_directories(${executable} PUBLIC ${TOOLCHAIN_LIB_DIR})
+
+      if (ASHT_HAS_LIBSWIFT AND SWIFT_TOOLS_ENABLE_LIBSWIFT)
+        # Workaround to make lldb happy: we have to explicitly add all libswift modules
+        # to the linker command line.
+        set(libswift_ast_path_flags "-Wl")
+        get_property(modules GLOBAL PROPERTY "libswift_modules")
+        foreach(module ${modules})
+          get_target_property(module_file "LibSwift${module}" "module_file")
+          string(APPEND libswift_ast_path_flags ",-add_ast_path,${module_file}")
+        endforeach()
+
+        set_property(TARGET ${executable} APPEND_STRING PROPERTY
+                     LINK_FLAGS ${libswift_ast_path_flags})
+
+        # Workaround for a linker crash related to autolinking: rdar://77839981
+        set_property(TARGET ${executable} APPEND_STRING PROPERTY
+                     LINK_FLAGS " -lobjc ")
+      endif()
     endif()
 
     # Lists of rpaths that we are going to add to our executables.
@@ -687,6 +820,22 @@ function(add_swift_host_tool executable)
     set_target_properties(${executable} PROPERTIES
       BUILD_WITH_INSTALL_RPATH YES
       INSTALL_RPATH "${RPATH_LIST}")
+
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL "LINUX")
+    if (ASHT_HAS_LIBSWIFT AND SWIFT_TOOLS_ENABLE_LIBSWIFT)
+      # At build time and and run time, link against the swift libraries in the
+      # installed host toolchain.
+      get_filename_component(swift_bin_dir ${CMAKE_Swift_COMPILER} DIRECTORY)
+      get_filename_component(swift_dir ${swift_bin_dir} DIRECTORY)
+      set(host_lib_dir "${swift_dir}/lib/swift/linux")
+
+      target_link_libraries(${executable} PRIVATE "swiftCore")
+
+      target_link_directories(${executable} PRIVATE ${host_lib_dir})
+      set_target_properties(${executable} PROPERTIES
+        BUILD_WITH_INSTALL_RPATH YES
+        INSTALL_RPATH  "${host_lib_dir}")
+    endif()
   endif()
 
   llvm_update_compile_flags(${executable})

include/swift/Basic/InitializeLibSwift.h

@@ -0,0 +1,26 @@
+//===--- InitializeLibSwift.h -----------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_INITIALIZELIBSWIFT_H
+#define SWIFT_BASIC_INITIALIZELIBSWIFT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void initializeLibSwift();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SWIFT_BASIC_INITIALIZELIBSWIFT_H

include/swift/SIL/BridgedSwiftObject.h

@@ -0,0 +1,43 @@
+//===--- BridgedSwiftObject.h - C header which defines SwiftObject --------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a C header, which defines the SwiftObject header. For the C++ version
+// see SwiftObjectHeader.h.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_BRIDGEDSWIFTOBJECT_H
+#define SWIFT_SIL_BRIDGEDSWIFTOBJECT_H
+
+#include <stdint.h>
+
+#if !__has_feature(nullability)
+# define _Nullable
+# define _Nonnull
+# define _Null_unspecified
+#endif
+
+typedef const void * _Nonnull SwiftMetatype;
+
+/// The header of a Swift object.
+///
+/// This must be in sync with HeapObject, which is defined in the runtime lib.
+/// It must be layout compatible with the Swift object header.
+struct BridgedSwiftObject {
+  SwiftMetatype metatype;
+  int64_t refCounts;
+};
+
+typedef struct BridgedSwiftObject * _Nonnull SwiftObject;
+typedef struct BridgedSwiftObject * _Nullable OptionalSwiftObject;
+
+#endif

include/swift/SIL/SILArgument.h

@@ -196,6 +196,10 @@ class SILArgument : public ValueBase {
   }
 };
 
+inline SILArgument *castToArgument(SwiftObject argument) {
+  return static_cast<SILArgument *>(argument);
+}
+
 class SILPhiArgument : public SILArgument {
   friend class SILBasicBlock;
 

include/swift/SIL/SILBasicBlock.h

@@ -22,6 +22,7 @@
 #include "swift/SIL/SILArgumentArrayRef.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SwiftObjectHeader.h"
 #include "llvm/ADT/TinyPtrVector.h"
 
 namespace swift {
@@ -31,13 +32,16 @@ class SILArgument;
 class SILPrintContext;
 
 class SILBasicBlock :
-public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
+public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock>,
+public SwiftObjectHeader {
   friend class SILSuccessor;
   friend class SILFunction;
   friend class SILGlobalVariable;
   template <typename, unsigned> friend class BasicBlockData;
   friend class BasicBlockBitfield;
 
+  static SwiftMetatype registeredMetatype;
+    
 public:
   using InstListType = llvm::iplist<SILInstruction>;
 private:
@@ -47,7 +51,7 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
   /// PrevList - This is a list of all of the terminator operands that are
   /// branching to this block, forming the predecessor list.  This is
   /// automatically managed by the SILSuccessor class.
-  SILSuccessor *PredList;
+  SILSuccessor *PredList = nullptr;
 
   /// This is the list of basic block arguments for this block.
   /// A TinyPtrVector is the right choice, because ~98% of blocks have 0 or 1
@@ -82,14 +86,18 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
   uint64_t lastInitializedBitfieldID = 0;
 
   friend struct llvm::ilist_traits<SILBasicBlock>;
-  SILBasicBlock() : Parent(nullptr) {}
-  void operator=(const SILBasicBlock &) = delete;
 
-  void operator delete(void *Ptr, size_t) = delete;
+  SILBasicBlock();
+  SILBasicBlock(SILFunction *parent);
 
-  SILBasicBlock(SILFunction *parent) : Parent(parent), PredList(nullptr) { }
+  void operator=(const SILBasicBlock &) = delete;
+  void operator delete(void *Ptr, size_t) = delete;
 
 public:
+  static void registerBridgedMetatype(SwiftMetatype metatype) {
+    registeredMetatype = metatype;
+  }
+
   ~SILBasicBlock();
 
   /// Gets the ID (= index in the function's block list) of the block.